/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

195

static·inline·void·_nocheck__trace_breakpoint_insert(int·cpu_index,·uint64_t·pc,·int·flags)

195

static·inline·void·_nocheck__trace_breakpoint_insert(int·cpu_index,·uint64_t·pc,·int·flags)

196

{

196

{

197

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

197

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

198

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

198

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

199

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

199

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

200

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

200

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

202

············qemu_log("%d@%zu.%06zu:breakpoint_insert·"·"cpu=%d·pc=0x%"·PRIx64·"·flags=0x%x"·"\n",

202

············qemu_log("%d@%zu.%06zu:breakpoint_insert·"·"cpu=%d·pc=0x%"·PRIx64·"·flags=0x%x"·"\n",

203

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

203

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

204

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

204

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

205

·····················,·cpu_index,·pc,·flags);

205

·····················,·cpu_index,·pc,·flags);

206

#line·208·"trace/trace-root.h"

206

#line·208·"trace/trace-root.h"

207

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

207

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

209

············qemu_log("breakpoint_insert·"·"cpu=%d·pc=0x%"·PRIx64·"·flags=0x%x"·"\n",·cpu_index,·pc,·flags);

209

············qemu_log("breakpoint_insert·"·"cpu=%d·pc=0x%"·PRIx64·"·flags=0x%x"·"\n",·cpu_index,·pc,·flags);

210

#line·212·"trace/trace-root.h"

210

#line·212·"trace/trace-root.h"

211

········}

211

········}

212

····}

212

····}

213

}

213

}

214

static·inline·void·trace_breakpoint_insert(int·cpu_index,·uint64_t·pc,·int·flags)

214

static·inline·void·trace_breakpoint_insert(int·cpu_index,·uint64_t·pc,·int·flags)

226

static·inline·void·_nocheck__trace_breakpoint_remove(int·cpu_index,·uint64_t·pc,·int·flags)

226

static·inline·void·_nocheck__trace_breakpoint_remove(int·cpu_index,·uint64_t·pc,·int·flags)

227

{

227

{

228

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

228

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

229

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

229

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

230

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

230

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

231

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

231

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

233

············qemu_log("%d@%zu.%06zu:breakpoint_remove·"·"cpu=%d·pc=0x%"·PRIx64·"·flags=0x%x"·"\n",

233

············qemu_log("%d@%zu.%06zu:breakpoint_remove·"·"cpu=%d·pc=0x%"·PRIx64·"·flags=0x%x"·"\n",

234

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

234

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

235

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

235

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

236

·····················,·cpu_index,·pc,·flags);

236

·····················,·cpu_index,·pc,·flags);

237

#line·239·"trace/trace-root.h"

237

#line·239·"trace/trace-root.h"

238

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

238

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

240

············qemu_log("breakpoint_remove·"·"cpu=%d·pc=0x%"·PRIx64·"·flags=0x%x"·"\n",·cpu_index,·pc,·flags);

240

············qemu_log("breakpoint_remove·"·"cpu=%d·pc=0x%"·PRIx64·"·flags=0x%x"·"\n",·cpu_index,·pc,·flags);

241

#line·243·"trace/trace-root.h"

241

#line·243·"trace/trace-root.h"

242

········}

242

········}

243

····}

243

····}

244

}

244

}

245

static·inline·void·trace_breakpoint_remove(int·cpu_index,·uint64_t·pc,·int·flags)

245

static·inline·void·trace_breakpoint_remove(int·cpu_index,·uint64_t·pc,·int·flags)

257

static·inline·void·_nocheck__trace_breakpoint_singlestep(int·cpu_index,·int·enabled)

257

static·inline·void·_nocheck__trace_breakpoint_singlestep(int·cpu_index,·int·enabled)

258

{

258

{

259

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

259

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

260

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

260

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

261

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

261

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

262

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

262

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

264

············qemu_log("%d@%zu.%06zu:breakpoint_singlestep·"·"cpu=%d·enable=%d"·"\n",

264

············qemu_log("%d@%zu.%06zu:breakpoint_singlestep·"·"cpu=%d·enable=%d"·"\n",

265

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

265

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

266

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

266

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

267

·····················,·cpu_index,·enabled);

267

·····················,·cpu_index,·enabled);

268

#line·270·"trace/trace-root.h"

268

#line·270·"trace/trace-root.h"

269

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

269

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

271

············qemu_log("breakpoint_singlestep·"·"cpu=%d·enable=%d"·"\n",·cpu_index,·enabled);

271

············qemu_log("breakpoint_singlestep·"·"cpu=%d·enable=%d"·"\n",·cpu_index,·enabled);

272

#line·274·"trace/trace-root.h"

272

#line·274·"trace/trace-root.h"

273

········}

273

········}

274

····}

274

····}

275

}

275

}

276

static·inline·void·trace_breakpoint_singlestep(int·cpu_index,·int·enabled)

276

static·inline·void·trace_breakpoint_singlestep(int·cpu_index,·int·enabled)

288

static·inline·void·_nocheck__trace_dma_blk_io(void·*·dbs,·void·*·bs,·int64_t·offset,·bool·to_dev)

288

static·inline·void·_nocheck__trace_dma_blk_io(void·*·dbs,·void·*·bs,·int64_t·offset,·bool·to_dev)

289

{

289

{

290

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

290

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

291

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

291

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

292

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

292

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

293

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

293

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

295

············qemu_log("%d@%zu.%06zu:dma_blk_io·"·"dbs=%p·bs=%p·offset=%"·PRId64·"·to_dev=%d"·"\n",

295

············qemu_log("%d@%zu.%06zu:dma_blk_io·"·"dbs=%p·bs=%p·offset=%"·PRId64·"·to_dev=%d"·"\n",

296

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

296

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

297

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

297

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

298

·····················,·dbs,·bs,·offset,·to_dev);

298

·····················,·dbs,·bs,·offset,·to_dev);

299

#line·301·"trace/trace-root.h"

299

#line·301·"trace/trace-root.h"

300

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

300

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

302

············qemu_log("dma_blk_io·"·"dbs=%p·bs=%p·offset=%"·PRId64·"·to_dev=%d"·"\n",·dbs,·bs,·offset,·to_dev);

302

············qemu_log("dma_blk_io·"·"dbs=%p·bs=%p·offset=%"·PRId64·"·to_dev=%d"·"\n",·dbs,·bs,·offset,·to_dev);

303

#line·305·"trace/trace-root.h"

303

#line·305·"trace/trace-root.h"

304

········}

304

········}

305

····}

305

····}

306

}

306

}

307

static·inline·void·trace_dma_blk_io(void·*·dbs,·void·*·bs,·int64_t·offset,·bool·to_dev)

307

static·inline·void·trace_dma_blk_io(void·*·dbs,·void·*·bs,·int64_t·offset,·bool·to_dev)

319

static·inline·void·_nocheck__trace_dma_aio_cancel(void·*·dbs)

319

static·inline·void·_nocheck__trace_dma_aio_cancel(void·*·dbs)

320

{

320

{

321

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

321

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

322

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

322

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

323

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

323

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

324

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

324

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

326

············qemu_log("%d@%zu.%06zu:dma_aio_cancel·"·"dbs=%p"·"\n",

326

············qemu_log("%d@%zu.%06zu:dma_aio_cancel·"·"dbs=%p"·"\n",

327

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

327

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

328

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

328

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

329

·····················,·dbs);

329

·····················,·dbs);

330

#line·332·"trace/trace-root.h"

330

#line·332·"trace/trace-root.h"

331

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

331

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

333

············qemu_log("dma_aio_cancel·"·"dbs=%p"·"\n",·dbs);

333

············qemu_log("dma_aio_cancel·"·"dbs=%p"·"\n",·dbs);

334

#line·336·"trace/trace-root.h"

334

#line·336·"trace/trace-root.h"

335

········}

335

········}

336

····}

336

····}

337

}

337

}

338

static·inline·void·trace_dma_aio_cancel(void·*·dbs)

338

static·inline·void·trace_dma_aio_cancel(void·*·dbs)

350

static·inline·void·_nocheck__trace_dma_complete(void·*·dbs,·int·ret,·void·*·cb)

350

static·inline·void·_nocheck__trace_dma_complete(void·*·dbs,·int·ret,·void·*·cb)

351

{

351

{

352

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

352

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

353

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

353

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

354

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

354

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

355

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

355

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

357

············qemu_log("%d@%zu.%06zu:dma_complete·"·"dbs=%p·ret=%d·cb=%p"·"\n",

357

············qemu_log("%d@%zu.%06zu:dma_complete·"·"dbs=%p·ret=%d·cb=%p"·"\n",

358

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

358

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

359

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

359

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

360

·····················,·dbs,·ret,·cb);

360

·····················,·dbs,·ret,·cb);

361

#line·363·"trace/trace-root.h"

361

#line·363·"trace/trace-root.h"

362

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

362

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

364

············qemu_log("dma_complete·"·"dbs=%p·ret=%d·cb=%p"·"\n",·dbs,·ret,·cb);

364

············qemu_log("dma_complete·"·"dbs=%p·ret=%d·cb=%p"·"\n",·dbs,·ret,·cb);

365

#line·367·"trace/trace-root.h"

365

#line·367·"trace/trace-root.h"

366

········}

366

········}

367

····}

367

····}

368

}

368

}

369

static·inline·void·trace_dma_complete(void·*·dbs,·int·ret,·void·*·cb)

369

static·inline·void·trace_dma_complete(void·*·dbs,·int·ret,·void·*·cb)

381

static·inline·void·_nocheck__trace_dma_blk_cb(void·*·dbs,·int·ret)

381

static·inline·void·_nocheck__trace_dma_blk_cb(void·*·dbs,·int·ret)

382

{

382

{

383

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

383

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

384

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

384

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

385

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

385

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

386

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

386

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

388

············qemu_log("%d@%zu.%06zu:dma_blk_cb·"·"dbs=%p·ret=%d"·"\n",

388

············qemu_log("%d@%zu.%06zu:dma_blk_cb·"·"dbs=%p·ret=%d"·"\n",

389

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

389

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

390

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

390

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

391

·····················,·dbs,·ret);

391

·····················,·dbs,·ret);

392

#line·394·"trace/trace-root.h"

392

#line·394·"trace/trace-root.h"

393

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

393

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

395

············qemu_log("dma_blk_cb·"·"dbs=%p·ret=%d"·"\n",·dbs,·ret);

395

············qemu_log("dma_blk_cb·"·"dbs=%p·ret=%d"·"\n",·dbs,·ret);

396

#line·398·"trace/trace-root.h"

396

#line·398·"trace/trace-root.h"

397

········}

397

········}

398

····}

398

····}

399

}

399

}

400

static·inline·void·trace_dma_blk_cb(void·*·dbs,·int·ret)

400

static·inline·void·trace_dma_blk_cb(void·*·dbs,·int·ret)

412

static·inline·void·_nocheck__trace_dma_map_wait(void·*·dbs)

412

static·inline·void·_nocheck__trace_dma_map_wait(void·*·dbs)

413

{

413

{

414

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

414

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

415

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

415

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

416

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

416

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

417

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

417

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

419

············qemu_log("%d@%zu.%06zu:dma_map_wait·"·"dbs=%p"·"\n",

419

············qemu_log("%d@%zu.%06zu:dma_map_wait·"·"dbs=%p"·"\n",

420

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

420

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

421

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

421

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

422

·····················,·dbs);

422

·····················,·dbs);

423

#line·425·"trace/trace-root.h"

423

#line·425·"trace/trace-root.h"

424

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

424

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

426

············qemu_log("dma_map_wait·"·"dbs=%p"·"\n",·dbs);

426

············qemu_log("dma_map_wait·"·"dbs=%p"·"\n",·dbs);

427

#line·429·"trace/trace-root.h"

427

#line·429·"trace/trace-root.h"

428

········}

428

········}

429

····}

429

····}

430

}

430

}

431

static·inline·void·trace_dma_map_wait(void·*·dbs)

431

static·inline·void·trace_dma_map_wait(void·*·dbs)

443

static·inline·void·_nocheck__trace_find_ram_offset(uint64_t·size,·uint64_t·offset)

443

static·inline·void·_nocheck__trace_find_ram_offset(uint64_t·size,·uint64_t·offset)

444

{

444

{

445

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

445

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

446

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

446

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

447

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

447

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

448

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

448

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

450

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

450

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

451

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

451

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

452

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

452

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

453

·····················,·size,·offset);

453

·····················,·size,·offset);

454

#line·456·"trace/trace-root.h"

454

#line·456·"trace/trace-root.h"

455

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

455

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

457

············qemu_log("find_ram_offset·"·"size:·0x%"·PRIx64·"·@·0x%"·PRIx64·"\n",·size,·offset);

457

············qemu_log("find_ram_offset·"·"size:·0x%"·PRIx64·"·@·0x%"·PRIx64·"\n",·size,·offset);

458

#line·460·"trace/trace-root.h"

458

#line·460·"trace/trace-root.h"

459

········}

459

········}

460

····}

460

····}

461

}

461

}

462

static·inline·void·trace_find_ram_offset(uint64_t·size,·uint64_t·offset)

462

static·inline·void·trace_find_ram_offset(uint64_t·size,·uint64_t·offset)

474

static·inline·void·_nocheck__trace_find_ram_offset_loop(uint64_t·size,·uint64_t·candidate,·uint64_t·offset,·uint64_t·next,·uint64_t·mingap)

474

static·inline·void·_nocheck__trace_find_ram_offset_loop(uint64_t·size,·uint64_t·candidate,·uint64_t·offset,·uint64_t·next,·uint64_t·mingap)

475

{

475

{

476

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

476

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

477

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

477

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

478

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

478

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

479

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

479

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

481

············qemu_log("%d@%zu.%06zu:find_ram_offset_loop·"·"trying·size:·0x%"·PRIx64·"·@·0x%"·PRIx64·",·offset:·0x%"·PRIx64"·next:·0x%"·PRIx64·"·mingap:·0x%"·PRIx64·"\n",

481

············qemu_log("%d@%zu.%06zu:find_ram_offset_loop·"·"trying·size:·0x%"·PRIx64·"·@·0x%"·PRIx64·",·offset:·0x%"·PRIx64"·next:·0x%"·PRIx64·"·mingap:·0x%"·PRIx64·"\n",

482

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

482

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

483

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

483

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

484

·····················,·size,·candidate,·offset,·next,·mingap);

484

·····················,·size,·candidate,·offset,·next,·mingap);

485

#line·487·"trace/trace-root.h"

485

#line·487·"trace/trace-root.h"

486

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

486

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

488

············qemu_log("find_ram_offset_loop·"·"trying·size:·0x%"·PRIx64·"·@·0x%"·PRIx64·",·offset:·0x%"·PRIx64"·next:·0x%"·PRIx64·"·mingap:·0x%"·PRIx64·"\n",·size,·candidate,·offset,·next,·mingap);

488

············qemu_log("find_ram_offset_loop·"·"trying·size:·0x%"·PRIx64·"·@·0x%"·PRIx64·",·offset:·0x%"·PRIx64"·next:·0x%"·PRIx64·"·mingap:·0x%"·PRIx64·"\n",·size,·candidate,·offset,·next,·mingap);

489

#line·491·"trace/trace-root.h"

489

#line·491·"trace/trace-root.h"

490

········}

490

········}

491

····}

491

····}

492

}

492

}

493

static·inline·void·trace_find_ram_offset_loop(uint64_t·size,·uint64_t·candidate,·uint64_t·offset,·uint64_t·next,·uint64_t·mingap)

493

static·inline·void·trace_find_ram_offset_loop(uint64_t·size,·uint64_t·candidate,·uint64_t·offset,·uint64_t·next,·uint64_t·mingap)

505

static·inline·void·_nocheck__trace_ram_block_discard_range(const·char·*·rbname,·void·*·hva,·size_t·length,·bool·need_madvise,·bool·need_fallocate,·int·ret)

505

static·inline·void·_nocheck__trace_ram_block_discard_range(const·char·*·rbname,·void·*·hva,·size_t·length,·bool·need_madvise,·bool·need_fallocate,·int·ret)

506

{

506

{

507

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

507

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

508

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

508

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

509

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

509

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

510

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

510

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

512

············qemu_log("%d@%zu.%06zu:ram_block_discard_range·"·"%s@%p·+·0x%zx:·madvise:·%d·fallocate:·%d·ret:·%d"·"\n",

512

············qemu_log("%d@%zu.%06zu:ram_block_discard_range·"·"%s@%p·+·0x%zx:·madvise:·%d·fallocate:·%d·ret:·%d"·"\n",

513

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

513

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

514

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

514

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

515

·····················,·rbname,·hva,·length,·need_madvise,·need_fallocate,·ret);

515

·····················,·rbname,·hva,·length,·need_madvise,·need_fallocate,·ret);

516

#line·518·"trace/trace-root.h"

516

#line·518·"trace/trace-root.h"

517

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

517

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

519

············qemu_log("ram_block_discard_range·"·"%s@%p·+·0x%zx:·madvise:·%d·fallocate:·%d·ret:·%d"·"\n",·rbname,·hva,·length,·need_madvise,·need_fallocate,·ret);

519

············qemu_log("ram_block_discard_range·"·"%s@%p·+·0x%zx:·madvise:·%d·fallocate:·%d·ret:·%d"·"\n",·rbname,·hva,·length,·need_madvise,·need_fallocate,·ret);

520

#line·522·"trace/trace-root.h"

520

#line·522·"trace/trace-root.h"

521

········}

521

········}

522

····}

522

····}

523

}

523

}

524

static·inline·void·trace_ram_block_discard_range(const·char·*·rbname,·void·*·hva,·size_t·length,·bool·need_madvise,·bool·need_fallocate,·int·ret)

524

static·inline·void·trace_ram_block_discard_range(const·char·*·rbname,·void·*·hva,·size_t·length,·bool·need_madvise,·bool·need_fallocate,·int·ret)

536

static·inline·void·_nocheck__trace_memory_notdirty_write_access(uint64_t·vaddr,·uint64_t·ram_addr,·unsigned·size)

536

static·inline·void·_nocheck__trace_memory_notdirty_write_access(uint64_t·vaddr,·uint64_t·ram_addr,·unsigned·size)

537

{

537

{

538

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

538

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

539

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

539

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

540

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

540

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

541

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

541

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

543

············qemu_log("%d@%zu.%06zu:memory_notdirty_write_access·"·"0x%"·PRIx64·"·ram_addr·0x%"·PRIx64·"·size·%u"·"\n",

543

············qemu_log("%d@%zu.%06zu:memory_notdirty_write_access·"·"0x%"·PRIx64·"·ram_addr·0x%"·PRIx64·"·size·%u"·"\n",

544

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

544

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

545

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

545

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

546

·····················,·vaddr,·ram_addr,·size);

546

·····················,·vaddr,·ram_addr,·size);

547

#line·549·"trace/trace-root.h"

547

#line·549·"trace/trace-root.h"

548

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

548

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

550

············qemu_log("memory_notdirty_write_access·"·"0x%"·PRIx64·"·ram_addr·0x%"·PRIx64·"·size·%u"·"\n",·vaddr,·ram_addr,·size);

550

············qemu_log("memory_notdirty_write_access·"·"0x%"·PRIx64·"·ram_addr·0x%"·PRIx64·"·size·%u"·"\n",·vaddr,·ram_addr,·size);

551

#line·553·"trace/trace-root.h"

551

#line·553·"trace/trace-root.h"

552

········}

552

········}

553

····}

553

····}

554

}

554

}

555

static·inline·void·trace_memory_notdirty_write_access(uint64_t·vaddr,·uint64_t·ram_addr,·unsigned·size)

555

static·inline·void·trace_memory_notdirty_write_access(uint64_t·vaddr,·uint64_t·ram_addr,·unsigned·size)

567

static·inline·void·_nocheck__trace_memory_notdirty_set_dirty(uint64_t·vaddr)

567

static·inline·void·_nocheck__trace_memory_notdirty_set_dirty(uint64_t·vaddr)

568

{

568

{

569

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

569

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

570

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

570

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

571

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

571

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

572

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

572

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

574

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

574

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

575

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

575

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

576

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

576

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

577

·····················,·vaddr);

577

·····················,·vaddr);

578

#line·580·"trace/trace-root.h"

578

#line·580·"trace/trace-root.h"

579

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

579

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

581

············qemu_log("memory_notdirty_set_dirty·"·"0x%"·PRIx64·"\n",·vaddr);

581

············qemu_log("memory_notdirty_set_dirty·"·"0x%"·PRIx64·"\n",·vaddr);

582

#line·584·"trace/trace-root.h"

582

#line·584·"trace/trace-root.h"

583

········}

583

········}

584

····}

584

····}

585

}

585

}

586

static·inline·void·trace_memory_notdirty_set_dirty(uint64_t·vaddr)

586

static·inline·void·trace_memory_notdirty_set_dirty(uint64_t·vaddr)

598

static·inline·void·_nocheck__trace_gdbstub_op_start(const·char·*·device)

598

static·inline·void·_nocheck__trace_gdbstub_op_start(const·char·*·device)

599

{

599

{

600

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

600

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

601

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

601

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

602

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

602

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

603

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

603

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

605

············qemu_log("%d@%zu.%06zu:gdbstub_op_start·"·"Starting·gdbstub·using·device·%s"·"\n",

605

············qemu_log("%d@%zu.%06zu:gdbstub_op_start·"·"Starting·gdbstub·using·device·%s"·"\n",

606

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

606

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

607

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

607

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

608

·····················,·device);

608

·····················,·device);

609

#line·611·"trace/trace-root.h"

609

#line·611·"trace/trace-root.h"

610

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

610

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

612

············qemu_log("gdbstub_op_start·"·"Starting·gdbstub·using·device·%s"·"\n",·device);

612

············qemu_log("gdbstub_op_start·"·"Starting·gdbstub·using·device·%s"·"\n",·device);

613

#line·615·"trace/trace-root.h"

613

#line·615·"trace/trace-root.h"

614

········}

614

········}

615

····}

615

····}

616

}

616

}

617

static·inline·void·trace_gdbstub_op_start(const·char·*·device)

617

static·inline·void·trace_gdbstub_op_start(const·char·*·device)

629

static·inline·void·_nocheck__trace_gdbstub_op_exiting(uint8_t·code)

629

static·inline·void·_nocheck__trace_gdbstub_op_exiting(uint8_t·code)

630

{

630

{

631

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

631

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

632

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

632

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

633

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

633

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

634

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

634

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

636

············qemu_log("%d@%zu.%06zu:gdbstub_op_exiting·"·"notifying·exit·with·code=0x%02x"·"\n",

636

············qemu_log("%d@%zu.%06zu:gdbstub_op_exiting·"·"notifying·exit·with·code=0x%02x"·"\n",

637

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

637

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

638

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

638

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

639

·····················,·code);

639

·····················,·code);

640

#line·642·"trace/trace-root.h"

640

#line·642·"trace/trace-root.h"

641

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

641

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

643

············qemu_log("gdbstub_op_exiting·"·"notifying·exit·with·code=0x%02x"·"\n",·code);

643

············qemu_log("gdbstub_op_exiting·"·"notifying·exit·with·code=0x%02x"·"\n",·code);

644

#line·646·"trace/trace-root.h"

644

#line·646·"trace/trace-root.h"

645

········}

645

········}

646

····}

646

····}

647

}

647

}

648

static·inline·void·trace_gdbstub_op_exiting(uint8_t·code)

648

static·inline·void·trace_gdbstub_op_exiting(uint8_t·code)

660

static·inline·void·_nocheck__trace_gdbstub_op_continue(void)

660

static·inline·void·_nocheck__trace_gdbstub_op_continue(void)

661

{

661

{

662

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

662

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

663

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

663

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

664

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

664

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

665

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

665

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

667

············qemu_log("%d@%zu.%06zu:gdbstub_op_continue·"·"Continuing·all·CPUs"·"\n",

667

············qemu_log("%d@%zu.%06zu:gdbstub_op_continue·"·"Continuing·all·CPUs"·"\n",

668

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

668

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

669

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

669

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

670

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

670

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

671

#line·673·"trace/trace-root.h"

671

#line·673·"trace/trace-root.h"

672

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

672

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

674

············qemu_log("gdbstub_op_continue·"·"Continuing·all·CPUs"·"\n");

674

············qemu_log("gdbstub_op_continue·"·"Continuing·all·CPUs"·"\n");

675

#line·677·"trace/trace-root.h"

675

#line·677·"trace/trace-root.h"

676

········}

676

········}

677

····}

677

····}

678

}

678

}

679

static·inline·void·trace_gdbstub_op_continue(void)

679

static·inline·void·trace_gdbstub_op_continue(void)

691

static·inline·void·_nocheck__trace_gdbstub_op_continue_cpu(int·cpu_index)

691

static·inline·void·_nocheck__trace_gdbstub_op_continue_cpu(int·cpu_index)

692

{

692

{

693

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

693

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

694

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

694

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

695

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

695

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

696

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

696

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

698

············qemu_log("%d@%zu.%06zu:gdbstub_op_continue_cpu·"·"Continuing·CPU·%d"·"\n",

698

············qemu_log("%d@%zu.%06zu:gdbstub_op_continue_cpu·"·"Continuing·CPU·%d"·"\n",

699

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

699

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

700

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

700

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

701

·····················,·cpu_index);

701

·····················,·cpu_index);

702

#line·704·"trace/trace-root.h"

702

#line·704·"trace/trace-root.h"

703

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

703

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

705

············qemu_log("gdbstub_op_continue_cpu·"·"Continuing·CPU·%d"·"\n",·cpu_index);

705

············qemu_log("gdbstub_op_continue_cpu·"·"Continuing·CPU·%d"·"\n",·cpu_index);

706

#line·708·"trace/trace-root.h"

706

#line·708·"trace/trace-root.h"

707

········}

707

········}

708

····}

708

····}

709

}

709

}

710

static·inline·void·trace_gdbstub_op_continue_cpu(int·cpu_index)

710

static·inline·void·trace_gdbstub_op_continue_cpu(int·cpu_index)

722

static·inline·void·_nocheck__trace_gdbstub_op_stepping(int·cpu_index)

722

static·inline·void·_nocheck__trace_gdbstub_op_stepping(int·cpu_index)

723

{

723

{

724

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

724

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

725

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

725

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

726

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

726

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

727

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

727

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

729

············qemu_log("%d@%zu.%06zu:gdbstub_op_stepping·"·"Stepping·CPU·%d"·"\n",

729

············qemu_log("%d@%zu.%06zu:gdbstub_op_stepping·"·"Stepping·CPU·%d"·"\n",

730

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

730

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

731

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

731

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

732

·····················,·cpu_index);

732

·····················,·cpu_index);

733

#line·735·"trace/trace-root.h"

733

#line·735·"trace/trace-root.h"

734

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

734

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

736

············qemu_log("gdbstub_op_stepping·"·"Stepping·CPU·%d"·"\n",·cpu_index);

736

············qemu_log("gdbstub_op_stepping·"·"Stepping·CPU·%d"·"\n",·cpu_index);

737

#line·739·"trace/trace-root.h"

737

#line·739·"trace/trace-root.h"

738

········}

738

········}

739

····}

739

····}

740

}

740

}

741

static·inline·void·trace_gdbstub_op_stepping(int·cpu_index)

741

static·inline·void·trace_gdbstub_op_stepping(int·cpu_index)

753

static·inline·void·_nocheck__trace_gdbstub_op_extra_info(const·char·*·info)

753

static·inline·void·_nocheck__trace_gdbstub_op_extra_info(const·char·*·info)

754

{

754

{

755

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

755

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

756

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

756

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

757

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

757

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

758

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

758

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

760

············qemu_log("%d@%zu.%06zu:gdbstub_op_extra_info·"·"Thread·extra·info:·%s"·"\n",

760

············qemu_log("%d@%zu.%06zu:gdbstub_op_extra_info·"·"Thread·extra·info:·%s"·"\n",

761

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

761

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

762

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

762

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

763

·····················,·info);

763

·····················,·info);

764

#line·766·"trace/trace-root.h"

764

#line·766·"trace/trace-root.h"

765

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

765

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

767

············qemu_log("gdbstub_op_extra_info·"·"Thread·extra·info:·%s"·"\n",·info);

767

············qemu_log("gdbstub_op_extra_info·"·"Thread·extra·info:·%s"·"\n",·info);

768

#line·770·"trace/trace-root.h"

768

#line·770·"trace/trace-root.h"

769

········}

769

········}

770

····}

770

····}

771

}

771

}

772

static·inline·void·trace_gdbstub_op_extra_info(const·char·*·info)

772

static·inline·void·trace_gdbstub_op_extra_info(const·char·*·info)

784

static·inline·void·_nocheck__trace_gdbstub_hit_watchpoint(const·char·*·type,·int·cpu_gdb_index,·uint64_t·vaddr)

784

static·inline·void·_nocheck__trace_gdbstub_hit_watchpoint(const·char·*·type,·int·cpu_gdb_index,·uint64_t·vaddr)

785

{

785

{

786

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

786

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

787

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

787

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

788

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

788

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

789

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

789

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

791

············qemu_log("%d@%zu.%06zu:gdbstub_hit_watchpoint·"·"Watchpoint·hit,·type=\"%s\"·cpu=%d,·vaddr=0x%"·PRIx64·""·"\n",

791

············qemu_log("%d@%zu.%06zu:gdbstub_hit_watchpoint·"·"Watchpoint·hit,·type=\"%s\"·cpu=%d,·vaddr=0x%"·PRIx64·""·"\n",

792

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

792

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

793

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

793

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

794

·····················,·type,·cpu_gdb_index,·vaddr);

794

·····················,·type,·cpu_gdb_index,·vaddr);

795

#line·797·"trace/trace-root.h"

795

#line·797·"trace/trace-root.h"

796

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

796

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

798

············qemu_log("gdbstub_hit_watchpoint·"·"Watchpoint·hit,·type=\"%s\"·cpu=%d,·vaddr=0x%"·PRIx64·""·"\n",·type,·cpu_gdb_index,·vaddr);

798

············qemu_log("gdbstub_hit_watchpoint·"·"Watchpoint·hit,·type=\"%s\"·cpu=%d,·vaddr=0x%"·PRIx64·""·"\n",·type,·cpu_gdb_index,·vaddr);

799

#line·801·"trace/trace-root.h"

799

#line·801·"trace/trace-root.h"

800

········}

800

········}

801

····}

801

····}

802

}

802

}

803

static·inline·void·trace_gdbstub_hit_watchpoint(const·char·*·type,·int·cpu_gdb_index,·uint64_t·vaddr)

803

static·inline·void·trace_gdbstub_hit_watchpoint(const·char·*·type,·int·cpu_gdb_index,·uint64_t·vaddr)

815

static·inline·void·_nocheck__trace_gdbstub_hit_internal_error(void)

815

static·inline·void·_nocheck__trace_gdbstub_hit_internal_error(void)

816

{

816

{

817

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

817

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

818

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

818

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

819

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

819

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

820

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

820

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

822

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

822

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

823

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

823

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

824

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

824

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

825

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

825

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

826

#line·828·"trace/trace-root.h"

826

#line·828·"trace/trace-root.h"

827

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

827

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

829

············qemu_log("gdbstub_hit_internal_error·"·"RUN_STATE_INTERNAL_ERROR"·"\n");

829

············qemu_log("gdbstub_hit_internal_error·"·"RUN_STATE_INTERNAL_ERROR"·"\n");

830

#line·832·"trace/trace-root.h"

830

#line·832·"trace/trace-root.h"

831

········}

831

········}

832

····}

832

····}

833

}

833

}

834

static·inline·void·trace_gdbstub_hit_internal_error(void)

834

static·inline·void·trace_gdbstub_hit_internal_error(void)

846

static·inline·void·_nocheck__trace_gdbstub_hit_break(void)

846

static·inline·void·_nocheck__trace_gdbstub_hit_break(void)

847

{

847

{

848

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

848

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

849

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

849

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

850

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

850

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

851

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

851

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

853

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

853

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

854

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

854

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

855

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

855

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

856

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

856

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

857

#line·859·"trace/trace-root.h"

857

#line·859·"trace/trace-root.h"

858

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

858

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

860

············qemu_log("gdbstub_hit_break·"·"RUN_STATE_DEBUG"·"\n");

860

············qemu_log("gdbstub_hit_break·"·"RUN_STATE_DEBUG"·"\n");

861

#line·863·"trace/trace-root.h"

861

#line·863·"trace/trace-root.h"

862

········}

862

········}

863

····}

863

····}

864

}

864

}

865

static·inline·void·trace_gdbstub_hit_break(void)

865

static·inline·void·trace_gdbstub_hit_break(void)

877

static·inline·void·_nocheck__trace_gdbstub_hit_paused(void)

877

static·inline·void·_nocheck__trace_gdbstub_hit_paused(void)

878

{

878

{

879

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

879

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

880

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

880

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

881

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

881

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

882

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

882

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

884

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

884

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

885

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

885

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

886

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

886

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

887

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

887

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

888

#line·890·"trace/trace-root.h"

888

#line·890·"trace/trace-root.h"

889

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

889

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

891

············qemu_log("gdbstub_hit_paused·"·"RUN_STATE_PAUSED"·"\n");

891

············qemu_log("gdbstub_hit_paused·"·"RUN_STATE_PAUSED"·"\n");

892

#line·894·"trace/trace-root.h"

892

#line·894·"trace/trace-root.h"

893

········}

893

········}

894

····}

894

····}

895

}

895

}

896

static·inline·void·trace_gdbstub_hit_paused(void)

896

static·inline·void·trace_gdbstub_hit_paused(void)

908

static·inline·void·_nocheck__trace_gdbstub_hit_shutdown(void)

908

static·inline·void·_nocheck__trace_gdbstub_hit_shutdown(void)

909

{

909

{

910

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

910

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

911

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

911

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

912

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

912

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

913

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

913

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

915

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

915

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

916

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

916

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

917

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

917

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

918

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

918

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

919

#line·921·"trace/trace-root.h"

919

#line·921·"trace/trace-root.h"

920

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

920

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

922

············qemu_log("gdbstub_hit_shutdown·"·"RUN_STATE_SHUTDOWN"·"\n");

922

············qemu_log("gdbstub_hit_shutdown·"·"RUN_STATE_SHUTDOWN"·"\n");

923

#line·925·"trace/trace-root.h"

923

#line·925·"trace/trace-root.h"

924

········}

924

········}

925

····}

925

····}

926

}

926

}

927

static·inline·void·trace_gdbstub_hit_shutdown(void)

927

static·inline·void·trace_gdbstub_hit_shutdown(void)

939

static·inline·void·_nocheck__trace_gdbstub_hit_io_error(void)

939

static·inline·void·_nocheck__trace_gdbstub_hit_io_error(void)

940

{

940

{

941

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

941

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

942

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

942

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

943

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

943

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

944

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

944

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

946

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

946

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

947

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

947

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

948

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

948

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

949

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

949

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

950

#line·952·"trace/trace-root.h"

950

#line·952·"trace/trace-root.h"

951

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

951

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

953

············qemu_log("gdbstub_hit_io_error·"·"RUN_STATE_IO_ERROR"·"\n");

953

············qemu_log("gdbstub_hit_io_error·"·"RUN_STATE_IO_ERROR"·"\n");

954

#line·956·"trace/trace-root.h"

954

#line·956·"trace/trace-root.h"

955

········}

955

········}

956

····}

956

····}

957

}

957

}

958

static·inline·void·trace_gdbstub_hit_io_error(void)

958

static·inline·void·trace_gdbstub_hit_io_error(void)

970

static·inline·void·_nocheck__trace_gdbstub_hit_watchdog(void)

970

static·inline·void·_nocheck__trace_gdbstub_hit_watchdog(void)

971

{

971

{

972

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

972

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

973

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

973

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

974

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

974

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

975

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

975

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

977

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

977

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

978

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

978

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

979

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

979

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

980

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

980

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

981

#line·983·"trace/trace-root.h"

981

#line·983·"trace/trace-root.h"

982

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

982

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

984

············qemu_log("gdbstub_hit_watchdog·"·"RUN_STATE_WATCHDOG"·"\n");

984

············qemu_log("gdbstub_hit_watchdog·"·"RUN_STATE_WATCHDOG"·"\n");

985

#line·987·"trace/trace-root.h"

985

#line·987·"trace/trace-root.h"

986

········}

986

········}

987

····}

987

····}

988

}

988

}

989

static·inline·void·trace_gdbstub_hit_watchdog(void)

989

static·inline·void·trace_gdbstub_hit_watchdog(void)

1001

static·inline·void·_nocheck__trace_gdbstub_hit_unknown(int·state)

1001

static·inline·void·_nocheck__trace_gdbstub_hit_unknown(int·state)

1002

{

1002

{

1003

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

1003

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

1004

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

1004

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

1005

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

1005

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

1006

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

1006

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

1008

············qemu_log("%d@%zu.%06zu:gdbstub_hit_unknown·"·"Unknown·run·state=0x%x"·"\n",

1008

············qemu_log("%d@%zu.%06zu:gdbstub_hit_unknown·"·"Unknown·run·state=0x%x"·"\n",

1009

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

1009

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

1010

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

1010

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

1011

·····················,·state);

1011

·····················,·state);

1012

#line·1014·"trace/trace-root.h"

1012

#line·1014·"trace/trace-root.h"

1013

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

1013

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

1015

············qemu_log("gdbstub_hit_unknown·"·"Unknown·run·state=0x%x"·"\n",·state);

1015

············qemu_log("gdbstub_hit_unknown·"·"Unknown·run·state=0x%x"·"\n",·state);

1016

#line·1018·"trace/trace-root.h"

1016

#line·1018·"trace/trace-root.h"

1017

········}

1017

········}

1018

····}

1018

····}

1019

}

1019

}

1020

static·inline·void·trace_gdbstub_hit_unknown(int·state)

1020

static·inline·void·trace_gdbstub_hit_unknown(int·state)

1032

static·inline·void·_nocheck__trace_gdbstub_io_reply(const·char·*·message)

1032

static·inline·void·_nocheck__trace_gdbstub_io_reply(const·char·*·message)

1033

{

1033

{

1034

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

1034

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

1035

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

1035

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

1036

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

1036

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

1037

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

1037

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

1039

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

1039

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

1040

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

1040

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

1041

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

1041

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

1042

·····················,·message);

1042

·····················,·message);

1043

#line·1045·"trace/trace-root.h"

1043

#line·1045·"trace/trace-root.h"

1044

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

1044

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

1046

············qemu_log("gdbstub_io_reply·"·"Sent:·%s"·"\n",·message);

1046

············qemu_log("gdbstub_io_reply·"·"Sent:·%s"·"\n",·message);

1047

#line·1049·"trace/trace-root.h"

1047

#line·1049·"trace/trace-root.h"

1048

········}

1048

········}

1049

····}

1049

····}

1050

}

1050

}

1051

static·inline·void·trace_gdbstub_io_reply(const·char·*·message)

1051

static·inline·void·trace_gdbstub_io_reply(const·char·*·message)

1063

static·inline·void·_nocheck__trace_gdbstub_io_binaryreply(size_t·ofs,·const·char·*·line)

1063

static·inline·void·_nocheck__trace_gdbstub_io_binaryreply(size_t·ofs,·const·char·*·line)

1064

{

1064

{

1065

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

1065

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

1066

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

1066

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

1067

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

1067

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

1068

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

1068

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

1070

············qemu_log("%d@%zu.%06zu:gdbstub_io_binaryreply·"·"0x%04zx:·%s"·"\n",

1070

············qemu_log("%d@%zu.%06zu:gdbstub_io_binaryreply·"·"0x%04zx:·%s"·"\n",

1071

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

1071

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

1072

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

1072

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

1073

·····················,·ofs,·line);

1073

·····················,·ofs,·line);

1074

#line·1076·"trace/trace-root.h"

1074

#line·1076·"trace/trace-root.h"

1075

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

1075

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

1077

············qemu_log("gdbstub_io_binaryreply·"·"0x%04zx:·%s"·"\n",·ofs,·line);

1077

············qemu_log("gdbstub_io_binaryreply·"·"0x%04zx:·%s"·"\n",·ofs,·line);

1078

#line·1080·"trace/trace-root.h"

1078

#line·1080·"trace/trace-root.h"

1079

········}

1079

········}

1080

····}

1080

····}

1081

}

1081

}

1082

static·inline·void·trace_gdbstub_io_binaryreply(size_t·ofs,·const·char·*·line)

1082

static·inline·void·trace_gdbstub_io_binaryreply(size_t·ofs,·const·char·*·line)

1094

static·inline·void·_nocheck__trace_gdbstub_io_command(const·char·*·command)

1094

static·inline·void·_nocheck__trace_gdbstub_io_command(const·char·*·command)

1095

{

1095

{

1096

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

1096

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

1097

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

1097

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

1098

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

1098

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

1099

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

1099

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

1101

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

1101

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

1102

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

1102

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

1103

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

1103

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

1104

·····················,·command);

1104

·····················,·command);

1105

#line·1107·"trace/trace-root.h"

1105

#line·1107·"trace/trace-root.h"

1106

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

1106

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

1108

············qemu_log("gdbstub_io_command·"·"Received:·%s"·"\n",·command);

1108

············qemu_log("gdbstub_io_command·"·"Received:·%s"·"\n",·command);

1109

#line·1111·"trace/trace-root.h"

1109

#line·1111·"trace/trace-root.h"

1110

········}

1110

········}

1111

····}

1111

····}

1112

}

1112

}

1113

static·inline·void·trace_gdbstub_io_command(const·char·*·command)

1113

static·inline·void·trace_gdbstub_io_command(const·char·*·command)

1125

static·inline·void·_nocheck__trace_gdbstub_io_got_ack(void)

1125

static·inline·void·_nocheck__trace_gdbstub_io_got_ack(void)

1126

{

1126

{

1127

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

1127

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

1128

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

1128

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

1129

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

1129

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

1130

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

1130

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

1132

············qemu_log("%d@%zu.%06zu:gdbstub_io_got_ack·"·"Got·ACK"·"\n",

1132

············qemu_log("%d@%zu.%06zu:gdbstub_io_got_ack·"·"Got·ACK"·"\n",

1133

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

1133

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

1134

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

1134

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

1135

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

1135

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

1136

#line·1138·"trace/trace-root.h"

1136

#line·1138·"trace/trace-root.h"

1137

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

1137

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

1139

············qemu_log("gdbstub_io_got_ack·"·"Got·ACK"·"\n");

1139

············qemu_log("gdbstub_io_got_ack·"·"Got·ACK"·"\n");

1140

#line·1142·"trace/trace-root.h"

1140

#line·1142·"trace/trace-root.h"

1141

········}

1141

········}

1142

····}

1142

····}

1143

}

1143

}

1144

static·inline·void·trace_gdbstub_io_got_ack(void)

1144

static·inline·void·trace_gdbstub_io_got_ack(void)

1156

static·inline·void·_nocheck__trace_gdbstub_io_got_unexpected(uint8_t·ch)

1156

static·inline·void·_nocheck__trace_gdbstub_io_got_unexpected(uint8_t·ch)

1157

{

1157

{

1158

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

1158

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

1159

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

1159

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

1160

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

1160

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

1161

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

1161

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

1163

············qemu_log("%d@%zu.%06zu:gdbstub_io_got_unexpected·"·"Got·0x%02x·when·expecting·ACK/NACK"·"\n",

1163

············qemu_log("%d@%zu.%06zu:gdbstub_io_got_unexpected·"·"Got·0x%02x·when·expecting·ACK/NACK"·"\n",

1164

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

1164

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

1165

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

1165

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

1166

·····················,·ch);

1166

·····················,·ch);

1167

#line·1169·"trace/trace-root.h"

1167

#line·1169·"trace/trace-root.h"

1168

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

1168

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

1170

············qemu_log("gdbstub_io_got_unexpected·"·"Got·0x%02x·when·expecting·ACK/NACK"·"\n",·ch);

1170

············qemu_log("gdbstub_io_got_unexpected·"·"Got·0x%02x·when·expecting·ACK/NACK"·"\n",·ch);

1171

#line·1173·"trace/trace-root.h"

1171

#line·1173·"trace/trace-root.h"

1172

········}

1172

········}

1173

····}

1173

····}

1174

}

1174

}

1175

static·inline·void·trace_gdbstub_io_got_unexpected(uint8_t·ch)

1175

static·inline·void·trace_gdbstub_io_got_unexpected(uint8_t·ch)

1187

static·inline·void·_nocheck__trace_gdbstub_err_got_nack(void)

1187

static·inline·void·_nocheck__trace_gdbstub_err_got_nack(void)

1188

{

1188

{

1189

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

1189

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

1190

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

1190

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

1191

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

1191

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

1192

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

1192

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

1194

············qemu_log("%d@%zu.%06zu:gdbstub_err_got_nack·"·"Got·NACK,·retransmitting"·"\n",

1194

············qemu_log("%d@%zu.%06zu:gdbstub_err_got_nack·"·"Got·NACK,·retransmitting"·"\n",

1195

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

1195

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

1196

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

1196

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

1197

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

1197

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

1198

#line·1200·"trace/trace-root.h"

1198

#line·1200·"trace/trace-root.h"

1199

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

1199

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

1201

············qemu_log("gdbstub_err_got_nack·"·"Got·NACK,·retransmitting"·"\n");

1201

············qemu_log("gdbstub_err_got_nack·"·"Got·NACK,·retransmitting"·"\n");

1202

#line·1204·"trace/trace-root.h"

1202

#line·1204·"trace/trace-root.h"

1203

········}

1203

········}

1204

····}

1204

····}

1205

}

1205

}

1206

static·inline·void·trace_gdbstub_err_got_nack(void)

1206

static·inline·void·trace_gdbstub_err_got_nack(void)

1218

static·inline·void·_nocheck__trace_gdbstub_err_garbage(uint8_t·ch)

1218

static·inline·void·_nocheck__trace_gdbstub_err_garbage(uint8_t·ch)

1219

{

1219

{

1220

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

1220

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

1221

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

1221

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

1222

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

1222

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

1223

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

1223

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

1225

············qemu_log("%d@%zu.%06zu:gdbstub_err_garbage·"·"received·garbage·between·packets:·0x%02x"·"\n",

1225

············qemu_log("%d@%zu.%06zu:gdbstub_err_garbage·"·"received·garbage·between·packets:·0x%02x"·"\n",

1226

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

1226

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

1227

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

1227

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

1228

·····················,·ch);

1228

·····················,·ch);

1229

#line·1231·"trace/trace-root.h"

1229

#line·1231·"trace/trace-root.h"

1230

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

1230

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

1232

············qemu_log("gdbstub_err_garbage·"·"received·garbage·between·packets:·0x%02x"·"\n",·ch);

1232

············qemu_log("gdbstub_err_garbage·"·"received·garbage·between·packets:·0x%02x"·"\n",·ch);

1233

#line·1235·"trace/trace-root.h"

1233

#line·1235·"trace/trace-root.h"

1234

········}

1234

········}

1235

····}

1235

····}

1236

}

1236

}

1237

static·inline·void·trace_gdbstub_err_garbage(uint8_t·ch)

1237

static·inline·void·trace_gdbstub_err_garbage(uint8_t·ch)

1249

static·inline·void·_nocheck__trace_gdbstub_err_overrun(void)

1249

static·inline·void·_nocheck__trace_gdbstub_err_overrun(void)

1250

{

1250

{

1251

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

1251

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

1252

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

1252

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

1253

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

1253

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

1254

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

1254

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

1256

············qemu_log("%d@%zu.%06zu:gdbstub_err_overrun·"·"command·buffer·overrun,·dropping·command"·"\n",

1256

············qemu_log("%d@%zu.%06zu:gdbstub_err_overrun·"·"command·buffer·overrun,·dropping·command"·"\n",

1257

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

1257

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

1258

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

1258

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

1259

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

1259

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

1260

#line·1262·"trace/trace-root.h"

1260

#line·1262·"trace/trace-root.h"

1261

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

1261

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

1263

············qemu_log("gdbstub_err_overrun·"·"command·buffer·overrun,·dropping·command"·"\n");

1263

············qemu_log("gdbstub_err_overrun·"·"command·buffer·overrun,·dropping·command"·"\n");

1264

#line·1266·"trace/trace-root.h"

1264

#line·1266·"trace/trace-root.h"

1265

········}

1265

········}

1266

····}

1266

····}

1267

}

1267

}

1268

static·inline·void·trace_gdbstub_err_overrun(void)

1268

static·inline·void·trace_gdbstub_err_overrun(void)

1280

static·inline·void·_nocheck__trace_gdbstub_err_invalid_repeat(uint8_t·ch)

1280

static·inline·void·_nocheck__trace_gdbstub_err_invalid_repeat(uint8_t·ch)

1281

{

1281

{

1282

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

1282

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

1283

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

1283

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

1284

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

1284

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

1285

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

1285

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

1287

············qemu_log("%d@%zu.%06zu:gdbstub_err_invalid_repeat·"·"got·invalid·RLE·count:·0x%02x"·"\n",

1287

············qemu_log("%d@%zu.%06zu:gdbstub_err_invalid_repeat·"·"got·invalid·RLE·count:·0x%02x"·"\n",

1288

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

1288

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

1289

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

1289

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

1290

·····················,·ch);

1290

·····················,·ch);

1291

#line·1293·"trace/trace-root.h"

1291

#line·1293·"trace/trace-root.h"

1292

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

1292

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

1294

············qemu_log("gdbstub_err_invalid_repeat·"·"got·invalid·RLE·count:·0x%02x"·"\n",·ch);

1294

············qemu_log("gdbstub_err_invalid_repeat·"·"got·invalid·RLE·count:·0x%02x"·"\n",·ch);

1295

#line·1297·"trace/trace-root.h"

1295

#line·1297·"trace/trace-root.h"

1296

········}

1296

········}

1297

····}

1297

····}

1298

}

1298

}

1299

static·inline·void·trace_gdbstub_err_invalid_repeat(uint8_t·ch)

1299

static·inline·void·trace_gdbstub_err_invalid_repeat(uint8_t·ch)

1311

static·inline·void·_nocheck__trace_gdbstub_err_invalid_rle(void)

1311

static·inline·void·_nocheck__trace_gdbstub_err_invalid_rle(void)

1312

{

1312

{

1313

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

1313

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

1314

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

1314

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

1315

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

1315

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

1316

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

1316

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

1318

············qemu_log("%d@%zu.%06zu:gdbstub_err_invalid_rle·"·"got·invalid·RLE·sequence"·"\n",

1318

············qemu_log("%d@%zu.%06zu:gdbstub_err_invalid_rle·"·"got·invalid·RLE·sequence"·"\n",

1319

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

1319

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

1320

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

1320

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

1321

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

1321

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

1322

#line·1324·"trace/trace-root.h"

1322

#line·1324·"trace/trace-root.h"

1323

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

1323

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

1325

············qemu_log("gdbstub_err_invalid_rle·"·"got·invalid·RLE·sequence"·"\n");

1325

············qemu_log("gdbstub_err_invalid_rle·"·"got·invalid·RLE·sequence"·"\n");

1326

#line·1328·"trace/trace-root.h"

1326

#line·1328·"trace/trace-root.h"

1327

········}

1327

········}

1328

····}

1328

····}

1329

}

1329

}

1330

static·inline·void·trace_gdbstub_err_invalid_rle(void)

1330

static·inline·void·trace_gdbstub_err_invalid_rle(void)

1342

static·inline·void·_nocheck__trace_gdbstub_err_checksum_invalid(uint8_t·ch)

1342

static·inline·void·_nocheck__trace_gdbstub_err_checksum_invalid(uint8_t·ch)

1343

{

1343

{

1344

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

1344

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

1345

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

1345

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

1346

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

1346

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

1347

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

1347

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

1349

············qemu_log("%d@%zu.%06zu:gdbstub_err_checksum_invalid·"·"got·invalid·command·checksum·digit:·0x%02x"·"\n",

1349

············qemu_log("%d@%zu.%06zu:gdbstub_err_checksum_invalid·"·"got·invalid·command·checksum·digit:·0x%02x"·"\n",

1350

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

1350

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

1351

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

1351

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

1352

·····················,·ch);

1352

·····················,·ch);

1353

#line·1355·"trace/trace-root.h"

1353

#line·1355·"trace/trace-root.h"

1354

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

1354

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

1356

············qemu_log("gdbstub_err_checksum_invalid·"·"got·invalid·command·checksum·digit:·0x%02x"·"\n",·ch);

1356

············qemu_log("gdbstub_err_checksum_invalid·"·"got·invalid·command·checksum·digit:·0x%02x"·"\n",·ch);

1357

#line·1359·"trace/trace-root.h"

1357

#line·1359·"trace/trace-root.h"

1358

········}

1358

········}

1359

····}

1359

····}

1360

}

1360

}

1361

static·inline·void·trace_gdbstub_err_checksum_invalid(uint8_t·ch)

1361

static·inline·void·trace_gdbstub_err_checksum_invalid(uint8_t·ch)

1373

static·inline·void·_nocheck__trace_gdbstub_err_checksum_incorrect(uint8_t·expected,·uint8_t·got)

1373

static·inline·void·_nocheck__trace_gdbstub_err_checksum_incorrect(uint8_t·expected,·uint8_t·got)

1374

{

1374

{

1375

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

1375

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

1376

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

1376

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

1377

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

1377

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

1378

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

1378

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

1380

············qemu_log("%d@%zu.%06zu:gdbstub_err_checksum_incorrect·"·"got·command·packet·with·incorrect·checksum,·expected=0x%02x,·received=0x%02x"·"\n",

1380

············qemu_log("%d@%zu.%06zu:gdbstub_err_checksum_incorrect·"·"got·command·packet·with·incorrect·checksum,·expected=0x%02x,·received=0x%02x"·"\n",

1381

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

1381

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

1382

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

1382

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

1383

·····················,·expected,·got);

1383

·····················,·expected,·got);

1384

#line·1386·"trace/trace-root.h"

1384

#line·1386·"trace/trace-root.h"

1385

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

1385

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

1387

············qemu_log("gdbstub_err_checksum_incorrect·"·"got·command·packet·with·incorrect·checksum,·expected=0x%02x,·received=0x%02x"·"\n",·expected,·got);

1387

············qemu_log("gdbstub_err_checksum_incorrect·"·"got·command·packet·with·incorrect·checksum,·expected=0x%02x,·received=0x%02x"·"\n",·expected,·got);

1388

#line·1390·"trace/trace-root.h"

1388

#line·1390·"trace/trace-root.h"

1389

········}

1389

········}

1390

····}

1390

····}

1391

}

1391

}

1392

static·inline·void·trace_gdbstub_err_checksum_incorrect(uint8_t·expected,·uint8_t·got)

1392

static·inline·void·trace_gdbstub_err_checksum_incorrect(uint8_t·expected,·uint8_t·got)

1404

static·inline·void·_nocheck__trace_job_state_transition(void·*·job,·int·ret,·const·char·*·legal,·const·char·*·s0,·const·char·*·s1)

1404

static·inline·void·_nocheck__trace_job_state_transition(void·*·job,·int·ret,·const·char·*·legal,·const·char·*·s0,·const·char·*·s1)

1405

{

1405

{

1406

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

1406

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

1407

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

1407

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

1408

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

1408

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

1409

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

1409

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

1411

············qemu_log("%d@%zu.%06zu:job_state_transition·"·"job·%p·(ret:·%d)·attempting·%s·transition·(%s-->%s)"·"\n",

1411

············qemu_log("%d@%zu.%06zu:job_state_transition·"·"job·%p·(ret:·%d)·attempting·%s·transition·(%s-->%s)"·"\n",

1412

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

1412

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

1413

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

1413

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

1414

·····················,·job,·ret,·legal,·s0,·s1);

1414

·····················,·job,·ret,·legal,·s0,·s1);

1415

#line·1417·"trace/trace-root.h"

1415

#line·1417·"trace/trace-root.h"

1416

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

1416

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

1418

············qemu_log("job_state_transition·"·"job·%p·(ret:·%d)·attempting·%s·transition·(%s-->%s)"·"\n",·job,·ret,·legal,·s0,·s1);

1418

············qemu_log("job_state_transition·"·"job·%p·(ret:·%d)·attempting·%s·transition·(%s-->%s)"·"\n",·job,·ret,·legal,·s0,·s1);

1419

#line·1421·"trace/trace-root.h"

1419

#line·1421·"trace/trace-root.h"

1420

········}

1420

········}

1421

····}

1421

····}

1422

}

1422

}

1423

static·inline·void·trace_job_state_transition(void·*·job,·int·ret,·const·char·*·legal,·const·char·*·s0,·const·char·*·s1)

1423

static·inline·void·trace_job_state_transition(void·*·job,·int·ret,·const·char·*·legal,·const·char·*·s0,·const·char·*·s1)

1435

static·inline·void·_nocheck__trace_job_apply_verb(void·*·job,·const·char·*·state,·const·char·*·verb,·const·char·*·legal)

1435

static·inline·void·_nocheck__trace_job_apply_verb(void·*·job,·const·char·*·state,·const·char·*·verb,·const·char·*·legal)

1436

{

1436

{

1437

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

1437

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

1438

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

1438

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

1439

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

1439

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

1440

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

1440

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

1442

············qemu_log("%d@%zu.%06zu:job_apply_verb·"·"job·%p·in·state·%s;·applying·verb·%s·(%s)"·"\n",

1442

············qemu_log("%d@%zu.%06zu:job_apply_verb·"·"job·%p·in·state·%s;·applying·verb·%s·(%s)"·"\n",

1443

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

1443

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

1444

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

1444

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

1445

·····················,·job,·state,·verb,·legal);

1445

·····················,·job,·state,·verb,·legal);

1446

#line·1448·"trace/trace-root.h"

1446

#line·1448·"trace/trace-root.h"

1447

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

1447

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

1449

············qemu_log("job_apply_verb·"·"job·%p·in·state·%s;·applying·verb·%s·(%s)"·"\n",·job,·state,·verb,·legal);

1449

············qemu_log("job_apply_verb·"·"job·%p·in·state·%s;·applying·verb·%s·(%s)"·"\n",·job,·state,·verb,·legal);

1450

#line·1452·"trace/trace-root.h"

1450

#line·1452·"trace/trace-root.h"

1451

········}

1451

········}

1452

····}

1452

····}

1453

}

1453

}

1454

static·inline·void·trace_job_apply_verb(void·*·job,·const·char·*·state,·const·char·*·verb,·const·char·*·legal)

1454

static·inline·void·trace_job_apply_verb(void·*·job,·const·char·*·state,·const·char·*·verb,·const·char·*·legal)

1466

static·inline·void·_nocheck__trace_job_completed(void·*·job,·int·ret)

1466

static·inline·void·_nocheck__trace_job_completed(void·*·job,·int·ret)

1467

{

1467

{

1468

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

1468

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

1469

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

1469

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

1470

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

1470

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

1471

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

1471

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

1473

············qemu_log("%d@%zu.%06zu:job_completed·"·"job·%p·ret·%d"·"\n",

1473

············qemu_log("%d@%zu.%06zu:job_completed·"·"job·%p·ret·%d"·"\n",

1474

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

1474

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

1475

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

1475

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

1476

·····················,·job,·ret);

1476

·····················,·job,·ret);

1477

#line·1479·"trace/trace-root.h"

1477

#line·1479·"trace/trace-root.h"

1478

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

1478

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

1480

············qemu_log("job_completed·"·"job·%p·ret·%d"·"\n",·job,·ret);

1480

············qemu_log("job_completed·"·"job·%p·ret·%d"·"\n",·job,·ret);

1481

#line·1483·"trace/trace-root.h"

1481

#line·1483·"trace/trace-root.h"

1482

········}

1482

········}

1483

····}

1483

····}

1484

}

1484

}

1485

static·inline·void·trace_job_completed(void·*·job,·int·ret)

1485

static·inline·void·trace_job_completed(void·*·job,·int·ret)

1497

static·inline·void·_nocheck__trace_qmp_job_cancel(void·*·job)

1497

static·inline·void·_nocheck__trace_qmp_job_cancel(void·*·job)

1498

{

1498

{

1499

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

1499

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

1500

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

1500

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

1501

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

1501

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

1502

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

1502

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

1504

············qemu_log("%d@%zu.%06zu:qmp_job_cancel·"·"job·%p"·"\n",

1504

············qemu_log("%d@%zu.%06zu:qmp_job_cancel·"·"job·%p"·"\n",

1505

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

1505

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

1506

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

1506

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

1507

·····················,·job);

1507

·····················,·job);

1508

#line·1510·"trace/trace-root.h"

1508

#line·1510·"trace/trace-root.h"

1509

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

1509

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

1511

············qemu_log("qmp_job_cancel·"·"job·%p"·"\n",·job);

1511

············qemu_log("qmp_job_cancel·"·"job·%p"·"\n",·job);

1512

#line·1514·"trace/trace-root.h"

1512

#line·1514·"trace/trace-root.h"

1513

········}

1513

········}

1514

····}

1514

····}

1515

}

1515

}

1516

static·inline·void·trace_qmp_job_cancel(void·*·job)

1516

static·inline·void·trace_qmp_job_cancel(void·*·job)

1528

static·inline·void·_nocheck__trace_qmp_job_pause(void·*·job)

1528

static·inline·void·_nocheck__trace_qmp_job_pause(void·*·job)

1529

{

1529

{

1530

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

1530

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

1531

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

1531

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

1532

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

1532

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

1533

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

1533

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

1535

············qemu_log("%d@%zu.%06zu:qmp_job_pause·"·"job·%p"·"\n",

1535

············qemu_log("%d@%zu.%06zu:qmp_job_pause·"·"job·%p"·"\n",

1536

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

1536

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

1537

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

1537

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

1538

·····················,·job);

1538

·····················,·job);

1539

#line·1541·"trace/trace-root.h"

1539

#line·1541·"trace/trace-root.h"

1540

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

1540

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

1542

············qemu_log("qmp_job_pause·"·"job·%p"·"\n",·job);

1542

············qemu_log("qmp_job_pause·"·"job·%p"·"\n",·job);

1543

#line·1545·"trace/trace-root.h"

1543

#line·1545·"trace/trace-root.h"

1544

········}

1544

········}

1545

····}

1545

····}

1546

}

1546

}

1547

static·inline·void·trace_qmp_job_pause(void·*·job)

1547

static·inline·void·trace_qmp_job_pause(void·*·job)

1559

static·inline·void·_nocheck__trace_qmp_job_resume(void·*·job)

1559

static·inline·void·_nocheck__trace_qmp_job_resume(void·*·job)

1560

{

1560

{

1561

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

1561

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

1562

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

1562

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

1563

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

1563

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

1564

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

1564

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

1566

············qemu_log("%d@%zu.%06zu:qmp_job_resume·"·"job·%p"·"\n",

1566

············qemu_log("%d@%zu.%06zu:qmp_job_resume·"·"job·%p"·"\n",

1567

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

1567

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

1568

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

1568

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

1569

·····················,·job);

1569

·····················,·job);

1570

#line·1572·"trace/trace-root.h"

1570

#line·1572·"trace/trace-root.h"

1571

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

1571

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

1573

············qemu_log("qmp_job_resume·"·"job·%p"·"\n",·job);

1573

············qemu_log("qmp_job_resume·"·"job·%p"·"\n",·job);

1574

#line·1576·"trace/trace-root.h"

1574

#line·1576·"trace/trace-root.h"

1575

········}

1575

········}

1576

····}

1576

····}

1577

}

1577

}

1578

static·inline·void·trace_qmp_job_resume(void·*·job)

1578

static·inline·void·trace_qmp_job_resume(void·*·job)

1590

static·inline·void·_nocheck__trace_qmp_job_complete(void·*·job)

1590

static·inline·void·_nocheck__trace_qmp_job_complete(void·*·job)

1591

{

1591

{

1592

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

1592

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

1593

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

1593

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

1594

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

1594

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

1595

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

1595

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

1597

············qemu_log("%d@%zu.%06zu:qmp_job_complete·"·"job·%p"·"\n",

1597

············qemu_log("%d@%zu.%06zu:qmp_job_complete·"·"job·%p"·"\n",

1598

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

1598

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

1599

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

1599

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

1600

·····················,·job);

1600

·····················,·job);

1601

#line·1603·"trace/trace-root.h"

1601

#line·1603·"trace/trace-root.h"

1602

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

1602

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

1604

············qemu_log("qmp_job_complete·"·"job·%p"·"\n",·job);

1604

············qemu_log("qmp_job_complete·"·"job·%p"·"\n",·job);

1605

#line·1607·"trace/trace-root.h"

1605

#line·1607·"trace/trace-root.h"

1606

········}

1606

········}

1607

····}

1607

····}

1608

}

1608

}

1609

static·inline·void·trace_qmp_job_complete(void·*·job)

1609

static·inline·void·trace_qmp_job_complete(void·*·job)

1621

static·inline·void·_nocheck__trace_qmp_job_finalize(void·*·job)

1621

static·inline·void·_nocheck__trace_qmp_job_finalize(void·*·job)

1622

{

1622

{

1623

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

1623

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

1624

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

1624

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

1625

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

1625

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

1626

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

1626

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

1628

············qemu_log("%d@%zu.%06zu:qmp_job_finalize·"·"job·%p"·"\n",

1628

············qemu_log("%d@%zu.%06zu:qmp_job_finalize·"·"job·%p"·"\n",

1629

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

1629

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

1630

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

1630

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

1631

·····················,·job);

1631

·····················,·job);

1632

#line·1634·"trace/trace-root.h"

1632

#line·1634·"trace/trace-root.h"

1633

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

1633

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

1635

············qemu_log("qmp_job_finalize·"·"job·%p"·"\n",·job);

1635

············qemu_log("qmp_job_finalize·"·"job·%p"·"\n",·job);

1636

#line·1638·"trace/trace-root.h"

1636

#line·1638·"trace/trace-root.h"

1637

········}

1637

········}

1638

····}

1638

····}

1639

}

1639

}

1640

static·inline·void·trace_qmp_job_finalize(void·*·job)

1640

static·inline·void·trace_qmp_job_finalize(void·*·job)

1652

static·inline·void·_nocheck__trace_qmp_job_dismiss(void·*·job)

1652

static·inline·void·_nocheck__trace_qmp_job_dismiss(void·*·job)

1653

{

1653

{

1654

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

1654

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

1655

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

1655

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

1656

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

1656

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

1657

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

1657

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

1659

············qemu_log("%d@%zu.%06zu:qmp_job_dismiss·"·"job·%p"·"\n",

1659

············qemu_log("%d@%zu.%06zu:qmp_job_dismiss·"·"job·%p"·"\n",

1660

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

1660

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

1661

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

1661

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

1662

·····················,·job);

1662

·····················,·job);

1663

#line·1665·"trace/trace-root.h"

1663

#line·1665·"trace/trace-root.h"

1664

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

1664

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

1666

············qemu_log("qmp_job_dismiss·"·"job·%p"·"\n",·job);

1666

············qemu_log("qmp_job_dismiss·"·"job·%p"·"\n",·job);

1667

#line·1669·"trace/trace-root.h"

1667

#line·1669·"trace/trace-root.h"

1668

········}

1668

········}

1669

····}

1669

····}

1670

}

1670

}

1671

static·inline·void·trace_qmp_job_dismiss(void·*·job)

1671

static·inline·void·trace_qmp_job_dismiss(void·*·job)

1683

static·inline·void·_nocheck__trace_guest_cpu_enter(void·*·__cpu)

1683

static·inline·void·_nocheck__trace_guest_cpu_enter(void·*·__cpu)

1684

{

1684

{

1685

····if·(true·&&·qemu_loglevel_mask(LOG_TRACE))·{

1685

····if·(true·&&·qemu_loglevel_mask(LOG_TRACE))·{

1686

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

1686

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

1687

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

1687

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

1688

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

1688

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

1690

············qemu_log("%d@%zu.%06zu:guest_cpu_enter·"·"cpu=%p·"·"\n",

1690

············qemu_log("%d@%zu.%06zu:guest_cpu_enter·"·"cpu=%p·"·"\n",

1691

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

1691

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

1692

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

1692

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

1693

·····················,·__cpu);

1693

·····················,·__cpu);

1694

#line·1696·"trace/trace-root.h"

1694

#line·1696·"trace/trace-root.h"

1695

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

1695

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

1697

············qemu_log("guest_cpu_enter·"·"cpu=%p·"·"\n",·__cpu);

1697

············qemu_log("guest_cpu_enter·"·"cpu=%p·"·"\n",·__cpu);

1698

#line·1700·"trace/trace-root.h"

1698

#line·1700·"trace/trace-root.h"

1699

········}

1699

········}

1700

····}

1700

····}

1701

}

1701

}

1702

static·inline·void·trace_guest_cpu_enter(void·*·__cpu)

1702

static·inline·void·trace_guest_cpu_enter(void·*·__cpu)

1714

static·inline·void·_nocheck__trace_guest_cpu_exit(void·*·__cpu)

1714

static·inline·void·_nocheck__trace_guest_cpu_exit(void·*·__cpu)

1715

{

1715

{

1716

····if·(true·&&·qemu_loglevel_mask(LOG_TRACE))·{

1716

····if·(true·&&·qemu_loglevel_mask(LOG_TRACE))·{

1717

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

1717

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

1718

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

1718

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

1719

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

1719

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

1721

············qemu_log("%d@%zu.%06zu:guest_cpu_exit·"·"cpu=%p·"·"\n",

1721

············qemu_log("%d@%zu.%06zu:guest_cpu_exit·"·"cpu=%p·"·"\n",

1722

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

1722

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

1723

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

1723

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

1724

·····················,·__cpu);

1724

·····················,·__cpu);

1725

#line·1727·"trace/trace-root.h"

1725

#line·1727·"trace/trace-root.h"

1726

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

1726

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

1728

············qemu_log("guest_cpu_exit·"·"cpu=%p·"·"\n",·__cpu);

1728

············qemu_log("guest_cpu_exit·"·"cpu=%p·"·"\n",·__cpu);

1729

#line·1731·"trace/trace-root.h"

1729

#line·1731·"trace/trace-root.h"

1730

········}

1730

········}

1731

····}

1731

····}

1732

}

1732

}

1733

static·inline·void·trace_guest_cpu_exit(void·*·__cpu)

1733

static·inline·void·trace_guest_cpu_exit(void·*·__cpu)

1745

static·inline·void·_nocheck__trace_guest_cpu_reset(void·*·__cpu)

1745

static·inline·void·_nocheck__trace_guest_cpu_reset(void·*·__cpu)

1746

{

1746

{

1747

····if·(true·&&·qemu_loglevel_mask(LOG_TRACE))·{

1747

····if·(true·&&·qemu_loglevel_mask(LOG_TRACE))·{

1748

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

1748

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

1749

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

1749

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

1750

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

1750

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

1752

············qemu_log("%d@%zu.%06zu:guest_cpu_reset·"·"cpu=%p·"·"\n",

1752

············qemu_log("%d@%zu.%06zu:guest_cpu_reset·"·"cpu=%p·"·"\n",

1753

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

1753

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

1754

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

1754

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

1755

·····················,·__cpu);

1755

·····················,·__cpu);

1756

#line·1758·"trace/trace-root.h"

1756

#line·1758·"trace/trace-root.h"

1757

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

1757

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

1759

············qemu_log("guest_cpu_reset·"·"cpu=%p·"·"\n",·__cpu);

1759

············qemu_log("guest_cpu_reset·"·"cpu=%p·"·"\n",·__cpu);

1760

#line·1762·"trace/trace-root.h"

1760

#line·1762·"trace/trace-root.h"

1761

········}

1761

········}

1762

····}

1762

····}

1763

}

1763

}

1764

static·inline·void·trace_guest_cpu_reset(void·*·__cpu)

1764

static·inline·void·trace_guest_cpu_reset(void·*·__cpu)

1776

static·inline·void·_nocheck__trace_guest_ld_before_trans(void·*·__cpu,·uint32_t·memopidx)

1776

static·inline·void·_nocheck__trace_guest_ld_before_trans(void·*·__cpu,·uint32_t·memopidx)

1777

{

1777

{

1778

····if·(true·&&·qemu_loglevel_mask(LOG_TRACE))·{

1778

····if·(true·&&·qemu_loglevel_mask(LOG_TRACE))·{

1779

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

1779

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

1780

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

1780

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

1781

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

1781

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

1783

············qemu_log("%d@%zu.%06zu:guest_ld_before_trans·"·"cpu=%p·""info=%d"·"\n",

1783

············qemu_log("%d@%zu.%06zu:guest_ld_before_trans·"·"cpu=%p·""info=%d"·"\n",

1784

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

1784

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

1785

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

1785

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

1786

·····················,·__cpu,·memopidx);

1786

·····················,·__cpu,·memopidx);

1787

#line·1789·"trace/trace-root.h"

1787

#line·1789·"trace/trace-root.h"

1788

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

1788

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

1790

············qemu_log("guest_ld_before_trans·"·"cpu=%p·""info=%d"·"\n",·__cpu,·memopidx);

1790

············qemu_log("guest_ld_before_trans·"·"cpu=%p·""info=%d"·"\n",·__cpu,·memopidx);

1791

#line·1793·"trace/trace-root.h"

1791

#line·1793·"trace/trace-root.h"

1792

········}

1792

········}

1793

····}

1793

····}

1794

}

1794

}

1795

static·inline·void·trace_guest_ld_before_trans(void·*·__cpu,·uint32_t·memopidx)

1795

static·inline·void·trace_guest_ld_before_trans(void·*·__cpu,·uint32_t·memopidx)

1807

static·inline·void·_nocheck__trace_guest_ld_before_exec(void·*·__cpu,·uint64_t·vaddr,·uint32_t·memopidx)

1807

static·inline·void·_nocheck__trace_guest_ld_before_exec(void·*·__cpu,·uint64_t·vaddr,·uint32_t·memopidx)

1808

{

1808

{

1809

····if·(true·&&·qemu_loglevel_mask(LOG_TRACE))·{

1809

····if·(true·&&·qemu_loglevel_mask(LOG_TRACE))·{

1810

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

1810

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

1811

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

1811

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

1812

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

1812

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

1814

············qemu_log("%d@%zu.%06zu:guest_ld_before_exec·"·"cpu=%p·""vaddr=0x%016"PRIx64"·memopidx=0x%x"·"\n",

1814

············qemu_log("%d@%zu.%06zu:guest_ld_before_exec·"·"cpu=%p·""vaddr=0x%016"PRIx64"·memopidx=0x%x"·"\n",

1815

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

1815

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

1816

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

1816

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

1817

·····················,·__cpu,·vaddr,·memopidx);

1817

·····················,·__cpu,·vaddr,·memopidx);

1818

#line·1820·"trace/trace-root.h"

1818

#line·1820·"trace/trace-root.h"

1819

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

1819

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

1821

············qemu_log("guest_ld_before_exec·"·"cpu=%p·""vaddr=0x%016"PRIx64"·memopidx=0x%x"·"\n",·__cpu,·vaddr,·memopidx);

1821

············qemu_log("guest_ld_before_exec·"·"cpu=%p·""vaddr=0x%016"PRIx64"·memopidx=0x%x"·"\n",·__cpu,·vaddr,·memopidx);

1822

#line·1824·"trace/trace-root.h"

1822

#line·1824·"trace/trace-root.h"

1823

········}

1823

········}

1824

····}

1824

····}

1825

}

1825

}

1826

static·inline·void·trace_guest_ld_before_exec(void·*·__cpu,·uint64_t·vaddr,·uint32_t·memopidx)

1826

static·inline·void·trace_guest_ld_before_exec(void·*·__cpu,·uint64_t·vaddr,·uint32_t·memopidx)

1838

static·inline·void·_nocheck__trace_guest_st_before_trans(void·*·__cpu,·uint32_t·memopidx)

1838

static·inline·void·_nocheck__trace_guest_st_before_trans(void·*·__cpu,·uint32_t·memopidx)

1839

{

1839

{

1840

····if·(true·&&·qemu_loglevel_mask(LOG_TRACE))·{

1840

····if·(true·&&·qemu_loglevel_mask(LOG_TRACE))·{

1841

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

1841

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

1842

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

1842

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

1843

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

1843

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

1845

············qemu_log("%d@%zu.%06zu:guest_st_before_trans·"·"cpu=%p·""info=%d"·"\n",

1845

············qemu_log("%d@%zu.%06zu:guest_st_before_trans·"·"cpu=%p·""info=%d"·"\n",

1846

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

1846

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

1847

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

1847

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

1848

·····················,·__cpu,·memopidx);

1848

·····················,·__cpu,·memopidx);

1849

#line·1851·"trace/trace-root.h"

1849

#line·1851·"trace/trace-root.h"

1850

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

1850

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

1852

············qemu_log("guest_st_before_trans·"·"cpu=%p·""info=%d"·"\n",·__cpu,·memopidx);

1852

············qemu_log("guest_st_before_trans·"·"cpu=%p·""info=%d"·"\n",·__cpu,·memopidx);

1853

#line·1855·"trace/trace-root.h"

1853

#line·1855·"trace/trace-root.h"

1854

········}

1854

········}

1855

····}

1855

····}

1856

}

1856

}

1857

static·inline·void·trace_guest_st_before_trans(void·*·__cpu,·uint32_t·memopidx)

1857

static·inline·void·trace_guest_st_before_trans(void·*·__cpu,·uint32_t·memopidx)

1869

static·inline·void·_nocheck__trace_guest_st_before_exec(void·*·__cpu,·uint64_t·vaddr,·uint32_t·memopidx)

1869

static·inline·void·_nocheck__trace_guest_st_before_exec(void·*·__cpu,·uint64_t·vaddr,·uint32_t·memopidx)

1870

{

1870

{

1871

····if·(true·&&·qemu_loglevel_mask(LOG_TRACE))·{

1871

····if·(true·&&·qemu_loglevel_mask(LOG_TRACE))·{

1872

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

1872

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

1873

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

1873

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

1874

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

1874

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

1876

············qemu_log("%d@%zu.%06zu:guest_st_before_exec·"·"cpu=%p·""vaddr=0x%016"PRIx64"·memopidx=0x%x"·"\n",

1876

············qemu_log("%d@%zu.%06zu:guest_st_before_exec·"·"cpu=%p·""vaddr=0x%016"PRIx64"·memopidx=0x%x"·"\n",

1877

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

1877

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

1878

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

1878

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

1879

·····················,·__cpu,·vaddr,·memopidx);

1879

·····················,·__cpu,·vaddr,·memopidx);

1880

#line·1882·"trace/trace-root.h"

1880

#line·1882·"trace/trace-root.h"

1881

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

1881

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

1883

············qemu_log("guest_st_before_exec·"·"cpu=%p·""vaddr=0x%016"PRIx64"·memopidx=0x%x"·"\n",·__cpu,·vaddr,·memopidx);

1883

············qemu_log("guest_st_before_exec·"·"cpu=%p·""vaddr=0x%016"PRIx64"·memopidx=0x%x"·"\n",·__cpu,·vaddr,·memopidx);

1884

#line·1886·"trace/trace-root.h"

1884

#line·1886·"trace/trace-root.h"

1885

········}

1885

········}

1886

····}

1886

····}

1887

}

1887

}

1888

static·inline·void·trace_guest_st_before_exec(void·*·__cpu,·uint64_t·vaddr,·uint32_t·memopidx)

1888

static·inline·void·trace_guest_st_before_exec(void·*·__cpu,·uint64_t·vaddr,·uint32_t·memopidx)

1900

static·inline·void·_nocheck__trace_guest_rmw_before_trans(void·*·__cpu,·uint32_t·memopidx)

1900

static·inline·void·_nocheck__trace_guest_rmw_before_trans(void·*·__cpu,·uint32_t·memopidx)

1901

{

1901

{

1902

····if·(true·&&·qemu_loglevel_mask(LOG_TRACE))·{

1902

····if·(true·&&·qemu_loglevel_mask(LOG_TRACE))·{

1903

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

1903

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

1904

············struct·timeval·_now;

1904

············struct·timeval·_now;

1905

············gettimeofday(&_now,·NULL);

1905

············gettimeofday(&_now,·NULL);

1907

············qemu_log("%d@%zu.%06zu:guest_rmw_before_trans·"·"cpu=%p·""info=%d"·"\n",

1907

············qemu_log("%d@%zu.%06zu:guest_rmw_before_trans·"·"cpu=%p·""info=%d"·"\n",

1908

·····················qemu_get_thread_id(),

1908

·····················qemu_get_thread_id(),

1909

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1909

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1910

·····················,·__cpu,·memopidx);

1910

·····················,·__cpu,·memopidx);

1911

#line·1913·"trace/trace-root.h"

1911

#line·1913·"trace/trace-root.h"

1912

········}·else·{

1912

········}·else·{

1914

············qemu_log("guest_rmw_before_trans·"·"cpu=%p·""info=%d"·"\n",·__cpu,·memopidx);

1914

············qemu_log("guest_rmw_before_trans·"·"cpu=%p·""info=%d"·"\n",·__cpu,·memopidx);

1915

#line·1917·"trace/trace-root.h"

1915

#line·1917·"trace/trace-root.h"

1916

········}

1916

········}

1917

····}

1917

····}

1918

}

1918

}

1919

static·inline·void·trace_guest_rmw_before_trans(void·*·__cpu,·uint32_t·memopidx)

1919

static·inline·void·trace_guest_rmw_before_trans(void·*·__cpu,·uint32_t·memopidx)

1931

static·inline·void·_nocheck__trace_guest_rmw_before_exec(void·*·__cpu,·uint64_t·vaddr,·uint32_t·memopidx)

1931

static·inline·void·_nocheck__trace_guest_rmw_before_exec(void·*·__cpu,·uint64_t·vaddr,·uint32_t·memopidx)

1932

{

1932

{

1933

····if·(true·&&·qemu_loglevel_mask(LOG_TRACE))·{

1933

····if·(true·&&·qemu_loglevel_mask(LOG_TRACE))·{

1934

········if·(message_with_timestamp)·{

1934

········if·(message_with_timestamp)·{

1935

············struct·timeval·_now;

1935

············struct·timeval·_now;

1936

············gettimeofday(&_now,·NULL);

1936

············gettimeofday(&_now,·NULL);

1938

············qemu_log("%d@%zu.%06zu:guest_rmw_before_exec·"·"cpu=%p·""vaddr=0x%016"PRIx64"·memopidx=0x%x"·"\n",

1938

············qemu_log("%d@%zu.%06zu:guest_rmw_before_exec·"·"cpu=%p·""vaddr=0x%016"PRIx64"·memopidx=0x%x"·"\n",

1939

·····················qemu_get_thread_id(),

1939

·····················qemu_get_thread_id(),

1940

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1940

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1941

·····················,·__cpu,·vaddr,·memopidx);

1941

·····················,·__cpu,·vaddr,·memopidx);

1942

#line·1944·"trace/trace-root.h"

1942

#line·1944·"trace/trace-root.h"

1943

········}·else·{

1943

········}·else·{

1945

············qemu_log("guest_rmw_before_exec·"·"cpu=%p·""vaddr=0x%016"PRIx64"·memopidx=0x%x"·"\n",·__cpu,·vaddr,·memopidx);

1945

············qemu_log("guest_rmw_before_exec·"·"cpu=%p·""vaddr=0x%016"PRIx64"·memopidx=0x%x"·"\n",·__cpu,·vaddr,·memopidx);

1946

#line·1948·"trace/trace-root.h"

1946

#line·1948·"trace/trace-root.h"

1947

········}

1947

········}

1948

····}

1948

····}

1949

}

1949

}

1950

static·inline·void·trace_guest_rmw_before_exec(void·*·__cpu,·uint64_t·vaddr,·uint32_t·memopidx)

1950

static·inline·void·trace_guest_rmw_before_exec(void·*·__cpu,·uint64_t·vaddr,·uint32_t·memopidx)

1962

static·inline·void·_nocheck__trace_guest_user_syscall(void·*·__cpu,·uint64_t·num,·uint64_t·arg1,·uint64_t·arg2,·uint64_t·arg3,·uint64_t·arg4,·uint64_t·arg5,·uint64_t·arg6,·uint64_t·arg7,·uint64_t·arg8)

1962

static·inline·void·_nocheck__trace_guest_user_syscall(void·*·__cpu,·uint64_t·num,·uint64_t·arg1,·uint64_t·arg2,·uint64_t·arg3,·uint64_t·arg4,·uint64_t·arg5,·uint64_t·arg6,·uint64_t·arg7,·uint64_t·arg8)

1963

{

1963

{

1964

····if·(true·&&·qemu_loglevel_mask(LOG_TRACE))·{

1964

····if·(true·&&·qemu_loglevel_mask(LOG_TRACE))·{

1965

········if·(message_with_timestamp)·{

1965

········if·(message_with_timestamp)·{

1966

············struct·timeval·_now;

1966

············struct·timeval·_now;

1967

············gettimeofday(&_now,·NULL);

1967

············gettimeofday(&_now,·NULL);

1969

············qemu_log("%d@%zu.%06zu:guest_user_syscall·"·"cpu=%p·""num=0x%016"PRIx64"·arg1=0x%016"PRIx64"·arg2=0x%016"PRIx64"·arg3=0x%016"PRIx64"·arg4=0x%016"PRIx64"·arg5=0x%016"PRIx64"·arg6=0x%016"PRIx64"·arg7=0x%016"PRIx64"·arg8=0x%016"PRIx64·"\n",

1969

············qemu_log("%d@%zu.%06zu:guest_user_syscall·"·"cpu=%p·""num=0x%016"PRIx64"·arg1=0x%016"PRIx64"·arg2=0x%016"PRIx64"·arg3=0x%016"PRIx64"·arg4=0x%016"PRIx64"·arg5=0x%016"PRIx64"·arg6=0x%016"PRIx64"·arg7=0x%016"PRIx64"·arg8=0x%016"PRIx64·"\n",

1970

·····················qemu_get_thread_id(),

1970

·····················qemu_get_thread_id(),

1971

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1971

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1972

·····················,·__cpu,·num,·arg1,·arg2,·arg3,·arg4,·arg5,·arg6,·arg7,·arg8);

1972

·····················,·__cpu,·num,·arg1,·arg2,·arg3,·arg4,·arg5,·arg6,·arg7,·arg8);

1973

#line·1975·"trace/trace-root.h"

1973

#line·1975·"trace/trace-root.h"

1974

········}·else·{

1974

········}·else·{

1976

············qemu_log("guest_user_syscall·"·"cpu=%p·""num=0x%016"PRIx64"·arg1=0x%016"PRIx64"·arg2=0x%016"PRIx64"·arg3=0x%016"PRIx64"·arg4=0x%016"PRIx64"·arg5=0x%016"PRIx64"·arg6=0x%016"PRIx64"·arg7=0x%016"PRIx64"·arg8=0x%016"PRIx64·"\n",·__cpu,·num,·arg1,·arg2,·arg3,·arg4,·arg5,·arg6,·arg7,·arg8);

1976

············qemu_log("guest_user_syscall·"·"cpu=%p·""num=0x%016"PRIx64"·arg1=0x%016"PRIx64"·arg2=0x%016"PRIx64"·arg3=0x%016"PRIx64"·arg4=0x%016"PRIx64"·arg5=0x%016"PRIx64"·arg6=0x%016"PRIx64"·arg7=0x%016"PRIx64"·arg8=0x%016"PRIx64·"\n",·__cpu,·num,·arg1,·arg2,·arg3,·arg4,·arg5,·arg6,·arg7,·arg8);

1977

#line·1979·"trace/trace-root.h"

1977

#line·1979·"trace/trace-root.h"

1978

········}

1978

········}

1979

····}

1979

····}

1980

}

1980

}

1981

static·inline·void·trace_guest_user_syscall(void·*·__cpu,·uint64_t·num,·uint64_t·arg1,·uint64_t·arg2,·uint64_t·arg3,·uint64_t·arg4,·uint64_t·arg5,·uint64_t·arg6,·uint64_t·arg7,·uint64_t·arg8)

1981

static·inline·void·trace_guest_user_syscall(void·*·__cpu,·uint64_t·num,·uint64_t·arg1,·uint64_t·arg2,·uint64_t·arg3,·uint64_t·arg4,·uint64_t·arg5,·uint64_t·arg6,·uint64_t·arg7,·uint64_t·arg8)

1993

static·inline·void·_nocheck__trace_guest_user_syscall_ret(void·*·__cpu,·uint64_t·num,·uint64_t·ret)

1993

static·inline·void·_nocheck__trace_guest_user_syscall_ret(void·*·__cpu,·uint64_t·num,·uint64_t·ret)

1994

{

1994

{

1995

····if·(true·&&·qemu_loglevel_mask(LOG_TRACE))·{

1995

····if·(true·&&·qemu_loglevel_mask(LOG_TRACE))·{

1996

········if·(message_with_timestamp)·{

1996

········if·(message_with_timestamp)·{

1997

············struct·timeval·_now;

1997

············struct·timeval·_now;

1998

············gettimeofday(&_now,·NULL);

1998

············gettimeofday(&_now,·NULL);

2000

············qemu_log("%d@%zu.%06zu:guest_user_syscall_ret·"·"cpu=%p·""num=0x%016"PRIx64"·ret=0x%016"PRIx64·"\n",

2000

············qemu_log("%d@%zu.%06zu:guest_user_syscall_ret·"·"cpu=%p·""num=0x%016"PRIx64"·ret=0x%016"PRIx64·"\n",

2001

·····················qemu_get_thread_id(),

2001

·····················qemu_get_thread_id(),

2002

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2002

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

2003

·····················,·__cpu,·num,·ret);

2003

·····················,·__cpu,·num,·ret);

2004

#line·2006·"trace/trace-root.h"

2004

#line·2006·"trace/trace-root.h"

2005

········}·else·{

2005

········}·else·{

2007

············qemu_log("guest_user_syscall_ret·"·"cpu=%p·""num=0x%016"PRIx64"·ret=0x%016"PRIx64·"\n",·__cpu,·num,·ret);

2007

············qemu_log("guest_user_syscall_ret·"·"cpu=%p·""num=0x%016"PRIx64"·ret=0x%016"PRIx64·"\n",·__cpu,·num,·ret);

2008

#line·2010·"trace/trace-root.h"

2008

#line·2010·"trace/trace-root.h"

2009

········}

2009

········}

2010

····}

2010

····}

2011

}

2011

}

2012

static·inline·void·trace_guest_user_syscall_ret(void·*·__cpu,·uint64_t·num,·uint64_t·ret)

2012

static·inline·void·trace_guest_user_syscall_ret(void·*·__cpu,·uint64_t·num,·uint64_t·ret)