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

153

static·inline·void·_nocheck__trace_mhp_acpi_invalid_slot_selected(uint32_t·slot)

153

static·inline·void·_nocheck__trace_mhp_acpi_invalid_slot_selected(uint32_t·slot)

154

{

154

{

155

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

155

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

156

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

156

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

157

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

157

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

158

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

158

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

160

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

160

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

161

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

161

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

162

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

162

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

163

·····················,·slot);

163

·····················,·slot);

164

#line·166·"trace/trace-hw_acpi.h"

164

#line·166·"trace/trace-hw_acpi.h"

165

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

165

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

167

············qemu_log("mhp_acpi_invalid_slot_selected·"·"0x%"PRIx32·"\n",·slot);

167

············qemu_log("mhp_acpi_invalid_slot_selected·"·"0x%"PRIx32·"\n",·slot);

168

#line·170·"trace/trace-hw_acpi.h"

168

#line·170·"trace/trace-hw_acpi.h"

169

········}

169

········}

170

····}

170

····}

171

}

171

}

172

static·inline·void·trace_mhp_acpi_invalid_slot_selected(uint32_t·slot)

172

static·inline·void·trace_mhp_acpi_invalid_slot_selected(uint32_t·slot)

184

static·inline·void·_nocheck__trace_mhp_acpi_ejecting_invalid_slot(uint32_t·slot)

184

static·inline·void·_nocheck__trace_mhp_acpi_ejecting_invalid_slot(uint32_t·slot)

185

{

185

{

186

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

186

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

187

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

187

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

188

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

188

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

189

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

189

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

191

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

191

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

192

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

192

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

193

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

193

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

194

·····················,·slot);

194

·····················,·slot);

195

#line·197·"trace/trace-hw_acpi.h"

195

#line·197·"trace/trace-hw_acpi.h"

196

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

196

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

198

············qemu_log("mhp_acpi_ejecting_invalid_slot·"·"0x%"PRIx32·"\n",·slot);

198

············qemu_log("mhp_acpi_ejecting_invalid_slot·"·"0x%"PRIx32·"\n",·slot);

199

#line·201·"trace/trace-hw_acpi.h"

199

#line·201·"trace/trace-hw_acpi.h"

200

········}

200

········}

201

····}

201

····}

202

}

202

}

203

static·inline·void·trace_mhp_acpi_ejecting_invalid_slot(uint32_t·slot)

203

static·inline·void·trace_mhp_acpi_ejecting_invalid_slot(uint32_t·slot)

215

static·inline·void·_nocheck__trace_mhp_acpi_read_addr_lo(uint32_t·slot,·uint32_t·addr)

215

static·inline·void·_nocheck__trace_mhp_acpi_read_addr_lo(uint32_t·slot,·uint32_t·addr)

216

{

216

{

217

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

217

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

218

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

218

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

219

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

219

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

220

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

220

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

222

············qemu_log("%d@%zu.%06zu:mhp_acpi_read_addr_lo·"·"slot[0x%"PRIx32"]·addr·lo:·0x%"PRIx32·"\n",

222

············qemu_log("%d@%zu.%06zu:mhp_acpi_read_addr_lo·"·"slot[0x%"PRIx32"]·addr·lo:·0x%"PRIx32·"\n",

223

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

223

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

224

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

224

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

225

·····················,·slot,·addr);

225

·····················,·slot,·addr);

226

#line·228·"trace/trace-hw_acpi.h"

226

#line·228·"trace/trace-hw_acpi.h"

227

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

227

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

229

············qemu_log("mhp_acpi_read_addr_lo·"·"slot[0x%"PRIx32"]·addr·lo:·0x%"PRIx32·"\n",·slot,·addr);

229

············qemu_log("mhp_acpi_read_addr_lo·"·"slot[0x%"PRIx32"]·addr·lo:·0x%"PRIx32·"\n",·slot,·addr);

230

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

230

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

231

········}

231

········}

232

····}

232

····}

233

}

233

}

234

static·inline·void·trace_mhp_acpi_read_addr_lo(uint32_t·slot,·uint32_t·addr)

234

static·inline·void·trace_mhp_acpi_read_addr_lo(uint32_t·slot,·uint32_t·addr)

246

static·inline·void·_nocheck__trace_mhp_acpi_read_addr_hi(uint32_t·slot,·uint32_t·addr)

246

static·inline·void·_nocheck__trace_mhp_acpi_read_addr_hi(uint32_t·slot,·uint32_t·addr)

247

{

247

{

248

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

248

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

249

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

249

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

250

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

250

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

251

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

251

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

253

············qemu_log("%d@%zu.%06zu:mhp_acpi_read_addr_hi·"·"slot[0x%"PRIx32"]·addr·hi:·0x%"PRIx32·"\n",

253

············qemu_log("%d@%zu.%06zu:mhp_acpi_read_addr_hi·"·"slot[0x%"PRIx32"]·addr·hi:·0x%"PRIx32·"\n",

254

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

254

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

255

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

255

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

256

·····················,·slot,·addr);

256

·····················,·slot,·addr);

257

#line·259·"trace/trace-hw_acpi.h"

257

#line·259·"trace/trace-hw_acpi.h"

258

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

258

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

260

············qemu_log("mhp_acpi_read_addr_hi·"·"slot[0x%"PRIx32"]·addr·hi:·0x%"PRIx32·"\n",·slot,·addr);

260

············qemu_log("mhp_acpi_read_addr_hi·"·"slot[0x%"PRIx32"]·addr·hi:·0x%"PRIx32·"\n",·slot,·addr);

261

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

261

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

262

········}

262

········}

263

····}

263

····}

264

}

264

}

265

static·inline·void·trace_mhp_acpi_read_addr_hi(uint32_t·slot,·uint32_t·addr)

265

static·inline·void·trace_mhp_acpi_read_addr_hi(uint32_t·slot,·uint32_t·addr)

277

static·inline·void·_nocheck__trace_mhp_acpi_read_size_lo(uint32_t·slot,·uint32_t·size)

277

static·inline·void·_nocheck__trace_mhp_acpi_read_size_lo(uint32_t·slot,·uint32_t·size)

278

{

278

{

279

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

279

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

280

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

280

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

281

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

281

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

282

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

282

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

284

············qemu_log("%d@%zu.%06zu:mhp_acpi_read_size_lo·"·"slot[0x%"PRIx32"]·size·lo:·0x%"PRIx32·"\n",

284

············qemu_log("%d@%zu.%06zu:mhp_acpi_read_size_lo·"·"slot[0x%"PRIx32"]·size·lo:·0x%"PRIx32·"\n",

285

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

285

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

286

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

286

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

287

·····················,·slot,·size);

287

·····················,·slot,·size);

288

#line·290·"trace/trace-hw_acpi.h"

288

#line·290·"trace/trace-hw_acpi.h"

289

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

289

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

291

············qemu_log("mhp_acpi_read_size_lo·"·"slot[0x%"PRIx32"]·size·lo:·0x%"PRIx32·"\n",·slot,·size);

291

············qemu_log("mhp_acpi_read_size_lo·"·"slot[0x%"PRIx32"]·size·lo:·0x%"PRIx32·"\n",·slot,·size);

292

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

292

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

293

········}

293

········}

294

····}

294

····}

295

}

295

}

296

static·inline·void·trace_mhp_acpi_read_size_lo(uint32_t·slot,·uint32_t·size)

296

static·inline·void·trace_mhp_acpi_read_size_lo(uint32_t·slot,·uint32_t·size)

308

static·inline·void·_nocheck__trace_mhp_acpi_read_size_hi(uint32_t·slot,·uint32_t·size)

308

static·inline·void·_nocheck__trace_mhp_acpi_read_size_hi(uint32_t·slot,·uint32_t·size)

309

{

309

{

310

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

310

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

311

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

311

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

312

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

312

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

313

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

313

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

315

············qemu_log("%d@%zu.%06zu:mhp_acpi_read_size_hi·"·"slot[0x%"PRIx32"]·size·hi:·0x%"PRIx32·"\n",

315

············qemu_log("%d@%zu.%06zu:mhp_acpi_read_size_hi·"·"slot[0x%"PRIx32"]·size·hi:·0x%"PRIx32·"\n",

316

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

316

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

317

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

317

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

318

·····················,·slot,·size);

318

·····················,·slot,·size);

319

#line·321·"trace/trace-hw_acpi.h"

319

#line·321·"trace/trace-hw_acpi.h"

320

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

320

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

322

············qemu_log("mhp_acpi_read_size_hi·"·"slot[0x%"PRIx32"]·size·hi:·0x%"PRIx32·"\n",·slot,·size);

322

············qemu_log("mhp_acpi_read_size_hi·"·"slot[0x%"PRIx32"]·size·hi:·0x%"PRIx32·"\n",·slot,·size);

323

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

323

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

324

········}

324

········}

325

····}

325

····}

326

}

326

}

327

static·inline·void·trace_mhp_acpi_read_size_hi(uint32_t·slot,·uint32_t·size)

327

static·inline·void·trace_mhp_acpi_read_size_hi(uint32_t·slot,·uint32_t·size)

339

static·inline·void·_nocheck__trace_mhp_acpi_read_pxm(uint32_t·slot,·uint32_t·pxm)

339

static·inline·void·_nocheck__trace_mhp_acpi_read_pxm(uint32_t·slot,·uint32_t·pxm)

340

{

340

{

341

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

341

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

342

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

342

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

343

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

343

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

344

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

344

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

346

············qemu_log("%d@%zu.%06zu:mhp_acpi_read_pxm·"·"slot[0x%"PRIx32"]·proximity:·0x%"PRIx32·"\n",

346

············qemu_log("%d@%zu.%06zu:mhp_acpi_read_pxm·"·"slot[0x%"PRIx32"]·proximity:·0x%"PRIx32·"\n",

347

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

347

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

348

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

348

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

349

·····················,·slot,·pxm);

349

·····················,·slot,·pxm);

350

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

350

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

351

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

351

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

353

············qemu_log("mhp_acpi_read_pxm·"·"slot[0x%"PRIx32"]·proximity:·0x%"PRIx32·"\n",·slot,·pxm);

353

············qemu_log("mhp_acpi_read_pxm·"·"slot[0x%"PRIx32"]·proximity:·0x%"PRIx32·"\n",·slot,·pxm);

354

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

354

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

355

········}

355

········}

356

····}

356

····}

357

}

357

}

358

static·inline·void·trace_mhp_acpi_read_pxm(uint32_t·slot,·uint32_t·pxm)

358

static·inline·void·trace_mhp_acpi_read_pxm(uint32_t·slot,·uint32_t·pxm)

370

static·inline·void·_nocheck__trace_mhp_acpi_read_flags(uint32_t·slot,·uint32_t·flags)

370

static·inline·void·_nocheck__trace_mhp_acpi_read_flags(uint32_t·slot,·uint32_t·flags)

371

{

371

{

372

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

372

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

373

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

373

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

374

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

374

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

375

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

375

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

377

············qemu_log("%d@%zu.%06zu:mhp_acpi_read_flags·"·"slot[0x%"PRIx32"]·flags:·0x%"PRIx32·"\n",

377

············qemu_log("%d@%zu.%06zu:mhp_acpi_read_flags·"·"slot[0x%"PRIx32"]·flags:·0x%"PRIx32·"\n",

378

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

378

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

379

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

379

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

380

·····················,·slot,·flags);

380

·····················,·slot,·flags);

381

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

381

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

382

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

382

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

384

············qemu_log("mhp_acpi_read_flags·"·"slot[0x%"PRIx32"]·flags:·0x%"PRIx32·"\n",·slot,·flags);

384

············qemu_log("mhp_acpi_read_flags·"·"slot[0x%"PRIx32"]·flags:·0x%"PRIx32·"\n",·slot,·flags);

385

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

385

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

386

········}

386

········}

387

····}

387

····}

388

}

388

}

389

static·inline·void·trace_mhp_acpi_read_flags(uint32_t·slot,·uint32_t·flags)

389

static·inline·void·trace_mhp_acpi_read_flags(uint32_t·slot,·uint32_t·flags)

401

static·inline·void·_nocheck__trace_mhp_acpi_write_slot(uint32_t·slot)

401

static·inline·void·_nocheck__trace_mhp_acpi_write_slot(uint32_t·slot)

402

{

402

{

403

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

403

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

404

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

404

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

405

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

405

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

406

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

406

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

408

············qemu_log("%d@%zu.%06zu:mhp_acpi_write_slot·"·"set·active·slot:·0x%"PRIx32·"\n",

408

············qemu_log("%d@%zu.%06zu:mhp_acpi_write_slot·"·"set·active·slot:·0x%"PRIx32·"\n",

409

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

409

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

410

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

410

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

411

·····················,·slot);

411

·····················,·slot);

412

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

412

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

413

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

413

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

415

············qemu_log("mhp_acpi_write_slot·"·"set·active·slot:·0x%"PRIx32·"\n",·slot);

415

············qemu_log("mhp_acpi_write_slot·"·"set·active·slot:·0x%"PRIx32·"\n",·slot);

416

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

416

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

417

········}

417

········}

418

····}

418

····}

419

}

419

}

420

static·inline·void·trace_mhp_acpi_write_slot(uint32_t·slot)

420

static·inline·void·trace_mhp_acpi_write_slot(uint32_t·slot)

432

static·inline·void·_nocheck__trace_mhp_acpi_write_ost_ev(uint32_t·slot,·uint32_t·ev)

432

static·inline·void·_nocheck__trace_mhp_acpi_write_ost_ev(uint32_t·slot,·uint32_t·ev)

433

{

433

{

434

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

434

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

435

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

435

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

436

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

436

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

437

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

437

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

439

············qemu_log("%d@%zu.%06zu:mhp_acpi_write_ost_ev·"·"slot[0x%"PRIx32"]·OST·EVENT:·0x%"PRIx32·"\n",

439

············qemu_log("%d@%zu.%06zu:mhp_acpi_write_ost_ev·"·"slot[0x%"PRIx32"]·OST·EVENT:·0x%"PRIx32·"\n",

440

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

440

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

441

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

441

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

442

·····················,·slot,·ev);

442

·····················,·slot,·ev);

443

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

443

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

444

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

444

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

446

············qemu_log("mhp_acpi_write_ost_ev·"·"slot[0x%"PRIx32"]·OST·EVENT:·0x%"PRIx32·"\n",·slot,·ev);

446

············qemu_log("mhp_acpi_write_ost_ev·"·"slot[0x%"PRIx32"]·OST·EVENT:·0x%"PRIx32·"\n",·slot,·ev);

447

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

447

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

448

········}

448

········}

449

····}

449

····}

450

}

450

}

451

static·inline·void·trace_mhp_acpi_write_ost_ev(uint32_t·slot,·uint32_t·ev)

451

static·inline·void·trace_mhp_acpi_write_ost_ev(uint32_t·slot,·uint32_t·ev)

463

static·inline·void·_nocheck__trace_mhp_acpi_write_ost_status(uint32_t·slot,·uint32_t·st)

463

static·inline·void·_nocheck__trace_mhp_acpi_write_ost_status(uint32_t·slot,·uint32_t·st)

464

{

464

{

465

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

465

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

466

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

466

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

467

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

467

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

468

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

468

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

470

············qemu_log("%d@%zu.%06zu:mhp_acpi_write_ost_status·"·"slot[0x%"PRIx32"]·OST·STATUS:·0x%"PRIx32·"\n",

470

············qemu_log("%d@%zu.%06zu:mhp_acpi_write_ost_status·"·"slot[0x%"PRIx32"]·OST·STATUS:·0x%"PRIx32·"\n",

471

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

471

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

472

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

472

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

473

·····················,·slot,·st);

473

·····················,·slot,·st);

474

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

474

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

475

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

475

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

477

············qemu_log("mhp_acpi_write_ost_status·"·"slot[0x%"PRIx32"]·OST·STATUS:·0x%"PRIx32·"\n",·slot,·st);

477

············qemu_log("mhp_acpi_write_ost_status·"·"slot[0x%"PRIx32"]·OST·STATUS:·0x%"PRIx32·"\n",·slot,·st);

478

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

478

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

479

········}

479

········}

480

····}

480

····}

481

}

481

}

482

static·inline·void·trace_mhp_acpi_write_ost_status(uint32_t·slot,·uint32_t·st)

482

static·inline·void·trace_mhp_acpi_write_ost_status(uint32_t·slot,·uint32_t·st)

494

static·inline·void·_nocheck__trace_mhp_acpi_clear_insert_evt(uint32_t·slot)

494

static·inline·void·_nocheck__trace_mhp_acpi_clear_insert_evt(uint32_t·slot)

495

{

495

{

496

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

496

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

497

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

497

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

498

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

498

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

499

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

499

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

501

············qemu_log("%d@%zu.%06zu:mhp_acpi_clear_insert_evt·"·"slot[0x%"PRIx32"]·clear·insert·event"·"\n",

501

············qemu_log("%d@%zu.%06zu:mhp_acpi_clear_insert_evt·"·"slot[0x%"PRIx32"]·clear·insert·event"·"\n",

502

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

502

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

503

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

503

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

504

·····················,·slot);

504

·····················,·slot);

505

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

505

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

506

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

506

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

508

············qemu_log("mhp_acpi_clear_insert_evt·"·"slot[0x%"PRIx32"]·clear·insert·event"·"\n",·slot);

508

············qemu_log("mhp_acpi_clear_insert_evt·"·"slot[0x%"PRIx32"]·clear·insert·event"·"\n",·slot);

509

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

509

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

510

········}

510

········}

511

····}

511

····}

512

}

512

}

513

static·inline·void·trace_mhp_acpi_clear_insert_evt(uint32_t·slot)

513

static·inline·void·trace_mhp_acpi_clear_insert_evt(uint32_t·slot)

525

static·inline·void·_nocheck__trace_mhp_acpi_clear_remove_evt(uint32_t·slot)

525

static·inline·void·_nocheck__trace_mhp_acpi_clear_remove_evt(uint32_t·slot)

526

{

526

{

527

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

527

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

528

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

528

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

529

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

529

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

530

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

530

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

532

············qemu_log("%d@%zu.%06zu:mhp_acpi_clear_remove_evt·"·"slot[0x%"PRIx32"]·clear·remove·event"·"\n",

532

············qemu_log("%d@%zu.%06zu:mhp_acpi_clear_remove_evt·"·"slot[0x%"PRIx32"]·clear·remove·event"·"\n",

533

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

533

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

534

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

534

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

535

·····················,·slot);

535

·····················,·slot);

536

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

536

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

537

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

537

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

539

············qemu_log("mhp_acpi_clear_remove_evt·"·"slot[0x%"PRIx32"]·clear·remove·event"·"\n",·slot);

539

············qemu_log("mhp_acpi_clear_remove_evt·"·"slot[0x%"PRIx32"]·clear·remove·event"·"\n",·slot);

540

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

540

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

541

········}

541

········}

542

····}

542

····}

543

}

543

}

544

static·inline·void·trace_mhp_acpi_clear_remove_evt(uint32_t·slot)

544

static·inline·void·trace_mhp_acpi_clear_remove_evt(uint32_t·slot)

556

static·inline·void·_nocheck__trace_mhp_acpi_pc_dimm_deleted(uint32_t·slot)

556

static·inline·void·_nocheck__trace_mhp_acpi_pc_dimm_deleted(uint32_t·slot)

557

{

557

{

558

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

558

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

559

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

559

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

560

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

560

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

561

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

561

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

563

············qemu_log("%d@%zu.%06zu:mhp_acpi_pc_dimm_deleted·"·"slot[0x%"PRIx32"]·pc-dimm·deleted"·"\n",

563

············qemu_log("%d@%zu.%06zu:mhp_acpi_pc_dimm_deleted·"·"slot[0x%"PRIx32"]·pc-dimm·deleted"·"\n",

564

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

564

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

565

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

565

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

566

·····················,·slot);

566

·····················,·slot);

567

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

567

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

568

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

568

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

570

············qemu_log("mhp_acpi_pc_dimm_deleted·"·"slot[0x%"PRIx32"]·pc-dimm·deleted"·"\n",·slot);

570

············qemu_log("mhp_acpi_pc_dimm_deleted·"·"slot[0x%"PRIx32"]·pc-dimm·deleted"·"\n",·slot);

571

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

571

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

572

········}

572

········}

573

····}

573

····}

574

}

574

}

575

static·inline·void·trace_mhp_acpi_pc_dimm_deleted(uint32_t·slot)

575

static·inline·void·trace_mhp_acpi_pc_dimm_deleted(uint32_t·slot)

587

static·inline·void·_nocheck__trace_mhp_acpi_pc_dimm_delete_failed(uint32_t·slot)

587

static·inline·void·_nocheck__trace_mhp_acpi_pc_dimm_delete_failed(uint32_t·slot)

588

{

588

{

589

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

589

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

590

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

590

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

591

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

591

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

592

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

592

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

594

············qemu_log("%d@%zu.%06zu:mhp_acpi_pc_dimm_delete_failed·"·"slot[0x%"PRIx32"]·pc-dimm·delete·failed"·"\n",

594

············qemu_log("%d@%zu.%06zu:mhp_acpi_pc_dimm_delete_failed·"·"slot[0x%"PRIx32"]·pc-dimm·delete·failed"·"\n",

595

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

595

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

596

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

596

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

597

·····················,·slot);

597

·····················,·slot);

598

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

598

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

599

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

599

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

601

············qemu_log("mhp_acpi_pc_dimm_delete_failed·"·"slot[0x%"PRIx32"]·pc-dimm·delete·failed"·"\n",·slot);

601

············qemu_log("mhp_acpi_pc_dimm_delete_failed·"·"slot[0x%"PRIx32"]·pc-dimm·delete·failed"·"\n",·slot);

602

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

602

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

603

········}

603

········}

604

····}

604

····}

605

}

605

}

606

static·inline·void·trace_mhp_acpi_pc_dimm_delete_failed(uint32_t·slot)

606

static·inline·void·trace_mhp_acpi_pc_dimm_delete_failed(uint32_t·slot)

618

static·inline·void·_nocheck__trace_cpuhp_acpi_invalid_idx_selected(uint32_t·idx)

618

static·inline·void·_nocheck__trace_cpuhp_acpi_invalid_idx_selected(uint32_t·idx)

619

{

619

{

620

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

620

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

621

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

621

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

622

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

622

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

623

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

623

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

625

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

625

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

626

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

626

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

627

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

627

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

628

·····················,·idx);

628

·····················,·idx);

629

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

629

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

630

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

630

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

632

············qemu_log("cpuhp_acpi_invalid_idx_selected·"·"0x%"PRIx32·"\n",·idx);

632

············qemu_log("cpuhp_acpi_invalid_idx_selected·"·"0x%"PRIx32·"\n",·idx);

633

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

633

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

634

········}

634

········}

635

····}

635

····}

636

}

636

}

637

static·inline·void·trace_cpuhp_acpi_invalid_idx_selected(uint32_t·idx)

637

static·inline·void·trace_cpuhp_acpi_invalid_idx_selected(uint32_t·idx)

649

static·inline·void·_nocheck__trace_cpuhp_acpi_read_flags(uint32_t·idx,·uint8_t·flags)

649

static·inline·void·_nocheck__trace_cpuhp_acpi_read_flags(uint32_t·idx,·uint8_t·flags)

650

{

650

{

651

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

651

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

652

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

652

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

653

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

653

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

654

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

654

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

656

············qemu_log("%d@%zu.%06zu:cpuhp_acpi_read_flags·"·"idx[0x%"PRIx32"]·flags:·0x%"PRIx8·"\n",

656

············qemu_log("%d@%zu.%06zu:cpuhp_acpi_read_flags·"·"idx[0x%"PRIx32"]·flags:·0x%"PRIx8·"\n",

657

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

657

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

658

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

658

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

659

·····················,·idx,·flags);

659

·····················,·idx,·flags);

660

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

660

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

661

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

661

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

663

············qemu_log("cpuhp_acpi_read_flags·"·"idx[0x%"PRIx32"]·flags:·0x%"PRIx8·"\n",·idx,·flags);

663

············qemu_log("cpuhp_acpi_read_flags·"·"idx[0x%"PRIx32"]·flags:·0x%"PRIx8·"\n",·idx,·flags);

664

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

664

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

665

········}

665

········}

666

····}

666

····}

667

}

667

}

668

static·inline·void·trace_cpuhp_acpi_read_flags(uint32_t·idx,·uint8_t·flags)

668

static·inline·void·trace_cpuhp_acpi_read_flags(uint32_t·idx,·uint8_t·flags)

680

static·inline·void·_nocheck__trace_cpuhp_acpi_write_idx(uint32_t·idx)

680

static·inline·void·_nocheck__trace_cpuhp_acpi_write_idx(uint32_t·idx)

681

{

681

{

682

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

682

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

683

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

683

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

684

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

684

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

685

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

685

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

687

············qemu_log("%d@%zu.%06zu:cpuhp_acpi_write_idx·"·"set·active·cpu·idx:·0x%"PRIx32·"\n",

687

············qemu_log("%d@%zu.%06zu:cpuhp_acpi_write_idx·"·"set·active·cpu·idx:·0x%"PRIx32·"\n",

688

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

688

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

689

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

689

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

690

·····················,·idx);

690

·····················,·idx);

691

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

691

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

692

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

692

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

694

············qemu_log("cpuhp_acpi_write_idx·"·"set·active·cpu·idx:·0x%"PRIx32·"\n",·idx);

694

············qemu_log("cpuhp_acpi_write_idx·"·"set·active·cpu·idx:·0x%"PRIx32·"\n",·idx);

695

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

695

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

696

········}

696

········}

697

····}

697

····}

698

}

698

}

699

static·inline·void·trace_cpuhp_acpi_write_idx(uint32_t·idx)

699

static·inline·void·trace_cpuhp_acpi_write_idx(uint32_t·idx)

711

static·inline·void·_nocheck__trace_cpuhp_acpi_write_cmd(uint32_t·idx,·uint8_t·cmd)

711

static·inline·void·_nocheck__trace_cpuhp_acpi_write_cmd(uint32_t·idx,·uint8_t·cmd)

712

{

712

{

713

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

713

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

714

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

714

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

715

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

715

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

716

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

716

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

718

············qemu_log("%d@%zu.%06zu:cpuhp_acpi_write_cmd·"·"idx[0x%"PRIx32"]·cmd:·0x%"PRIx8·"\n",

718

············qemu_log("%d@%zu.%06zu:cpuhp_acpi_write_cmd·"·"idx[0x%"PRIx32"]·cmd:·0x%"PRIx8·"\n",

719

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

719

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

720

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

720

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

721

·····················,·idx,·cmd);

721

·····················,·idx,·cmd);

722

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

722

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

723

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

723

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

725

············qemu_log("cpuhp_acpi_write_cmd·"·"idx[0x%"PRIx32"]·cmd:·0x%"PRIx8·"\n",·idx,·cmd);

725

············qemu_log("cpuhp_acpi_write_cmd·"·"idx[0x%"PRIx32"]·cmd:·0x%"PRIx8·"\n",·idx,·cmd);

726

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

726

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

727

········}

727

········}

728

····}

728

····}

729

}

729

}

730

static·inline·void·trace_cpuhp_acpi_write_cmd(uint32_t·idx,·uint8_t·cmd)

730

static·inline·void·trace_cpuhp_acpi_write_cmd(uint32_t·idx,·uint8_t·cmd)

742

static·inline·void·_nocheck__trace_cpuhp_acpi_read_cmd_data(uint32_t·idx,·uint32_t·data)

742

static·inline·void·_nocheck__trace_cpuhp_acpi_read_cmd_data(uint32_t·idx,·uint32_t·data)

743

{

743

{

744

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

744

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

745

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

745

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

746

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

746

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

747

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

747

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

749

············qemu_log("%d@%zu.%06zu:cpuhp_acpi_read_cmd_data·"·"idx[0x%"PRIx32"]·data:·0x%"PRIx32·"\n",

749

············qemu_log("%d@%zu.%06zu:cpuhp_acpi_read_cmd_data·"·"idx[0x%"PRIx32"]·data:·0x%"PRIx32·"\n",

750

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

750

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

751

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

751

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

752

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

752

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

753

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

753

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

754

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

754

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

756

············qemu_log("cpuhp_acpi_read_cmd_data·"·"idx[0x%"PRIx32"]·data:·0x%"PRIx32·"\n",·idx,·data);

756

············qemu_log("cpuhp_acpi_read_cmd_data·"·"idx[0x%"PRIx32"]·data:·0x%"PRIx32·"\n",·idx,·data);

757

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

757

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

758

········}

758

········}

759

····}

759

····}

760

}

760

}

761

static·inline·void·trace_cpuhp_acpi_read_cmd_data(uint32_t·idx,·uint32_t·data)

761

static·inline·void·trace_cpuhp_acpi_read_cmd_data(uint32_t·idx,·uint32_t·data)

773

static·inline·void·_nocheck__trace_cpuhp_acpi_read_cmd_data2(uint32_t·idx,·uint32_t·data)

773

static·inline·void·_nocheck__trace_cpuhp_acpi_read_cmd_data2(uint32_t·idx,·uint32_t·data)

774

{

774

{

775

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

775

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

776

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

776

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

777

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

777

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

778

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

778

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

780

············qemu_log("%d@%zu.%06zu:cpuhp_acpi_read_cmd_data2·"·"idx[0x%"PRIx32"]·data:·0x%"PRIx32·"\n",

780

············qemu_log("%d@%zu.%06zu:cpuhp_acpi_read_cmd_data2·"·"idx[0x%"PRIx32"]·data:·0x%"PRIx32·"\n",

781

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

781

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

782

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

782

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

783

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

783

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

784

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

784

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

785

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

785

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

787

············qemu_log("cpuhp_acpi_read_cmd_data2·"·"idx[0x%"PRIx32"]·data:·0x%"PRIx32·"\n",·idx,·data);

787

············qemu_log("cpuhp_acpi_read_cmd_data2·"·"idx[0x%"PRIx32"]·data:·0x%"PRIx32·"\n",·idx,·data);

788

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

788

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

789

········}

789

········}

790

····}

790

····}

791

}

791

}

792

static·inline·void·trace_cpuhp_acpi_read_cmd_data2(uint32_t·idx,·uint32_t·data)

792

static·inline·void·trace_cpuhp_acpi_read_cmd_data2(uint32_t·idx,·uint32_t·data)

804

static·inline·void·_nocheck__trace_cpuhp_acpi_cpu_has_events(uint32_t·idx,·bool·ins,·bool·rm)

804

static·inline·void·_nocheck__trace_cpuhp_acpi_cpu_has_events(uint32_t·idx,·bool·ins,·bool·rm)

805

{

805

{

806

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

806

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

807

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

807

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

808

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

808

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

809

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

809

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

811

············qemu_log("%d@%zu.%06zu:cpuhp_acpi_cpu_has_events·"·"idx[0x%"PRIx32"]·inserting:·%d,·removing:·%d"·"\n",

811

············qemu_log("%d@%zu.%06zu:cpuhp_acpi_cpu_has_events·"·"idx[0x%"PRIx32"]·inserting:·%d,·removing:·%d"·"\n",

812

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

812

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

813

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

813

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

814

·····················,·idx,·ins,·rm);

814

·····················,·idx,·ins,·rm);

815

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

815

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

816

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

816

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

818

············qemu_log("cpuhp_acpi_cpu_has_events·"·"idx[0x%"PRIx32"]·inserting:·%d,·removing:·%d"·"\n",·idx,·ins,·rm);

818

············qemu_log("cpuhp_acpi_cpu_has_events·"·"idx[0x%"PRIx32"]·inserting:·%d,·removing:·%d"·"\n",·idx,·ins,·rm);

819

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

819

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

820

········}

820

········}

821

····}

821

····}

822

}

822

}

823

static·inline·void·trace_cpuhp_acpi_cpu_has_events(uint32_t·idx,·bool·ins,·bool·rm)

823

static·inline·void·trace_cpuhp_acpi_cpu_has_events(uint32_t·idx,·bool·ins,·bool·rm)

835

static·inline·void·_nocheck__trace_cpuhp_acpi_clear_inserting_evt(uint32_t·idx)

835

static·inline·void·_nocheck__trace_cpuhp_acpi_clear_inserting_evt(uint32_t·idx)

836

{

836

{

837

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

837

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

838

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

838

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

839

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

839

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

840

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

840

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

842

············qemu_log("%d@%zu.%06zu:cpuhp_acpi_clear_inserting_evt·"·"idx[0x%"PRIx32"]"·"\n",

842

············qemu_log("%d@%zu.%06zu:cpuhp_acpi_clear_inserting_evt·"·"idx[0x%"PRIx32"]"·"\n",

843

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

843

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

844

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

844

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

845

·····················,·idx);

845

·····················,·idx);

846

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

846

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

847

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

847

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

849

············qemu_log("cpuhp_acpi_clear_inserting_evt·"·"idx[0x%"PRIx32"]"·"\n",·idx);

849

············qemu_log("cpuhp_acpi_clear_inserting_evt·"·"idx[0x%"PRIx32"]"·"\n",·idx);

850

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

850

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

851

········}

851

········}

852

····}

852

····}

853

}

853

}

854

static·inline·void·trace_cpuhp_acpi_clear_inserting_evt(uint32_t·idx)

854

static·inline·void·trace_cpuhp_acpi_clear_inserting_evt(uint32_t·idx)

866

static·inline·void·_nocheck__trace_cpuhp_acpi_clear_remove_evt(uint32_t·idx)

866

static·inline·void·_nocheck__trace_cpuhp_acpi_clear_remove_evt(uint32_t·idx)

867

{

867

{

868

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

868

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

869

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

869

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

870

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

870

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

871

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

871

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

873

············qemu_log("%d@%zu.%06zu:cpuhp_acpi_clear_remove_evt·"·"idx[0x%"PRIx32"]"·"\n",

873

············qemu_log("%d@%zu.%06zu:cpuhp_acpi_clear_remove_evt·"·"idx[0x%"PRIx32"]"·"\n",

874

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

874

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

875

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

875

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

876

·····················,·idx);

876

·····················,·idx);

877

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

877

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

878

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

878

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

880

············qemu_log("cpuhp_acpi_clear_remove_evt·"·"idx[0x%"PRIx32"]"·"\n",·idx);

880

············qemu_log("cpuhp_acpi_clear_remove_evt·"·"idx[0x%"PRIx32"]"·"\n",·idx);

881

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

881

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

882

········}

882

········}

883

····}

883

····}

884

}

884

}

885

static·inline·void·trace_cpuhp_acpi_clear_remove_evt(uint32_t·idx)

885

static·inline·void·trace_cpuhp_acpi_clear_remove_evt(uint32_t·idx)

897

static·inline·void·_nocheck__trace_cpuhp_acpi_ejecting_invalid_cpu(uint32_t·idx)

897

static·inline·void·_nocheck__trace_cpuhp_acpi_ejecting_invalid_cpu(uint32_t·idx)

898

{

898

{

899

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

899

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

900

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

900

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

901

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

901

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

902

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

902

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

904

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

904

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

905

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

905

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

906

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

906

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

907

·····················,·idx);

907

·····················,·idx);

908

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

908

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

909

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

909

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

911

············qemu_log("cpuhp_acpi_ejecting_invalid_cpu·"·"0x%"PRIx32·"\n",·idx);

911

············qemu_log("cpuhp_acpi_ejecting_invalid_cpu·"·"0x%"PRIx32·"\n",·idx);

912

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

912

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

913

········}

913

········}

914

····}

914

····}

915

}

915

}

916

static·inline·void·trace_cpuhp_acpi_ejecting_invalid_cpu(uint32_t·idx)

916

static·inline·void·trace_cpuhp_acpi_ejecting_invalid_cpu(uint32_t·idx)

928

static·inline·void·_nocheck__trace_cpuhp_acpi_ejecting_cpu(uint32_t·idx)

928

static·inline·void·_nocheck__trace_cpuhp_acpi_ejecting_cpu(uint32_t·idx)

929

{

929

{

930

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

930

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

931

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

931

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

932

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

932

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

933

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

933

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

935

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

935

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

936

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

936

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

937

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

937

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

938

·····················,·idx);

938

·····················,·idx);

939

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

939

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

940

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

940

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

942

············qemu_log("cpuhp_acpi_ejecting_cpu·"·"0x%"PRIx32·"\n",·idx);

942

············qemu_log("cpuhp_acpi_ejecting_cpu·"·"0x%"PRIx32·"\n",·idx);

943

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

943

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

944

········}

944

········}

945

····}

945

····}

946

}

946

}

947

static·inline·void·trace_cpuhp_acpi_ejecting_cpu(uint32_t·idx)

947

static·inline·void·trace_cpuhp_acpi_ejecting_cpu(uint32_t·idx)

959

static·inline·void·_nocheck__trace_cpuhp_acpi_fw_remove_invalid_cpu(uint32_t·idx)

959

static·inline·void·_nocheck__trace_cpuhp_acpi_fw_remove_invalid_cpu(uint32_t·idx)

960

{

960

{

961

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

961

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

962

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

962

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

963

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

963

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

964

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

964

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

966

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

966

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

967

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

967

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

968

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

968

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

969

·····················,·idx);

969

·····················,·idx);

970

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

970

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

971

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

971

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

973

············qemu_log("cpuhp_acpi_fw_remove_invalid_cpu·"·"0x%"PRIx32·"\n",·idx);

973

············qemu_log("cpuhp_acpi_fw_remove_invalid_cpu·"·"0x%"PRIx32·"\n",·idx);

974

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

974

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

975

········}

975

········}

976

····}

976

····}

977

}

977

}

978

static·inline·void·trace_cpuhp_acpi_fw_remove_invalid_cpu(uint32_t·idx)

978

static·inline·void·trace_cpuhp_acpi_fw_remove_invalid_cpu(uint32_t·idx)

990

static·inline·void·_nocheck__trace_cpuhp_acpi_fw_remove_cpu(uint32_t·idx)

990

static·inline·void·_nocheck__trace_cpuhp_acpi_fw_remove_cpu(uint32_t·idx)

991

{

991

{

992

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

992

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

993

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

993

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

994

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

994

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

995

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

995

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

997

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

997

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

998

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

998

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

999

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

999

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

1000

·····················,·idx);

1000

·····················,·idx);

1001

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

1001

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

1002

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

1002

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

1004

············qemu_log("cpuhp_acpi_fw_remove_cpu·"·"0x%"PRIx32·"\n",·idx);

1004

············qemu_log("cpuhp_acpi_fw_remove_cpu·"·"0x%"PRIx32·"\n",·idx);

1005

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

1005

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

1006

········}

1006

········}

1007

····}

1007

····}

1008

}

1008

}

1009

static·inline·void·trace_cpuhp_acpi_fw_remove_cpu(uint32_t·idx)

1009

static·inline·void·trace_cpuhp_acpi_fw_remove_cpu(uint32_t·idx)

1021

static·inline·void·_nocheck__trace_cpuhp_acpi_write_ost_ev(uint32_t·slot,·uint32_t·ev)

1021

static·inline·void·_nocheck__trace_cpuhp_acpi_write_ost_ev(uint32_t·slot,·uint32_t·ev)

1022

{

1022

{

1023

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

1023

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

1024

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

1024

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

1025

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

1025

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

1026

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

1026

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

1028

············qemu_log("%d@%zu.%06zu:cpuhp_acpi_write_ost_ev·"·"idx[0x%"PRIx32"]·OST·EVENT:·0x%"PRIx32·"\n",

1028

············qemu_log("%d@%zu.%06zu:cpuhp_acpi_write_ost_ev·"·"idx[0x%"PRIx32"]·OST·EVENT:·0x%"PRIx32·"\n",

1029

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

1029

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

1030

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

1030

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

1031

·····················,·slot,·ev);

1031

·····················,·slot,·ev);

1032

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

1032

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

1033

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

1033

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

1035

············qemu_log("cpuhp_acpi_write_ost_ev·"·"idx[0x%"PRIx32"]·OST·EVENT:·0x%"PRIx32·"\n",·slot,·ev);

1035

············qemu_log("cpuhp_acpi_write_ost_ev·"·"idx[0x%"PRIx32"]·OST·EVENT:·0x%"PRIx32·"\n",·slot,·ev);

1036

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

1036

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

1037

········}

1037

········}

1038

····}

1038

····}

1039

}

1039

}

1040

static·inline·void·trace_cpuhp_acpi_write_ost_ev(uint32_t·slot,·uint32_t·ev)

1040

static·inline·void·trace_cpuhp_acpi_write_ost_ev(uint32_t·slot,·uint32_t·ev)

1052

static·inline·void·_nocheck__trace_cpuhp_acpi_write_ost_status(uint32_t·slot,·uint32_t·st)

1052

static·inline·void·_nocheck__trace_cpuhp_acpi_write_ost_status(uint32_t·slot,·uint32_t·st)

1053

{

1053

{

1054

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

1054

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

1055

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

1055

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

1056

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

1056

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

1057

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

1057

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

1059

············qemu_log("%d@%zu.%06zu:cpuhp_acpi_write_ost_status·"·"idx[0x%"PRIx32"]·OST·STATUS:·0x%"PRIx32·"\n",

1059

············qemu_log("%d@%zu.%06zu:cpuhp_acpi_write_ost_status·"·"idx[0x%"PRIx32"]·OST·STATUS:·0x%"PRIx32·"\n",

1060

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

1060

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

1061

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

1061

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

1062

·····················,·slot,·st);

1062

·····················,·slot,·st);

1063

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

1063

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

1064

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

1064

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

1066

············qemu_log("cpuhp_acpi_write_ost_status·"·"idx[0x%"PRIx32"]·OST·STATUS:·0x%"PRIx32·"\n",·slot,·st);

1066

············qemu_log("cpuhp_acpi_write_ost_status·"·"idx[0x%"PRIx32"]·OST·STATUS:·0x%"PRIx32·"\n",·slot,·st);

1067

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

1067

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

1068

········}

1068

········}

1069

····}

1069

····}

1070

}

1070

}

1071

static·inline·void·trace_cpuhp_acpi_write_ost_status(uint32_t·slot,·uint32_t·st)

1071

static·inline·void·trace_cpuhp_acpi_write_ost_status(uint32_t·slot,·uint32_t·st)

1083

static·inline·void·_nocheck__trace_acpi_pci_eject_slot(unsigned·bsel,·unsigned·slot)

1083

static·inline·void·_nocheck__trace_acpi_pci_eject_slot(unsigned·bsel,·unsigned·slot)

1084

{

1084

{

1085

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

1085

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

1086

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

1086

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

1087

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

1087

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

1088

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

1088

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

1090

············qemu_log("%d@%zu.%06zu:acpi_pci_eject_slot·"·"bsel:·%u·slot:·%u"·"\n",

1090

············qemu_log("%d@%zu.%06zu:acpi_pci_eject_slot·"·"bsel:·%u·slot:·%u"·"\n",

1091

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

1091

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

1092

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

1092

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

1093

·····················,·bsel,·slot);

1093

·····················,·bsel,·slot);

1094

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

1094

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

1095

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

1095

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

1097

············qemu_log("acpi_pci_eject_slot·"·"bsel:·%u·slot:·%u"·"\n",·bsel,·slot);

1097

············qemu_log("acpi_pci_eject_slot·"·"bsel:·%u·slot:·%u"·"\n",·bsel,·slot);

1098

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

1098

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

1099

········}

1099

········}

1100

····}

1100

····}

1101

}

1101

}

1102

static·inline·void·trace_acpi_pci_eject_slot(unsigned·bsel,·unsigned·slot)

1102

static·inline·void·trace_acpi_pci_eject_slot(unsigned·bsel,·unsigned·slot)

1114

static·inline·void·_nocheck__trace_acpi_pci_unplug(int·bsel,·int·slot)

1114

static·inline·void·_nocheck__trace_acpi_pci_unplug(int·bsel,·int·slot)

1115

{

1115

{

1116

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

1116

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

1117

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

1117

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

1118

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

1118

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

1119

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

1119

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

1121

············qemu_log("%d@%zu.%06zu:acpi_pci_unplug·"·"bsel:·%d·slot:·%d"·"\n",

1121

············qemu_log("%d@%zu.%06zu:acpi_pci_unplug·"·"bsel:·%d·slot:·%d"·"\n",

1122

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

1122

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

1123

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

1123

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

1124

·····················,·bsel,·slot);

1124

·····················,·bsel,·slot);

1125

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

1125

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

1126

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

1126

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

1128

············qemu_log("acpi_pci_unplug·"·"bsel:·%d·slot:·%d"·"\n",·bsel,·slot);

1128

············qemu_log("acpi_pci_unplug·"·"bsel:·%d·slot:·%d"·"\n",·bsel,·slot);

1129

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

1129

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

1130

········}

1130

········}

1131

····}

1131

····}

1132

}

1132

}

1133

static·inline·void·trace_acpi_pci_unplug(int·bsel,·int·slot)

1133

static·inline·void·trace_acpi_pci_unplug(int·bsel,·int·slot)

1145

static·inline·void·_nocheck__trace_acpi_pci_unplug_request(int·bsel,·int·slot)

1145

static·inline·void·_nocheck__trace_acpi_pci_unplug_request(int·bsel,·int·slot)

1146

{

1146

{

1147

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

1147

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

1148

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

1148

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

1149

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

1149

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

1150

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

1150

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

1152

············qemu_log("%d@%zu.%06zu:acpi_pci_unplug_request·"·"bsel:·%d·slot:·%d"·"\n",

1152

············qemu_log("%d@%zu.%06zu:acpi_pci_unplug_request·"·"bsel:·%d·slot:·%d"·"\n",

1153

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

1153

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

1154

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

1154

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

1155

·····················,·bsel,·slot);

1155

·····················,·bsel,·slot);

1156

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

1156

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

1157

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

1157

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

1159

············qemu_log("acpi_pci_unplug_request·"·"bsel:·%d·slot:·%d"·"\n",·bsel,·slot);

1159

············qemu_log("acpi_pci_unplug_request·"·"bsel:·%d·slot:·%d"·"\n",·bsel,·slot);

1160

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

1160

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

1161

········}

1161

········}

1162

····}

1162

····}

1163

}

1163

}

1164

static·inline·void·trace_acpi_pci_unplug_request(int·bsel,·int·slot)

1164

static·inline·void·trace_acpi_pci_unplug_request(int·bsel,·int·slot)

1176

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

1176

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

1177

{

1177

{

1178

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

1178

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

1179

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

1179

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

1180

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

1180

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

1181

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

1181

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

1183

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

1183

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

1184

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

1184

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

1185

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

1185

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

1186

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

1186

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

1187

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

1187

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

1188

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

1188

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

1190

············qemu_log("acpi_pci_up_read·"·"%"·PRIu32·"\n",·val);

1190

············qemu_log("acpi_pci_up_read·"·"%"·PRIu32·"\n",·val);

1191

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

1191

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

1192

········}

1192

········}

1193

····}

1193

····}

1194

}

1194

}

1195

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

1195

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

1207

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

1207

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

1208

{

1208

{

1209

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

1209

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

1210

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

1210

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

1211

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

1211

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

1212

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

1212

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

1214

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

1214

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

1215

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

1215

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

1216

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

1216

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

1217

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

1217

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

1218

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

1218

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

1219

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

1219

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

1221

············qemu_log("acpi_pci_down_read·"·"%"·PRIu32·"\n",·val);

1221

············qemu_log("acpi_pci_down_read·"·"%"·PRIu32·"\n",·val);

1222

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

1222

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

1223

········}

1223

········}

1224

····}

1224

····}

1225

}

1225

}

1226

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

1226

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

1238

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

1238

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

1239

{

1239

{

1240

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

1240

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

1241

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

1241

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

1242

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

1242

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

1243

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

1243

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

1245

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

1245

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

1246

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

1246

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

1247

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

1247

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

1248

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

1248

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

1249

#line·1251·"trace/trace-hw_acpi.h"

1249

#line·1251·"trace/trace-hw_acpi.h"

1250

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

1250

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

1252

············qemu_log("acpi_pci_features_read·"·"%"·PRIu32·"\n",·val);

1252

············qemu_log("acpi_pci_features_read·"·"%"·PRIu32·"\n",·val);

1253

#line·1255·"trace/trace-hw_acpi.h"

1253

#line·1255·"trace/trace-hw_acpi.h"

1254

········}

1254

········}

1255

····}

1255

····}

1256

}

1256

}

1257

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

1257

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

1269

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

1269

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

1270

{

1270

{

1271

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

1271

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

1272

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

1272

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

1273

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

1273

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

1274

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

1274

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

1276

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

1276

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

1277

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

1277

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

1278

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

1278

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

1279

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

1279

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

1280

#line·1282·"trace/trace-hw_acpi.h"

1280

#line·1282·"trace/trace-hw_acpi.h"

1281

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

1281

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

1283

············qemu_log("acpi_pci_acpi_index_read·"·"%"·PRIu32·"\n",·val);

1283

············qemu_log("acpi_pci_acpi_index_read·"·"%"·PRIu32·"\n",·val);

1284

#line·1286·"trace/trace-hw_acpi.h"

1284

#line·1286·"trace/trace-hw_acpi.h"

1285

········}

1285

········}

1286

····}

1286

····}

1287

}

1287

}

1288

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

1288

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

1300

static·inline·void·_nocheck__trace_acpi_pci_acpi_index_write(unsigned·bsel,·unsigned·slot,·uint32_t·aidx)

1300

static·inline·void·_nocheck__trace_acpi_pci_acpi_index_write(unsigned·bsel,·unsigned·slot,·uint32_t·aidx)

1301

{

1301

{

1302

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

1302

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

1303

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

1303

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

1304

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

1304

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

1305

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

1305

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

1307

············qemu_log("%d@%zu.%06zu:acpi_pci_acpi_index_write·"·"bsel:·%u·slot:·%u·aidx:·%"·PRIu32·"\n",

1307

············qemu_log("%d@%zu.%06zu:acpi_pci_acpi_index_write·"·"bsel:·%u·slot:·%u·aidx:·%"·PRIu32·"\n",

1308

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

1308

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

1309

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

1309

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

1310

·····················,·bsel,·slot,·aidx);

1310

·····················,·bsel,·slot,·aidx);

1311

#line·1313·"trace/trace-hw_acpi.h"

1311

#line·1313·"trace/trace-hw_acpi.h"

1312

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

1312

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

1314

············qemu_log("acpi_pci_acpi_index_write·"·"bsel:·%u·slot:·%u·aidx:·%"·PRIu32·"\n",·bsel,·slot,·aidx);

1314

············qemu_log("acpi_pci_acpi_index_write·"·"bsel:·%u·slot:·%u·aidx:·%"·PRIu32·"\n",·bsel,·slot,·aidx);

1315

#line·1317·"trace/trace-hw_acpi.h"

1315

#line·1317·"trace/trace-hw_acpi.h"

1316

········}

1316

········}

1317

····}

1317

····}

1318

}

1318

}

1319

static·inline·void·trace_acpi_pci_acpi_index_write(unsigned·bsel,·unsigned·slot,·uint32_t·aidx)

1319

static·inline·void·trace_acpi_pci_acpi_index_write(unsigned·bsel,·unsigned·slot,·uint32_t·aidx)

1331

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

1331

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

1332

{

1332

{

1333

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

1333

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

1334

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

1334

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

1335

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

1335

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

1336

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

1336

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

1338

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

1338

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

1339

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

1339

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

1340

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

1340

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

1341

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

1341

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

1342

#line·1344·"trace/trace-hw_acpi.h"

1342

#line·1344·"trace/trace-hw_acpi.h"

1343

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

1343

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

1345

············qemu_log("acpi_pci_rmv_read·"·"%"·PRIu32·"\n",·val);

1345

············qemu_log("acpi_pci_rmv_read·"·"%"·PRIu32·"\n",·val);

1346

#line·1348·"trace/trace-hw_acpi.h"

1346

#line·1348·"trace/trace-hw_acpi.h"

1347

········}

1347

········}

1348

····}

1348

····}

1349

}

1349

}

1350

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

1350

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

1362

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

1362

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

1363

{

1363

{

1364

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

1364

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

1365

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

1365

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

1366

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

1366

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

1367

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

1367

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

1369

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

1369

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

1370

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

1370

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

1371

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

1371

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

1372

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

1372

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

1373

#line·1375·"trace/trace-hw_acpi.h"

1373

#line·1375·"trace/trace-hw_acpi.h"

1374

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

1374

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

1376

············qemu_log("acpi_pci_sel_read·"·"%"·PRIu32·"\n",·val);

1376

············qemu_log("acpi_pci_sel_read·"·"%"·PRIu32·"\n",·val);

1377

#line·1379·"trace/trace-hw_acpi.h"

1377

#line·1379·"trace/trace-hw_acpi.h"

1378

········}

1378

········}

1379

····}

1379

····}

1380

}

1380

}

1381

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

1381

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

1393

static·inline·void·_nocheck__trace_acpi_pci_ej_write(uint64_t·addr,·uint64_t·data)

1393

static·inline·void·_nocheck__trace_acpi_pci_ej_write(uint64_t·addr,·uint64_t·data)

1394

{

1394

{

1395

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

1395

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

1396

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

1396

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

1397

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

1397

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

1398

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

1398

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

1400

············qemu_log("%d@%zu.%06zu:acpi_pci_ej_write·"·"0x%"·PRIx64·"·<==·%"·PRIu64·"\n",

1400

············qemu_log("%d@%zu.%06zu:acpi_pci_ej_write·"·"0x%"·PRIx64·"·<==·%"·PRIu64·"\n",

1401

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

1401

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

1402

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

1402

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

1403

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

1403

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

1404

#line·1406·"trace/trace-hw_acpi.h"

1404

#line·1406·"trace/trace-hw_acpi.h"

1405

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

1405

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

1407

············qemu_log("acpi_pci_ej_write·"·"0x%"·PRIx64·"·<==·%"·PRIu64·"\n",·addr,·data);

1407

············qemu_log("acpi_pci_ej_write·"·"0x%"·PRIx64·"·<==·%"·PRIu64·"\n",·addr,·data);

1408

#line·1410·"trace/trace-hw_acpi.h"

1408

#line·1410·"trace/trace-hw_acpi.h"

1409

········}

1409

········}

1410

····}

1410

····}

1411

}

1411

}

1412

static·inline·void·trace_acpi_pci_ej_write(uint64_t·addr,·uint64_t·data)

1412

static·inline·void·trace_acpi_pci_ej_write(uint64_t·addr,·uint64_t·data)

1424

static·inline·void·_nocheck__trace_acpi_pci_sel_write(uint64_t·addr,·uint64_t·data)

1424

static·inline·void·_nocheck__trace_acpi_pci_sel_write(uint64_t·addr,·uint64_t·data)

1425

{

1425

{

1426

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

1426

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

1427

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

1427

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

1428

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

1428

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

1429

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

1429

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

1431

············qemu_log("%d@%zu.%06zu:acpi_pci_sel_write·"·"0x%"·PRIx64·"·<==·%"·PRIu64·"\n",

1431

············qemu_log("%d@%zu.%06zu:acpi_pci_sel_write·"·"0x%"·PRIx64·"·<==·%"·PRIu64·"\n",

1432

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

1432

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

1433

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

1433

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

1434

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

1434

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

1435

#line·1437·"trace/trace-hw_acpi.h"

1435

#line·1437·"trace/trace-hw_acpi.h"

1436

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

1436

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

1438

············qemu_log("acpi_pci_sel_write·"·"0x%"·PRIx64·"·<==·%"·PRIu64·"\n",·addr,·data);

1438

············qemu_log("acpi_pci_sel_write·"·"0x%"·PRIx64·"·<==·%"·PRIu64·"\n",·addr,·data);

1439

#line·1441·"trace/trace-hw_acpi.h"

1439

#line·1441·"trace/trace-hw_acpi.h"

1440

········}

1440

········}

1441

····}

1441

····}

1442

}

1442

}

1443

static·inline·void·trace_acpi_pci_sel_write(uint64_t·addr,·uint64_t·data)

1443

static·inline·void·trace_acpi_pci_sel_write(uint64_t·addr,·uint64_t·data)

1455

static·inline·void·_nocheck__trace_piix4_gpe_readb(uint64_t·addr,·unsigned·width,·uint64_t·val)

1455

static·inline·void·_nocheck__trace_piix4_gpe_readb(uint64_t·addr,·unsigned·width,·uint64_t·val)

1456

{

1456

{

1457

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

1457

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

1458

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

1458

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

1459

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

1459

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

1460

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

1460

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

1462

············qemu_log("%d@%zu.%06zu:piix4_gpe_readb·"·"addr:·0x%"·PRIx64·"·width:·%d·==>·0x%"·PRIx64·"\n",

1462

············qemu_log("%d@%zu.%06zu:piix4_gpe_readb·"·"addr:·0x%"·PRIx64·"·width:·%d·==>·0x%"·PRIx64·"\n",

1463

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

1463

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

1464

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

1464

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

1465

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

1465

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

1466

#line·1468·"trace/trace-hw_acpi.h"

1466

#line·1468·"trace/trace-hw_acpi.h"

1467

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

1467

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

1469

············qemu_log("piix4_gpe_readb·"·"addr:·0x%"·PRIx64·"·width:·%d·==>·0x%"·PRIx64·"\n",·addr,·width,·val);

1469

············qemu_log("piix4_gpe_readb·"·"addr:·0x%"·PRIx64·"·width:·%d·==>·0x%"·PRIx64·"\n",·addr,·width,·val);

1470

#line·1472·"trace/trace-hw_acpi.h"

1470

#line·1472·"trace/trace-hw_acpi.h"

1471

········}

1471

········}

1472

····}

1472

····}

1473

}

1473

}

1474

static·inline·void·trace_piix4_gpe_readb(uint64_t·addr,·unsigned·width,·uint64_t·val)

1474

static·inline·void·trace_piix4_gpe_readb(uint64_t·addr,·unsigned·width,·uint64_t·val)

1486

static·inline·void·_nocheck__trace_piix4_gpe_writeb(uint64_t·addr,·unsigned·width,·uint64_t·val)

1486

static·inline·void·_nocheck__trace_piix4_gpe_writeb(uint64_t·addr,·unsigned·width,·uint64_t·val)

1487

{

1487

{

1488

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

1488

····if·(trace_event_get_state(TRACE_PIIX4_GPE_WRITEB)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1489

········if·(message_with_timestamp)·{

1489

········if·(message_with_timestamp)·{

1490

············struct·timeval·_now;

1490

············struct·timeval·_now;

1491

············gettimeofday(&_now,·NULL);

1491

············gettimeofday(&_now,·NULL);

1493

············qemu_log("%d@%zu.%06zu:piix4_gpe_writeb·"·"addr:·0x%"·PRIx64·"·width:·%d·<==·0x%"·PRIx64·"\n",

1493

············qemu_log("%d@%zu.%06zu:piix4_gpe_writeb·"·"addr:·0x%"·PRIx64·"·width:·%d·<==·0x%"·PRIx64·"\n",

1494

·····················qemu_get_thread_id(),

1494

·····················qemu_get_thread_id(),

1495

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1495

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1496

·····················,·addr,·width,·val);

1496

·····················,·addr,·width,·val);

1497

#line·1499·"trace/trace-hw_acpi.h"

1497

#line·1499·"trace/trace-hw_acpi.h"

1498

········}·else·{

1498

········}·else·{

1500

············qemu_log("piix4_gpe_writeb·"·"addr:·0x%"·PRIx64·"·width:·%d·<==·0x%"·PRIx64·"\n",·addr,·width,·val);

1500

············qemu_log("piix4_gpe_writeb·"·"addr:·0x%"·PRIx64·"·width:·%d·<==·0x%"·PRIx64·"\n",·addr,·width,·val);

1501

#line·1503·"trace/trace-hw_acpi.h"

1501

#line·1503·"trace/trace-hw_acpi.h"

1502

········}

1502

········}

1503

····}

1503

····}

1504

}

1504

}

1505

static·inline·void·trace_piix4_gpe_writeb(uint64_t·addr,·unsigned·width,·uint64_t·val)

1505

static·inline·void·trace_piix4_gpe_writeb(uint64_t·addr,·unsigned·width,·uint64_t·val)

1517

static·inline·void·_nocheck__trace_tco_timer_reload(int·ticks,·int·msec)

1517

static·inline·void·_nocheck__trace_tco_timer_reload(int·ticks,·int·msec)

1518

{

1518

{

1519

····if·(trace_event_get_state(TRACE_TCO_TIMER_RELOAD)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1519

····if·(trace_event_get_state(TRACE_TCO_TIMER_RELOAD)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1520

········if·(message_with_timestamp)·{

1520

········if·(message_with_timestamp)·{

1521

············struct·timeval·_now;

1521

············struct·timeval·_now;

1522

············gettimeofday(&_now,·NULL);

1522

············gettimeofday(&_now,·NULL);

1524

············qemu_log("%d@%zu.%06zu:tco_timer_reload·"·"ticks=%d·(%d·ms)"·"\n",

1524

············qemu_log("%d@%zu.%06zu:tco_timer_reload·"·"ticks=%d·(%d·ms)"·"\n",

1525

·····················qemu_get_thread_id(),

1525

·····················qemu_get_thread_id(),

1526

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1526

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1527

·····················,·ticks,·msec);

1527

·····················,·ticks,·msec);

1528

#line·1530·"trace/trace-hw_acpi.h"

1528

#line·1530·"trace/trace-hw_acpi.h"

1529

········}·else·{

1529

········}·else·{

1531

············qemu_log("tco_timer_reload·"·"ticks=%d·(%d·ms)"·"\n",·ticks,·msec);

1531

············qemu_log("tco_timer_reload·"·"ticks=%d·(%d·ms)"·"\n",·ticks,·msec);

1532

#line·1534·"trace/trace-hw_acpi.h"

1532

#line·1534·"trace/trace-hw_acpi.h"

1533

········}

1533

········}

1534

····}

1534

····}

1535

}

1535

}

1536

static·inline·void·trace_tco_timer_reload(int·ticks,·int·msec)

1536

static·inline·void·trace_tco_timer_reload(int·ticks,·int·msec)

1548

static·inline·void·_nocheck__trace_tco_timer_expired(int·timeouts_no,·bool·strap,·bool·no_reboot)

1548

static·inline·void·_nocheck__trace_tco_timer_expired(int·timeouts_no,·bool·strap,·bool·no_reboot)

1549

{

1549

{

1550

····if·(trace_event_get_state(TRACE_TCO_TIMER_EXPIRED)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1550

····if·(trace_event_get_state(TRACE_TCO_TIMER_EXPIRED)·&&·qemu_loglevel_mask(LOG_TRACE))·{

1551

········if·(message_with_timestamp)·{

1551

········if·(message_with_timestamp)·{

1552

············struct·timeval·_now;

1552

············struct·timeval·_now;

1553

············gettimeofday(&_now,·NULL);

1553

············gettimeofday(&_now,·NULL);

1555

············qemu_log("%d@%zu.%06zu:tco_timer_expired·"·"timeouts_no=%d·no_reboot=%d/%d"·"\n",

1555

············qemu_log("%d@%zu.%06zu:tco_timer_expired·"·"timeouts_no=%d·no_reboot=%d/%d"·"\n",

1556

·····················qemu_get_thread_id(),

1556

·····················qemu_get_thread_id(),

1557

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1557

·····················(size_t)_now.tv_sec,·(size_t)_now.tv_usec

1558

·····················,·timeouts_no,·strap,·no_reboot);

1558

·····················,·timeouts_no,·strap,·no_reboot);

1559

#line·1561·"trace/trace-hw_acpi.h"

1559

#line·1561·"trace/trace-hw_acpi.h"

1560

········}·else·{

1560

········}·else·{

1562

············qemu_log("tco_timer_expired·"·"timeouts_no=%d·no_reboot=%d/%d"·"\n",·timeouts_no,·strap,·no_reboot);

1562

············qemu_log("tco_timer_expired·"·"timeouts_no=%d·no_reboot=%d/%d"·"\n",·timeouts_no,·strap,·no_reboot);

1563

#line·1565·"trace/trace-hw_acpi.h"

1563

#line·1565·"trace/trace-hw_acpi.h"

1564

········}

1564

········}

1565

····}

1565

····}

1566

}

1566

}

1567

static·inline·void·trace_tco_timer_expired(int·timeouts_no,·bool·strap,·bool·no_reboot)

1567

static·inline·void·trace_tco_timer_expired(int·timeouts_no,·bool·strap,·bool·no_reboot)