arch/arm64/kvm/arch_timer.c

409

struct kvm_sync_regs *regs = &vcpu->run->s.regs;

arch/arm64/kvm/arch_timer.c

894

struct kvm_sync_regs *sregs = &vcpu->run->s.regs;

arch/arm64/kvm/arm.c

1054

memset(&vcpu->run->system_event, 0, sizeof(vcpu->run->system_event));

arch/arm64/kvm/arm.c

1055

vcpu->run->system_event.type = KVM_SYSTEM_EVENT_WAKEUP;

arch/arm64/kvm/arm.c

1056

vcpu->run->exit_reason = KVM_EXIT_SYSTEM_EVENT;

arch/arm64/kvm/arm.c

1155

struct kvm_run *run = vcpu->run;

arch/arm64/kvm/arm.c

1168

run->exit_reason = KVM_EXIT_INTR;

arch/arm64/kvm/arm.c

1174

run->exit_reason = KVM_EXIT_FAIL_ENTRY;

arch/arm64/kvm/arm.c

1175

run->fail_entry.hardware_entry_failure_reason = KVM_EXIT_FAIL_ENTRY_CPU_UNSUPPORTED;

arch/arm64/kvm/arm.c

1176

run->fail_entry.cpu = smp_processor_id();

arch/arm64/kvm/arm.c

1215

struct kvm_run *run = vcpu->run;

arch/arm64/kvm/arm.c

1218

if (run->exit_reason == KVM_EXIT_MMIO) {

arch/arm64/kvm/arm.c

1234

run->exit_reason = KVM_EXIT_UNKNOWN;

arch/arm64/kvm/arm.c

1235

run->flags = 0;

arch/arm64/kvm/handle_exit.c

193

struct kvm_run *run = vcpu->run;

arch/arm64/kvm/handle_exit.c

199

run->exit_reason = KVM_EXIT_DEBUG;

arch/arm64/kvm/handle_exit.c

200

run->debug.arch.hsr = lower_32_bits(esr);

arch/arm64/kvm/handle_exit.c

201

run->debug.arch.hsr_high = upper_32_bits(esr);

arch/arm64/kvm/handle_exit.c

202

run->flags = KVM_DEBUG_ARCH_HSR_HIGH_VALID;

arch/arm64/kvm/handle_exit.c

206

run->debug.arch.far = vcpu->arch.fault.far_el2;

arch/arm64/kvm/handle_exit.c

448

struct kvm_run *run = vcpu->run;

arch/arm64/kvm/handle_exit.c

472

run->exit_reason = KVM_EXIT_FAIL_ENTRY;

arch/arm64/kvm/handle_exit.c

479

run->exit_reason = KVM_EXIT_FAIL_ENTRY;

arch/arm64/kvm/handle_exit.c

484

run->exit_reason = KVM_EXIT_INTERNAL_ERROR;

arch/arm64/kvm/hypercalls.c

249

struct kvm_run *run = vcpu->run;

arch/arm64/kvm/hypercalls.c

258

run->exit_reason = KVM_EXIT_HYPERCALL;

arch/arm64/kvm/hypercalls.c

259

run->hypercall = (typeof(run->hypercall)) {

arch/arm64/kvm/mmio.c

124

struct kvm_run *run = vcpu->run;

arch/arm64/kvm/mmio.c

127

data = kvm_mmio_read_buf(run->mmio.data, len);

arch/arm64/kvm/mmio.c

138

trace_kvm_mmio(KVM_TRACE_MMIO_READ, len, run->mmio.phys_addr,

arch/arm64/kvm/mmio.c

155

struct kvm_run *run = vcpu->run;

arch/arm64/kvm/mmio.c

182

run->exit_reason = KVM_EXIT_ARM_NISV;

arch/arm64/kvm/mmio.c

183

run->arm_nisv.esr_iss = kvm_vcpu_dabt_iss_nisv_sanitized(vcpu);

arch/arm64/kvm/mmio.c

184

run->arm_nisv.fault_ipa = fault_ipa;

arch/arm64/kvm/mmio.c

206

run->exit_reason = KVM_EXIT_ARM_LDST64B;

arch/arm64/kvm/mmio.c

207

run->arm_nisv.esr_iss = esr & ~(u64)ESR_ELx_FSC;

arch/arm64/kvm/mmio.c

208

run->arm_nisv.fault_ipa = fault_ipa;

arch/arm64/kvm/mmio.c

240

run->mmio.is_write = is_write;

arch/arm64/kvm/mmio.c

241

run->mmio.phys_addr = fault_ipa;

arch/arm64/kvm/mmio.c

242

run->mmio.len = len;

arch/arm64/kvm/mmio.c

248

memcpy(run->mmio.data, data_buf, len);

arch/arm64/kvm/mmio.c

255

memcpy(run->mmio.data, data_buf, len);

arch/arm64/kvm/mmio.c

257

run->exit_reason = KVM_EXIT_MMIO;

arch/arm64/kvm/mmu.c

1990

struct kvm_run *run = vcpu->run;

arch/arm64/kvm/mmu.c

2022

memset(&run->arm_sea, 0, sizeof(run->arm_sea));

arch/arm64/kvm/mmu.c

2023

run->exit_reason = KVM_EXIT_ARM_SEA;

arch/arm64/kvm/mmu.c

2024

run->arm_sea.esr = esr & esr_mask;

arch/arm64/kvm/mmu.c

2027

run->arm_sea.gva = kvm_vcpu_get_hfar(vcpu);

arch/arm64/kvm/mmu.c

2031

run->arm_sea.flags |= KVM_EXIT_ARM_SEA_FLAG_GPA_VALID;

arch/arm64/kvm/mmu.c

2032

run->arm_sea.gpa = ipa;

arch/arm64/kvm/pmu-emul.c

417

struct kvm_sync_regs *sregs = &vcpu->run->s.regs;

arch/arm64/kvm/pmu-emul.c

431

struct kvm_sync_regs *regs = &vcpu->run->s.regs;

arch/arm64/kvm/psci.c

185

memset(&vcpu->run->system_event, 0, sizeof(vcpu->run->system_event));

arch/arm64/kvm/psci.c

186

vcpu->run->system_event.type = type;

arch/arm64/kvm/psci.c

187

vcpu->run->system_event.ndata = 1;

arch/arm64/kvm/psci.c

188

vcpu->run->system_event.data[0] = flags;

arch/arm64/kvm/psci.c

189

vcpu->run->exit_reason = KVM_EXIT_SYSTEM_EVENT;

arch/arm64/kvm/psci.c

216

struct kvm_run *run = vcpu->run;

arch/arm64/kvm/psci.c

218

memset(&run->system_event, 0, sizeof(vcpu->run->system_event));

arch/arm64/kvm/psci.c

219

run->system_event.type = KVM_SYSTEM_EVENT_SUSPEND;

arch/arm64/kvm/psci.c

220

run->exit_reason = KVM_EXIT_SYSTEM_EVENT;

arch/loongarch/include/asm/kvm_csr.h

187

int kvm_emu_iocsr(larch_inst inst, struct kvm_run *run, struct kvm_vcpu *vcpu);

arch/loongarch/include/asm/kvm_host.h

182

int (*handle_exit)(struct kvm_run *run, struct kvm_vcpu *vcpu);

arch/loongarch/include/asm/kvm_host.h

356

int kvm_enter_guest(struct kvm_run *run, struct kvm_vcpu *vcpu);

arch/loongarch/include/asm/kvm_host.h

88

int (*enter_guest)(struct kvm_run *run, struct kvm_vcpu *vcpu);

arch/loongarch/include/asm/kvm_vcpu.h

45

int kvm_complete_mmio_read(struct kvm_vcpu *vcpu, struct kvm_run *run);

arch/loongarch/include/asm/kvm_vcpu.h

46

int kvm_complete_iocsr_read(struct kvm_vcpu *vcpu, struct kvm_run *run);

arch/loongarch/include/asm/kvm_vcpu.h

47

int kvm_complete_user_service(struct kvm_vcpu *vcpu, struct kvm_run *run);

arch/loongarch/kernel/asm-offsets.c

297

OFFSET(KVM_VCPU_RUN, kvm_vcpu, run);

arch/loongarch/kvm/exit.c

157

int kvm_emu_iocsr(larch_inst inst, struct kvm_run *run, struct kvm_vcpu *vcpu)

arch/loongarch/kvm/exit.c

170

run->iocsr_io.phys_addr = addr;

arch/loongarch/kvm/exit.c

171

run->iocsr_io.is_write = 0;

arch/loongarch/kvm/exit.c

177

run->iocsr_io.len = 1;

arch/loongarch/kvm/exit.c

180

run->iocsr_io.len = 2;

arch/loongarch/kvm/exit.c

183

run->iocsr_io.len = 4;

arch/loongarch/kvm/exit.c

186

run->iocsr_io.len = 8;

arch/loongarch/kvm/exit.c

189

run->iocsr_io.len = 1;

arch/loongarch/kvm/exit.c

190

run->iocsr_io.is_write = 1;

arch/loongarch/kvm/exit.c

193

run->iocsr_io.len = 2;

arch/loongarch/kvm/exit.c

194

run->iocsr_io.is_write = 1;

arch/loongarch/kvm/exit.c

197

run->iocsr_io.len = 4;

arch/loongarch/kvm/exit.c

198

run->iocsr_io.is_write = 1;

arch/loongarch/kvm/exit.c

201

run->iocsr_io.len = 8;

arch/loongarch/kvm/exit.c

202

run->iocsr_io.is_write = 1;

arch/loongarch/kvm/exit.c

208

if (run->iocsr_io.is_write) {

arch/loongarch/kvm/exit.c

210

ret = kvm_io_bus_write(vcpu, KVM_IOCSR_BUS, addr, run->iocsr_io.len, val);

arch/loongarch/kvm/exit.c

217

memcpy(run->iocsr_io.data, val, run->iocsr_io.len);

arch/loongarch/kvm/exit.c

219

trace_kvm_iocsr(KVM_TRACE_IOCSR_WRITE, run->iocsr_io.len, addr, val);

arch/loongarch/kvm/exit.c

224

run->iocsr_io.len, run->iocsr_io.data);

arch/loongarch/kvm/exit.c

227

kvm_complete_iocsr_read(vcpu, run);

arch/loongarch/kvm/exit.c

231

trace_kvm_iocsr(KVM_TRACE_IOCSR_READ, run->iocsr_io.len, addr, NULL);

arch/loongarch/kvm/exit.c

237

int kvm_complete_iocsr_read(struct kvm_vcpu *vcpu, struct kvm_run *run)

arch/loongarch/kvm/exit.c

242

switch (run->iocsr_io.len) {

arch/loongarch/kvm/exit.c

244

*gpr = *(s8 *)run->iocsr_io.data;

arch/loongarch/kvm/exit.c

247

*gpr = *(s16 *)run->iocsr_io.data;

arch/loongarch/kvm/exit.c

250

*gpr = *(s32 *)run->iocsr_io.data;

arch/loongarch/kvm/exit.c

253

*gpr = *(s64 *)run->iocsr_io.data;

arch/loongarch/kvm/exit.c

257

run->iocsr_io.len, vcpu->arch.badv);

arch/loongarch/kvm/exit.c

281

struct kvm_run *run = vcpu->run;

arch/loongarch/kvm/exit.c

308

er = kvm_emu_iocsr(inst, run, vcpu);

arch/loongarch/kvm/exit.c

356

vcpu->run->exit_reason = KVM_EXIT_MMIO;

arch/loongarch/kvm/exit.c

359

vcpu->run->exit_reason = KVM_EXIT_LOONGARCH_IOCSR;

arch/loongarch/kvm/exit.c

373

struct kvm_run *run = vcpu->run;

arch/loongarch/kvm/exit.c

375

run->mmio.phys_addr = vcpu->arch.badv;

arch/loongarch/kvm/exit.c

387

run->mmio.len = 4;

arch/loongarch/kvm/exit.c

390

run->mmio.len = 8;

arch/loongarch/kvm/exit.c

402

run->mmio.len = 1;

arch/loongarch/kvm/exit.c

406

run->mmio.len = 1;

arch/loongarch/kvm/exit.c

409

run->mmio.len = 2;

arch/loongarch/kvm/exit.c

413

run->mmio.len = 2;

arch/loongarch/kvm/exit.c

416

run->mmio.len = 4;

arch/loongarch/kvm/exit.c

420

run->mmio.len = 4;

arch/loongarch/kvm/exit.c

423

run->mmio.len = 8;

arch/loongarch/kvm/exit.c

436

run->mmio.len = 1;

arch/loongarch/kvm/exit.c

439

run->mmio.len = 1;

arch/loongarch/kvm/exit.c

443

run->mmio.len = 2;

arch/loongarch/kvm/exit.c

446

run->mmio.len = 2;

arch/loongarch/kvm/exit.c

450

run->mmio.len = 4;

arch/loongarch/kvm/exit.c

453

run->mmio.len = 4;

arch/loongarch/kvm/exit.c

457

run->mmio.len = 8;

arch/loongarch/kvm/exit.c

469

trace_kvm_mmio(KVM_TRACE_MMIO_READ, run->mmio.len, run->mmio.phys_addr, NULL);

arch/loongarch/kvm/exit.c

480

run->mmio.len, run->mmio.data);

arch/loongarch/kvm/exit.c

483

kvm_complete_mmio_read(vcpu, run);

arch/loongarch/kvm/exit.c

489

run->mmio.is_write = 0;

arch/loongarch/kvm/exit.c

502

int kvm_complete_mmio_read(struct kvm_vcpu *vcpu, struct kvm_run *run)

arch/loongarch/kvm/exit.c

509

switch (run->mmio.len) {

arch/loongarch/kvm/exit.c

512

*gpr = *(s8 *)run->mmio.data;

arch/loongarch/kvm/exit.c

514

*gpr = *(u8 *)run->mmio.data;

arch/loongarch/kvm/exit.c

518

*gpr = *(s16 *)run->mmio.data;

arch/loongarch/kvm/exit.c

520

*gpr = *(u16 *)run->mmio.data;

arch/loongarch/kvm/exit.c

524

*gpr = *(s32 *)run->mmio.data;

arch/loongarch/kvm/exit.c

526

*gpr = *(u32 *)run->mmio.data;

arch/loongarch/kvm/exit.c

529

*gpr = *(s64 *)run->mmio.data;

arch/loongarch/kvm/exit.c

533

run->mmio.len, vcpu->arch.badv);

arch/loongarch/kvm/exit.c

538

trace_kvm_mmio(KVM_TRACE_MMIO_READ, run->mmio.len,

arch/loongarch/kvm/exit.c

539

run->mmio.phys_addr, run->mmio.data);

arch/loongarch/kvm/exit.c

549

struct kvm_run *run = vcpu->run;

arch/loongarch/kvm/exit.c

550

void *data = run->mmio.data;

arch/loongarch/kvm/exit.c

560

run->mmio.phys_addr = vcpu->arch.badv;

arch/loongarch/kvm/exit.c

569

run->mmio.len = 4;

arch/loongarch/kvm/exit.c

573

run->mmio.len = 8;

arch/loongarch/kvm/exit.c

588

run->mmio.len = 1;

arch/loongarch/kvm/exit.c

592

run->mmio.len = 2;

arch/loongarch/kvm/exit.c

596

run->mmio.len = 4;

arch/loongarch/kvm/exit.c

600

run->mmio.len = 8;

arch/loongarch/kvm/exit.c

614

run->mmio.len = 1;

arch/loongarch/kvm/exit.c

618

run->mmio.len = 2;

arch/loongarch/kvm/exit.c

622

run->mmio.len = 4;

arch/loongarch/kvm/exit.c

626

run->mmio.len = 8;

arch/loongarch/kvm/exit.c

639

trace_kvm_mmio(KVM_TRACE_MMIO_WRITE, run->mmio.len, run->mmio.phys_addr, data);

arch/loongarch/kvm/exit.c

647

ret = kvm_io_bus_write(vcpu, KVM_MMIO_BUS, vcpu->arch.badv, run->mmio.len, data);

arch/loongarch/kvm/exit.c

652

run->mmio.is_write = 1;

arch/loongarch/kvm/exit.c

672

struct kvm_run *run = vcpu->run;

arch/loongarch/kvm/exit.c

701

run->exit_reason = KVM_EXIT_MMIO;

arch/loongarch/kvm/exit.c

721

int kvm_complete_user_service(struct kvm_vcpu *vcpu, struct kvm_run *run)

arch/loongarch/kvm/exit.c

724

kvm_write_reg(vcpu, LOONGARCH_GPR_A0, run->hypercall.ret);

arch/loongarch/kvm/exit.c

739

struct kvm_run *run = vcpu->run;

arch/loongarch/kvm/exit.c

753

run->exit_reason = KVM_EXIT_INTERNAL_ERROR;

arch/loongarch/kvm/exit.c

907

vcpu->run->exit_reason = KVM_EXIT_HYPERCALL;

arch/loongarch/kvm/exit.c

908

vcpu->run->hypercall.nr = KVM_HCALL_USER_SERVICE;

arch/loongarch/kvm/exit.c

909

vcpu->run->hypercall.args[0] = kvm_read_reg(vcpu, LOONGARCH_GPR_A0);

arch/loongarch/kvm/exit.c

910

vcpu->run->hypercall.args[1] = kvm_read_reg(vcpu, LOONGARCH_GPR_A1);

arch/loongarch/kvm/exit.c

911

vcpu->run->hypercall.args[2] = kvm_read_reg(vcpu, LOONGARCH_GPR_A2);

arch/loongarch/kvm/exit.c

912

vcpu->run->hypercall.args[3] = kvm_read_reg(vcpu, LOONGARCH_GPR_A3);

arch/loongarch/kvm/exit.c

913

vcpu->run->hypercall.args[4] = kvm_read_reg(vcpu, LOONGARCH_GPR_A4);

arch/loongarch/kvm/exit.c

914

vcpu->run->hypercall.args[5] = kvm_read_reg(vcpu, LOONGARCH_GPR_A5);

arch/loongarch/kvm/exit.c

915

vcpu->run->hypercall.flags = 0;

arch/loongarch/kvm/exit.c

919

vcpu->run->hypercall.ret = KVM_HCALL_INVALID_CODE;

arch/loongarch/kvm/exit.c

925

vcpu->run->exit_reason = KVM_EXIT_DEBUG;

arch/loongarch/kvm/vcpu.c

1869

struct kvm_run *run = vcpu->run;

arch/loongarch/kvm/vcpu.c

1873

kvm_complete_mmio_read(vcpu, run);

arch/loongarch/kvm/vcpu.c

1877

switch (run->exit_reason) {

arch/loongarch/kvm/vcpu.c

1879

kvm_complete_user_service(vcpu, run);

arch/loongarch/kvm/vcpu.c

1882

if (!run->iocsr_io.is_write)

arch/loongarch/kvm/vcpu.c

1883

kvm_complete_iocsr_read(vcpu, run);

arch/loongarch/kvm/vcpu.c

1891

run->exit_reason = KVM_EXIT_UNKNOWN;

arch/loongarch/kvm/vcpu.c

1902

r = kvm_loongarch_ops->enter_guest(run, vcpu);

arch/loongarch/kvm/vcpu.c

345

static int kvm_handle_exit(struct kvm_run *run, struct kvm_vcpu *vcpu)

arch/loongarch/kvm/vcpu.c

355

run->exit_reason = KVM_EXIT_UNKNOWN;

arch/mips/kvm/emulate.c

1009

run->mmio.len = 4;

arch/mips/kvm/emulate.c

1018

run->mmio.len = 2;

arch/mips/kvm/emulate.c

1027

run->mmio.len = 1;

arch/mips/kvm/emulate.c

1036

run->mmio.phys_addr = kvm_mips_callbacks->gva_to_gpa(

arch/mips/kvm/emulate.c

1038

run->mmio.len = 4;

arch/mips/kvm/emulate.c

1066

run->mmio.phys_addr = kvm_mips_callbacks->gva_to_gpa(

arch/mips/kvm/emulate.c

1068

run->mmio.len = 4;

arch/mips/kvm/emulate.c

1097

run->mmio.phys_addr = kvm_mips_callbacks->gva_to_gpa(

arch/mips/kvm/emulate.c

1100

run->mmio.len = 8;

arch/mips/kvm/emulate.c

1144

run->mmio.phys_addr = kvm_mips_callbacks->gva_to_gpa(

arch/mips/kvm/emulate.c

1147

run->mmio.len = 8;

arch/mips/kvm/emulate.c

1204

run->mmio.len = 1;

arch/mips/kvm/emulate.c

1212

run->mmio.len = 2;

arch/mips/kvm/emulate.c

1220

run->mmio.len = 4;

arch/mips/kvm/emulate.c

1228

run->mmio.len = 8;

arch/mips/kvm/emulate.c

1249

run->mmio.is_write = 1;

arch/mips/kvm/emulate.c

1253

run->mmio.phys_addr, run->mmio.len, data);

arch/mips/kvm/emulate.c

1271

struct kvm_run *run = vcpu->run;

arch/mips/kvm/emulate.c

1295

run->mmio.phys_addr = kvm_mips_callbacks->gva_to_gpa(

arch/mips/kvm/emulate.c

1297

if (run->mmio.phys_addr == KVM_INVALID_ADDR)

arch/mips/kvm/emulate.c

1304

run->mmio.len = 8;

arch/mips/kvm/emulate.c

1312

run->mmio.len = 4;

arch/mips/kvm/emulate.c

1319

run->mmio.len = 2;

arch/mips/kvm/emulate.c

1326

run->mmio.len = 1;

arch/mips/kvm/emulate.c

1330

run->mmio.phys_addr = kvm_mips_callbacks->gva_to_gpa(

arch/mips/kvm/emulate.c

1333

run->mmio.len = 4;

arch/mips/kvm/emulate.c

1354

run->mmio.phys_addr = kvm_mips_callbacks->gva_to_gpa(

arch/mips/kvm/emulate.c

1357

run->mmio.len = 4;

arch/mips/kvm/emulate.c

1379

run->mmio.phys_addr = kvm_mips_callbacks->gva_to_gpa(

arch/mips/kvm/emulate.c

1382

run->mmio.len = 8;

arch/mips/kvm/emulate.c

1415

run->mmio.phys_addr = kvm_mips_callbacks->gva_to_gpa(

arch/mips/kvm/emulate.c

1418

run->mmio.len = 8;

arch/mips/kvm/emulate.c

1464

run->mmio.len = 1;

arch/mips/kvm/emulate.c

1468

run->mmio.len = 2;

arch/mips/kvm/emulate.c

1472

run->mmio.len = 4;

arch/mips/kvm/emulate.c

1476

run->mmio.len = 8;

arch/mips/kvm/emulate.c

1494

run->mmio.is_write = 0;

arch/mips/kvm/emulate.c

1498

run->mmio.phys_addr, run->mmio.len, run->mmio.data);

arch/mips/kvm/emulate.c

1511

struct kvm_run *run = vcpu->run;

arch/mips/kvm/emulate.c

1515

if (run->mmio.len > sizeof(*gpr)) {

arch/mips/kvm/emulate.c

1516

kvm_err("Bad MMIO length: %d", run->mmio.len);

arch/mips/kvm/emulate.c

1524

switch (run->mmio.len) {

arch/mips/kvm/emulate.c

1529

(((*(s64 *)run->mmio.data) & 0xff) << 56);

arch/mips/kvm/emulate.c

1533

(((*(s64 *)run->mmio.data) & 0xffff) << 48);

arch/mips/kvm/emulate.c

1537

(((*(s64 *)run->mmio.data) & 0xffffff) << 40);

arch/mips/kvm/emulate.c

1541

(((*(s64 *)run->mmio.data) & 0xffffffff) << 32);

arch/mips/kvm/emulate.c

1545

(((*(s64 *)run->mmio.data) & 0xffffffffff) << 24);

arch/mips/kvm/emulate.c

1549

(((*(s64 *)run->mmio.data) & 0xffffffffffff) << 16);

arch/mips/kvm/emulate.c

1553

(((*(s64 *)run->mmio.data) & 0xffffffffffffff) << 8);

arch/mips/kvm/emulate.c

1557

*gpr = *(s64 *)run->mmio.data;

arch/mips/kvm/emulate.c

1561

((((*(s64 *)run->mmio.data)) >> 8) & 0xffffffffffffff);

arch/mips/kvm/emulate.c

1565

((((*(s64 *)run->mmio.data)) >> 16) & 0xffffffffffff);

arch/mips/kvm/emulate.c

1569

((((*(s64 *)run->mmio.data)) >> 24) & 0xffffffffff);

arch/mips/kvm/emulate.c

1573

((((*(s64 *)run->mmio.data)) >> 32) & 0xffffffff);

arch/mips/kvm/emulate.c

1577

((((*(s64 *)run->mmio.data)) >> 40) & 0xffffff);

arch/mips/kvm/emulate.c

1581

((((*(s64 *)run->mmio.data)) >> 48) & 0xffff);

arch/mips/kvm/emulate.c

1585

((((*(s64 *)run->mmio.data)) >> 56) & 0xff);

arch/mips/kvm/emulate.c

1588

*gpr = *(s64 *)run->mmio.data;

arch/mips/kvm/emulate.c

1595

*gpr = *(u32 *)run->mmio.data;

arch/mips/kvm/emulate.c

1598

*gpr = *(s32 *)run->mmio.data;

arch/mips/kvm/emulate.c

1602

(((*(s32 *)run->mmio.data) & 0xff) << 24);

arch/mips/kvm/emulate.c

1606

(((*(s32 *)run->mmio.data) & 0xffff) << 16);

arch/mips/kvm/emulate.c

1610

(((*(s32 *)run->mmio.data) & 0xffffff) << 8);

arch/mips/kvm/emulate.c

1614

*gpr = *(s32 *)run->mmio.data;

arch/mips/kvm/emulate.c

1618

((((*(s32 *)run->mmio.data)) >> 8) & 0xffffff);

arch/mips/kvm/emulate.c

1622

((((*(s32 *)run->mmio.data)) >> 16) & 0xffff);

arch/mips/kvm/emulate.c

1626

((((*(s32 *)run->mmio.data)) >> 24) & 0xff);

arch/mips/kvm/emulate.c

1629

*gpr = *(s32 *)run->mmio.data;

arch/mips/kvm/emulate.c

1635

*gpr = *(u16 *)run->mmio.data;

arch/mips/kvm/emulate.c

1637

*gpr = *(s16 *)run->mmio.data;

arch/mips/kvm/emulate.c

1642

*gpr = *(u8 *)run->mmio.data;

arch/mips/kvm/emulate.c

1644

*gpr = *(s8 *)run->mmio.data;

arch/mips/kvm/emulate.c

962

vcpu->run->exit_reason = KVM_EXIT_IRQ_WINDOW_OPEN;

arch/mips/kvm/emulate.c

975

struct kvm_run *run = vcpu->run;

arch/mips/kvm/emulate.c

976

void *data = run->mmio.data;

arch/mips/kvm/emulate.c

991

run->mmio.phys_addr = kvm_mips_callbacks->gva_to_gpa(

arch/mips/kvm/emulate.c

993

if (run->mmio.phys_addr == KVM_INVALID_ADDR)

arch/mips/kvm/emulate.c

999

run->mmio.len = 8;

arch/mips/kvm/mips.c

1169

struct kvm_run *run = vcpu->run;

arch/mips/kvm/mips.c

1181

run->exit_reason = KVM_EXIT_UNKNOWN;

arch/mips/kvm/mips.c

1182

run->ready_for_interrupt_injection = 1;

arch/mips/kvm/mips.c

1193

cause, opc, run, vcpu);

arch/mips/kvm/mips.c

1214

if (run->exit_reason == KVM_EXIT_IRQ_WINDOW_OPEN)

arch/mips/kvm/mips.c

1299

run->exit_reason = KVM_EXIT_INTERNAL_ERROR;

arch/mips/kvm/mips.c

1316

run->exit_reason = KVM_EXIT_INTR;

arch/mips/kvm/vz.c

1537

vcpu->run->exit_reason = KVM_EXIT_INTERNAL_ERROR;

arch/mips/kvm/vz.c

1582

vcpu->run->exit_reason = KVM_EXIT_INTERNAL_ERROR;

arch/mips/kvm/vz.c

1614

vcpu->run->exit_reason = KVM_EXIT_INTERNAL_ERROR;

arch/mips/kvm/vz.c

1625

struct kvm_run *run = vcpu->run;

arch/mips/kvm/vz.c

1636

run->exit_reason = KVM_EXIT_INTERNAL_ERROR;

arch/mips/kvm/vz.c

1645

run->exit_reason = KVM_EXIT_INTERNAL_ERROR;

arch/mips/kvm/vz.c

1654

run->exit_reason = KVM_EXIT_INTERNAL_ERROR;

arch/mips/kvm/vz.c

1661

run->exit_reason = KVM_EXIT_MMIO;

arch/mips/kvm/vz.c

1664

run->exit_reason = KVM_EXIT_INTERNAL_ERROR;

arch/mips/kvm/vz.c

1672

struct kvm_run *run = vcpu->run;

arch/mips/kvm/vz.c

1692

run->exit_reason = KVM_EXIT_INTERNAL_ERROR;

arch/mips/kvm/vz.c

1701

run->exit_reason = KVM_EXIT_INTERNAL_ERROR;

arch/mips/kvm/vz.c

1708

run->exit_reason = KVM_EXIT_MMIO;

arch/mips/kvm/vz.c

1711

run->exit_reason = KVM_EXIT_INTERNAL_ERROR;

arch/mips/kvm/vz.c

836

vcpu->run->exit_reason = KVM_EXIT_INTERNAL_ERROR;

arch/powerpc/kvm/book3s_emulate.c

370

vcpu->run->papr_hcall.nr = cmd;

arch/powerpc/kvm/book3s_emulate.c

373

vcpu->run->papr_hcall.args[i] = gpr;

arch/powerpc/kvm/book3s_emulate.c

376

vcpu->run->exit_reason = KVM_EXIT_PAPR_HCALL;

arch/powerpc/kvm/book3s_hv.c

1488

vcpu->run->exit_reason = KVM_EXIT_DEBUG;

arch/powerpc/kvm/book3s_hv.c

1489

vcpu->run->debug.arch.address = kvmppc_get_pc(vcpu);

arch/powerpc/kvm/book3s_hv.c

1633

struct kvm_run *run = vcpu->run;

arch/powerpc/kvm/book3s_hv.c

1652

run->exit_reason = KVM_EXIT_INTERNAL_ERROR;

arch/powerpc/kvm/book3s_hv.c

1653

run->hw.hardware_exit_reason = vcpu->arch.trap;

arch/powerpc/kvm/book3s_hv.c

1656

run->exit_reason = KVM_EXIT_UNKNOWN;

arch/powerpc/kvm/book3s_hv.c

1657

run->ready_for_interrupt_injection = 1;

arch/powerpc/kvm/book3s_hv.c

1705

run->exit_reason = KVM_EXIT_NMI;

arch/powerpc/kvm/book3s_hv.c

1706

run->hw.hardware_exit_reason = vcpu->arch.trap;

arch/powerpc/kvm/book3s_hv.c

1708

run->flags &= ~KVM_RUN_PPC_NMI_DISP_MASK;

arch/powerpc/kvm/book3s_hv.c

1711

run->flags |= KVM_RUN_PPC_NMI_DISP_FULLY_RECOV;

arch/powerpc/kvm/book3s_hv.c

1713

run->flags |= KVM_RUN_PPC_NMI_DISP_NOT_RECOV;

arch/powerpc/kvm/book3s_hv.c

1768

run->papr_hcall.nr = kvmppc_get_gpr(vcpu, 3);

arch/powerpc/kvm/book3s_hv.c

1770

run->papr_hcall.args[i] = kvmppc_get_gpr(vcpu, 4 + i);

arch/powerpc/kvm/book3s_hv.c

1771

run->exit_reason = KVM_EXIT_PAPR_HCALL;

arch/powerpc/kvm/book3s_hv.c

1961

run->hw.hardware_exit_reason = vcpu->arch.trap;

arch/powerpc/kvm/book3s_hv.c

4740

struct kvm_run *run = vcpu->run;

arch/powerpc/kvm/book3s_hv.c

4747

run->exit_reason = 0;

arch/powerpc/kvm/book3s_hv.c

4791

run->exit_reason = KVM_EXIT_FAIL_ENTRY;

arch/powerpc/kvm/book3s_hv.c

4792

run->fail_entry.

arch/powerpc/kvm/book3s_hv.c

4811

v->run->exit_reason = KVM_EXIT_INTR;

arch/powerpc/kvm/book3s_hv.c

4852

run->exit_reason = KVM_EXIT_INTR;

arch/powerpc/kvm/book3s_hv.c

4872

struct kvm_run *run = vcpu->run;

arch/powerpc/kvm/book3s_hv.c

4883

run->exit_reason = 0;

arch/powerpc/kvm/book3s_hv.c

4896

run->exit_reason = KVM_EXIT_FAIL_ENTRY;

arch/powerpc/kvm/book3s_hv.c

4897

run->fail_entry.hardware_entry_failure_reason = 0;

arch/powerpc/kvm/book3s_hv.c

5051

run->exit_reason = KVM_EXIT_INTR;

arch/powerpc/kvm/book3s_hv.c

5074

run->exit_reason = KVM_EXIT_INTR;

arch/powerpc/kvm/book3s_hv.c

5087

struct kvm_run *run = vcpu->run;

arch/powerpc/kvm/book3s_hv.c

5096

run->exit_reason = KVM_EXIT_INTERNAL_ERROR;

arch/powerpc/kvm/book3s_hv.c

5102

run->exit_reason = KVM_EXIT_INTR;

arch/powerpc/kvm/book3s_hv.c

5114

run->exit_reason = KVM_EXIT_FAIL_ENTRY;

arch/powerpc/kvm/book3s_hv.c

5115

run->fail_entry.hardware_entry_failure_reason = 0;

arch/powerpc/kvm/book3s_hv.c

5167

if (run->exit_reason == KVM_EXIT_PAPR_HCALL) {

arch/powerpc/kvm/book3s_pr.c

1122

vcpu->run->exit_reason = KVM_EXIT_MMIO;

arch/powerpc/kvm/book3s_pr.c

1137

struct kvm_run *run = vcpu->run;

arch/powerpc/kvm/book3s_pr.c

1143

run->exit_reason = KVM_EXIT_UNKNOWN;

arch/powerpc/kvm/book3s_pr.c

1144

run->ready_for_interrupt_injection = 1;

arch/powerpc/kvm/book3s_pr.c

1307

run->papr_hcall.nr = cmd;

arch/powerpc/kvm/book3s_pr.c

1310

run->papr_hcall.args[i] = gpr;

arch/powerpc/kvm/book3s_pr.c

1312

run->exit_reason = KVM_EXIT_PAPR_HCALL;

arch/powerpc/kvm/book3s_pr.c

1319

u64 *gprs = run->osi.gprs;

arch/powerpc/kvm/book3s_pr.c

1322

run->exit_reason = KVM_EXIT_OSI;

arch/powerpc/kvm/book3s_pr.c

1409

run->exit_reason = KVM_EXIT_DEBUG;

arch/powerpc/kvm/book3s_pr.c

1813

vcpu->run->exit_reason = KVM_EXIT_INTERNAL_ERROR;

arch/powerpc/kvm/book3s_pr.c

775

vcpu->run->exit_reason = KVM_EXIT_INTERNAL_ERROR;

arch/powerpc/kvm/booke.c

1013

struct kvm_run *run = vcpu->run;

arch/powerpc/kvm/booke.c

1071

run->exit_reason = KVM_EXIT_UNKNOWN;

arch/powerpc/kvm/booke.c

1072

run->ready_for_interrupt_injection = 1;

arch/powerpc/kvm/booke.c

1084

run->hw.hardware_exit_reason = ~1ULL << 32;

arch/powerpc/kvm/booke.c

1085

run->hw.hardware_exit_reason |= mfspr(SPRN_MCSR);

arch/powerpc/kvm/booke.c

1146

run->exit_reason = KVM_EXIT_DEBUG;

arch/powerpc/kvm/booke.c

1213

run->hw.hardware_exit_reason = exit_nr;

arch/powerpc/kvm/booke.c

1386

run->exit_reason = KVM_EXIT_DEBUG;

arch/powerpc/kvm/booke.c

746

vcpu->run->exit_reason = KVM_EXIT_WATCHDOG;

arch/powerpc/kvm/booke.c

751

vcpu->run->epr.epr = 0;

arch/powerpc/kvm/booke.c

753

vcpu->run->exit_reason = KVM_EXIT_EPR;

arch/powerpc/kvm/booke.c

766

vcpu->run->exit_reason = KVM_EXIT_INTERNAL_ERROR;

arch/powerpc/kvm/booke.c

851

vcpu->run->hw.hardware_exit_reason = ~0ULL << 32;

arch/powerpc/kvm/booke.c

852

vcpu->run->hw.hardware_exit_reason |= vcpu->arch.last_inst;

arch/powerpc/kvm/booke.c

866

struct kvm_run *run = vcpu->run;

arch/powerpc/kvm/booke.c

897

run->debug.arch.status = 0;

arch/powerpc/kvm/booke.c

898

run->debug.arch.address = vcpu->arch.regs.nip;

arch/powerpc/kvm/booke.c

901

run->debug.arch.status |= KVMPPC_DEBUG_BREAKPOINT;

arch/powerpc/kvm/booke.c

904

run->debug.arch.status |= KVMPPC_DEBUG_WATCH_WRITE;

arch/powerpc/kvm/booke.c

906

run->debug.arch.status |= KVMPPC_DEBUG_WATCH_READ;

arch/powerpc/kvm/booke.c

908

run->debug.arch.address = dbg_reg->dac1;

arch/powerpc/kvm/booke.c

910

run->debug.arch.address = dbg_reg->dac2;

arch/powerpc/kvm/booke.c

996

vcpu->run->hw.hardware_exit_reason = ~0ULL << 32;

arch/powerpc/kvm/booke.c

997

vcpu->run->hw.hardware_exit_reason |= last_inst;

arch/powerpc/kvm/e500_emulate.c

93

vcpu->run->exit_reason = KVM_EXIT_DEBUG;

arch/powerpc/kvm/e500_emulate.c

94

vcpu->run->debug.arch.address = vcpu->arch.regs.nip;

arch/powerpc/kvm/e500_emulate.c

95

vcpu->run->debug.arch.status = 0;

arch/powerpc/kvm/emulate.c

275

vcpu->run->exit_reason = KVM_EXIT_DEBUG;

arch/powerpc/kvm/emulate.c

276

vcpu->run->debug.arch.status = 0;

arch/powerpc/kvm/emulate.c

277

vcpu->run->debug.arch.address = kvmppc_get_pc(vcpu);

arch/powerpc/kvm/powerpc.c

1129

struct kvm_run *run = vcpu->run;

arch/powerpc/kvm/powerpc.c

1132

if (run->mmio.len > sizeof(gpr))

arch/powerpc/kvm/powerpc.c

1136

switch (run->mmio.len) {

arch/powerpc/kvm/powerpc.c

1137

case 8: gpr = *(u64 *)run->mmio.data; break;

arch/powerpc/kvm/powerpc.c

1138

case 4: gpr = *(u32 *)run->mmio.data; break;

arch/powerpc/kvm/powerpc.c

1139

case 2: gpr = *(u16 *)run->mmio.data; break;

arch/powerpc/kvm/powerpc.c

1140

case 1: gpr = *(u8 *)run->mmio.data; break;

arch/powerpc/kvm/powerpc.c

1143

switch (run->mmio.len) {

arch/powerpc/kvm/powerpc.c

1144

case 8: gpr = swab64(*(u64 *)run->mmio.data); break;

arch/powerpc/kvm/powerpc.c

1145

case 4: gpr = swab32(*(u32 *)run->mmio.data); break;

arch/powerpc/kvm/powerpc.c

1146

case 2: gpr = swab16(*(u16 *)run->mmio.data); break;

arch/powerpc/kvm/powerpc.c

1147

case 1: gpr = *(u8 *)run->mmio.data; break;

arch/powerpc/kvm/powerpc.c

1152

if ((vcpu->arch.mmio_sp64_extend) && (run->mmio.len == 4))

arch/powerpc/kvm/powerpc.c

1156

switch (run->mmio.len) {

arch/powerpc/kvm/powerpc.c

1241

struct kvm_run *run = vcpu->run;

arch/powerpc/kvm/powerpc.c

1252

if (bytes > sizeof(run->mmio.data))

arch/powerpc/kvm/powerpc.c

1255

run->mmio.phys_addr = vcpu->arch.paddr_accessed;

arch/powerpc/kvm/powerpc.c

1256

run->mmio.len = bytes;

arch/powerpc/kvm/powerpc.c

1257

run->mmio.is_write = 0;

arch/powerpc/kvm/powerpc.c

1267

ret = kvm_io_bus_read(vcpu, KVM_MMIO_BUS, run->mmio.phys_addr,

arch/powerpc/kvm/powerpc.c

1268

bytes, &run->mmio.data);

arch/powerpc/kvm/powerpc.c

1315

vcpu->arch.paddr_accessed += vcpu->run->mmio.len;

arch/powerpc/kvm/powerpc.c

1327

struct kvm_run *run = vcpu->run;

arch/powerpc/kvm/powerpc.c

1328

void *data = run->mmio.data;

arch/powerpc/kvm/powerpc.c

1339

if (bytes > sizeof(run->mmio.data))

arch/powerpc/kvm/powerpc.c

1342

run->mmio.phys_addr = vcpu->arch.paddr_accessed;

arch/powerpc/kvm/powerpc.c

1343

run->mmio.len = bytes;

arch/powerpc/kvm/powerpc.c

1344

run->mmio.is_write = 1;

arch/powerpc/kvm/powerpc.c

1370

ret = kvm_io_bus_write(vcpu, KVM_MMIO_BUS, run->mmio.phys_addr,

arch/powerpc/kvm/powerpc.c

1371

bytes, &run->mmio.data);

arch/powerpc/kvm/powerpc.c

1461

vcpu->arch.paddr_accessed += vcpu->run->mmio.len;

arch/powerpc/kvm/powerpc.c

1472

struct kvm_run *run = vcpu->run;

arch/powerpc/kvm/powerpc.c

1476

vcpu->arch.paddr_accessed += run->mmio.len;

arch/powerpc/kvm/powerpc.c

1480

run->mmio.len, 1, vcpu->arch.mmio_sign_extend);

arch/powerpc/kvm/powerpc.c

1483

vcpu->arch.io_gpr, run->mmio.len, 1);

arch/powerpc/kvm/powerpc.c

1488

run->exit_reason = KVM_EXIT_MMIO;

arch/powerpc/kvm/powerpc.c

1493

run->exit_reason = KVM_EXIT_INTERNAL_ERROR;

arch/powerpc/kvm/powerpc.c

1494

run->internal.suberror = KVM_INTERNAL_ERROR_EMULATION;

arch/powerpc/kvm/powerpc.c

1521

vcpu->arch.paddr_accessed += vcpu->run->mmio.len;

arch/powerpc/kvm/powerpc.c

1641

vcpu->arch.paddr_accessed += vcpu->run->mmio.len;

arch/powerpc/kvm/powerpc.c

1651

struct kvm_run *run = vcpu->run;

arch/powerpc/kvm/powerpc.c

1655

vcpu->arch.paddr_accessed += run->mmio.len;

arch/powerpc/kvm/powerpc.c

1659

vcpu->arch.io_gpr, run->mmio.len, 1);

arch/powerpc/kvm/powerpc.c

1662

vcpu->arch.io_gpr, run->mmio.len, 1);

arch/powerpc/kvm/powerpc.c

1667

run->exit_reason = KVM_EXIT_MMIO;

arch/powerpc/kvm/powerpc.c

1672

run->exit_reason = KVM_EXIT_INTERNAL_ERROR;

arch/powerpc/kvm/powerpc.c

1673

run->internal.suberror = KVM_INTERNAL_ERROR_EMULATION;

arch/powerpc/kvm/powerpc.c

1783

struct kvm_run *run = vcpu->run;

arch/powerpc/kvm/powerpc.c

1821

u64 *gprs = run->osi.gprs;

arch/powerpc/kvm/powerpc.c

1830

kvmppc_set_gpr(vcpu, 3, run->papr_hcall.ret);

arch/powerpc/kvm/powerpc.c

1832

kvmppc_set_gpr(vcpu, 4 + i, run->papr_hcall.args[i]);

arch/powerpc/kvm/powerpc.c

1836

kvmppc_set_epr(vcpu, run->epr.epr);

arch/powerpc/kvm/powerpc.c

298

vcpu->run->exit_reason = KVM_EXIT_MMIO;

arch/powerpc/kvm/powerpc.c

96

vcpu->run->exit_reason = KVM_EXIT_INTR;

arch/powerpc/kvm/trace_hv.h

507

__entry->exit = vcpu->run->exit_reason;

arch/powerpc/platforms/powernv/pci-ioda.c

156

int run = 0, pe, i;

arch/powerpc/platforms/powernv/pci-ioda.c

163

run = 0;

arch/powerpc/platforms/powernv/pci-ioda.c

167

run++;

arch/powerpc/platforms/powernv/pci-ioda.c

168

if (run == count)

arch/powerpc/platforms/powernv/pci-ioda.c

171

if (run != count)

arch/riscv/include/asm/kvm_host.h

306

int kvm_riscv_vcpu_exit(struct kvm_vcpu *vcpu, struct kvm_run *run,

arch/riscv/include/asm/kvm_vcpu_insn.h

36

int kvm_riscv_vcpu_csr_return(struct kvm_vcpu *vcpu, struct kvm_run *run);

arch/riscv/include/asm/kvm_vcpu_insn.h

37

int kvm_riscv_vcpu_virtual_insn(struct kvm_vcpu *vcpu, struct kvm_run *run,

arch/riscv/include/asm/kvm_vcpu_insn.h

40

int kvm_riscv_vcpu_mmio_load(struct kvm_vcpu *vcpu, struct kvm_run *run,

arch/riscv/include/asm/kvm_vcpu_insn.h

43

int kvm_riscv_vcpu_mmio_store(struct kvm_vcpu *vcpu, struct kvm_run *run,

arch/riscv/include/asm/kvm_vcpu_insn.h

46

int kvm_riscv_vcpu_mmio_return(struct kvm_vcpu *vcpu, struct kvm_run *run);

arch/riscv/include/asm/kvm_vcpu_sbi.h

47

int (*handler)(struct kvm_vcpu *vcpu, struct kvm_run *run,

arch/riscv/include/asm/kvm_vcpu_sbi.h

73

struct kvm_run *run,

arch/riscv/include/asm/kvm_vcpu_sbi.h

76

struct kvm_run *run,

arch/riscv/include/asm/kvm_vcpu_sbi.h

81

int kvm_riscv_vcpu_sbi_return(struct kvm_vcpu *vcpu, struct kvm_run *run);

arch/riscv/include/asm/kvm_vcpu_sbi.h

92

int kvm_riscv_vcpu_sbi_ecall(struct kvm_vcpu *vcpu, struct kvm_run *run);

arch/riscv/kvm/aia_imsic.c

791

struct kvm_run *run = vcpu->run;

arch/riscv/kvm/aia_imsic.c

820

run->fail_entry.hardware_entry_failure_reason =

arch/riscv/kvm/aia_imsic.c

822

run->fail_entry.cpu = vcpu->cpu;

arch/riscv/kvm/aia_imsic.c

823

run->exit_reason = KVM_EXIT_FAIL_ENTRY;

arch/riscv/kvm/vcpu.c

1008

ret = kvm_riscv_vcpu_exit(vcpu, run, &trap);

arch/riscv/kvm/vcpu.c

868

struct kvm_run *run = vcpu->run;

arch/riscv/kvm/vcpu.c

878

switch (run->exit_reason) {

arch/riscv/kvm/vcpu.c

881

ret = kvm_riscv_vcpu_mmio_return(vcpu, vcpu->run);

arch/riscv/kvm/vcpu.c

885

ret = kvm_riscv_vcpu_sbi_return(vcpu, vcpu->run);

arch/riscv/kvm/vcpu.c

889

ret = kvm_riscv_vcpu_csr_return(vcpu, vcpu->run);

arch/riscv/kvm/vcpu.c

910

run->exit_reason = KVM_EXIT_UNKNOWN;

arch/riscv/kvm/vcpu_exit.c

15

static int gstage_page_fault(struct kvm_vcpu *vcpu, struct kvm_run *run,

arch/riscv/kvm/vcpu_exit.c

187

int kvm_riscv_vcpu_exit(struct kvm_vcpu *vcpu, struct kvm_run *run,

arch/riscv/kvm/vcpu_exit.c

198

run->exit_reason = KVM_EXIT_UNKNOWN;

arch/riscv/kvm/vcpu_exit.c

230

ret = kvm_riscv_vcpu_virtual_insn(vcpu, run, trap);

arch/riscv/kvm/vcpu_exit.c

236

ret = gstage_page_fault(vcpu, run, trap);

arch/riscv/kvm/vcpu_exit.c

240

ret = kvm_riscv_vcpu_sbi_ecall(vcpu, run);

arch/riscv/kvm/vcpu_exit.c

243

run->exit_reason = KVM_EXIT_DEBUG;

arch/riscv/kvm/vcpu_exit.c

34

return kvm_riscv_vcpu_mmio_load(vcpu, run,

arch/riscv/kvm/vcpu_exit.c

38

return kvm_riscv_vcpu_mmio_store(vcpu, run,

arch/riscv/kvm/vcpu_insn.c

127

int kvm_riscv_vcpu_csr_return(struct kvm_vcpu *vcpu, struct kvm_run *run)

arch/riscv/kvm/vcpu_insn.c

139

run->riscv_csr.ret_value);

arch/riscv/kvm/vcpu_insn.c

147

static int csr_insn(struct kvm_vcpu *vcpu, struct kvm_run *run, ulong insn)

arch/riscv/kvm/vcpu_insn.c

191

run->riscv_csr.csr_num = csr_num;

arch/riscv/kvm/vcpu_insn.c

192

run->riscv_csr.new_value = new_val;

arch/riscv/kvm/vcpu_insn.c

193

run->riscv_csr.write_mask = wr_mask;

arch/riscv/kvm/vcpu_insn.c

194

run->riscv_csr.ret_value = 0;

arch/riscv/kvm/vcpu_insn.c

211

run->riscv_csr.ret_value = val;

arch/riscv/kvm/vcpu_insn.c

213

kvm_riscv_vcpu_csr_return(vcpu, run);

arch/riscv/kvm/vcpu_insn.c

223

run->exit_reason = KVM_EXIT_RISCV_CSR;

arch/riscv/kvm/vcpu_insn.c

27

int (*func)(struct kvm_vcpu *vcpu, struct kvm_run *run, ulong insn);

arch/riscv/kvm/vcpu_insn.c

272

static int system_opcode_insn(struct kvm_vcpu *vcpu, struct kvm_run *run,

arch/riscv/kvm/vcpu_insn.c

281

rc = ifn->func(vcpu, run, insn);

arch/riscv/kvm/vcpu_insn.c

288

return truly_illegal_insn(vcpu, run, insn);

arch/riscv/kvm/vcpu_insn.c

290

return truly_virtual_insn(vcpu, run, insn);

arch/riscv/kvm/vcpu_insn.c

30

static int truly_illegal_insn(struct kvm_vcpu *vcpu, struct kvm_run *run,

arch/riscv/kvm/vcpu_insn.c

328

int kvm_riscv_vcpu_virtual_insn(struct kvm_vcpu *vcpu, struct kvm_run *run,

arch/riscv/kvm/vcpu_insn.c

350

return truly_illegal_insn(vcpu, run, insn);

arch/riscv/kvm/vcpu_insn.c

355

return system_opcode_insn(vcpu, run, insn);

arch/riscv/kvm/vcpu_insn.c

357

return truly_illegal_insn(vcpu, run, insn);

arch/riscv/kvm/vcpu_insn.c

373

int kvm_riscv_vcpu_mmio_load(struct kvm_vcpu *vcpu, struct kvm_run *run,

arch/riscv/kvm/vcpu_insn.c

46

static int truly_virtual_insn(struct kvm_vcpu *vcpu, struct kvm_run *run,

arch/riscv/kvm/vcpu_insn.c

465

run->mmio.is_write = false;

arch/riscv/kvm/vcpu_insn.c

466

run->mmio.phys_addr = fault_addr;

arch/riscv/kvm/vcpu_insn.c

467

run->mmio.len = len;

arch/riscv/kvm/vcpu_insn.c

472

memcpy(run->mmio.data, data_buf, len);

arch/riscv/kvm/vcpu_insn.c

474

kvm_riscv_vcpu_mmio_return(vcpu, run);

arch/riscv/kvm/vcpu_insn.c

480

run->exit_reason = KVM_EXIT_MMIO;

arch/riscv/kvm/vcpu_insn.c

497

int kvm_riscv_vcpu_mmio_store(struct kvm_vcpu *vcpu, struct kvm_run *run,

arch/riscv/kvm/vcpu_insn.c

584

*((u8 *)run->mmio.data) = data8;

arch/riscv/kvm/vcpu_insn.c

587

*((u16 *)run->mmio.data) = data16;

arch/riscv/kvm/vcpu_insn.c

590

*((u32 *)run->mmio.data) = data32;

arch/riscv/kvm/vcpu_insn.c

593

*((u64 *)run->mmio.data) = data64;

arch/riscv/kvm/vcpu_insn.c

600

run->mmio.is_write = true;

arch/riscv/kvm/vcpu_insn.c

601

run->mmio.phys_addr = fault_addr;

arch/riscv/kvm/vcpu_insn.c

602

run->mmio.len = len;

arch/riscv/kvm/vcpu_insn.c

606

fault_addr, len, run->mmio.data)) {

arch/riscv/kvm/vcpu_insn.c

609

kvm_riscv_vcpu_mmio_return(vcpu, run);

arch/riscv/kvm/vcpu_insn.c

615

run->exit_reason = KVM_EXIT_MMIO;

arch/riscv/kvm/vcpu_insn.c

627

int kvm_riscv_vcpu_mmio_return(struct kvm_vcpu *vcpu, struct kvm_run *run)

arch/riscv/kvm/vcpu_insn.c

642

if (run->mmio.is_write)

arch/riscv/kvm/vcpu_insn.c

650

data8 = *((u8 *)run->mmio.data);

arch/riscv/kvm/vcpu_insn.c

655

data16 = *((u16 *)run->mmio.data);

arch/riscv/kvm/vcpu_insn.c

660

data32 = *((u32 *)run->mmio.data);

arch/riscv/kvm/vcpu_insn.c

665

data64 = *((u64 *)run->mmio.data);

arch/riscv/kvm/vcpu_insn.c

76

static int wfi_insn(struct kvm_vcpu *vcpu, struct kvm_run *run, ulong insn)

arch/riscv/kvm/vcpu_insn.c

83

static int wrs_insn(struct kvm_vcpu *vcpu, struct kvm_run *run, ulong insn)

arch/riscv/kvm/vcpu_sbi.c

128

struct kvm_run *run,

arch/riscv/kvm/vcpu_sbi.c

135

run->exit_reason = KVM_EXIT_RISCV_SBI;

arch/riscv/kvm/vcpu_sbi.c

136

run->riscv_sbi.extension_id = cp->a7;

arch/riscv/kvm/vcpu_sbi.c

137

run->riscv_sbi.function_id = cp->a6;

arch/riscv/kvm/vcpu_sbi.c

138

run->riscv_sbi.args[0] = cp->a0;

arch/riscv/kvm/vcpu_sbi.c

139

run->riscv_sbi.args[1] = cp->a1;

arch/riscv/kvm/vcpu_sbi.c

140

run->riscv_sbi.args[2] = cp->a2;

arch/riscv/kvm/vcpu_sbi.c

141

run->riscv_sbi.args[3] = cp->a3;

arch/riscv/kvm/vcpu_sbi.c

142

run->riscv_sbi.args[4] = cp->a4;

arch/riscv/kvm/vcpu_sbi.c

143

run->riscv_sbi.args[5] = cp->a5;

arch/riscv/kvm/vcpu_sbi.c

144

run->riscv_sbi.ret[0] = SBI_ERR_NOT_SUPPORTED;

arch/riscv/kvm/vcpu_sbi.c

145

run->riscv_sbi.ret[1] = 0;

arch/riscv/kvm/vcpu_sbi.c

151

struct kvm_run *run,

arch/riscv/kvm/vcpu_sbi.c

164

memset(&run->system_event, 0, sizeof(run->system_event));

arch/riscv/kvm/vcpu_sbi.c

165

run->system_event.type = type;

arch/riscv/kvm/vcpu_sbi.c

166

run->system_event.ndata = 1;

arch/riscv/kvm/vcpu_sbi.c

167

run->system_event.data[0] = reason;

arch/riscv/kvm/vcpu_sbi.c

168

run->exit_reason = KVM_EXIT_SYSTEM_EVENT;

arch/riscv/kvm/vcpu_sbi.c

199

int kvm_riscv_vcpu_sbi_return(struct kvm_vcpu *vcpu, struct kvm_run *run)

arch/riscv/kvm/vcpu_sbi.c

209

cp->a0 = run->riscv_sbi.ret[0];

arch/riscv/kvm/vcpu_sbi.c

210

cp->a1 = run->riscv_sbi.ret[1];

arch/riscv/kvm/vcpu_sbi.c

587

int kvm_riscv_vcpu_sbi_ecall(struct kvm_vcpu *vcpu, struct kvm_run *run)

arch/riscv/kvm/vcpu_sbi.c

608

ret = sbi_ext->handler(vcpu, run, &sbi_ret);

arch/riscv/kvm/vcpu_sbi_base.c

16

static int kvm_sbi_ext_base_handler(struct kvm_vcpu *vcpu, struct kvm_run *run,

arch/riscv/kvm/vcpu_sbi_base.c

44

return kvm_riscv_vcpu_sbi_forward_handler(vcpu, run, retdata);

arch/riscv/kvm/vcpu_sbi_fwft.c

324

static int kvm_sbi_ext_fwft_handler(struct kvm_vcpu *vcpu, struct kvm_run *run,

arch/riscv/kvm/vcpu_sbi_hsm.c

80

static int kvm_sbi_ext_hsm_handler(struct kvm_vcpu *vcpu, struct kvm_run *run,

arch/riscv/kvm/vcpu_sbi_pmu.c

16

static int kvm_sbi_ext_pmu_handler(struct kvm_vcpu *vcpu, struct kvm_run *run,

arch/riscv/kvm/vcpu_sbi_replace.c

148

struct kvm_run *run,

arch/riscv/kvm/vcpu_sbi_replace.c

160

kvm_riscv_vcpu_sbi_system_reset(vcpu, run,

arch/riscv/kvm/vcpu_sbi_replace.c

167

kvm_riscv_vcpu_sbi_system_reset(vcpu, run,

arch/riscv/kvm/vcpu_sbi_replace.c

17

static int kvm_sbi_ext_time_handler(struct kvm_vcpu *vcpu, struct kvm_run *run,

arch/riscv/kvm/vcpu_sbi_replace.c

45

static int kvm_sbi_ext_ipi_handler(struct kvm_vcpu *vcpu, struct kvm_run *run,

arch/riscv/kvm/vcpu_sbi_replace.c

92

static int kvm_sbi_ext_rfence_handler(struct kvm_vcpu *vcpu, struct kvm_run *run,

arch/riscv/kvm/vcpu_sbi_sta.c

123

static int kvm_sbi_ext_sta_handler(struct kvm_vcpu *vcpu, struct kvm_run *run,

arch/riscv/kvm/vcpu_sbi_system.c

12

static int kvm_sbi_ext_susp_handler(struct kvm_vcpu *vcpu, struct kvm_run *run,

arch/riscv/kvm/vcpu_sbi_system.c

50

return kvm_riscv_vcpu_sbi_forward_handler(vcpu, run, retdata);

arch/riscv/kvm/vcpu_sbi_v01.c

16

static int kvm_sbi_ext_v01_handler(struct kvm_vcpu *vcpu, struct kvm_run *run,

arch/riscv/kvm/vcpu_sbi_v01.c

35

ret = kvm_riscv_vcpu_sbi_forward_handler(vcpu, run, retdata);

arch/riscv/kvm/vcpu_sbi_v01.c

64

kvm_riscv_vcpu_sbi_system_reset(vcpu, run,

arch/s390/kvm/diag.c

100

rc = read_guest_real(vcpu, vcpu->run->s.regs.gprs[rx], &parm, sizeof(parm));

arch/s390/kvm/diag.c

117

vcpu->run->s.regs.gprs[ry] = 8;

arch/s390/kvm/diag.c

131

vcpu->run->s.regs.gprs[ry] = 0;

arch/s390/kvm/diag.c

145

vcpu->run->s.regs.gprs[ry] = 0;

arch/s390/kvm/diag.c

151

vcpu->run->s.regs.gprs[ry] = 4;

arch/s390/kvm/diag.c

192

tid = vcpu->run->s.regs.gprs[(vcpu->arch.sie_block->ipa & 0xf0) >> 4];

arch/s390/kvm/diag.c

235

unsigned long subcode = vcpu->run->s.regs.gprs[reg] & 0xffff;

arch/s390/kvm/diag.c

241

vcpu->run->s390_reset_flags = KVM_S390_RESET_CLEAR;

arch/s390/kvm/diag.c

244

vcpu->run->s390_reset_flags = 0;

arch/s390/kvm/diag.c

256

vcpu->run->s390_reset_flags |= KVM_S390_RESET_SUBSYSTEM;

arch/s390/kvm/diag.c

257

vcpu->run->s390_reset_flags |= KVM_S390_RESET_IPL;

arch/s390/kvm/diag.c

258

vcpu->run->s390_reset_flags |= KVM_S390_RESET_CPU_INIT;

arch/s390/kvm/diag.c

259

vcpu->run->exit_reason = KVM_EXIT_S390_RESET;

arch/s390/kvm/diag.c

261

vcpu->run->s390_reset_flags);

arch/s390/kvm/diag.c

262

trace_kvm_s390_request_resets(vcpu->run->s390_reset_flags);

arch/s390/kvm/diag.c

273

(vcpu->run->s.regs.gprs[1] != KVM_S390_VIRTIO_CCW_NOTIFY))

arch/s390/kvm/diag.c

277

(u32) vcpu->run->s.regs.gprs[2],

arch/s390/kvm/diag.c

278

(u32) vcpu->run->s.regs.gprs[3],

arch/s390/kvm/diag.c

279

vcpu->run->s.regs.gprs[4]);

arch/s390/kvm/diag.c

288

vcpu->run->s.regs.gprs[2] & 0xffffffff,

arch/s390/kvm/diag.c

289

8, &vcpu->run->s.regs.gprs[3],

arch/s390/kvm/diag.c

290

vcpu->run->s.regs.gprs[4]);

arch/s390/kvm/diag.c

297

vcpu->run->s.regs.gprs[2] = ret;

arch/s390/kvm/diag.c

43

start = vcpu->run->s.regs.gprs[(vcpu->arch.sie_block->ipa & 0xf0) >> 4];

arch/s390/kvm/diag.c

44

end = vcpu->run->s.regs.gprs[vcpu->arch.sie_block->ipa & 0xf] + PAGE_SIZE;

arch/s390/kvm/diag.c

96

vcpu->run->s.regs.gprs[rx]);

arch/s390/kvm/diag.c

98

if (vcpu->run->s.regs.gprs[rx] & 7)

arch/s390/kvm/gaccess.c

249

save_access_regs(vcpu->run->s.regs.acrs);

arch/s390/kvm/gaccess.c

250

alet.val = vcpu->run->s.regs.acrs[ar];

arch/s390/kvm/guestdbg.c

369

vcpu->run->exit_reason = KVM_EXIT_DEBUG;

arch/s390/kvm/guestdbg.c

387

struct kvm_debug_exit_arch *debug_exit = &vcpu->run->debug.arch;

arch/s390/kvm/guestdbg.c

481

*addr = base ? vcpu->run->s.regs.gprs[base] : 0;

arch/s390/kvm/guestdbg.c

482

*addr += index ? vcpu->run->s.regs.gprs[index] : 0;

arch/s390/kvm/intercept.c

367

rc = guest_translate_address_with_key(vcpu, vcpu->run->s.regs.gprs[reg2],

arch/s390/kvm/intercept.c

379

rc = guest_translate_address_with_key(vcpu, vcpu->run->s.regs.gprs[reg1],

arch/s390/kvm/intercept.c

422

code = vcpu->run->s.regs.gprs[reg1];

arch/s390/kvm/intercept.c

423

addr = vcpu->run->s.regs.gprs[reg2];

arch/s390/kvm/intercept.c

464

vcpu->run->s.regs.gprs[reg2 + 1] = rc;

arch/s390/kvm/interrupt.c

1418

struct kvm_debug_exit_arch *debug_exit = &vcpu->run->debug.arch;

arch/s390/kvm/interrupt.c

533

kvm_s390_fpu_store(vcpu->run);

arch/s390/kvm/interrupt.c

534

save_access_regs(vcpu->run->s.regs.acrs);

arch/s390/kvm/interrupt.c

564

if (write_guest_abs(vcpu, ext_sa_addr, vcpu->run->s.regs.vrs,

arch/s390/kvm/interrupt.c

573

&vcpu->run->s.regs.gscb, 32))

arch/s390/kvm/interrupt.c

589

convert_vx_to_fp(fprs, (__vector128 *) vcpu->run->s.regs.vrs);

arch/s390/kvm/interrupt.c

593

vcpu->run->s.regs.fprs, 128);

arch/s390/kvm/interrupt.c

596

vcpu->run->s.regs.gprs, 128);

arch/s390/kvm/interrupt.c

597

rc |= put_guest_lc(vcpu, vcpu->run->s.regs.fpc,

arch/s390/kvm/interrupt.c

606

&vcpu->run->s.regs.acrs, 64);

arch/s390/kvm/kvm-s390.c

3659

vcpu->arch.sie_block->sdnxo = virt_to_phys(&vcpu->run->s.regs.sdnx) | SDNXC;

arch/s390/kvm/kvm-s390.c

3660

vcpu->arch.sie_block->riccbd = virt_to_phys(&vcpu->run->s.regs.riccb);

arch/s390/kvm/kvm-s390.c

3729

vcpu->run->kvm_valid_regs = KVM_SYNC_PREFIX |

arch/s390/kvm/kvm-s390.c

3739

vcpu->run->kvm_valid_regs |= KVM_SYNC_RICCB;

arch/s390/kvm/kvm-s390.c

3741

vcpu->run->kvm_valid_regs |= KVM_SYNC_BPBC;

arch/s390/kvm/kvm-s390.c

3743

vcpu->run->kvm_valid_regs |= KVM_SYNC_GSCB;

arch/s390/kvm/kvm-s390.c

3745

vcpu->run->kvm_valid_regs |= KVM_SYNC_ETOKEN;

arch/s390/kvm/kvm-s390.c

3750

vcpu->run->kvm_valid_regs |= KVM_SYNC_VRS;

arch/s390/kvm/kvm-s390.c

3752

vcpu->run->kvm_valid_regs |= KVM_SYNC_FPRS;

arch/s390/kvm/kvm-s390.c

3964

memset(vcpu->run->s.regs.riccb, 0, sizeof(vcpu->run->s.regs.riccb));

arch/s390/kvm/kvm-s390.c

3991

memset(vcpu->run->s.regs.crs, 0, sizeof(vcpu->run->s.regs.crs));

arch/s390/kvm/kvm-s390.c

3992

vcpu->run->s.regs.ckc = 0;

arch/s390/kvm/kvm-s390.c

3993

vcpu->run->s.regs.crs[0] = CR0_INITIAL_MASK;

arch/s390/kvm/kvm-s390.c

3994

vcpu->run->s.regs.crs[14] = CR14_INITIAL_MASK;

arch/s390/kvm/kvm-s390.c

3995

vcpu->run->psw_addr = 0;

arch/s390/kvm/kvm-s390.c

3996

vcpu->run->psw_mask = 0;

arch/s390/kvm/kvm-s390.c

3997

vcpu->run->s.regs.todpr = 0;

arch/s390/kvm/kvm-s390.c

3998

vcpu->run->s.regs.cputm = 0;

arch/s390/kvm/kvm-s390.c

3999

vcpu->run->s.regs.ckc = 0;

arch/s390/kvm/kvm-s390.c

4000

vcpu->run->s.regs.pp = 0;

arch/s390/kvm/kvm-s390.c

4001

vcpu->run->s.regs.gbea = 1;

arch/s390/kvm/kvm-s390.c

4002

vcpu->run->s.regs.fpc = 0;

arch/s390/kvm/kvm-s390.c

4018

struct kvm_sync_regs *regs = &vcpu->run->s.regs;

arch/s390/kvm/kvm-s390.c

4035

memcpy(&vcpu->run->s.regs.gprs, &regs->gprs, sizeof(regs->gprs));

arch/s390/kvm/kvm-s390.c

4043

memcpy(&regs->gprs, &vcpu->run->s.regs.gprs, sizeof(regs->gprs));

arch/s390/kvm/kvm-s390.c

4053

memcpy(&vcpu->run->s.regs.acrs, &sregs->acrs, sizeof(sregs->acrs));

arch/s390/kvm/kvm-s390.c

4065

memcpy(&sregs->acrs, &vcpu->run->s.regs.acrs, sizeof(sregs->acrs));

arch/s390/kvm/kvm-s390.c

4076

vcpu->run->s.regs.fpc = fpu->fpc;

arch/s390/kvm/kvm-s390.c

4078

convert_fp_to_vx((__vector128 *) vcpu->run->s.regs.vrs,

arch/s390/kvm/kvm-s390.c

4081

memcpy(vcpu->run->s.regs.fprs, &fpu->fprs, sizeof(fpu->fprs));

arch/s390/kvm/kvm-s390.c

4093

(__vector128 *) vcpu->run->s.regs.vrs);

arch/s390/kvm/kvm-s390.c

4095

memcpy(fpu->fprs, vcpu->run->s.regs.fprs, sizeof(fpu->fprs));

arch/s390/kvm/kvm-s390.c

4096

fpu->fpc = vcpu->run->s.regs.fpc;

arch/s390/kvm/kvm-s390.c

4109

vcpu->run->psw_mask = psw.mask;

arch/s390/kvm/kvm-s390.c

4110

vcpu->run->psw_addr = psw.addr;

arch/s390/kvm/kvm-s390.c

4228

vcpu->run->exit_reason = KVM_EXIT_S390_UCONTROL;

arch/s390/kvm/kvm-s390.c

4229

vcpu->run->s390_ucontrol.trans_exc_code = *gaddr;

arch/s390/kvm/kvm-s390.c

4230

vcpu->run->s390_ucontrol.pgm_code = PGM_SEGMENT_TRANSLATION;

arch/s390/kvm/kvm-s390.c

4457

vcpu->arch.sie_block->gg14 = vcpu->run->s.regs.gprs[14];

arch/s390/kvm/kvm-s390.c

4458

vcpu->arch.sie_block->gg15 = vcpu->run->s.regs.gprs[15];

arch/s390/kvm/kvm-s390.c

4633

vcpu->run->s.regs.gprs[14] = vcpu->arch.sie_block->gg14;

arch/s390/kvm/kvm-s390.c

4634

vcpu->run->s.regs.gprs[15] = vcpu->arch.sie_block->gg15;

arch/s390/kvm/kvm-s390.c

4650

vcpu->run->exit_reason = KVM_EXIT_S390_SIEIC;

arch/s390/kvm/kvm-s390.c

4651

vcpu->run->s390_sieic.icptcode = vcpu->arch.sie_block->icptcode;

arch/s390/kvm/kvm-s390.c

4652

vcpu->run->s390_sieic.ipa = vcpu->arch.sie_block->ipa;

arch/s390/kvm/kvm-s390.c

4653

vcpu->run->s390_sieic.ipb = vcpu->arch.sie_block->ipb;

arch/s390/kvm/kvm-s390.c

4704

vcpu->run->s.regs.gprs,

arch/s390/kvm/kvm-s390.c

4723

vcpu->run->s.regs.gprs,

arch/s390/kvm/kvm-s390.c

4731

memcpy(vcpu->run->s.regs.gprs,

arch/s390/kvm/kvm-s390.c

4759

struct kvm_run *kvm_run = vcpu->run;

arch/s390/kvm/kvm-s390.c

4822

&vcpu->run->s.regs.gscb;

arch/s390/kvm/kvm-s390.c

4832

struct kvm_run *kvm_run = vcpu->run;

arch/s390/kvm/kvm-s390.c

4846

restore_access_regs(vcpu->run->s.regs.acrs);

arch/s390/kvm/kvm-s390.c

4848

kvm_s390_fpu_load(vcpu->run);

arch/s390/kvm/kvm-s390.c

4872

struct kvm_run *kvm_run = vcpu->run;

arch/s390/kvm/kvm-s390.c

4896

struct kvm_run *kvm_run = vcpu->run;

arch/s390/kvm/kvm-s390.c

4907

save_access_regs(vcpu->run->s.regs.acrs);

arch/s390/kvm/kvm-s390.c

4910

kvm_s390_fpu_store(vcpu->run);

arch/s390/kvm/kvm-s390.c

4917

struct kvm_run *kvm_run = vcpu->run;

arch/s390/kvm/kvm-s390.c

5023

convert_vx_to_fp(fprs, (__vector128 *) vcpu->run->s.regs.vrs);

arch/s390/kvm/kvm-s390.c

5028

vcpu->run->s.regs.fprs, 128);

arch/s390/kvm/kvm-s390.c

5031

vcpu->run->s.regs.gprs, 128);

arch/s390/kvm/kvm-s390.c

5037

&vcpu->run->s.regs.fpc, 4);

arch/s390/kvm/kvm-s390.c

5047

&vcpu->run->s.regs.acrs, 64);

arch/s390/kvm/kvm-s390.c

5060

kvm_s390_fpu_store(vcpu->run);

arch/s390/kvm/kvm-s390.c

5061

save_access_regs(vcpu->run->s.regs.acrs);

arch/s390/kvm/kvm-s390.h

148

return (base2 ? vcpu->run->s.regs.gprs[base2] : 0) + disp2;

arch/s390/kvm/kvm-s390.h

163

return (base1 ? vcpu->run->s.regs.gprs[base1] : 0) + disp1;

arch/s390/kvm/kvm-s390.h

175

*address1 = (base1 ? vcpu->run->s.regs.gprs[base1] : 0) + disp1;

arch/s390/kvm/kvm-s390.h

176

*address2 = (base2 ? vcpu->run->s.regs.gprs[base2] : 0) + disp2;

arch/s390/kvm/kvm-s390.h

204

return (base2 ? vcpu->run->s.regs.gprs[base2] : 0) + (long)(int)disp2;

arch/s390/kvm/kvm-s390.h

215

return (base2 ? vcpu->run->s.regs.gprs[base2] : 0) + disp2;

arch/s390/kvm/kvm-s390.h

35

static inline void kvm_s390_fpu_store(struct kvm_run *run)

arch/s390/kvm/kvm-s390.h

37

fpu_stfpc(&run->s.regs.fpc);

arch/s390/kvm/kvm-s390.h

39

save_vx_regs((__vector128 *)&run->s.regs.vrs);

arch/s390/kvm/kvm-s390.h

41

save_fp_regs((freg_t *)&run->s.regs.fprs);

arch/s390/kvm/kvm-s390.h

44

static inline void kvm_s390_fpu_load(struct kvm_run *run)

arch/s390/kvm/kvm-s390.h

46

fpu_lfpc_safe(&run->s.regs.fpc);

arch/s390/kvm/kvm-s390.h

48

load_vx_regs((__vector128 *)&run->s.regs.vrs);

arch/s390/kvm/kvm-s390.h

50

load_fp_regs((freg_t *)&run->s.regs.fprs);

arch/s390/kvm/priv.c

1019

vcpu->run->s.regs.gprs[reg1] &= 0xffffffff00000000UL;

arch/s390/kvm/priv.c

1020

vcpu->run->s.regs.gprs[reg1] |= vcpu->arch.sie_block->gpsw.mask >> 32;

arch/s390/kvm/priv.c

1022

vcpu->run->s.regs.gprs[reg2] &= 0xffffffff00000000UL;

arch/s390/kvm/priv.c

1023

vcpu->run->s.regs.gprs[reg2] |=

arch/s390/kvm/priv.c

1056

if (vcpu->run->s.regs.gprs[reg1] & PFMF_RESERVED)

arch/s390/kvm/priv.c

1060

if (vcpu->run->s.regs.gprs[reg1] & PFMF_NQ &&

arch/s390/kvm/priv.c

1065

if (vcpu->run->s.regs.gprs[reg1] & PFMF_SK &&

arch/s390/kvm/priv.c

1067

mr = vcpu->run->s.regs.gprs[reg1] & PFMF_MR;

arch/s390/kvm/priv.c

1068

mc = vcpu->run->s.regs.gprs[reg1] & PFMF_MC;

arch/s390/kvm/priv.c

1071

nq = vcpu->run->s.regs.gprs[reg1] & PFMF_NQ;

arch/s390/kvm/priv.c

1072

key.skey = vcpu->run->s.regs.gprs[reg1] & PFMF_KEY;

arch/s390/kvm/priv.c

1073

start = vcpu->run->s.regs.gprs[reg2] & PAGE_MASK;

arch/s390/kvm/priv.c

1076

if (vcpu->run->s.regs.gprs[reg1] & PFMF_CF) {

arch/s390/kvm/priv.c

1081

switch (vcpu->run->s.regs.gprs[reg1] & PFMF_FSC) {

arch/s390/kvm/priv.c

1103

if (vcpu->run->s.regs.gprs[reg1] & PFMF_CF) {

arch/s390/kvm/priv.c

1108

if (vcpu->run->s.regs.gprs[reg1] & PFMF_SK) {

arch/s390/kvm/priv.c

1129

if (vcpu->run->s.regs.gprs[reg1] & PFMF_FSC) {

arch/s390/kvm/priv.c

1131

vcpu->run->s.regs.gprs[reg2] = end;

arch/s390/kvm/priv.c

1133

vcpu->run->s.regs.gprs[reg2] &= ~0xffffffffUL;

arch/s390/kvm/priv.c

1135

vcpu->run->s.regs.gprs[reg2] |= end;

arch/s390/kvm/priv.c

1158

gfn = vcpu->run->s.regs.gprs[r2] >> PAGE_SHIFT;

arch/s390/kvm/priv.c

1162

vcpu->run->s.regs.gprs[r1] = state.val;

arch/s390/kvm/priv.c

1529

if (vcpu->run->s.regs.gprs[0] & 0x00000000ffff0000)

arch/s390/kvm/priv.c

1533

value = vcpu->run->s.regs.gprs[0] & 0x000000000000ffff;

arch/s390/kvm/priv.c

275

gaddr = vcpu->run->s.regs.gprs[reg2] & PAGE_MASK;

arch/s390/kvm/priv.c

284

vcpu->run->s.regs.gprs[reg1] &= ~0xff;

arch/s390/kvm/priv.c

285

vcpu->run->s.regs.gprs[reg1] |= key.skey;

arch/s390/kvm/priv.c

306

gaddr = vcpu->run->s.regs.gprs[reg2] & PAGE_MASK;

arch/s390/kvm/priv.c

349

key.skey = vcpu->run->s.regs.gprs[reg1] & 0xfe;

arch/s390/kvm/priv.c

350

start = vcpu->run->s.regs.gprs[reg2] & PAGE_MASK;

arch/s390/kvm/priv.c

383

vcpu->run->s.regs.gprs[reg1] &= ~0xff00UL;

arch/s390/kvm/priv.c

384

vcpu->run->s.regs.gprs[reg1] |= (u64)oldkey.skey << 8;

arch/s390/kvm/priv.c

389

vcpu->run->s.regs.gprs[reg2] &= ~PAGE_MASK;

arch/s390/kvm/priv.c

391

vcpu->run->s.regs.gprs[reg2] &= ~0xfffff000UL;

arch/s390/kvm/priv.c

393

vcpu->run->s.regs.gprs[reg2] |= end;

arch/s390/kvm/priv.c

420

addr = vcpu->run->s.regs.gprs[reg2] & PAGE_MASK;

arch/s390/kvm/priv.c

435

vcpu->run->s.regs.gprs[0] = 0;

arch/s390/kvm/priv.c

513

if (vcpu->run->s.regs.gprs[1])

arch/s390/kvm/priv.c

515

vcpu->run->s.regs.gprs[1]);

arch/s390/kvm/priv.c

525

vcpu->run->exit_reason = KVM_EXIT_S390_TSCH;

arch/s390/kvm/priv.c

526

vcpu->run->s390_tsch.dequeued = !!inti;

arch/s390/kvm/priv.c

528

vcpu->run->s390_tsch.subchannel_id = inti->io.subchannel_id;

arch/s390/kvm/priv.c

529

vcpu->run->s390_tsch.subchannel_nr = inti->io.subchannel_nr;

arch/s390/kvm/priv.c

530

vcpu->run->s390_tsch.io_int_parm = inti->io.io_int_parm;

arch/s390/kvm/priv.c

531

vcpu->run->s390_tsch.io_int_word = inti->io.io_int_word;

arch/s390/kvm/priv.c

533

vcpu->run->s390_tsch.ipb = vcpu->arch.sie_block->ipb;

arch/s390/kvm/priv.c

612

reg0 = vcpu->run->s.regs.gprs[0];

arch/s390/kvm/priv.c

62

current->thread.gs_cb = (struct gs_cb *)&vcpu->run->s.regs.gscb;

arch/s390/kvm/priv.c

647

if (vcpu->run->s.regs.gprs[1] & 0x00ff0000)

arch/s390/kvm/priv.c

662

memcpy(&vcpu->run->s.regs.gprs[1], &status, sizeof(status));

arch/s390/kvm/priv.c

852

vcpu->run->exit_reason = KVM_EXIT_S390_STSI;

arch/s390/kvm/priv.c

853

vcpu->run->s390_stsi.addr = addr;

arch/s390/kvm/priv.c

854

vcpu->run->s390_stsi.ar = ar;

arch/s390/kvm/priv.c

855

vcpu->run->s390_stsi.fc = fc;

arch/s390/kvm/priv.c

856

vcpu->run->s390_stsi.sel1 = sel1;

arch/s390/kvm/priv.c

857

vcpu->run->s390_stsi.sel2 = sel2;

arch/s390/kvm/priv.c

862

int fc = (vcpu->run->s.regs.gprs[0] & 0xf0000000) >> 28;

arch/s390/kvm/priv.c

863

int sel1 = vcpu->run->s.regs.gprs[0] & 0xff;

arch/s390/kvm/priv.c

864

int sel2 = vcpu->run->s.regs.gprs[1] & 0xffff;

arch/s390/kvm/priv.c

889

if (vcpu->run->s.regs.gprs[0] & 0x0fffff00

arch/s390/kvm/priv.c

890

|| vcpu->run->s.regs.gprs[1] & 0xffff0000)

arch/s390/kvm/priv.c

894

vcpu->run->s.regs.gprs[0] = 3 << 28;

arch/s390/kvm/priv.c

943

vcpu->run->s.regs.gprs[0] = 0;

arch/s390/kvm/sigp.c

430

u16 cpu_addr = vcpu->run->s.regs.gprs[r3];

arch/s390/kvm/sigp.c

443

parameter = vcpu->run->s.regs.gprs[r1];

arch/s390/kvm/sigp.c

445

parameter = vcpu->run->s.regs.gprs[r1 + 1];

arch/s390/kvm/sigp.c

452

&vcpu->run->s.regs.gprs[r1]);

arch/s390/kvm/sigp.c

457

&vcpu->run->s.regs.gprs[r1]);

arch/s390/kvm/sigp.c

479

u16 cpu_addr = vcpu->run->s.regs.gprs[r3];

arch/s390/kvm/vsie.c

1035

return vcpu->run->s.regs.gprs[reg];

arch/s390/kvm/vsie.c

1167

sie_return = kvm_s390_enter_exit_sie(scb_s, vcpu->run->s.regs.gprs, sg->asce.val);

arch/x86/include/uapi/asm/sgx.h

164

struct sgx_enclave_run *run);

arch/x86/include/uapi/asm/sgx.h

236

struct sgx_enclave_run *run);

arch/x86/kvm/hyperv.c

2410

return kvm_hv_hypercall_complete(vcpu, vcpu->run->hyperv.u.hcall.result);

arch/x86/kvm/hyperv.c

2689

vcpu->run->exit_reason = KVM_EXIT_HYPERV;

arch/x86/kvm/hyperv.c

2690

vcpu->run->hyperv.type = KVM_EXIT_HYPERV_HCALL;

arch/x86/kvm/hyperv.c

2691

vcpu->run->hyperv.u.hcall.input = hc.param;

arch/x86/kvm/hyperv.c

2692

vcpu->run->hyperv.u.hcall.params[0] = hc.ingpa;

arch/x86/kvm/hyperv.c

2693

vcpu->run->hyperv.u.hcall.params[1] = hc.outgpa;

arch/x86/kvm/hyperv.c

340

if (vcpu->run->hyperv.u.syndbg.msr == HV_X64_MSR_SYNDBG_CONTROL)

arch/x86/kvm/hyperv.c

342

vcpu->run->hyperv.u.syndbg.status;

arch/x86/kvm/lapic.c

1677

struct kvm_run *run = vcpu->run;

arch/x86/kvm/lapic.c

1680

run->tpr_access.rip = kvm_rip_read(vcpu);

arch/x86/kvm/lapic.c

1681

run->tpr_access.is_write = write;

arch/x86/kvm/svm/nested.c

1958

vcpu->run->exit_reason = KVM_EXIT_INTERNAL_ERROR;

arch/x86/kvm/svm/nested.c

1959

vcpu->run->internal.suberror =

arch/x86/kvm/svm/nested.c

1961

vcpu->run->internal.ndata = 0;

arch/x86/kvm/svm/sev.c

3723

if (vcpu->run->hypercall.ret)

arch/x86/kvm/svm/sev.c

3747

vcpu->run->exit_reason = KVM_EXIT_HYPERCALL;

arch/x86/kvm/svm/sev.c

3748

vcpu->run->hypercall.nr = KVM_HC_MAP_GPA_RANGE;

arch/x86/kvm/svm/sev.c

3755

vcpu->run->hypercall.ret = 0;

arch/x86/kvm/svm/sev.c

3756

vcpu->run->hypercall.args[0] = gpa;

arch/x86/kvm/svm/sev.c

3757

vcpu->run->hypercall.args[1] = 1;

arch/x86/kvm/svm/sev.c

3758

vcpu->run->hypercall.args[2] = (op == SNP_PAGE_STATE_PRIVATE)

arch/x86/kvm/svm/sev.c

3761

vcpu->run->hypercall.args[2] |= KVM_MAP_GPA_RANGE_PAGE_SZ_4K;

arch/x86/kvm/svm/sev.c

3817

if (vcpu->run->hypercall.ret) {

arch/x86/kvm/svm/sev.c

3924

vcpu->run->exit_reason = KVM_EXIT_HYPERCALL;

arch/x86/kvm/svm/sev.c

3925

vcpu->run->hypercall.nr = KVM_HC_MAP_GPA_RANGE;

arch/x86/kvm/svm/sev.c

3932

vcpu->run->hypercall.ret = 0;

arch/x86/kvm/svm/sev.c

3933

vcpu->run->hypercall.args[0] = gfn_to_gpa(gfn);

arch/x86/kvm/svm/sev.c

3934

vcpu->run->hypercall.args[1] = npages;

arch/x86/kvm/svm/sev.c

3935

vcpu->run->hypercall.args[2] = entry_start.operation == VMGEXIT_PSC_OP_PRIVATE

arch/x86/kvm/svm/sev.c

3938

vcpu->run->hypercall.args[2] |= entry_start.pagesize

arch/x86/kvm/svm/sev.c

4166

switch (READ_ONCE(vcpu->run->snp_req_certs.ret)) {

arch/x86/kvm/svm/sev.c

4171

vcpu->arch.regs[VCPU_REGS_RBX] = vcpu->run->snp_req_certs.npages;

arch/x86/kvm/svm/sev.c

4222

vcpu->run->exit_reason = KVM_EXIT_SNP_REQ_CERTS;

arch/x86/kvm/svm/sev.c

4223

vcpu->run->snp_req_certs.gpa = data_gpa;

arch/x86/kvm/svm/sev.c

4224

vcpu->run->snp_req_certs.npages = data_npages;

arch/x86/kvm/svm/sev.c

4225

vcpu->run->snp_req_certs.ret = 0;

arch/x86/kvm/svm/sev.c

4381

vcpu->run->exit_reason = KVM_EXIT_SYSTEM_EVENT;

arch/x86/kvm/svm/sev.c

4382

vcpu->run->system_event.type = KVM_SYSTEM_EVENT_SEV_TERM;

arch/x86/kvm/svm/sev.c

4383

vcpu->run->system_event.ndata = 1;

arch/x86/kvm/svm/sev.c

4384

vcpu->run->system_event.data[0] = control->ghcb_gpa;

arch/x86/kvm/svm/sev.c

4494

vcpu->run->exit_reason = KVM_EXIT_SYSTEM_EVENT;

arch/x86/kvm/svm/sev.c

4495

vcpu->run->system_event.type = KVM_SYSTEM_EVENT_SEV_TERM;

arch/x86/kvm/svm/sev.c

4496

vcpu->run->system_event.ndata = 1;

arch/x86/kvm/svm/sev.c

4497

vcpu->run->system_event.data[0] = control->ghcb_gpa;

arch/x86/kvm/svm/svm.c

1970

struct kvm_run *kvm_run = vcpu->run;

arch/x86/kvm/svm/svm.c

2004

struct kvm_run *kvm_run = vcpu->run;

arch/x86/kvm/svm/svm.c

2083

struct kvm_run *kvm_run = vcpu->run;

arch/x86/kvm/svm/svm.c

2687

vcpu->run->exit_reason = KVM_EXIT_SET_TPR;

arch/x86/kvm/svm/svm.c

3220

vcpu->run->exit_reason = KVM_EXIT_X86_BUS_LOCK;

arch/x86/kvm/svm/svm.c

3221

vcpu->run->flags |= KVM_RUN_X86_BUS_LOCK;

arch/x86/kvm/svm/svm.c

3602

struct kvm_run *kvm_run = vcpu->run;

arch/x86/kvm/svm/svm.c

4320

vcpu->run->exit_reason = KVM_EXIT_FAIL_ENTRY;

arch/x86/kvm/svm/svm.c

4321

vcpu->run->fail_entry.hardware_entry_failure_reason = SVM_EXIT_ERR;

arch/x86/kvm/svm/svm.c

4322

vcpu->run->fail_entry.cpu = vcpu->cpu;

arch/x86/kvm/vmx/nested.c

3445

vcpu->run->exit_reason = KVM_EXIT_INTERNAL_ERROR;

arch/x86/kvm/vmx/nested.c

3446

vcpu->run->internal.suberror =

arch/x86/kvm/vmx/nested.c

3448

vcpu->run->internal.ndata = 0;

arch/x86/kvm/vmx/nested.c

3519

vcpu->run->exit_reason = KVM_EXIT_INTERNAL_ERROR;

arch/x86/kvm/vmx/nested.c

3520

vcpu->run->internal.suberror =

arch/x86/kvm/vmx/nested.c

3522

vcpu->run->internal.ndata = 0;

arch/x86/kvm/vmx/sgx.c

397

vcpu->run->exit_reason = KVM_EXIT_UNKNOWN;

arch/x86/kvm/vmx/sgx.c

398

vcpu->run->hw.hardware_exit_reason = EXIT_REASON_ENCLS;

arch/x86/kvm/vmx/tdx.c

1155

vcpu->run->exit_reason = KVM_EXIT_EXCEPTION;

arch/x86/kvm/vmx/tdx.c

1156

vcpu->run->ex.exception = intr_info & INTR_INFO_VECTOR_MASK;

arch/x86/kvm/vmx/tdx.c

1157

vcpu->run->ex.error_code = 0;

arch/x86/kvm/vmx/tdx.c

1164

tdvmcall_set_return_code(vcpu, vcpu->run->hypercall.ret);

arch/x86/kvm/vmx/tdx.c

1191

if (vcpu->run->hypercall.ret) {

arch/x86/kvm/vmx/tdx.c

1224

tdx->vcpu.run->exit_reason = KVM_EXIT_HYPERCALL;

arch/x86/kvm/vmx/tdx.c

1225

tdx->vcpu.run->hypercall.nr = KVM_HC_MAP_GPA_RANGE;

arch/x86/kvm/vmx/tdx.c

1232

tdx->vcpu.run->hypercall.ret = 0;

arch/x86/kvm/vmx/tdx.c

1233

tdx->vcpu.run->hypercall.args[0] = gpa & ~gfn_to_gpa(kvm_gfn_direct_bits(tdx->vcpu.kvm));

arch/x86/kvm/vmx/tdx.c

1234

tdx->vcpu.run->hypercall.args[1] = size / PAGE_SIZE;

arch/x86/kvm/vmx/tdx.c

1235

tdx->vcpu.run->hypercall.args[2] = vt_is_tdx_private_gpa(tdx->vcpu.kvm, gpa) ?

arch/x86/kvm/vmx/tdx.c

1238

tdx->vcpu.run->hypercall.flags = KVM_EXIT_HYPERCALL_LONG_MODE;

arch/x86/kvm/vmx/tdx.c

1291

u64 *regs = vcpu->run->system_event.data;

arch/x86/kvm/vmx/tdx.c

1295

vcpu->run->exit_reason = KVM_EXIT_SYSTEM_EVENT;

arch/x86/kvm/vmx/tdx.c

1296

vcpu->run->system_event.type = KVM_SYSTEM_EVENT_TDX_FATAL;

arch/x86/kvm/vmx/tdx.c

1297

vcpu->run->system_event.ndata = 16;

arch/x86/kvm/vmx/tdx.c

1400

memcpy(&val, vcpu->run->mmio.data, size);

arch/x86/kvm/vmx/tdx.c

1473

vcpu->run->mmio.phys_addr = gpa;

arch/x86/kvm/vmx/tdx.c

1474

vcpu->run->mmio.len = size;

arch/x86/kvm/vmx/tdx.c

1475

vcpu->run->mmio.is_write = write;

arch/x86/kvm/vmx/tdx.c

1476

vcpu->run->exit_reason = KVM_EXIT_MMIO;

arch/x86/kvm/vmx/tdx.c

1479

memcpy(vcpu->run->mmio.data, &val, size);

arch/x86/kvm/vmx/tdx.c

1496

tdvmcall_set_return_code(vcpu, vcpu->run->tdx.get_tdvmcall_info.ret);

arch/x86/kvm/vmx/tdx.c

1503

tdx->vp_enter_args.r11 = vcpu->run->tdx.get_tdvmcall_info.r11;

arch/x86/kvm/vmx/tdx.c

1504

tdx->vp_enter_args.r12 = vcpu->run->tdx.get_tdvmcall_info.r12;

arch/x86/kvm/vmx/tdx.c

1505

tdx->vp_enter_args.r13 = vcpu->run->tdx.get_tdvmcall_info.r13;

arch/x86/kvm/vmx/tdx.c

1506

tdx->vp_enter_args.r14 = vcpu->run->tdx.get_tdvmcall_info.r14;

arch/x86/kvm/vmx/tdx.c

1524

vcpu->run->tdx.get_tdvmcall_info.leaf = tdx->vp_enter_args.r12;

arch/x86/kvm/vmx/tdx.c

1525

vcpu->run->exit_reason = KVM_EXIT_TDX;

arch/x86/kvm/vmx/tdx.c

1526

vcpu->run->tdx.flags = 0;

arch/x86/kvm/vmx/tdx.c

1527

vcpu->run->tdx.nr = TDVMCALL_GET_TD_VM_CALL_INFO;

arch/x86/kvm/vmx/tdx.c

1528

vcpu->run->tdx.get_tdvmcall_info.ret = TDVMCALL_STATUS_SUCCESS;

arch/x86/kvm/vmx/tdx.c

1529

vcpu->run->tdx.get_tdvmcall_info.r11 = 0;

arch/x86/kvm/vmx/tdx.c

1530

vcpu->run->tdx.get_tdvmcall_info.r12 = 0;

arch/x86/kvm/vmx/tdx.c

1531

vcpu->run->tdx.get_tdvmcall_info.r13 = 0;

arch/x86/kvm/vmx/tdx.c

1532

vcpu->run->tdx.get_tdvmcall_info.r14 = 0;

arch/x86/kvm/vmx/tdx.c

1543

tdvmcall_set_return_code(vcpu, vcpu->run->tdx.unknown.ret);

arch/x86/kvm/vmx/tdx.c

1559

vcpu->run->exit_reason = KVM_EXIT_TDX;

arch/x86/kvm/vmx/tdx.c

1560

vcpu->run->tdx.flags = 0;

arch/x86/kvm/vmx/tdx.c

1561

vcpu->run->tdx.nr = TDVMCALL_GET_QUOTE;

arch/x86/kvm/vmx/tdx.c

1562

vcpu->run->tdx.get_quote.ret = TDVMCALL_STATUS_SUBFUNC_UNSUPPORTED;

arch/x86/kvm/vmx/tdx.c

1563

vcpu->run->tdx.get_quote.gpa = gpa & ~gfn_to_gpa(kvm_gfn_direct_bits(tdx->vcpu.kvm));

arch/x86/kvm/vmx/tdx.c

1564

vcpu->run->tdx.get_quote.size = size;

arch/x86/kvm/vmx/tdx.c

1581

vcpu->run->exit_reason = KVM_EXIT_TDX;

arch/x86/kvm/vmx/tdx.c

1582

vcpu->run->tdx.flags = 0;

arch/x86/kvm/vmx/tdx.c

1583

vcpu->run->tdx.nr = TDVMCALL_SETUP_EVENT_NOTIFY_INTERRUPT;

arch/x86/kvm/vmx/tdx.c

1584

vcpu->run->tdx.setup_event_notify.ret = TDVMCALL_STATUS_SUBFUNC_UNSUPPORTED;

arch/x86/kvm/vmx/tdx.c

1585

vcpu->run->tdx.setup_event_notify.vector = vector;

arch/x86/kvm/vmx/tdx.c

2008

vcpu->run->exit_reason = KVM_EXIT_FAIL_ENTRY;

arch/x86/kvm/vmx/tdx.c

2009

vcpu->run->fail_entry.hardware_entry_failure_reason = exit_reason.full;

arch/x86/kvm/vmx/tdx.c

2010

vcpu->run->fail_entry.cpu = vcpu->arch.last_vmentry_cpu;

arch/x86/kvm/vmx/tdx.c

2025

vcpu->run->exit_reason = KVM_EXIT_SHUTDOWN;

arch/x86/kvm/vmx/vmx.c

5480

struct kvm_run *kvm_run = vcpu->run;

arch/x86/kvm/vmx/vmx.c

5547

vcpu->run->exit_reason = KVM_EXIT_INTERNAL_ERROR;

arch/x86/kvm/vmx/vmx.c

5548

vcpu->run->internal.suberror = KVM_INTERNAL_ERROR_SIMUL_EX;

arch/x86/kvm/vmx/vmx.c

5549

vcpu->run->internal.ndata = 4;

arch/x86/kvm/vmx/vmx.c

5550

vcpu->run->internal.data[0] = vect_info;

arch/x86/kvm/vmx/vmx.c

5551

vcpu->run->internal.data[1] = intr_info;

arch/x86/kvm/vmx/vmx.c

5552

vcpu->run->internal.data[2] = error_code;

arch/x86/kvm/vmx/vmx.c

5553

vcpu->run->internal.data[3] = vcpu->arch.last_vmentry_cpu;

arch/x86/kvm/vmx/vmx.c

5649

vcpu->run->exit_reason = KVM_EXIT_SHUTDOWN;

arch/x86/kvm/vmx/vmx.c

5782

vcpu->run->exit_reason = KVM_EXIT_SET_TPR;

arch/x86/kvm/vmx/vmx.c

5815

vcpu->run->exit_reason = 0;

arch/x86/kvm/vmx/vmx.c

5845

vcpu->run->debug.arch.dr6 = DR6_BD | DR6_ACTIVE_LOW;

arch/x86/kvm/vmx/vmx.c

5846

vcpu->run->debug.arch.dr7 = dr7;

arch/x86/kvm/vmx/vmx.c

5847

vcpu->run->debug.arch.pc = kvm_get_linear_rip(vcpu);

arch/x86/kvm/vmx/vmx.c

5848

vcpu->run->debug.arch.exception = DB_VECTOR;

arch/x86/kvm/vmx/vmx.c

5849

vcpu->run->exit_reason = KVM_EXIT_DEBUG;

arch/x86/kvm/vmx/vmx.c

6371

vcpu->run->exit_reason = KVM_EXIT_NOTIFY;

arch/x86/kvm/vmx/vmx.c

6372

vcpu->run->notify.flags = context_invalid ?

arch/x86/kvm/vmx/vmx.c

6855

vcpu->run->exit_reason = KVM_EXIT_FAIL_ENTRY;

arch/x86/kvm/vmx/vmx.c

6856

vcpu->run->fail_entry.hardware_entry_failure_reason

arch/x86/kvm/vmx/vmx.c

6858

vcpu->run->fail_entry.cpu = vcpu->arch.last_vmentry_cpu;

arch/x86/kvm/vmx/vmx.c

6864

vcpu->run->exit_reason = KVM_EXIT_FAIL_ENTRY;

arch/x86/kvm/vmx/vmx.c

6865

vcpu->run->fail_entry.hardware_entry_failure_reason

arch/x86/kvm/vmx/vmx.c

6867

vcpu->run->fail_entry.cpu = vcpu->arch.last_vmentry_cpu;

arch/x86/kvm/vmx/vmx.c

6947

vcpu->run->exit_reason = KVM_EXIT_X86_BUS_LOCK;

arch/x86/kvm/vmx/vmx.c

6949

vcpu->run->flags |= KVM_RUN_X86_BUS_LOCK;

arch/x86/kvm/x86.c

10373

u64 ret = vcpu->run->hypercall.ret;

arch/x86/kvm/x86.c

10454

vcpu->run->exit_reason = KVM_EXIT_HYPERCALL;

arch/x86/kvm/x86.c

10455

vcpu->run->hypercall.nr = KVM_HC_MAP_GPA_RANGE;

arch/x86/kvm/x86.c

10462

vcpu->run->hypercall.ret = 0;

arch/x86/kvm/x86.c

10463

vcpu->run->hypercall.args[0] = gpa;

arch/x86/kvm/x86.c

10464

vcpu->run->hypercall.args[1] = npages;

arch/x86/kvm/x86.c

10465

vcpu->run->hypercall.args[2] = attrs;

arch/x86/kvm/x86.c

10466

vcpu->run->hypercall.flags = 0;

arch/x86/kvm/x86.c

10468

vcpu->run->hypercall.flags |= KVM_EXIT_HYPERCALL_LONG_MODE;

arch/x86/kvm/x86.c

10470

WARN_ON_ONCE(vcpu->run->hypercall.flags & KVM_EXIT_HYPERCALL_MBZ);

arch/x86/kvm/x86.c

10480

vcpu->run->hypercall.ret = ret;

arch/x86/kvm/x86.c

10523

return vcpu->run->request_interrupt_window &&

arch/x86/kvm/x86.c

10530

struct kvm_run *kvm_run = vcpu->run;

arch/x86/kvm/x86.c

11148

vcpu->run->exit_reason = KVM_EXIT_TPR_ACCESS;

arch/x86/kvm/x86.c

11157

vcpu->run->exit_reason = KVM_EXIT_SHUTDOWN;

arch/x86/kvm/x86.c

11185

vcpu->run->exit_reason = KVM_EXIT_IOAPIC_EOI;

arch/x86/kvm/x86.c

11186

vcpu->run->eoi.vector =

arch/x86/kvm/x86.c

11200

vcpu->run->exit_reason = KVM_EXIT_SYSTEM_EVENT;

arch/x86/kvm/x86.c

11201

vcpu->run->system_event.type = KVM_SYSTEM_EVENT_CRASH;

arch/x86/kvm/x86.c

11202

vcpu->run->system_event.ndata = 0;

arch/x86/kvm/x86.c

11207

vcpu->run->exit_reason = KVM_EXIT_SYSTEM_EVENT;

arch/x86/kvm/x86.c

11208

vcpu->run->system_event.type = KVM_SYSTEM_EVENT_RESET;

arch/x86/kvm/x86.c

11209

vcpu->run->system_event.ndata = 0;

arch/x86/kvm/x86.c

11216

vcpu->run->exit_reason = KVM_EXIT_HYPERV;

arch/x86/kvm/x86.c

11217

vcpu->run->hyperv = hv_vcpu->exit;

arch/x86/kvm/x86.c

11666

vcpu->run->exit_reason = KVM_EXIT_UNKNOWN;

arch/x86/kvm/x86.c

11695

vcpu->run->exit_reason = KVM_EXIT_IRQ_WINDOW_OPEN;

arch/x86/kvm/x86.c

11728

vcpu->run->exit_reason = reason;

arch/x86/kvm/x86.c

11832

struct kvm_run *run = vcpu->run;

arch/x86/kvm/x86.c

11842

memcpy(frag->data, run->mmio.data, len);

arch/x86/kvm/x86.c

11865

run->exit_reason = KVM_EXIT_MMIO;

arch/x86/kvm/x86.c

11866

run->mmio.phys_addr = frag->gpa;

arch/x86/kvm/x86.c

11868

memcpy(run->mmio.data, frag->data, min(8u, frag->len));

arch/x86/kvm/x86.c

11869

run->mmio.len = min(8u, frag->len);

arch/x86/kvm/x86.c

11870

run->mmio.is_write = vcpu->mmio_is_write;

arch/x86/kvm/x86.c

11922

struct kvm_run *kvm_run = vcpu->run;

arch/x86/kvm/x86.c

12322

vcpu->run->exit_reason = KVM_EXIT_INTERNAL_ERROR;

arch/x86/kvm/x86.c

12323

vcpu->run->internal.suberror = KVM_INTERNAL_ERROR_EMULATION;

arch/x86/kvm/x86.c

12324

vcpu->run->internal.ndata = 0;

arch/x86/kvm/x86.c

12655

if (vcpu->run->kvm_valid_regs & KVM_SYNC_X86_REGS)

arch/x86/kvm/x86.c

12656

__get_regs(vcpu, &vcpu->run->s.regs.regs);

arch/x86/kvm/x86.c

12658

if (vcpu->run->kvm_valid_regs & KVM_SYNC_X86_SREGS)

arch/x86/kvm/x86.c

12659

__get_sregs(vcpu, &vcpu->run->s.regs.sregs);

arch/x86/kvm/x86.c

12661

if (vcpu->run->kvm_valid_regs & KVM_SYNC_X86_EVENTS)

arch/x86/kvm/x86.c

12663

vcpu, &vcpu->run->s.regs.events);

arch/x86/kvm/x86.c

12668

if (vcpu->run->kvm_dirty_regs & KVM_SYNC_X86_REGS) {

arch/x86/kvm/x86.c

12669

__set_regs(vcpu, &vcpu->run->s.regs.regs);

arch/x86/kvm/x86.c

12670

vcpu->run->kvm_dirty_regs &= ~KVM_SYNC_X86_REGS;

arch/x86/kvm/x86.c

12673

if (vcpu->run->kvm_dirty_regs & KVM_SYNC_X86_SREGS) {

arch/x86/kvm/x86.c

12674

struct kvm_sregs sregs = vcpu->run->s.regs.sregs;

arch/x86/kvm/x86.c

12679

vcpu->run->kvm_dirty_regs &= ~KVM_SYNC_X86_SREGS;

arch/x86/kvm/x86.c

12682

if (vcpu->run->kvm_dirty_regs & KVM_SYNC_X86_EVENTS) {

arch/x86/kvm/x86.c

12683

struct kvm_vcpu_events events = vcpu->run->s.regs.events;

arch/x86/kvm/x86.c

12688

vcpu->run->kvm_dirty_regs &= ~KVM_SYNC_X86_EVENTS;

arch/x86/kvm/x86.c

14242

struct kvm_run *run = vcpu->run;

arch/x86/kvm/x86.c

14252

memcpy(frag->data, run->mmio.data, len);

arch/x86/kvm/x86.c

14274

run->mmio.phys_addr = frag->gpa;

arch/x86/kvm/x86.c

14275

run->mmio.len = min(8u, frag->len);

arch/x86/kvm/x86.c

14276

run->mmio.is_write = vcpu->mmio_is_write;

arch/x86/kvm/x86.c

14277

if (run->mmio.is_write)

arch/x86/kvm/x86.c

14278

memcpy(run->mmio.data, frag->data, min(8u, frag->len));

arch/x86/kvm/x86.c

14279

run->exit_reason = KVM_EXIT_MMIO;

arch/x86/kvm/x86.c

14313

vcpu->run->mmio.phys_addr = gpa;

arch/x86/kvm/x86.c

14314

vcpu->run->mmio.len = min(8u, frag->len);

arch/x86/kvm/x86.c

14315

vcpu->run->mmio.is_write = 1;

arch/x86/kvm/x86.c

14316

memcpy(vcpu->run->mmio.data, frag->data, min(8u, frag->len));

arch/x86/kvm/x86.c

14317

vcpu->run->exit_reason = KVM_EXIT_MMIO;

arch/x86/kvm/x86.c

14352

vcpu->run->mmio.phys_addr = gpa;

arch/x86/kvm/x86.c

14353

vcpu->run->mmio.len = min(8u, frag->len);

arch/x86/kvm/x86.c

14354

vcpu->run->mmio.is_write = 0;

arch/x86/kvm/x86.c

14355

vcpu->run->exit_reason = KVM_EXIT_MMIO;

arch/x86/kvm/x86.c

2058

if (!vcpu->run->msr.error) {

arch/x86/kvm/x86.c

2059

kvm_rax_write(vcpu, (u32)vcpu->run->msr.data);

arch/x86/kvm/x86.c

2060

kvm_rdx_write(vcpu, vcpu->run->msr.data >> 32);

arch/x86/kvm/x86.c

2066

return complete_emulated_insn_gp(vcpu, vcpu->run->msr.error);

arch/x86/kvm/x86.c

2077

return kvm_x86_call(complete_emulated_msr)(vcpu, vcpu->run->msr.error);

arch/x86/kvm/x86.c

2088

if (!vcpu->run->msr.error)

arch/x86/kvm/x86.c

2090

vcpu->run->msr.data);

arch/x86/kvm/x86.c

2118

vcpu->run->exit_reason = exit_reason;

arch/x86/kvm/x86.c

2119

vcpu->run->msr.error = 0;

arch/x86/kvm/x86.c

2120

memset(vcpu->run->msr.pad, 0, sizeof(vcpu->run->msr.pad));

arch/x86/kvm/x86.c

2121

vcpu->run->msr.reason = msr_reason;

arch/x86/kvm/x86.c

2122

vcpu->run->msr.index = index;

arch/x86/kvm/x86.c

2123

vcpu->run->msr.data = data;

arch/x86/kvm/x86.c

8164

memcpy(vcpu->run->mmio.data, frag->data, min(8u, frag->len));

arch/x86/kvm/x86.c

8279

vcpu->run->mmio.len = min(8u, vcpu->mmio_fragments[0].len);

arch/x86/kvm/x86.c

8280

vcpu->run->mmio.is_write = vcpu->mmio_is_write = ops->write;

arch/x86/kvm/x86.c

8281

vcpu->run->exit_reason = KVM_EXIT_MMIO;

arch/x86/kvm/x86.c

8282

vcpu->run->mmio.phys_addr = gpa;

arch/x86/kvm/x86.c

8435

vcpu->run->exit_reason = KVM_EXIT_IO;

arch/x86/kvm/x86.c

8436

vcpu->run->io.direction = in ? KVM_EXIT_IO_IN : KVM_EXIT_IO_OUT;

arch/x86/kvm/x86.c

8437

vcpu->run->io.size = size;

arch/x86/kvm/x86.c

8438

vcpu->run->io.data_offset = KVM_PIO_PAGE_OFFSET * PAGE_SIZE;

arch/x86/kvm/x86.c

8439

vcpu->run->io.count = count;

arch/x86/kvm/x86.c

8440

vcpu->run->io.port = port;

arch/x86/kvm/x86.c

9042

struct kvm_run *run = vcpu->run;

arch/x86/kvm/x86.c

9055

run->exit_reason = KVM_EXIT_INTERNAL_ERROR;

arch/x86/kvm/x86.c

9056

run->emulation_failure.suberror = KVM_INTERNAL_ERROR_EMULATION;

arch/x86/kvm/x86.c

9068

run->emulation_failure.flags = 0;

arch/x86/kvm/x86.c

9071

BUILD_BUG_ON((sizeof(run->emulation_failure.insn_size) +

arch/x86/kvm/x86.c

9072

sizeof(run->emulation_failure.insn_bytes) != 16));

arch/x86/kvm/x86.c

9074

run->emulation_failure.flags |=

arch/x86/kvm/x86.c

9076

run->emulation_failure.insn_size = insn_size;

arch/x86/kvm/x86.c

9077

memset(run->emulation_failure.insn_bytes, 0x90,

arch/x86/kvm/x86.c

9078

sizeof(run->emulation_failure.insn_bytes));

arch/x86/kvm/x86.c

9079

memcpy(run->emulation_failure.insn_bytes, insn_bytes, insn_size);

arch/x86/kvm/x86.c

9082

memcpy(&run->internal.data[info_start], info, sizeof(info));

arch/x86/kvm/x86.c

9083

memcpy(&run->internal.data[info_start + ARRAY_SIZE(info)], data,

arch/x86/kvm/x86.c

9086

run->emulation_failure.ndata = info_start + ARRAY_SIZE(info) + ndata;

arch/x86/kvm/x86.c

9113

struct kvm_run *run = vcpu->run;

arch/x86/kvm/x86.c

9120

run->internal.data[ndata++] = info2;

arch/x86/kvm/x86.c

9121

run->internal.data[ndata++] = reason;

arch/x86/kvm/x86.c

9122

run->internal.data[ndata++] = info1;

arch/x86/kvm/x86.c

9123

run->internal.data[ndata++] = gpa;

arch/x86/kvm/x86.c

9124

run->internal.data[ndata++] = vcpu->arch.last_vmentry_cpu;

arch/x86/kvm/x86.c

9126

run->exit_reason = KVM_EXIT_INTERNAL_ERROR;

arch/x86/kvm/x86.c

9127

run->internal.suberror = KVM_INTERNAL_ERROR_DELIVERY_EV;

arch/x86/kvm/x86.c

9128

run->internal.ndata = ndata;

arch/x86/kvm/x86.c

9136

vcpu->run->exit_reason = KVM_EXIT_INTERNAL_ERROR;

arch/x86/kvm/x86.c

9137

vcpu->run->internal.suberror = KVM_INTERNAL_ERROR_UNEXPECTED_EXIT_REASON;

arch/x86/kvm/x86.c

9138

vcpu->run->internal.ndata = 2;

arch/x86/kvm/x86.c

9139

vcpu->run->internal.data[0] = exit_reason;

arch/x86/kvm/x86.c

9140

vcpu->run->internal.data[1] = vcpu->arch.last_vmentry_cpu;

arch/x86/kvm/x86.c

9230

struct kvm_run *kvm_run = vcpu->run;

arch/x86/kvm/x86.c

9308

struct kvm_run *kvm_run = vcpu->run;

arch/x86/kvm/xen.c

1417

struct kvm_run *run = vcpu->run;

arch/x86/kvm/xen.c

1422

return kvm_xen_hypercall_set_result(vcpu, run->xen.u.hcall.result);

arch/x86/kvm/xen.c

1753

vcpu->run->exit_reason = KVM_EXIT_XEN;

arch/x86/kvm/xen.c

1754

vcpu->run->xen.type = KVM_EXIT_XEN_HCALL;

arch/x86/kvm/xen.c

1755

vcpu->run->xen.u.hcall.longmode = longmode;

arch/x86/kvm/xen.c

1756

vcpu->run->xen.u.hcall.cpl = cpl;

arch/x86/kvm/xen.c

1757

vcpu->run->xen.u.hcall.input = input;

arch/x86/kvm/xen.c

1758

vcpu->run->xen.u.hcall.params[0] = params[0];

arch/x86/kvm/xen.c

1759

vcpu->run->xen.u.hcall.params[1] = params[1];

arch/x86/kvm/xen.c

1760

vcpu->run->xen.u.hcall.params[2] = params[2];

arch/x86/kvm/xen.c

1761

vcpu->run->xen.u.hcall.params[3] = params[3];

arch/x86/kvm/xen.c

1762

vcpu->run->xen.u.hcall.params[4] = params[4];

arch/x86/kvm/xen.c

1763

vcpu->run->xen.u.hcall.params[5] = params[5];

drivers/acpi/apei/apei-base.c

151

apei_exec_ins_func_t run;

drivers/acpi/apei/apei-base.c

169

!ctx->ins_table[entry->instruction].run) {

drivers/acpi/apei/apei-base.c

175

run = ctx->ins_table[entry->instruction].run;

drivers/acpi/apei/apei-base.c

176

rc = run(ctx, entry);

drivers/acpi/apei/apei-base.c

210

if (ins >= ctx->instructions || !ins_table[ins].run) {

drivers/acpi/apei/apei-internal.h

21

apei_exec_ins_func_t run;

drivers/acpi/apei/einj-core.c

151

.run = apei_exec_read_register,

drivers/acpi/apei/einj-core.c

155

.run = apei_exec_read_register_value,

drivers/acpi/apei/einj-core.c

159

.run = apei_exec_write_register,

drivers/acpi/apei/einj-core.c

163

.run = apei_exec_write_register_value,

drivers/acpi/apei/einj-core.c

167

.run = apei_exec_noop,

drivers/acpi/apei/erst.c

312

.run = apei_exec_read_register,

drivers/acpi/apei/erst.c

316

.run = apei_exec_read_register_value,

drivers/acpi/apei/erst.c

320

.run = apei_exec_write_register,

drivers/acpi/apei/erst.c

324

.run = apei_exec_write_register_value,

drivers/acpi/apei/erst.c

328

.run = apei_exec_noop,

drivers/acpi/apei/erst.c

332

.run = erst_exec_load_var1,

drivers/acpi/apei/erst.c

336

.run = erst_exec_load_var2,

drivers/acpi/apei/erst.c

340

.run = erst_exec_store_var1,

drivers/acpi/apei/erst.c

344

.run = erst_exec_add,

drivers/acpi/apei/erst.c

348

.run = erst_exec_subtract,

drivers/acpi/apei/erst.c

352

.run = erst_exec_add_value,

drivers/acpi/apei/erst.c

356

.run = erst_exec_subtract_value,

drivers/acpi/apei/erst.c

360

.run = erst_exec_stall,

drivers/acpi/apei/erst.c

364

.run = erst_exec_stall_while_true,

drivers/acpi/apei/erst.c

368

.run = erst_exec_skip_next_instruction_if_true,

drivers/acpi/apei/erst.c

372

.run = erst_exec_goto,

drivers/acpi/apei/erst.c

376

.run = erst_exec_set_src_address_base,

drivers/acpi/apei/erst.c

380

.run = erst_exec_set_dst_address_base,

drivers/acpi/apei/erst.c

384

.run = erst_exec_move_data,

drivers/comedi/drivers/amplc_pci230.c

1220

bool run;

drivers/comedi/drivers/amplc_pci230.c

1223

run = pci230_handle_ao_fifo(dev, s);

drivers/comedi/drivers/amplc_pci230.c

1225

if (!run) {

drivers/comedi/drivers/s626.h

334

* Start ADC: run A1

drivers/dma/dmatest.c

162

module_param_cb(run, &run_ops, &dmatest_run, 0644);

drivers/dma/dmatest.c

163

MODULE_PARM_DESC(run, "Run the test (default: false)");

drivers/firmware/arm_ffa/driver.c

1567

.run = ffa_run,

drivers/gpu/drm/drm_panic.c

976

bool run;

drivers/gpu/drm/drm_panic.c

978

if (kstrtobool_from_user(user_buf, count, &run) == 0 && run) {

drivers/gpu/drm/nouveau/nouveau_exec.c

198

.run = nouveau_exec_job_run,

drivers/gpu/drm/nouveau/nouveau_sched.c

350

fence = job->ops->run(job);

drivers/gpu/drm/nouveau/nouveau_sched.h

82

struct dma_fence *(*run)(struct nouveau_job *);

drivers/gpu/drm/nouveau/nouveau_uvmm.c

1611

.run = nouveau_uvmm_bind_job_run,

drivers/gpu/ipu-v3/ipu-image-convert.c

1239

struct ipu_image_convert_run *run;

drivers/gpu/ipu-v3/ipu-image-convert.c

1244

list_for_each_entry(run, q, list) {

drivers/gpu/ipu-v3/ipu-image-convert.c

1245

if (run->ctx == ctx)

drivers/gpu/ipu-v3/ipu-image-convert.c

1252

static void convert_stop(struct ipu_image_convert_run *run)

drivers/gpu/ipu-v3/ipu-image-convert.c

1254

struct ipu_image_convert_ctx *ctx = run->ctx;

drivers/gpu/ipu-v3/ipu-image-convert.c

1259

__func__, chan->ic_task, ctx, run);

drivers/gpu/ipu-v3/ipu-image-convert.c

1365

static int convert_start(struct ipu_image_convert_run *run, unsigned int tile)

drivers/gpu/ipu-v3/ipu-image-convert.c

1367

struct ipu_image_convert_ctx *ctx = run->ctx;

drivers/gpu/ipu-v3/ipu-image-convert.c

1379

__func__, chan->ic_task, ctx, run, tile, dst_tile);

drivers/gpu/ipu-v3/ipu-image-convert.c

1480

static int do_run(struct ipu_image_convert_run *run)

drivers/gpu/ipu-v3/ipu-image-convert.c

1482

struct ipu_image_convert_ctx *ctx = run->ctx;

drivers/gpu/ipu-v3/ipu-image-convert.c

1487

ctx->in.base.phys0 = run->in_phys;

drivers/gpu/ipu-v3/ipu-image-convert.c

1488

ctx->out.base.phys0 = run->out_phys;

drivers/gpu/ipu-v3/ipu-image-convert.c

1494

list_del(&run->list);

drivers/gpu/ipu-v3/ipu-image-convert.c

1495

chan->current_run = run;

drivers/gpu/ipu-v3/ipu-image-convert.c

1497

return convert_start(run, 0);

drivers/gpu/ipu-v3/ipu-image-convert.c

1504

struct ipu_image_convert_run *run, *tmp;

drivers/gpu/ipu-v3/ipu-image-convert.c

1509

list_for_each_entry_safe(run, tmp, &chan->pending_q, list) {

drivers/gpu/ipu-v3/ipu-image-convert.c

1511

if (run->ctx->aborting) {

drivers/gpu/ipu-v3/ipu-image-convert.c

1514

__func__, chan->ic_task, run->ctx, run);

drivers/gpu/ipu-v3/ipu-image-convert.c

1518

ret = do_run(run);

drivers/gpu/ipu-v3/ipu-image-convert.c

1527

run->status = ret;

drivers/gpu/ipu-v3/ipu-image-convert.c

1528

list_add_tail(&run->list, &chan->done_q);

drivers/gpu/ipu-v3/ipu-image-convert.c

1536

struct ipu_image_convert_run *run;

drivers/gpu/ipu-v3/ipu-image-convert.c

1542

run = list_entry(chan->done_q.next,

drivers/gpu/ipu-v3/ipu-image-convert.c

1546

list_del(&run->list);

drivers/gpu/ipu-v3/ipu-image-convert.c

1550

__func__, chan->ic_task, run->ctx, run, run->status);

drivers/gpu/ipu-v3/ipu-image-convert.c

1554

run->ctx->complete(run, run->ctx->complete_context);

drivers/gpu/ipu-v3/ipu-image-convert.c

1619

static irqreturn_t do_tile_complete(struct ipu_image_convert_run *run)

drivers/gpu/ipu-v3/ipu-image-convert.c

1621

struct ipu_image_convert_ctx *ctx = run->ctx;

drivers/gpu/ipu-v3/ipu-image-convert.c

1643

convert_stop(run);

drivers/gpu/ipu-v3/ipu-image-convert.c

1644

run->status = -EIO;

drivers/gpu/ipu-v3/ipu-image-convert.c

1652

convert_stop(run);

drivers/gpu/ipu-v3/ipu-image-convert.c

1653

run->status = 0;

drivers/gpu/ipu-v3/ipu-image-convert.c

1662

convert_stop(run);

drivers/gpu/ipu-v3/ipu-image-convert.c

1663

convert_start(run, ctx->next_tile);

drivers/gpu/ipu-v3/ipu-image-convert.c

1708

list_add_tail(&run->list, &chan->done_q);

drivers/gpu/ipu-v3/ipu-image-convert.c

1719

struct ipu_image_convert_run *run;

drivers/gpu/ipu-v3/ipu-image-convert.c

1727

run = chan->current_run;

drivers/gpu/ipu-v3/ipu-image-convert.c

1728

if (!run) {

drivers/gpu/ipu-v3/ipu-image-convert.c

1733

ctx = run->ctx;

drivers/gpu/ipu-v3/ipu-image-convert.c

1761

ret = do_tile_complete(run);

drivers/gpu/ipu-v3/ipu-image-convert.c

1774

struct ipu_image_convert_run *run;

drivers/gpu/ipu-v3/ipu-image-convert.c

1779

run = chan->current_run;

drivers/gpu/ipu-v3/ipu-image-convert.c

1780

if (run && run->ctx == ctx) {

drivers/gpu/ipu-v3/ipu-image-convert.c

1781

convert_stop(run);

drivers/gpu/ipu-v3/ipu-image-convert.c

1782

run->status = -EIO;

drivers/gpu/ipu-v3/ipu-image-convert.c

1783

list_add_tail(&run->list, &chan->done_q);

drivers/gpu/ipu-v3/ipu-image-convert.c

2251

int ipu_image_convert_queue(struct ipu_image_convert_run *run)

drivers/gpu/ipu-v3/ipu-image-convert.c

2259

if (!run || !run->ctx || !run->in_phys || !run->out_phys)

drivers/gpu/ipu-v3/ipu-image-convert.c

2262

ctx = run->ctx;

drivers/gpu/ipu-v3/ipu-image-convert.c

2267

chan->ic_task, ctx, run);

drivers/gpu/ipu-v3/ipu-image-convert.c

2269

INIT_LIST_HEAD(&run->list);

drivers/gpu/ipu-v3/ipu-image-convert.c

2278

list_add_tail(&run->list, &chan->pending_q);

drivers/gpu/ipu-v3/ipu-image-convert.c

2281

ret = do_run(run);

drivers/gpu/ipu-v3/ipu-image-convert.c

2296

struct ipu_image_convert_run *run, *active_run, *tmp;

drivers/gpu/ipu-v3/ipu-image-convert.c

2303

list_for_each_entry_safe(run, tmp, &chan->pending_q, list) {

drivers/gpu/ipu-v3/ipu-image-convert.c

2304

if (run->ctx != ctx)

drivers/gpu/ipu-v3/ipu-image-convert.c

2306

run->status = -EIO;

drivers/gpu/ipu-v3/ipu-image-convert.c

2307

list_move_tail(&run->list, &chan->done_q);

drivers/gpu/ipu-v3/ipu-image-convert.c

2397

struct ipu_image_convert_run *run;

drivers/gpu/ipu-v3/ipu-image-convert.c

2405

run = kzalloc_obj(*run);

drivers/gpu/ipu-v3/ipu-image-convert.c

2406

if (!run) {

drivers/gpu/ipu-v3/ipu-image-convert.c

2411

run->ctx = ctx;

drivers/gpu/ipu-v3/ipu-image-convert.c

2412

run->in_phys = in->phys0;

drivers/gpu/ipu-v3/ipu-image-convert.c

2413

run->out_phys = out->phys0;

drivers/gpu/ipu-v3/ipu-image-convert.c

2415

ret = ipu_image_convert_queue(run);

drivers/gpu/ipu-v3/ipu-image-convert.c

2418

kfree(run);

drivers/gpu/ipu-v3/ipu-image-convert.c

2422

return run;

drivers/hv/mshv_eventfd.c

180

if (vp->run.flags.root_sched_dispatched &&

drivers/hv/mshv_eventfd.c

184

wake_up(&vp->run.vp_suspend_queue);

drivers/hv/mshv_root.h

54

} run;

drivers/hv/mshv_root_main.c

1094

init_waitqueue_head(&vp->run.vp_suspend_queue);

drivers/hv/mshv_root_main.c

1095

atomic64_set(&vp->run.vp_signaled_count, 0);

drivers/hv/mshv_root_main.c

1677

vp_signal_count = atomic64_read(&vp->run.vp_signaled_count);

drivers/hv/mshv_root_main.c

1686

if (wait_event_interruptible(vp->run.vp_suspend_queue,

drivers/hv/mshv_root_main.c

1687

vp->run.kicked_by_hv == 1))

drivers/hv/mshv_root_main.c

1689

vp->run.kicked_by_hv = 0;

drivers/hv/mshv_root_main.c

1690

vp_signal_count = atomic64_read(&vp->run.vp_signaled_count);

drivers/hv/mshv_root_main.c

377

ret = wait_event_interruptible(vp->run.vp_suspend_queue,

drivers/hv/mshv_root_main.c

378

vp->run.kicked_by_hv == 1);

drivers/hv/mshv_root_main.c

395

wait_event(vp->run.vp_suspend_queue, vp->run.kicked_by_hv == 1);

drivers/hv/mshv_root_main.c

402

vp->run.kicked_by_hv = 0;

drivers/hv/mshv_root_main.c

428

vp->run.flags.root_sched_dispatched = 1;

drivers/hv/mshv_root_main.c

430

vp->run.flags.root_sched_dispatched = 0;

drivers/hv/mshv_root_main.c

489

ret = wait_event_interruptible(vp->run.vp_suspend_queue,

drivers/hv/mshv_root_main.c

490

(vp->run.kicked_by_hv == 1 &&

drivers/hv/mshv_root_main.c

496

vp->run.flags.root_sched_blocked = 0;

drivers/hv/mshv_root_main.c

497

vp->run.kicked_by_hv = 0;

drivers/hv/mshv_root_main.c

507

if (vp->run.flags.root_sched_blocked) {

drivers/hv/mshv_root_main.c

528

if (vp->run.flags.intercept_suspend)

drivers/hv/mshv_root_main.c

538

vp->run.flags.intercept_suspend = 0;

drivers/hv/mshv_root_main.c

547

WARN_ONCE(atomic64_read(&vp->run.vp_signaled_count),

drivers/hv/mshv_root_main.c

567

vp->run.flags.root_sched_blocked = 1;

drivers/hv/mshv_root_main.c

576

vp->run.flags.intercept_suspend = 1;

drivers/hv/mshv_root_main.c

578

} while (!vp->run.flags.intercept_suspend);

drivers/hv/mshv_synic.c

182

atomic64_inc(&vp->run.vp_signaled_count);

drivers/hv/mshv_synic.c

183

vp->run.kicked_by_hv = 1;

drivers/hv/mshv_synic.c

184

wake_up(&vp->run.vp_suspend_queue);

drivers/hv/mshv_vtl_main.c

193

return *this_cpu_ptr(&mshv_vtl_per_cpu.run);

drivers/hv/mshv_vtl_main.c

198

return *per_cpu_ptr(&mshv_vtl_per_cpu.run, cpu);

drivers/hv/mshv_vtl_main.c

330

per_cpu->run = (struct mshv_vtl_run *)__get_free_page(GFP_KERNEL | __GFP_ZERO);

drivers/hv/mshv_vtl_main.c

331

if (!per_cpu->run)

drivers/hv/mshv_vtl_main.c

84

struct mshv_vtl_run *run;

drivers/iio/light/si1145.c

469

int run = 1;

drivers/iio/light/si1145.c

471

while (i + run < iio_get_masklength(indio_dev)) {

drivers/iio/light/si1145.c

472

if (!test_bit(i + run, indio_dev->active_scan_mask))

drivers/iio/light/si1145.c

474

if (indio_dev->channels[i + run].address !=

drivers/iio/light/si1145.c

475

indio_dev->channels[i].address + 2 * run)

drivers/iio/light/si1145.c

477

run++;

drivers/iio/light/si1145.c

482

sizeof(u16) * run, &data->buffer[j]);

drivers/iio/light/si1145.c

485

j += run * sizeof(u16);

drivers/iio/light/si1145.c

486

i += run - 1;

drivers/md/md-linear.c

325

.run = linear_run,

drivers/md/md.c

4214

pers->run(mddev);

drivers/md/md.c

6601

err = pers->run(mddev);

drivers/md/md.c

8508

thread->run(thread);

drivers/md/md.c

8539

struct md_thread *md_register_thread(void (*run) (struct md_thread *),

drivers/md/md.c

8550

thread->run = run;

drivers/md/md.h

755

int (*run)(struct mddev *mddev);

drivers/md/md.h

864

void (*run) (struct md_thread *thread);

drivers/md/md.h

900

void (*run)(struct md_thread *thread),

drivers/md/raid0.c

816

.run = raid0_run,

drivers/md/raid1.c

3469

.run = raid1_run,

drivers/md/raid10.c

5054

.run = raid10_run,

drivers/md/raid5.c

9014

.run = raid5_run,

drivers/md/raid5.c

9044

.run = raid5_run,

drivers/md/raid5.c

9075

.run = raid5_run,

drivers/media/platform/mediatek/vpu/mtk_vpu.c

212

struct vpu_run run;

drivers/media/platform/mediatek/vpu/mtk_vpu.c

444

return vpu->run.dec_capability;

drivers/media/platform/mediatek/vpu/mtk_vpu.c

452

return vpu->run.enc_capability;

drivers/media/platform/mediatek/vpu/mtk_vpu.c

566

struct vpu_run *run;

drivers/media/platform/mediatek/vpu/mtk_vpu.c

577

run = &vpu->run;

drivers/media/platform/mediatek/vpu/mtk_vpu.c

594

run->signaled = false;

drivers/media/platform/mediatek/vpu/mtk_vpu.c

614

ret = wait_event_interruptible_timeout(run->wq,

drivers/media/platform/mediatek/vpu/mtk_vpu.c

615

run->signaled,

drivers/media/platform/mediatek/vpu/mtk_vpu.c

628

dev_info(dev, "vpu is ready. Fw version %s\n", run->fw_ver);

drivers/media/platform/mediatek/vpu/mtk_vpu.c

641

const struct vpu_run *run = data;

drivers/media/platform/mediatek/vpu/mtk_vpu.c

643

vpu->run.signaled = run->signaled;

drivers/media/platform/mediatek/vpu/mtk_vpu.c

644

strscpy(vpu->run.fw_ver, run->fw_ver, sizeof(vpu->run.fw_ver));

drivers/media/platform/mediatek/vpu/mtk_vpu.c

645

vpu->run.dec_capability = run->dec_capability;

drivers/media/platform/mediatek/vpu/mtk_vpu.c

646

vpu->run.enc_capability = run->enc_capability;

drivers/media/platform/mediatek/vpu/mtk_vpu.c

647

wake_up_interruptible(&vpu->run.wq);

drivers/media/platform/mediatek/vpu/mtk_vpu.c

689

vpu->run.fw_ver, pc, wdt,

drivers/media/platform/mediatek/vpu/mtk_vpu.c

909

init_waitqueue_head(&vpu->run.wq);

drivers/media/platform/qcom/venus/firmware.c

287

const struct firmware_version *run = &core->venus_ver;

drivers/media/platform/qcom/venus/firmware.c

298

run->major, run->minor, run->rev,

drivers/media/platform/rockchip/rkvdec/rkvdec-h264-common.c

138

dpb_valid = !!(run->ref_buf[ref->index]);

drivers/media/platform/rockchip/rkvdec/rkvdec-h264-common.c

146

void assemble_hw_scaling_list(struct rkvdec_h264_run *run,

drivers/media/platform/rockchip/rkvdec/rkvdec-h264-common.c

149

const struct v4l2_ctrl_h264_scaling_matrix *scaling = run->scaling_matrix;

drivers/media/platform/rockchip/rkvdec/rkvdec-h264-common.c

150

const struct v4l2_ctrl_h264_pps *pps = run->pps;

drivers/media/platform/rockchip/rkvdec/rkvdec-h264-common.c

240

struct rkvdec_h264_run *run)

drivers/media/platform/rockchip/rkvdec/rkvdec-h264-common.c

246

run->decode_params = ctrl ? ctrl->p_cur.p : NULL;

drivers/media/platform/rockchip/rkvdec/rkvdec-h264-common.c

249

run->sps = ctrl ? ctrl->p_cur.p : NULL;

drivers/media/platform/rockchip/rkvdec/rkvdec-h264-common.c

252

run->pps = ctrl ? ctrl->p_cur.p : NULL;

drivers/media/platform/rockchip/rkvdec/rkvdec-h264-common.c

255

run->scaling_matrix = ctrl ? ctrl->p_cur.p : NULL;

drivers/media/platform/rockchip/rkvdec/rkvdec-h264-common.c

257

rkvdec_run_preamble(ctx, &run->base);

drivers/media/platform/rockchip/rkvdec/rkvdec-h264-common.c

70

struct rkvdec_h264_run *run)

drivers/media/platform/rockchip/rkvdec/rkvdec-h264-common.c

72

const struct v4l2_ctrl_h264_decode_params *dec_params = run->decode_params;

drivers/media/platform/rockchip/rkvdec/rkvdec-h264-common.c

77

const struct v4l2_h264_dpb_entry *dpb = run->decode_params->dpb;

drivers/media/platform/rockchip/rkvdec/rkvdec-h264-common.c

88

run->ref_buf[i] = buf;

drivers/media/platform/rockchip/rkvdec/rkvdec-h264-common.c

93

struct rkvdec_h264_run *run,

drivers/media/platform/rockchip/rkvdec/rkvdec-h264-common.c

97

const struct v4l2_ctrl_h264_decode_params *dec_params = run->decode_params;

drivers/media/platform/rockchip/rkvdec/rkvdec-h264-common.h

75

void lookup_ref_buf_idx(struct rkvdec_ctx *ctx, struct rkvdec_h264_run *run);

drivers/media/platform/rockchip/rkvdec/rkvdec-h264-common.h

77

struct rkvdec_h264_run *run,

drivers/media/platform/rockchip/rkvdec/rkvdec-h264-common.h

80

void assemble_hw_scaling_list(struct rkvdec_h264_run *run,

drivers/media/platform/rockchip/rkvdec/rkvdec-h264-common.h

85

void rkvdec_h264_run_preamble(struct rkvdec_ctx *ctx, struct rkvdec_h264_run *run);

drivers/media/platform/rockchip/rkvdec/rkvdec-h264.c

109

struct rkvdec_h264_run *run)

drivers/media/platform/rockchip/rkvdec/rkvdec-h264.c

112

const struct v4l2_ctrl_h264_sps *sps = run->sps;

drivers/media/platform/rockchip/rkvdec/rkvdec-h264.c

113

const struct v4l2_ctrl_h264_pps *pps = run->pps;

drivers/media/platform/rockchip/rkvdec/rkvdec-h264.c

114

const struct v4l2_ctrl_h264_decode_params *dec_params = run->decode_params;

drivers/media/platform/rockchip/rkvdec/rkvdec-h264.c

249

struct rkvdec_h264_run *run)

drivers/media/platform/rockchip/rkvdec/rkvdec-h264.c

252

const struct v4l2_ctrl_h264_decode_params *dec_params = run->decode_params;

drivers/media/platform/rockchip/rkvdec/rkvdec-h264.c

253

const struct v4l2_ctrl_h264_sps *sps = run->sps;

drivers/media/platform/rockchip/rkvdec/rkvdec-h264.c

258

struct vb2_v4l2_buffer *src_buf = run->base.bufs.src;

drivers/media/platform/rockchip/rkvdec/rkvdec-h264.c

259

struct vb2_v4l2_buffer *dst_buf = run->base.bufs.dst;

drivers/media/platform/rockchip/rkvdec/rkvdec-h264.c

317

struct vb2_buffer *vb_buf = run->ref_buf[i];

drivers/media/platform/rockchip/rkvdec/rkvdec-h264.c

417

struct rkvdec_h264_run run;

drivers/media/platform/rockchip/rkvdec/rkvdec-h264.c

420

rkvdec_h264_run_preamble(ctx, &run);

drivers/media/platform/rockchip/rkvdec/rkvdec-h264.c

423

v4l2_h264_init_reflist_builder(&reflist_builder, run.decode_params,

drivers/media/platform/rockchip/rkvdec/rkvdec-h264.c

424

run.sps, run.decode_params->dpb);

drivers/media/platform/rockchip/rkvdec/rkvdec-h264.c

429

assemble_hw_scaling_list(&run, &tbl->scaling_list);

drivers/media/platform/rockchip/rkvdec/rkvdec-h264.c

430

assemble_hw_pps(ctx, &run);

drivers/media/platform/rockchip/rkvdec/rkvdec-h264.c

431

lookup_ref_buf_idx(ctx, &run);

drivers/media/platform/rockchip/rkvdec/rkvdec-h264.c

432

assemble_hw_rps(&reflist_builder, &run, &h264_ctx->reflists, &tbl->rps);

drivers/media/platform/rockchip/rkvdec/rkvdec-h264.c

433

config_registers(ctx, &run);

drivers/media/platform/rockchip/rkvdec/rkvdec-h264.c

435

rkvdec_run_postamble(ctx, &run.base);

drivers/media/platform/rockchip/rkvdec/rkvdec-h264.c

462

.run = rkvdec_h264_run,

drivers/media/platform/rockchip/rkvdec/rkvdec-hevc-common.c

197

struct rkvdec_hevc_run *run,

drivers/media/platform/rockchip/rkvdec/rkvdec-hevc-common.c

201

const struct v4l2_ctrl_hevc_scaling_matrix *scaling = run->scaling_matrix;

drivers/media/platform/rockchip/rkvdec/rkvdec-hevc-common.c

213

static void rkvdec_hevc_assemble_hw_lt_rps(struct rkvdec_hevc_run *run, struct rkvdec_rps *rps)

drivers/media/platform/rockchip/rkvdec/rkvdec-hevc-common.c

215

const struct v4l2_ctrl_hevc_sps *sps = run->sps;

drivers/media/platform/rockchip/rkvdec/rkvdec-hevc-common.c

217

if (!run->ext_sps_lt_rps)

drivers/media/platform/rockchip/rkvdec/rkvdec-hevc-common.c

222

run->ext_sps_lt_rps[i].lt_ref_pic_poc_lsb_sps;

drivers/media/platform/rockchip/rkvdec/rkvdec-hevc-common.c

224

!!(run->ext_sps_lt_rps[i].flags & V4L2_HEVC_EXT_SPS_LT_RPS_FLAG_USED_LT);

drivers/media/platform/rockchip/rkvdec/rkvdec-hevc-common.c

228

static void rkvdec_hevc_assemble_hw_st_rps(struct rkvdec_hevc_run *run, struct rkvdec_rps *rps,

drivers/media/platform/rockchip/rkvdec/rkvdec-hevc-common.c

231

const struct v4l2_ctrl_hevc_sps *sps = run->sps;

drivers/media/platform/rockchip/rkvdec/rkvdec-hevc-common.c

257

static void st_ref_pic_set_prediction(struct rkvdec_hevc_run *run, int idx,

drivers/media/platform/rockchip/rkvdec/rkvdec-hevc-common.c

260

const struct v4l2_ctrl_hevc_ext_sps_st_rps *rps_data = &run->ext_sps_st_rps[idx];

drivers/media/platform/rockchip/rkvdec/rkvdec-hevc-common.c

334

static void st_ref_pic_set_calculate(struct rkvdec_hevc_run *run, int idx,

drivers/media/platform/rockchip/rkvdec/rkvdec-hevc-common.c

337

const struct v4l2_ctrl_hevc_ext_sps_st_rps *rps_data = &run->ext_sps_st_rps[idx];

drivers/media/platform/rockchip/rkvdec/rkvdec-hevc-common.c

35

void compute_tiles_uniform(struct rkvdec_hevc_run *run, u16 log2_min_cb_size,

drivers/media/platform/rockchip/rkvdec/rkvdec-hevc-common.c

380

static void rkvdec_hevc_prepare_hw_st_rps(struct rkvdec_hevc_run *run, struct rkvdec_rps *rps,

drivers/media/platform/rockchip/rkvdec/rkvdec-hevc-common.c

385

if (!run->ext_sps_st_rps)

drivers/media/platform/rockchip/rkvdec/rkvdec-hevc-common.c

388

if (!memcmp(cache, run->ext_sps_st_rps, sizeof(struct v4l2_ctrl_hevc_ext_sps_st_rps)))

drivers/media/platform/rockchip/rkvdec/rkvdec-hevc-common.c

39

const struct v4l2_ctrl_hevc_pps *pps = run->pps;

drivers/media/platform/rockchip/rkvdec/rkvdec-hevc-common.c

393

run->sps->num_short_term_ref_pic_sets, GFP_KERNEL);

drivers/media/platform/rockchip/rkvdec/rkvdec-hevc-common.c

395

for (idx = 0; idx < run->sps->num_short_term_ref_pic_sets; idx++) {

drivers/media/platform/rockchip/rkvdec/rkvdec-hevc-common.c

396

const struct v4l2_ctrl_hevc_ext_sps_st_rps *rps_data = &run->ext_sps_st_rps[idx];

drivers/media/platform/rockchip/rkvdec/rkvdec-hevc-common.c

399

st_ref_pic_set_prediction(run, idx, calculated_rps_st_sets);

drivers/media/platform/rockchip/rkvdec/rkvdec-hevc-common.c

401

st_ref_pic_set_calculate(run, idx, calculated_rps_st_sets);

drivers/media/platform/rockchip/rkvdec/rkvdec-hevc-common.c

404

rkvdec_hevc_assemble_hw_st_rps(run, rps, calculated_rps_st_sets);

drivers/media/platform/rockchip/rkvdec/rkvdec-hevc-common.c

408

memcpy(cache, run->ext_sps_st_rps, sizeof(struct v4l2_ctrl_hevc_ext_sps_st_rps));

drivers/media/platform/rockchip/rkvdec/rkvdec-hevc-common.c

411

void rkvdec_hevc_assemble_hw_rps(struct rkvdec_hevc_run *run, struct rkvdec_rps *rps,

drivers/media/platform/rockchip/rkvdec/rkvdec-hevc-common.c

414

rkvdec_hevc_prepare_hw_st_rps(run, rps, st_cache);

drivers/media/platform/rockchip/rkvdec/rkvdec-hevc-common.c

415

rkvdec_hevc_assemble_hw_lt_rps(run, rps);

drivers/media/platform/rockchip/rkvdec/rkvdec-hevc-common.c

419

get_ref_buf(struct rkvdec_ctx *ctx, struct rkvdec_hevc_run *run,

drivers/media/platform/rockchip/rkvdec/rkvdec-hevc-common.c

423

const struct v4l2_ctrl_hevc_decode_params *decode_params = run->decode_params;

drivers/media/platform/rockchip/rkvdec/rkvdec-hevc-common.c

436

return &run->base.bufs.dst->vb2_buf;

drivers/media/platform/rockchip/rkvdec/rkvdec-hevc-common.c

478

struct rkvdec_hevc_run *run)

drivers/media/platform/rockchip/rkvdec/rkvdec-hevc-common.c

484

run->decode_params = ctrl ? ctrl->p_cur.p : NULL;

drivers/media/platform/rockchip/rkvdec/rkvdec-hevc-common.c

487

run->slices_params = ctrl ? ctrl->p_cur.p : NULL;

drivers/media/platform/rockchip/rkvdec/rkvdec-hevc-common.c

488

run->num_slices = ctrl ? ctrl->new_elems : 0;

drivers/media/platform/rockchip/rkvdec/rkvdec-hevc-common.c

491

run->sps = ctrl ? ctrl->p_cur.p : NULL;

drivers/media/platform/rockchip/rkvdec/rkvdec-hevc-common.c

494

run->pps = ctrl ? ctrl->p_cur.p : NULL;

drivers/media/platform/rockchip/rkvdec/rkvdec-hevc-common.c

497

run->scaling_matrix = ctrl ? ctrl->p_cur.p : NULL;

drivers/media/platform/rockchip/rkvdec/rkvdec-hevc-common.c

502

run->ext_sps_st_rps = ctrl ? ctrl->p_cur.p : NULL;

drivers/media/platform/rockchip/rkvdec/rkvdec-hevc-common.c

504

run->ext_sps_st_rps = NULL;

drivers/media/platform/rockchip/rkvdec/rkvdec-hevc-common.c

509

run->ext_sps_lt_rps = ctrl ? ctrl->p_cur.p : NULL;

drivers/media/platform/rockchip/rkvdec/rkvdec-hevc-common.c

511

run->ext_sps_lt_rps = NULL;

drivers/media/platform/rockchip/rkvdec/rkvdec-hevc-common.c

514

rkvdec_run_preamble(ctx, &run->base);

drivers/media/platform/rockchip/rkvdec/rkvdec-hevc-common.c

55

void compute_tiles_non_uniform(struct rkvdec_hevc_run *run, u16 log2_min_cb_size,

drivers/media/platform/rockchip/rkvdec/rkvdec-hevc-common.c

59

const struct v4l2_ctrl_hevc_pps *pps = run->pps;

drivers/media/platform/rockchip/rkvdec/rkvdec-hevc-common.h

103

struct rkvdec_hevc_run *run,

drivers/media/platform/rockchip/rkvdec/rkvdec-hevc-common.h

107

void rkvdec_hevc_run_preamble(struct rkvdec_ctx *ctx, struct rkvdec_hevc_run *run);

drivers/media/platform/rockchip/rkvdec/rkvdec-hevc-common.h

90

void compute_tiles_uniform(struct rkvdec_hevc_run *run, u16 log2_min_cb_size,

drivers/media/platform/rockchip/rkvdec/rkvdec-hevc-common.h

93

void compute_tiles_non_uniform(struct rkvdec_hevc_run *run, u16 log2_min_cb_size,

drivers/media/platform/rockchip/rkvdec/rkvdec-hevc-common.h

96

void rkvdec_hevc_assemble_hw_rps(struct rkvdec_hevc_run *run, struct rkvdec_rps *rps,

drivers/media/platform/rockchip/rkvdec/rkvdec-hevc-common.h

99

struct rkvdec_hevc_run *run,

drivers/media/platform/rockchip/rkvdec/rkvdec-hevc.c

141

struct rkvdec_hevc_run *run)

drivers/media/platform/rockchip/rkvdec/rkvdec-hevc.c

144

const struct v4l2_ctrl_hevc_sps *sps = run->sps;

drivers/media/platform/rockchip/rkvdec/rkvdec-hevc.c

145

const struct v4l2_ctrl_hevc_pps *pps = run->pps;

drivers/media/platform/rockchip/rkvdec/rkvdec-hevc.c

312

struct rkvdec_hevc_run *run)

drivers/media/platform/rockchip/rkvdec/rkvdec-hevc.c

314

const struct v4l2_ctrl_hevc_decode_params *decode_params = run->decode_params;

drivers/media/platform/rockchip/rkvdec/rkvdec-hevc.c

315

const struct v4l2_ctrl_hevc_sps *sps = run->sps;

drivers/media/platform/rockchip/rkvdec/rkvdec-hevc.c

336

for (j = 0; j < run->num_slices; j++) {

drivers/media/platform/rockchip/rkvdec/rkvdec-hevc.c

341

sl_params = &run->slices_params[j];

drivers/media/platform/rockchip/rkvdec/rkvdec-hevc.c

403

struct rkvdec_hevc_run *run)

drivers/media/platform/rockchip/rkvdec/rkvdec-hevc.c

406

const struct v4l2_ctrl_hevc_decode_params *decode_params = run->decode_params;

drivers/media/platform/rockchip/rkvdec/rkvdec-hevc.c

407

const struct v4l2_ctrl_hevc_sps *sps = run->sps;

drivers/media/platform/rockchip/rkvdec/rkvdec-hevc.c

408

const struct v4l2_ctrl_hevc_slice_params *sl_params = &run->slices_params[0];

drivers/media/platform/rockchip/rkvdec/rkvdec-hevc.c

414

struct vb2_v4l2_buffer *src_buf = run->base.bufs.src;

drivers/media/platform/rockchip/rkvdec/rkvdec-hevc.c

415

struct vb2_v4l2_buffer *dst_buf = run->base.bufs.dst;

drivers/media/platform/rockchip/rkvdec/rkvdec-hevc.c

445

regs->common.reg03.slice_num_lowbits = run->num_slices;

drivers/media/platform/rockchip/rkvdec/rkvdec-hevc.c

469

struct vb2_buffer *vb_buf = get_ref_buf(ctx, run, i);

drivers/media/platform/rockchip/rkvdec/rkvdec-hevc.c

564

struct rkvdec_hevc_run run;

drivers/media/platform/rockchip/rkvdec/rkvdec-hevc.c

569

rkvdec_hevc_run_preamble(ctx, &run);

drivers/media/platform/rockchip/rkvdec/rkvdec-hevc.c

571

rkvdec_hevc_assemble_hw_scaling_list(ctx, &run, &tbl->scaling_list,

drivers/media/platform/rockchip/rkvdec/rkvdec-hevc.c

573

assemble_hw_pps(ctx, &run);

drivers/media/platform/rockchip/rkvdec/rkvdec-hevc.c

574

assemble_sw_rps(ctx, &run);

drivers/media/platform/rockchip/rkvdec/rkvdec-hevc.c

575

config_registers(ctx, &run);

drivers/media/platform/rockchip/rkvdec/rkvdec-hevc.c

577

rkvdec_run_postamble(ctx, &run.base);

drivers/media/platform/rockchip/rkvdec/rkvdec-hevc.c

588

reg = (run.pps->flags & V4L2_HEVC_PPS_FLAG_TILES_ENABLED) ?

drivers/media/platform/rockchip/rkvdec/rkvdec-hevc.c

609

.run = rkvdec_hevc_run,

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu381-h264.c

209

struct rkvdec_h264_run *run)

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu381-h264.c

211

const struct v4l2_ctrl_h264_decode_params *dec_params = run->decode_params;

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu381-h264.c

216

struct vb2_v4l2_buffer *src_buf = run->base.bufs.src;

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu381-h264.c

217

struct vb2_v4l2_buffer *dst_buf = run->base.bufs.dst;

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu381-h264.c

298

struct vb2_buffer *vb_buf = run->ref_buf[i];

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu381-h264.c

426

struct rkvdec_h264_run run;

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu381-h264.c

428

rkvdec_h264_run_preamble(ctx, &run);

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu381-h264.c

431

v4l2_h264_init_reflist_builder(&reflist_builder, run.decode_params,

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu381-h264.c

432

run.sps, run.decode_params->dpb);

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu381-h264.c

437

assemble_hw_scaling_list(&run, &tbl->scaling_list);

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu381-h264.c

438

assemble_hw_pps(ctx, &run);

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu381-h264.c

439

lookup_ref_buf_idx(ctx, &run);

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu381-h264.c

440

assemble_hw_rps(&reflist_builder, &run, &h264_ctx->reflists, &tbl->rps);

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu381-h264.c

442

config_registers(ctx, &run);

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu381-h264.c

444

rkvdec_run_postamble(ctx, &run.base);

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu381-h264.c

467

.run = rkvdec_h264_run,

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu381-h264.c

87

struct rkvdec_h264_run *run)

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu381-h264.c

90

const struct v4l2_ctrl_h264_sps *sps = run->sps;

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu381-h264.c

91

const struct v4l2_ctrl_h264_pps *pps = run->pps;

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu381-h264.c

92

const struct v4l2_ctrl_h264_decode_params *dec_params = run->decode_params;

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu381-hevc.c

125

struct rkvdec_hevc_run *run)

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu381-hevc.c

128

const struct v4l2_ctrl_hevc_sps *sps = run->sps;

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu381-hevc.c

129

const struct v4l2_ctrl_hevc_pps *pps = run->pps;

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu381-hevc.c

269

compute_tiles_uniform(run, log2_min_cb_size, width, height,

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu381-hevc.c

273

compute_tiles_non_uniform(run, log2_min_cb_size, width, height,

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu381-hevc.c

380

struct rkvdec_hevc_run *run)

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu381-hevc.c

382

const struct v4l2_ctrl_hevc_decode_params *dec_params = run->decode_params;

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu381-hevc.c

388

struct vb2_v4l2_buffer *src_buf = run->base.bufs.src;

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu381-hevc.c

389

struct vb2_v4l2_buffer *dst_buf = run->base.bufs.dst;

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu381-hevc.c

462

struct vb2_buffer *vb_buf = get_ref_buf(ctx, run, i);

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu381-hevc.c

591

struct rkvdec_hevc_run run;

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu381-hevc.c

595

rkvdec_hevc_run_preamble(ctx, &run);

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu381-hevc.c

597

rkvdec_hevc_assemble_hw_scaling_list(ctx, &run, &tbl->scaling_list,

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu381-hevc.c

599

assemble_hw_pps(ctx, &run);

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu381-hevc.c

605

if ((!ctx->has_sps_lt_rps && run.sps->num_long_term_ref_pics_sps) ||

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu381-hevc.c

606

(!ctx->has_sps_st_rps && run.sps->num_short_term_ref_pic_sets)) {

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu381-hevc.c

609

rkvdec_hevc_assemble_hw_rps(&run, &tbl->rps, &hevc_ctx->st_cache);

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu381-hevc.c

612

config_registers(ctx, &run);

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu381-hevc.c

614

rkvdec_run_postamble(ctx, &run.base);

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu381-hevc.c

636

.run = rkvdec_hevc_run,

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu383-h264.c

195

struct rkvdec_h264_run *run)

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu383-h264.c

198

const struct v4l2_ctrl_h264_sps *sps = run->sps;

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu383-h264.c

199

const struct v4l2_ctrl_h264_pps *pps = run->pps;

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu383-h264.c

200

const struct v4l2_ctrl_h264_decode_params *dec_params = run->decode_params;

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu383-h264.c

312

struct rkvdec_h264_run *run)

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu383-h264.c

314

const struct v4l2_ctrl_h264_decode_params *dec_params = run->decode_params;

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu383-h264.c

318

struct vb2_v4l2_buffer *src_buf = run->base.bufs.src;

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu383-h264.c

319

struct vb2_v4l2_buffer *dst_buf = run->base.bufs.dst;

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu383-h264.c

378

struct vb2_buffer *vb_buf = run->ref_buf[i];

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu383-h264.c

494

struct rkvdec_h264_run run;

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu383-h264.c

498

rkvdec_h264_run_preamble(ctx, &run);

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu383-h264.c

501

v4l2_h264_init_reflist_builder(&reflist_builder, run.decode_params,

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu383-h264.c

502

run.sps, run.decode_params->dpb);

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu383-h264.c

507

assemble_hw_scaling_list(&run, &tbl->scaling_list);

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu383-h264.c

508

assemble_hw_pps(ctx, &run);

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu383-h264.c

509

lookup_ref_buf_idx(ctx, &run);

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu383-h264.c

510

assemble_hw_rps(&reflist_builder, &run, &h264_ctx->reflists, &tbl->rps);

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu383-h264.c

512

config_registers(ctx, &run);

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu383-h264.c

514

rkvdec_run_postamble(ctx, &run.base);

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu383-h264.c

540

.run = rkvdec_h264_run,

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu383-hevc.c

220

struct rkvdec_hevc_run *run)

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu383-hevc.c

223

const struct v4l2_ctrl_hevc_sps *sps = run->sps;

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu383-hevc.c

224

const struct v4l2_ctrl_hevc_pps *pps = run->pps;

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu383-hevc.c

225

const struct v4l2_ctrl_hevc_decode_params *dec_params = run->decode_params;

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu383-hevc.c

357

compute_tiles_uniform(run, log2_min_cb_size, width, height,

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu383-hevc.c

361

compute_tiles_non_uniform(run, log2_min_cb_size, width, height,

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu383-hevc.c

402

struct rkvdec_hevc_run *run)

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu383-hevc.c

404

const struct v4l2_ctrl_hevc_decode_params *dec_params = run->decode_params;

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu383-hevc.c

406

const struct v4l2_ctrl_hevc_sps *sps = run->sps;

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu383-hevc.c

409

struct vb2_v4l2_buffer *src_buf = run->base.bufs.src;

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu383-hevc.c

410

struct vb2_v4l2_buffer *dst_buf = run->base.bufs.dst;

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu383-hevc.c

469

struct vb2_buffer *vb_buf = get_ref_buf(ctx, run, i);

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu383-hevc.c

599

struct rkvdec_hevc_run run;

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu383-hevc.c

604

rkvdec_hevc_run_preamble(ctx, &run);

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu383-hevc.c

611

if ((!ctx->has_sps_lt_rps && run.sps->num_long_term_ref_pics_sps) ||

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu383-hevc.c

612

(!ctx->has_sps_st_rps && run.sps->num_short_term_ref_pic_sets)) {

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu383-hevc.c

617

rkvdec_hevc_assemble_hw_scaling_list(ctx, &run, &tbl->scaling_list,

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu383-hevc.c

619

assemble_hw_pps(ctx, &run);

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu383-hevc.c

620

rkvdec_hevc_assemble_hw_rps(&run, &tbl->rps, &hevc_ctx->st_cache);

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu383-hevc.c

622

config_registers(ctx, &run);

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu383-hevc.c

624

rkvdec_run_postamble(ctx, &run.base);

drivers/media/platform/rockchip/rkvdec/rkvdec-vdpu383-hevc.c

649

.run = rkvdec_hevc_run,

drivers/media/platform/rockchip/rkvdec/rkvdec-vp9.c

1041

.run = rkvdec_vp9_run,

drivers/media/platform/rockchip/rkvdec/rkvdec-vp9.c

191

const struct rkvdec_vp9_run *run)

drivers/media/platform/rockchip/rkvdec/rkvdec-vp9.c

241

const struct rkvdec_vp9_run *run)

drivers/media/platform/rockchip/rkvdec/rkvdec-vp9.c

312

const struct rkvdec_vp9_run *run)

drivers/media/platform/rockchip/rkvdec/rkvdec-vp9.c

322

dec_params = run->decode_params;

drivers/media/platform/rockchip/rkvdec/rkvdec-vp9.c

346

init_intra_only_probs(ctx, run);

drivers/media/platform/rockchip/rkvdec/rkvdec-vp9.c

348

init_inter_probs(ctx, run);

drivers/media/platform/rockchip/rkvdec/rkvdec-vp9.c

382

const struct rkvdec_vp9_run *run,

drivers/media/platform/rockchip/rkvdec/rkvdec-vp9.c

396

if (&ref_buf->base.vb == run->base.bufs.dst)

drivers/media/platform/rockchip/rkvdec/rkvdec-vp9.c

476

const struct rkvdec_vp9_run *run)

drivers/media/platform/rockchip/rkvdec/rkvdec-vp9.c

490

dec_params = run->decode_params;

drivers/media/platform/rockchip/rkvdec/rkvdec-vp9.c

491

dst = vb2_to_rkvdec_decoded_buf(&run->base.bufs.dst->vb2_buf);

drivers/media/platform/rockchip/rkvdec/rkvdec-vp9.c

526

stream_len = vb2_get_plane_payload(&run->base.bufs.src->vb2_buf, 0);

drivers/media/platform/rockchip/rkvdec/rkvdec-vp9.c

546

config_ref_registers(ctx, run, ref_bufs[i], i);

drivers/media/platform/rockchip/rkvdec/rkvdec-vp9.c

630

addr = vb2_dma_contig_plane_dma_addr(&run->base.bufs.src->vb2_buf, 0);

drivers/media/platform/rockchip/rkvdec/rkvdec-vp9.c

696

struct rkvdec_vp9_run *run)

drivers/media/platform/rockchip/rkvdec/rkvdec-vp9.c

706

rkvdec_run_preamble(ctx, &run->base);

drivers/media/platform/rockchip/rkvdec/rkvdec-vp9.c

718

run->decode_params = dec_params;

drivers/media/platform/rockchip/rkvdec/rkvdec-vp9.c

772

struct rkvdec_vp9_run run = { };

drivers/media/platform/rockchip/rkvdec/rkvdec-vp9.c

775

ret = rkvdec_vp9_run_preamble(ctx, &run);

drivers/media/platform/rockchip/rkvdec/rkvdec-vp9.c

777

rkvdec_run_postamble(ctx, &run.base);

drivers/media/platform/rockchip/rkvdec/rkvdec-vp9.c

782

init_probs(ctx, &run);

drivers/media/platform/rockchip/rkvdec/rkvdec-vp9.c

785

config_registers(ctx, &run);

drivers/media/platform/rockchip/rkvdec/rkvdec-vp9.c

787

rkvdec_run_postamble(ctx, &run.base);

drivers/media/platform/rockchip/rkvdec/rkvdec.c

1101

void rkvdec_run_preamble(struct rkvdec_ctx *ctx, struct rkvdec_run *run)

drivers/media/platform/rockchip/rkvdec/rkvdec.c

1105

memset(run, 0, sizeof(*run));

drivers/media/platform/rockchip/rkvdec/rkvdec.c

1107

run->bufs.src = v4l2_m2m_next_src_buf(ctx->fh.m2m_ctx);

drivers/media/platform/rockchip/rkvdec/rkvdec.c

1108

run->bufs.dst = v4l2_m2m_next_dst_buf(ctx->fh.m2m_ctx);

drivers/media/platform/rockchip/rkvdec/rkvdec.c

1111

src_req = run->bufs.src->vb2_buf.req_obj.req;

drivers/media/platform/rockchip/rkvdec/rkvdec.c

1115

v4l2_m2m_buf_copy_metadata(run->bufs.src, run->bufs.dst);

drivers/media/platform/rockchip/rkvdec/rkvdec.c

1118

void rkvdec_run_postamble(struct rkvdec_ctx *ctx, struct rkvdec_run *run)

drivers/media/platform/rockchip/rkvdec/rkvdec.c

1120

struct media_request *src_req = run->bufs.src->vb2_buf.req_obj.req;

drivers/media/platform/rockchip/rkvdec/rkvdec.c

1177

ret = desc->ops->run(ctx);

drivers/media/platform/rockchip/rkvdec/rkvdec.h

179

void rkvdec_run_preamble(struct rkvdec_ctx *ctx, struct rkvdec_run *run);

drivers/media/platform/rockchip/rkvdec/rkvdec.h

180

void rkvdec_run_postamble(struct rkvdec_ctx *ctx, struct rkvdec_run *run);

drivers/media/platform/rockchip/rkvdec/rkvdec.h

96

int (*run)(struct rkvdec_ctx *ctx);

drivers/media/platform/verisilicon/hantro_drv.c

189

if (ctx->codec_ops->run(ctx))

drivers/media/platform/verisilicon/hantro_hw.h

385

int (*run)(struct hantro_ctx *ctx);

drivers/media/platform/verisilicon/imx8m_vpu_hw.c

257

.run = hantro_g1_mpeg2_dec_run,

drivers/media/platform/verisilicon/imx8m_vpu_hw.c

263

.run = hantro_g1_vp8_dec_run,

drivers/media/platform/verisilicon/imx8m_vpu_hw.c

269

.run = hantro_g1_h264_dec_run,

drivers/media/platform/verisilicon/imx8m_vpu_hw.c

278

.run = hantro_g1_mpeg2_dec_run,

drivers/media/platform/verisilicon/imx8m_vpu_hw.c

283

.run = hantro_g1_vp8_dec_run,

drivers/media/platform/verisilicon/imx8m_vpu_hw.c

288

.run = hantro_g1_h264_dec_run,

drivers/media/platform/verisilicon/imx8m_vpu_hw.c

296

.run = hantro_g2_hevc_dec_run,

drivers/media/platform/verisilicon/imx8m_vpu_hw.c

302

.run = hantro_g2_vp9_dec_run,

drivers/media/platform/verisilicon/rockchip_vpu_hw.c

503

.run = hantro_g1_h264_dec_run,

drivers/media/platform/verisilicon/rockchip_vpu_hw.c

509

.run = hantro_g1_mpeg2_dec_run,

drivers/media/platform/verisilicon/rockchip_vpu_hw.c

515

.run = hantro_g1_vp8_dec_run,

drivers/media/platform/verisilicon/rockchip_vpu_hw.c

524

.run = hantro_h1_jpeg_enc_run,

drivers/media/platform/verisilicon/rockchip_vpu_hw.c

529

.run = hantro_g1_h264_dec_run,

drivers/media/platform/verisilicon/rockchip_vpu_hw.c

535

.run = hantro_g1_mpeg2_dec_run,

drivers/media/platform/verisilicon/rockchip_vpu_hw.c

541

.run = hantro_g1_vp8_dec_run,

drivers/media/platform/verisilicon/rockchip_vpu_hw.c

550

.run = hantro_h1_jpeg_enc_run,

drivers/media/platform/verisilicon/rockchip_vpu_hw.c

555

.run = hantro_g1_h264_dec_run,

drivers/media/platform/verisilicon/rockchip_vpu_hw.c

561

.run = hantro_g1_mpeg2_dec_run,

drivers/media/platform/verisilicon/rockchip_vpu_hw.c

567

.run = hantro_g1_vp8_dec_run,

drivers/media/platform/verisilicon/rockchip_vpu_hw.c

576

.run = rockchip_vpu2_jpeg_enc_run,

drivers/media/platform/verisilicon/rockchip_vpu_hw.c

581

.run = rockchip_vpu2_h264_dec_run,

drivers/media/platform/verisilicon/rockchip_vpu_hw.c

587

.run = rockchip_vpu2_mpeg2_dec_run,

drivers/media/platform/verisilicon/rockchip_vpu_hw.c

593

.run = rockchip_vpu2_vp8_dec_run,

drivers/media/platform/verisilicon/rockchip_vpu_hw.c

602

.run = rockchip_vpu2_jpeg_enc_run,

drivers/media/platform/verisilicon/rockchip_vpu_hw.c

610

.run = rockchip_vpu981_av1_dec_run,

drivers/media/platform/verisilicon/sama5d4_vdec_hw.c

102

.run = hantro_g1_h264_dec_run,

drivers/media/platform/verisilicon/sama5d4_vdec_hw.c

90

.run = hantro_g1_mpeg2_dec_run,

drivers/media/platform/verisilicon/sama5d4_vdec_hw.c

96

.run = hantro_g1_vp8_dec_run,

drivers/media/platform/verisilicon/stm32mp25_vpu_hw.c

127

.run = hantro_g1_vp8_dec_run,

drivers/media/platform/verisilicon/stm32mp25_vpu_hw.c

133

.run = hantro_g1_h264_dec_run,

drivers/media/platform/verisilicon/stm32mp25_vpu_hw.c

142

.run = hantro_h1_jpeg_enc_run,

drivers/media/platform/verisilicon/sunxi_vpu_hw.c

99

.run = hantro_g2_vp9_dec_run,

drivers/media/test-drivers/visl/visl-debugfs.c

40

void visl_trace_bitstream(struct visl_ctx *ctx, struct visl_run *run)

drivers/media/test-drivers/visl/visl-debugfs.c

42

u8 *vaddr = vb2_plane_vaddr(&run->src->vb2_buf, 0);

drivers/media/test-drivers/visl/visl-debugfs.c

44

size_t data_sz = vb2_get_plane_payload(&run->src->vb2_buf, 0);

drivers/media/test-drivers/visl/visl-debugfs.c

57

snprintf(name, 32, "bitstream%d", run->src->sequence);

drivers/media/test-drivers/visl/visl-debugfs.h

18

void visl_trace_bitstream(struct visl_ctx *ctx, struct visl_run *run);

drivers/media/test-drivers/visl/visl-debugfs.h

35

static inline void visl_trace_bitstream(struct visl_ctx *ctx, struct visl_run *run) {}

drivers/media/test-drivers/visl/visl-dec.c

108

last = vb2_find_buffer(cap_q, run->vp8.frame->last_frame_ts);

drivers/media/test-drivers/visl/visl-dec.c

109

golden = vb2_find_buffer(cap_q, run->vp8.frame->golden_frame_ts);

drivers/media/test-drivers/visl/visl-dec.c

110

alt = vb2_find_buffer(cap_q, run->vp8.frame->alt_frame_ts);

drivers/media/test-drivers/visl/visl-dec.c

113

run->vp8.frame->last_frame_ts, last);

drivers/media/test-drivers/visl/visl-dec.c

115

run->vp8.frame->golden_frame_ts, golden);

drivers/media/test-drivers/visl/visl-dec.c

117

run->vp8.frame->alt_frame_ts, alt);

drivers/media/test-drivers/visl/visl-dec.c

127

last = vb2_find_buffer(cap_q, run->vp9.frame->last_frame_ts);

drivers/media/test-drivers/visl/visl-dec.c

128

golden = vb2_find_buffer(cap_q, run->vp9.frame->golden_frame_ts);

drivers/media/test-drivers/visl/visl-dec.c

129

alt = vb2_find_buffer(cap_q, run->vp9.frame->alt_frame_ts);

drivers/media/test-drivers/visl/visl-dec.c

132

run->vp9.frame->last_frame_ts, last);

drivers/media/test-drivers/visl/visl-dec.c

134

run->vp9.frame->golden_frame_ts, golden);

drivers/media/test-drivers/visl/visl-dec.c

136

run->vp9.frame->alt_frame_ts, alt);

drivers/media/test-drivers/visl/visl-dec.c

146

for (i = 0; i < ARRAY_SIZE(run->h264.dpram->dpb); i++) {

drivers/media/test-drivers/visl/visl-dec.c

148

run->h264.dpram->dpb[i].reference_ts);

drivers/media/test-drivers/visl/visl-dec.c

151

run->h264.dpram->dpb[i].reference_ts,

drivers/media/test-drivers/visl/visl-dec.c

155

run->h264.dpram->dpb[i].reference_ts);

drivers/media/test-drivers/visl/visl-dec.c

169

for (i = 0; i < ARRAY_SIZE(run->hevc.dpram->dpb); i++) {

drivers/media/test-drivers/visl/visl-dec.c

170

vb2_buf = vb2_find_buffer(cap_q, run->hevc.dpram->dpb[i].timestamp);

drivers/media/test-drivers/visl/visl-dec.c

173

run->hevc.dpram->dpb[i].timestamp,

drivers/media/test-drivers/visl/visl-dec.c

177

run->hevc.dpram->dpb[i].timestamp);

drivers/media/test-drivers/visl/visl-dec.c

188

int idx_last = run->av1.frame->ref_frame_idx[LAST_BUF_IDX];

drivers/media/test-drivers/visl/visl-dec.c

189

int idx_last2 = run->av1.frame->ref_frame_idx[LAST2_BUF_IDX];

drivers/media/test-drivers/visl/visl-dec.c

190

int idx_last3 = run->av1.frame->ref_frame_idx[LAST3_BUF_IDX];

drivers/media/test-drivers/visl/visl-dec.c

191

int idx_golden = run->av1.frame->ref_frame_idx[GOLDEN_BUF_IDX];

drivers/media/test-drivers/visl/visl-dec.c

192

int idx_bwd = run->av1.frame->ref_frame_idx[BWD_BUF_IDX];

drivers/media/test-drivers/visl/visl-dec.c

193

int idx_alt2 = run->av1.frame->ref_frame_idx[ALT2_BUF_IDX];

drivers/media/test-drivers/visl/visl-dec.c

194

int idx_alt = run->av1.frame->ref_frame_idx[ALT_BUF_IDX];

drivers/media/test-drivers/visl/visl-dec.c

196

const u64 *reference_frame_ts = run->av1.frame->reference_frame_ts;

drivers/media/test-drivers/visl/visl-dec.c

271

struct visl_run *run, char buf[], size_t bufsz)

drivers/media/test-drivers/visl/visl-dec.c

291

run->dst->sequence,

drivers/media/test-drivers/visl/visl-dec.c

292

run->dst->vb2_buf.timestamp,

drivers/media/test-drivers/visl/visl-dec.c

293

(run->dst->field == V4L2_FIELD_ALTERNATE) ?

drivers/media/test-drivers/visl/visl-dec.c

294

(run->dst->field == V4L2_FIELD_TOP ?

drivers/media/test-drivers/visl/visl-dec.c

299

struct visl_run *run,

drivers/media/test-drivers/visl/visl-dec.c

314

"H264: %u", run->h264.dpram->pic_order_cnt_lsb);

drivers/media/test-drivers/visl/visl-dec.c

318

"HEVC: %d", run->hevc.dpram->pic_order_cnt_val);

drivers/media/test-drivers/visl/visl-dec.c

327

static void visl_tpg_fill(struct visl_ctx *ctx, struct visl_run *run)

drivers/media/test-drivers/visl/visl-dec.c

345

&run->dst->vb2_buf, p,

drivers/media/test-drivers/visl/visl-dec.c

353

visl_tpg_fill_sequence(ctx, run, buf, TPG_STR_BUF_SZ);

drivers/media/test-drivers/visl/visl-dec.c

355

frame_dprintk(ctx->dev, run->dst->sequence, "%s\n", buf);

drivers/media/test-drivers/visl/visl-dec.c

356

frame_dprintk(ctx->dev, run->dst->sequence, "");

drivers/media/test-drivers/visl/visl-dec.c

359

if (visl_tpg_fill_codec_specific(ctx, run, buf, TPG_STR_BUF_SZ)) {

drivers/media/test-drivers/visl/visl-dec.c

361

frame_dprintk(ctx->dev, run->dst->sequence, "%s\n", buf);

drivers/media/test-drivers/visl/visl-dec.c

362

frame_dprintk(ctx->dev, run->dst->sequence, "");

drivers/media/test-drivers/visl/visl-dec.c

366

visl_get_ref_frames(ctx, buf, TPG_STR_BUF_SZ, run);

drivers/media/test-drivers/visl/visl-dec.c

370

frame_dprintk(ctx->dev, run->dst->sequence, "%s\n", line_str);

drivers/media/test-drivers/visl/visl-dec.c

373

frame_dprintk(ctx->dev, run->dst->sequence, "");

drivers/media/test-drivers/visl/visl-dec.c

388

frame_dprintk(ctx->dev, run->dst->sequence, "%s\n", buf);

drivers/media/test-drivers/visl/visl-dec.c

399

frame_dprintk(ctx->dev, run->dst->sequence, "%s\n", buf);

drivers/media/test-drivers/visl/visl-dec.c

404

frame_dprintk(ctx->dev, run->dst->sequence, "");

drivers/media/test-drivers/visl/visl-dec.c

407

frame_dprintk(ctx->dev, run->dst->sequence, "%s\n", buf);

drivers/media/test-drivers/visl/visl-dec.c

431

frame_dprintk(ctx->dev, run->dst->sequence, "%s", &buf[old_len]);

drivers/media/test-drivers/visl/visl-dec.c

436

frame_dprintk(ctx->dev, run->dst->sequence, "");

drivers/media/test-drivers/visl/visl-dec.c

450

frame_dprintk(ctx->dev, run->dst->sequence, "%s\n", buf);

drivers/media/test-drivers/visl/visl-dec.c

461

frame_dprintk(ctx->dev, run->dst->sequence, "%s\n", buf);

drivers/media/test-drivers/visl/visl-dec.c

466

frame_dprintk(ctx->dev, run->dst->sequence, "");

drivers/media/test-drivers/visl/visl-dec.c

469

frame_dprintk(ctx->dev, run->dst->sequence, "%s\n", buf);

drivers/media/test-drivers/visl/visl-dec.c

490

frame_dprintk(ctx->dev, run->dst->sequence, "%s", &buf[old_len]);

drivers/media/test-drivers/visl/visl-dec.c

495

static void visl_trace_ctrls(struct visl_ctx *ctx, struct visl_run *run)

drivers/media/test-drivers/visl/visl-dec.c

504

trace_v4l2_ctrl_fwht_params(run->fwht.params);

drivers/media/test-drivers/visl/visl-dec.c

507

trace_v4l2_ctrl_mpeg2_sequence(run->mpeg2.seq);

drivers/media/test-drivers/visl/visl-dec.c

508

trace_v4l2_ctrl_mpeg2_picture(run->mpeg2.pic);

drivers/media/test-drivers/visl/visl-dec.c

509

trace_v4l2_ctrl_mpeg2_quantisation(run->mpeg2.quant);

drivers/media/test-drivers/visl/visl-dec.c

512

trace_v4l2_ctrl_vp8_frame(run->vp8.frame);

drivers/media/test-drivers/visl/visl-dec.c

513

trace_v4l2_ctrl_vp8_entropy(run->vp8.frame);

drivers/media/test-drivers/visl/visl-dec.c

516

trace_v4l2_ctrl_vp9_frame(run->vp9.frame);

drivers/media/test-drivers/visl/visl-dec.c

517

trace_v4l2_ctrl_vp9_compressed_hdr(run->vp9.probs);

drivers/media/test-drivers/visl/visl-dec.c

518

trace_v4l2_ctrl_vp9_compressed_coeff(run->vp9.probs);

drivers/media/test-drivers/visl/visl-dec.c

519

trace_v4l2_vp9_mv_probs(&run->vp9.probs->mv);

drivers/media/test-drivers/visl/visl-dec.c

522

trace_v4l2_ctrl_h264_sps(run->h264.sps);

drivers/media/test-drivers/visl/visl-dec.c

523

trace_v4l2_ctrl_h264_pps(run->h264.pps);

drivers/media/test-drivers/visl/visl-dec.c

524

trace_v4l2_ctrl_h264_scaling_matrix(run->h264.sm);

drivers/media/test-drivers/visl/visl-dec.c

525

trace_v4l2_ctrl_h264_slice_params(run->h264.spram);

drivers/media/test-drivers/visl/visl-dec.c

527

for (i = 0; i < ARRAY_SIZE(run->h264.spram->ref_pic_list0); i++)

drivers/media/test-drivers/visl/visl-dec.c

528

trace_v4l2_h264_ref_pic_list0(&run->h264.spram->ref_pic_list0[i], i);

drivers/media/test-drivers/visl/visl-dec.c

529

for (i = 0; i < ARRAY_SIZE(run->h264.spram->ref_pic_list0); i++)

drivers/media/test-drivers/visl/visl-dec.c

530

trace_v4l2_h264_ref_pic_list1(&run->h264.spram->ref_pic_list1[i], i);

drivers/media/test-drivers/visl/visl-dec.c

532

trace_v4l2_ctrl_h264_decode_params(run->h264.dpram);

drivers/media/test-drivers/visl/visl-dec.c

534

for (i = 0; i < ARRAY_SIZE(run->h264.dpram->dpb); i++)

drivers/media/test-drivers/visl/visl-dec.c

535

trace_v4l2_h264_dpb_entry(&run->h264.dpram->dpb[i], i);

drivers/media/test-drivers/visl/visl-dec.c

537

trace_v4l2_ctrl_h264_pred_weights(run->h264.pwht);

drivers/media/test-drivers/visl/visl-dec.c

540

trace_v4l2_ctrl_hevc_sps(run->hevc.sps);

drivers/media/test-drivers/visl/visl-dec.c

541

trace_v4l2_ctrl_hevc_pps(run->hevc.pps);

drivers/media/test-drivers/visl/visl-dec.c

542

trace_v4l2_ctrl_hevc_slice_params(run->hevc.spram);

drivers/media/test-drivers/visl/visl-dec.c

543

trace_v4l2_ctrl_hevc_scaling_matrix(run->hevc.sm);

drivers/media/test-drivers/visl/visl-dec.c

544

trace_v4l2_ctrl_hevc_decode_params(run->hevc.dpram);

drivers/media/test-drivers/visl/visl-dec.c

546

for (i = 0; i < ARRAY_SIZE(run->hevc.dpram->dpb); i++)

drivers/media/test-drivers/visl/visl-dec.c

547

trace_v4l2_hevc_dpb_entry(&run->hevc.dpram->dpb[i]);

drivers/media/test-drivers/visl/visl-dec.c

549

trace_v4l2_hevc_pred_weight_table(&run->hevc.spram->pred_weight_table);

drivers/media/test-drivers/visl/visl-dec.c

550

trace_v4l2_ctrl_hevc_ext_sps_lt_rps(run->hevc.rps_lt);

drivers/media/test-drivers/visl/visl-dec.c

551

trace_v4l2_ctrl_hevc_ext_sps_st_rps(run->hevc.rps_st);

drivers/media/test-drivers/visl/visl-dec.c

555

trace_v4l2_ctrl_av1_sequence(run->av1.seq);

drivers/media/test-drivers/visl/visl-dec.c

556

trace_v4l2_ctrl_av1_frame(run->av1.frame);

drivers/media/test-drivers/visl/visl-dec.c

557

trace_v4l2_ctrl_av1_film_grain(run->av1.grain);

drivers/media/test-drivers/visl/visl-dec.c

558

trace_v4l2_ctrl_av1_tile_group_entry(run->av1.tge);

drivers/media/test-drivers/visl/visl-dec.c

566

struct visl_run run = {};

drivers/media/test-drivers/visl/visl-dec.c

569

run.src = v4l2_m2m_next_src_buf(ctx->fh.m2m_ctx);

drivers/media/test-drivers/visl/visl-dec.c

570

run.dst = v4l2_m2m_next_dst_buf(ctx->fh.m2m_ctx);

drivers/media/test-drivers/visl/visl-dec.c

573

src_req = run.src->vb2_buf.req_obj.req;

drivers/media/test-drivers/visl/visl-dec.c

578

v4l2_m2m_buf_copy_metadata(run.src, run.dst);

drivers/media/test-drivers/visl/visl-dec.c

579

run.dst->sequence = ctx->q_data[V4L2_M2M_DST].sequence++;

drivers/media/test-drivers/visl/visl-dec.c

580

run.src->sequence = ctx->q_data[V4L2_M2M_SRC].sequence++;

drivers/media/test-drivers/visl/visl-dec.c

581

run.dst->field = ctx->decoded_fmt.fmt.pix.field;

drivers/media/test-drivers/visl/visl-dec.c

588

run.fwht.params = visl_find_control_data(ctx, V4L2_CID_STATELESS_FWHT_PARAMS);

drivers/media/test-drivers/visl/visl-dec.c

591

run.mpeg2.seq = visl_find_control_data(ctx, V4L2_CID_STATELESS_MPEG2_SEQUENCE);

drivers/media/test-drivers/visl/visl-dec.c

592

run.mpeg2.pic = visl_find_control_data(ctx, V4L2_CID_STATELESS_MPEG2_PICTURE);

drivers/media/test-drivers/visl/visl-dec.c

593

run.mpeg2.quant = visl_find_control_data(ctx,

drivers/media/test-drivers/visl/visl-dec.c

597

run.vp8.frame = visl_find_control_data(ctx, V4L2_CID_STATELESS_VP8_FRAME);

drivers/media/test-drivers/visl/visl-dec.c

600

run.vp9.frame = visl_find_control_data(ctx, V4L2_CID_STATELESS_VP9_FRAME);

drivers/media/test-drivers/visl/visl-dec.c

601

run.vp9.probs = visl_find_control_data(ctx, V4L2_CID_STATELESS_VP9_COMPRESSED_HDR);

drivers/media/test-drivers/visl/visl-dec.c

604

run.h264.sps = visl_find_control_data(ctx, V4L2_CID_STATELESS_H264_SPS);

drivers/media/test-drivers/visl/visl-dec.c

605

run.h264.pps = visl_find_control_data(ctx, V4L2_CID_STATELESS_H264_PPS);

drivers/media/test-drivers/visl/visl-dec.c

606

run.h264.sm = visl_find_control_data(ctx, V4L2_CID_STATELESS_H264_SCALING_MATRIX);

drivers/media/test-drivers/visl/visl-dec.c

607

run.h264.spram = visl_find_control_data(ctx, V4L2_CID_STATELESS_H264_SLICE_PARAMS);

drivers/media/test-drivers/visl/visl-dec.c

608

run.h264.dpram = visl_find_control_data(ctx, V4L2_CID_STATELESS_H264_DECODE_PARAMS);

drivers/media/test-drivers/visl/visl-dec.c

609

run.h264.pwht = visl_find_control_data(ctx, V4L2_CID_STATELESS_H264_PRED_WEIGHTS);

drivers/media/test-drivers/visl/visl-dec.c

612

run.hevc.sps = visl_find_control_data(ctx, V4L2_CID_STATELESS_HEVC_SPS);

drivers/media/test-drivers/visl/visl-dec.c

613

run.hevc.pps = visl_find_control_data(ctx, V4L2_CID_STATELESS_HEVC_PPS);

drivers/media/test-drivers/visl/visl-dec.c

614

run.hevc.spram = visl_find_control_data(ctx, V4L2_CID_STATELESS_HEVC_SLICE_PARAMS);

drivers/media/test-drivers/visl/visl-dec.c

615

run.hevc.sm = visl_find_control_data(ctx, V4L2_CID_STATELESS_HEVC_SCALING_MATRIX);

drivers/media/test-drivers/visl/visl-dec.c

616

run.hevc.dpram = visl_find_control_data(ctx, V4L2_CID_STATELESS_HEVC_DECODE_PARAMS);

drivers/media/test-drivers/visl/visl-dec.c

617

run.hevc.rps_lt = visl_find_control_data(ctx,

drivers/media/test-drivers/visl/visl-dec.c

619

run.hevc.rps_st = visl_find_control_data(ctx,

drivers/media/test-drivers/visl/visl-dec.c

62

__kernel_size_t buflen, struct visl_run *run)

drivers/media/test-drivers/visl/visl-dec.c

623

run.av1.seq = visl_find_control_data(ctx, V4L2_CID_STATELESS_AV1_SEQUENCE);

drivers/media/test-drivers/visl/visl-dec.c

624

run.av1.frame = visl_find_control_data(ctx, V4L2_CID_STATELESS_AV1_FRAME);

drivers/media/test-drivers/visl/visl-dec.c

625

run.av1.tge = visl_find_control_data(ctx, V4L2_CID_STATELESS_AV1_TILE_GROUP_ENTRY);

drivers/media/test-drivers/visl/visl-dec.c

626

run.av1.grain = visl_find_control_data(ctx, V4L2_CID_STATELESS_AV1_FILM_GRAIN);

drivers/media/test-drivers/visl/visl-dec.c

630

frame_dprintk(ctx->dev, run.dst->sequence,

drivers/media/test-drivers/visl/visl-dec.c

632

run.src->sequence, run.src->vb2_buf.timestamp);

drivers/media/test-drivers/visl/visl-dec.c

634

frame_dprintk(ctx->dev, run.dst->sequence,

drivers/media/test-drivers/visl/visl-dec.c

636

run.dst->sequence, run.dst->vb2_buf.timestamp);

drivers/media/test-drivers/visl/visl-dec.c

638

visl_tpg_fill(ctx, &run);

drivers/media/test-drivers/visl/visl-dec.c

639

visl_trace_ctrls(ctx, &run);

drivers/media/test-drivers/visl/visl-dec.c

642

run.dst->sequence >= bitstream_trace_frame_start &&

drivers/media/test-drivers/visl/visl-dec.c

643

run.dst->sequence < bitstream_trace_frame_start + bitstream_trace_nframes)

drivers/media/test-drivers/visl/visl-dec.c

644

visl_trace_bitstream(ctx, &run);

drivers/media/test-drivers/visl/visl-dec.c

80

vb2_buf = vb2_find_buffer(cap_q, run->fwht.params->backward_ref_ts);

drivers/media/test-drivers/visl/visl-dec.c

83

run->fwht.params->backward_ref_ts, vb2_buf);

drivers/media/test-drivers/visl/visl-dec.c

92

b_ref = vb2_find_buffer(cap_q, run->mpeg2.pic->backward_ref_ts);

drivers/media/test-drivers/visl/visl-dec.c

93

f_ref = vb2_find_buffer(cap_q, run->mpeg2.pic->forward_ref_ts);

drivers/media/test-drivers/visl/visl-dec.c

96

run->mpeg2.pic->backward_ref_ts, b_ref);

drivers/media/test-drivers/visl/visl-dec.c

98

run->mpeg2.pic->forward_ref_ts, f_ref);

drivers/mmc/core/mmc_test.c

2561

.run = mmc_test_basic_write,

drivers/mmc/core/mmc_test.c

2566

.run = mmc_test_basic_read,

drivers/mmc/core/mmc_test.c

2572

.run = mmc_test_verify_write,

drivers/mmc/core/mmc_test.c

2579

.run = mmc_test_verify_read,

drivers/mmc/core/mmc_test.c

2586

.run = mmc_test_multi_write,

drivers/mmc/core/mmc_test.c

2593

.run = mmc_test_multi_read,

drivers/mmc/core/mmc_test.c

2600

.run = mmc_test_pow2_write,

drivers/mmc/core/mmc_test.c

2607

.run = mmc_test_pow2_read,

drivers/mmc/core/mmc_test.c

2614

.run = mmc_test_weird_write,

drivers/mmc/core/mmc_test.c

2621

.run = mmc_test_weird_read,

drivers/mmc/core/mmc_test.c

2628

.run = mmc_test_align_write,

drivers/mmc/core/mmc_test.c

2635

.run = mmc_test_align_read,

drivers/mmc/core/mmc_test.c

2642

.run = mmc_test_align_multi_write,

drivers/mmc/core/mmc_test.c

2649

.run = mmc_test_align_multi_read,

drivers/mmc/core/mmc_test.c

2655

.run = mmc_test_xfersize_write,

drivers/mmc/core/mmc_test.c

2660

.run = mmc_test_xfersize_read,

drivers/mmc/core/mmc_test.c

2665

.run = mmc_test_multi_xfersize_write,

drivers/mmc/core/mmc_test.c

2670

.run = mmc_test_multi_xfersize_read,

drivers/mmc/core/mmc_test.c

2678

.run = mmc_test_write_high,

drivers/mmc/core/mmc_test.c

2685

.run = mmc_test_read_high,

drivers/mmc/core/mmc_test.c

2692

.run = mmc_test_multi_write_high,

drivers/mmc/core/mmc_test.c

2699

.run = mmc_test_multi_read_high,

drivers/mmc/core/mmc_test.c

2707

.run = mmc_test_no_highmem,

drivers/mmc/core/mmc_test.c

2712

.run = mmc_test_no_highmem,

drivers/mmc/core/mmc_test.c

2717

.run = mmc_test_no_highmem,

drivers/mmc/core/mmc_test.c

2722

.run = mmc_test_no_highmem,

drivers/mmc/core/mmc_test.c

2730

.run = mmc_test_best_read_performance,

drivers/mmc/core/mmc_test.c

2737

.run = mmc_test_best_write_performance,

drivers/mmc/core/mmc_test.c

2744

.run = mmc_test_best_read_perf_max_scatter,

drivers/mmc/core/mmc_test.c

2751

.run = mmc_test_best_write_perf_max_scatter,

drivers/mmc/core/mmc_test.c

2758

.run = mmc_test_profile_read_perf,

drivers/mmc/core/mmc_test.c

2765

.run = mmc_test_profile_write_perf,

drivers/mmc/core/mmc_test.c

2772

.run = mmc_test_profile_trim_perf,

drivers/mmc/core/mmc_test.c

2779

.run = mmc_test_profile_seq_read_perf,

drivers/mmc/core/mmc_test.c

2786

.run = mmc_test_profile_seq_write_perf,

drivers/mmc/core/mmc_test.c

2793

.run = mmc_test_profile_seq_trim_perf,

drivers/mmc/core/mmc_test.c

2800

.run = mmc_test_random_read_perf,

drivers/mmc/core/mmc_test.c

2807

.run = mmc_test_random_write_perf,

drivers/mmc/core/mmc_test.c

2814

.run = mmc_test_large_seq_read_perf,

drivers/mmc/core/mmc_test.c

2821

.run = mmc_test_large_seq_write_perf,

drivers/mmc/core/mmc_test.c

2828

.run = mmc_test_profile_mult_write_blocking_perf,

drivers/mmc/core/mmc_test.c

2835

.run = mmc_test_profile_mult_write_nonblock_perf,

drivers/mmc/core/mmc_test.c

2842

.run = mmc_test_profile_mult_read_blocking_perf,

drivers/mmc/core/mmc_test.c

2849

.run = mmc_test_profile_mult_read_nonblock_perf,

drivers/mmc/core/mmc_test.c

2856

.run = mmc_test_profile_sglen_wr_blocking_perf,

drivers/mmc/core/mmc_test.c

2863

.run = mmc_test_profile_sglen_wr_nonblock_perf,

drivers/mmc/core/mmc_test.c

2870

.run = mmc_test_profile_sglen_r_blocking_perf,

drivers/mmc/core/mmc_test.c

2877

.run = mmc_test_profile_sglen_r_nonblock_perf,

drivers/mmc/core/mmc_test.c

2883

.run = mmc_test_reset,

drivers/mmc/core/mmc_test.c

2889

.run = mmc_test_cmds_during_read,

drivers/mmc/core/mmc_test.c

2896

.run = mmc_test_cmds_during_write,

drivers/mmc/core/mmc_test.c

2903

.run = mmc_test_cmds_during_read_cmd23,

drivers/mmc/core/mmc_test.c

2910

.run = mmc_test_cmds_during_write_cmd23,

drivers/mmc/core/mmc_test.c

2917

.run = mmc_test_cmds_during_read_cmd23_nonblock,

drivers/mmc/core/mmc_test.c

2924

.run = mmc_test_cmds_during_write_cmd23_nonblock,

drivers/mmc/core/mmc_test.c

2931

.run = mmc_test_retuning,

drivers/mmc/core/mmc_test.c

2988

ret = mmc_test_cases[i].run(test);

drivers/mmc/core/mmc_test.c

996

int (*run)(struct mmc_test_card *);

drivers/net/phy/phy_device.c

439

int (*run)(struct phy_device *))

drivers/net/phy/phy_device.c

450

fixup->run = run;

drivers/net/phy/phy_device.c

461

int (*run)(struct phy_device *))

drivers/net/phy/phy_device.c

463

return phy_register_fixup(NULL, phy_uid, phy_uid_mask, run);

drivers/net/phy/phy_device.c

469

int (*run)(struct phy_device *))

drivers/net/phy/phy_device.c

471

return phy_register_fixup(bus_id, 0, 0, run);

drivers/net/phy/phy_device.c

495

int err = fixup->run(phydev);

drivers/net/phy/phy_device.c

57

int (*run)(struct phy_device *phydev);

drivers/net/wan/farsync.c

1293

if (!port->run)

drivers/net/wan/farsync.c

1387

if (!port->run)

drivers/net/wan/farsync.c

1504

if (port->run)

drivers/net/wan/farsync.c

1512

if (port->run)

drivers/net/wan/farsync.c

2076

if (port->run) {

drivers/net/wan/farsync.c

2080

port->run = 0;

drivers/net/wan/farsync.c

2088

port->run = 1;

drivers/net/wan/farsync.c

2106

if (port->run) {

drivers/net/wan/farsync.c

2107

port->run = 0;

drivers/net/wan/farsync.c

2434

card->ports[i].run = 0;

drivers/net/wan/farsync.c

429

int run; /* Port is running */

drivers/net/wan/farsync.c

956

if (port->run)

drivers/net/wan/farsync.c

966

if (port->run)

drivers/net/wireless/ath/carl9170/tx.c

1404

bool run = false;

drivers/net/wireless/ath/carl9170/tx.c

1452

run = true;

drivers/net/wireless/ath/carl9170/tx.c

1459

return run;

drivers/net/wireless/ath/carl9170/tx.c

1480

bool run;

drivers/net/wireless/ath/carl9170/tx.c

1510

run = carl9170_tx_ampdu_queue(ar, sta, skb, info);

drivers/net/wireless/ath/carl9170/tx.c

1511

if (run)

drivers/net/wireless/broadcom/brcm80211/brcmfmac/cfg80211.c

1523

err = escan->run(cfg, ifp, request);

drivers/net/wireless/broadcom/brcm80211/brcmfmac/cfg80211.c

1567

cfg->escan_info.run = brcmf_run_escan;

drivers/net/wireless/broadcom/brcm80211/brcmfmac/cfg80211.c

3824

cfg->escan_info.run = brcmf_run_escan;

drivers/net/wireless/broadcom/brcm80211/brcmfmac/cfg80211.h

293

s32 (*run)(struct brcmf_cfg80211_info *cfg, struct brcmf_if *ifp,

drivers/net/wireless/broadcom/brcm80211/brcmfmac/p2p.c

916

cfg->escan_info.run = brcmf_p2p_run_escan;

drivers/net/wireless/realtek/rtw89/coex.c

4509

} else if (bt->rfk_info.map.run) {

drivers/net/wireless/realtek/rtw89/coex.c

4631

} else if (bt->rfk_info.map.run) {

drivers/net/wireless/realtek/rtw89/coex.c

7436

if (bt->rfk_info.map.run && !(val & BTC_BSCB_RFK_RUN))

drivers/net/wireless/realtek/rtw89/coex.c

7439

bt->rfk_info.map.run = !!(val & BTC_BSCB_RFK_RUN);

drivers/net/wireless/realtek/rtw89/coex.c

7480

if ((bt->rfk_info.map.run || bt->rfk_info.map.req) &&

drivers/net/wireless/realtek/rtw89/core.h

1594

u32 run: 1;

drivers/remoteproc/mtk_common.h

143

struct scp_run run;

drivers/remoteproc/mtk_scp.c

1233

init_waitqueue_head(&scp->run.wq);

drivers/remoteproc/mtk_scp.c

709

struct scp_run *run = &scp->run;

drivers/remoteproc/mtk_scp.c

718

run->signaled = false;

drivers/remoteproc/mtk_scp.c

723

run->wq,

drivers/remoteproc/mtk_scp.c

724

run->signaled,

drivers/remoteproc/mtk_scp.c

738

dev_info(dev, "SCP is ready. FW version %s\n", run->fw_ver);

drivers/remoteproc/mtk_scp.c

84

struct scp_run *run = data;

drivers/remoteproc/mtk_scp.c

86

scp->run.signaled = run->signaled;

drivers/remoteproc/mtk_scp.c

87

strscpy(scp->run.fw_ver, run->fw_ver, SCP_FW_VER_LEN);

drivers/remoteproc/mtk_scp.c

88

scp->run.dec_capability = run->dec_capability;

drivers/remoteproc/mtk_scp.c

89

scp->run.enc_capability = run->enc_capability;

drivers/remoteproc/mtk_scp.c

90

wake_up_interruptible(&scp->run.wq);

drivers/remoteproc/mtk_scp.c

982

return scp->run.dec_capability;

drivers/remoteproc/mtk_scp.c

995

return scp->run.enc_capability;

drivers/s390/crypto/vfio_ap_ops.c

353

*nib = vcpu->run->s.regs.gprs[2];

drivers/s390/crypto/vfio_ap_ops.c

591

apqn = vcpu->run->s.regs.gprs[0] & 0xffff;

drivers/s390/crypto/vfio_ap_ops.c

630

status = vcpu->run->s.regs.gprs[1];

drivers/s390/crypto/vfio_ap_ops.c

639

memcpy(&vcpu->run->s.regs.gprs[1], &qstatus, sizeof(qstatus));

drivers/s390/crypto/vfio_ap_ops.c

640

vcpu->run->s.regs.gprs[1] >>= 32;

drivers/s390/scsi/zfcp_dbf.c

415

rec->u.run.fsf_req_id = erp->fsf_req_id;

drivers/s390/scsi/zfcp_dbf.c

416

rec->u.run.rec_status = erp->status;

drivers/s390/scsi/zfcp_dbf.c

417

rec->u.run.rec_step = erp->step;

drivers/s390/scsi/zfcp_dbf.c

418

rec->u.run.rec_action = erp->type;

drivers/s390/scsi/zfcp_dbf.c

421

rec->u.run.rec_count =

drivers/s390/scsi/zfcp_dbf.c

424

rec->u.run.rec_count = atomic_read(&erp->port->erp_counter);

drivers/s390/scsi/zfcp_dbf.c

426

rec->u.run.rec_count = atomic_read(&erp->adapter->erp_counter);

drivers/s390/scsi/zfcp_dbf.c

468

rec->u.run.fsf_req_id = req_id;

drivers/s390/scsi/zfcp_dbf.c

469

rec->u.run.rec_status = ~0;

drivers/s390/scsi/zfcp_dbf.c

470

rec->u.run.rec_step = ~0;

drivers/s390/scsi/zfcp_dbf.c

471

rec->u.run.rec_action = ~0;

drivers/s390/scsi/zfcp_dbf.c

472

rec->u.run.rec_count = ~0;

drivers/s390/scsi/zfcp_dbf.h

92

struct zfcp_dbf_rec_running run;

drivers/scsi/aha152x.c

1374

INIT_WORK(&aha152x_tq, run);

drivers/scsi/aha152x.c

2408

if(states[STATE].run)

drivers/scsi/aha152x.c

2409

states[STATE].run(shpnt);

drivers/scsi/aha152x.c

616

void (*run)(struct Scsi_Host *);

drivers/staging/media/atomisp/pci/runtime/binary/src/binary.c

385

histo->run = NULL;

drivers/staging/media/atomisp/pci/sh_css_metrics.c

132

isp_histogram->run[pc]++;

drivers/staging/media/atomisp/pci/sh_css_metrics.c

143

sp_histogram->run[pc]++;

drivers/staging/media/atomisp/pci/sh_css_metrics.c

41

histogram->run[i] = 0;

drivers/staging/media/atomisp/pci/sh_css_metrics.c

60

if (histogram->run)

drivers/staging/media/atomisp/pci/sh_css_metrics.c

62

histogram->run = kvmalloc(length * sizeof(*histogram->run),

drivers/staging/media/atomisp/pci/sh_css_metrics.c

64

if (!histogram->run)

drivers/staging/media/atomisp/pci/sh_css_metrics.h

14

unsigned int *run;

drivers/staging/media/imx/imx-media-csc-scaler.c

107

v4l2_m2m_buf_done(src_buf, run->status ? VB2_BUF_STATE_ERROR :

drivers/staging/media/imx/imx-media-csc-scaler.c

109

v4l2_m2m_buf_done(dst_buf, run->status ? VB2_BUF_STATE_ERROR :

drivers/staging/media/imx/imx-media-csc-scaler.c

113

kfree(run);

drivers/staging/media/imx/imx-media-csc-scaler.c

121

struct ipu_image_convert_run *run;

drivers/staging/media/imx/imx-media-csc-scaler.c

127

run = kzalloc_obj(*run);

drivers/staging/media/imx/imx-media-csc-scaler.c

128

if (!run)

drivers/staging/media/imx/imx-media-csc-scaler.c

131

run->ctx = ctx->icc;

drivers/staging/media/imx/imx-media-csc-scaler.c

132

run->in_phys = vb2_dma_contig_plane_dma_addr(&src_buf->vb2_buf, 0);

drivers/staging/media/imx/imx-media-csc-scaler.c

133

run->out_phys = vb2_dma_contig_plane_dma_addr(&dst_buf->vb2_buf, 0);

drivers/staging/media/imx/imx-media-csc-scaler.c

135

ret = ipu_image_convert_queue(run);

drivers/staging/media/imx/imx-media-csc-scaler.c

93

static void ipu_ic_pp_complete(struct ipu_image_convert_run *run, void *_ctx)

drivers/staging/media/sunxi/cedrus/cedrus.h

167

int (*setup)(struct cedrus_ctx *ctx, struct cedrus_run *run);

drivers/staging/media/sunxi/cedrus/cedrus_dec.c

29

struct cedrus_run run = {};

drivers/staging/media/sunxi/cedrus/cedrus_dec.c

33

run.src = v4l2_m2m_next_src_buf(ctx->fh.m2m_ctx);

drivers/staging/media/sunxi/cedrus/cedrus_dec.c

34

run.dst = v4l2_m2m_next_dst_buf(ctx->fh.m2m_ctx);

drivers/staging/media/sunxi/cedrus/cedrus_dec.c

37

src_req = run.src->vb2_buf.req_obj.req;

drivers/staging/media/sunxi/cedrus/cedrus_dec.c

44

run.mpeg2.sequence = cedrus_find_control_data(ctx,

drivers/staging/media/sunxi/cedrus/cedrus_dec.c

46

run.mpeg2.picture = cedrus_find_control_data(ctx,

drivers/staging/media/sunxi/cedrus/cedrus_dec.c

48

run.mpeg2.quantisation = cedrus_find_control_data(ctx,

drivers/staging/media/sunxi/cedrus/cedrus_dec.c

53

run.h264.decode_params = cedrus_find_control_data(ctx,

drivers/staging/media/sunxi/cedrus/cedrus_dec.c

55

run.h264.pps = cedrus_find_control_data(ctx,

drivers/staging/media/sunxi/cedrus/cedrus_dec.c

57

run.h264.scaling_matrix = cedrus_find_control_data(ctx,

drivers/staging/media/sunxi/cedrus/cedrus_dec.c

59

run.h264.slice_params = cedrus_find_control_data(ctx,

drivers/staging/media/sunxi/cedrus/cedrus_dec.c

61

run.h264.sps = cedrus_find_control_data(ctx,

drivers/staging/media/sunxi/cedrus/cedrus_dec.c

63

run.h264.pred_weights = cedrus_find_control_data(ctx,

drivers/staging/media/sunxi/cedrus/cedrus_dec.c

68

run.h265.sps = cedrus_find_control_data(ctx,

drivers/staging/media/sunxi/cedrus/cedrus_dec.c

70

run.h265.pps = cedrus_find_control_data(ctx,

drivers/staging/media/sunxi/cedrus/cedrus_dec.c

72

run.h265.slice_params = cedrus_find_control_data(ctx,

drivers/staging/media/sunxi/cedrus/cedrus_dec.c

74

run.h265.decode_params = cedrus_find_control_data(ctx,

drivers/staging/media/sunxi/cedrus/cedrus_dec.c

76

run.h265.scaling_matrix = cedrus_find_control_data(ctx,

drivers/staging/media/sunxi/cedrus/cedrus_dec.c

78

run.h265.entry_points = cedrus_find_control_data(ctx,

drivers/staging/media/sunxi/cedrus/cedrus_dec.c

80

run.h265.entry_points_count = cedrus_get_num_of_controls(ctx,

drivers/staging/media/sunxi/cedrus/cedrus_dec.c

85

run.vp8.frame_params = cedrus_find_control_data(ctx,

drivers/staging/media/sunxi/cedrus/cedrus_dec.c

93

v4l2_m2m_buf_copy_metadata(run.src, run.dst);

drivers/staging/media/sunxi/cedrus/cedrus_dec.c

97

error = ctx->current_codec->setup(ctx, &run);

drivers/staging/media/sunxi/cedrus/cedrus_h264.c

120

if (run->dst->vb2_buf.timestamp == dpb->reference_ts) {

drivers/staging/media/sunxi/cedrus/cedrus_h264.c

139

output_buf = vb2_to_cedrus_buffer(&run->dst->vb2_buf);

drivers/staging/media/sunxi/cedrus/cedrus_h264.c

143

const struct v4l2_ctrl_h264_sps *sps = run->h264.sps;

drivers/staging/media/sunxi/cedrus/cedrus_h264.c

190

struct cedrus_run *run,

drivers/staging/media/sunxi/cedrus/cedrus_h264.c

194

const struct v4l2_ctrl_h264_decode_params *decode = run->h264.decode_params;

drivers/staging/media/sunxi/cedrus/cedrus_h264.c

235

struct cedrus_run *run)

drivers/staging/media/sunxi/cedrus/cedrus_h264.c

237

const struct v4l2_ctrl_h264_slice_params *slice = run->h264.slice_params;

drivers/staging/media/sunxi/cedrus/cedrus_h264.c

239

_cedrus_write_ref_list(ctx, run,

drivers/staging/media/sunxi/cedrus/cedrus_h264.c

246

struct cedrus_run *run)

drivers/staging/media/sunxi/cedrus/cedrus_h264.c

248

const struct v4l2_ctrl_h264_slice_params *slice = run->h264.slice_params;

drivers/staging/media/sunxi/cedrus/cedrus_h264.c

250

_cedrus_write_ref_list(ctx, run,

drivers/staging/media/sunxi/cedrus/cedrus_h264.c

257

struct cedrus_run *run)

drivers/staging/media/sunxi/cedrus/cedrus_h264.c

260

run->h264.scaling_matrix;

drivers/staging/media/sunxi/cedrus/cedrus_h264.c

261

const struct v4l2_ctrl_h264_pps *pps = run->h264.pps;

drivers/staging/media/sunxi/cedrus/cedrus_h264.c

281

struct cedrus_run *run)

drivers/staging/media/sunxi/cedrus/cedrus_h264.c

284

run->h264.pred_weights;

drivers/staging/media/sunxi/cedrus/cedrus_h264.c

342

struct cedrus_run *run)

drivers/staging/media/sunxi/cedrus/cedrus_h264.c

344

const struct v4l2_ctrl_h264_decode_params *decode = run->h264.decode_params;

drivers/staging/media/sunxi/cedrus/cedrus_h264.c

345

const struct v4l2_ctrl_h264_slice_params *slice = run->h264.slice_params;

drivers/staging/media/sunxi/cedrus/cedrus_h264.c

346

const struct v4l2_ctrl_h264_pps *pps = run->h264.pps;

drivers/staging/media/sunxi/cedrus/cedrus_h264.c

347

const struct v4l2_ctrl_h264_sps *sps = run->h264.sps;

drivers/staging/media/sunxi/cedrus/cedrus_h264.c

348

struct vb2_buffer *src_buf = &run->src->vb2_buf;

drivers/staging/media/sunxi/cedrus/cedrus_h264.c

392

cedrus_write_pred_weight_table(ctx, run);

drivers/staging/media/sunxi/cedrus/cedrus_h264.c

397

cedrus_write_ref_list0(ctx, run);

drivers/staging/media/sunxi/cedrus/cedrus_h264.c

400

cedrus_write_ref_list1(ctx, run);

drivers/staging/media/sunxi/cedrus/cedrus_h264.c

516

static int cedrus_h264_setup(struct cedrus_ctx *ctx, struct cedrus_run *run)

drivers/staging/media/sunxi/cedrus/cedrus_h264.c

529

cedrus_write_scaling_lists(ctx, run);

drivers/staging/media/sunxi/cedrus/cedrus_h264.c

530

ret = cedrus_write_frame_list(ctx, run);

drivers/staging/media/sunxi/cedrus/cedrus_h264.c

534

cedrus_set_params(ctx, run);

drivers/staging/media/sunxi/cedrus/cedrus_h264.c

87

struct cedrus_run *run)

drivers/staging/media/sunxi/cedrus/cedrus_h264.c

90

const struct v4l2_ctrl_h264_decode_params *decode = run->h264.decode_params;

drivers/staging/media/sunxi/cedrus/cedrus_h264.c

91

const struct v4l2_ctrl_h264_sps *sps = run->h264.sps;

drivers/staging/media/sunxi/cedrus/cedrus_h265.c

271

struct cedrus_run *run)

drivers/staging/media/sunxi/cedrus/cedrus_h265.c

277

scaling = run->h265.scaling_matrix;

drivers/staging/media/sunxi/cedrus/cedrus_h265.c

333

static int cedrus_h265_is_low_delay(struct cedrus_run *run)

drivers/staging/media/sunxi/cedrus/cedrus_h265.c

340

slice_params = run->h265.slice_params;

drivers/staging/media/sunxi/cedrus/cedrus_h265.c

341

poc = run->h265.decode_params->pic_order_cnt_val;

drivers/staging/media/sunxi/cedrus/cedrus_h265.c

342

dpb = run->h265.decode_params->dpb;

drivers/staging/media/sunxi/cedrus/cedrus_h265.c

359

struct cedrus_run *run,

drivers/staging/media/sunxi/cedrus/cedrus_h265.c

370

pps = run->h265.pps;

drivers/staging/media/sunxi/cedrus/cedrus_h265.c

371

slice_params = run->h265.slice_params;

drivers/staging/media/sunxi/cedrus/cedrus_h265.c

372

entry_points = run->h265.entry_points;

drivers/staging/media/sunxi/cedrus/cedrus_h265.c

417

static int cedrus_h265_setup(struct cedrus_ctx *ctx, struct cedrus_run *run)

drivers/staging/media/sunxi/cedrus/cedrus_h265.c

439

sps = run->h265.sps;

drivers/staging/media/sunxi/cedrus/cedrus_h265.c

440

pps = run->h265.pps;

drivers/staging/media/sunxi/cedrus/cedrus_h265.c

441

slice_params = run->h265.slice_params;

drivers/staging/media/sunxi/cedrus/cedrus_h265.c

442

decode_params = run->h265.decode_params;

drivers/staging/media/sunxi/cedrus/cedrus_h265.c

445

cedrus_buf = vb2_to_cedrus_buffer(&run->dst->vb2_buf);

drivers/staging/media/sunxi/cedrus/cedrus_h265.c

446

slice_bytes = vb2_get_plane_payload(&run->src->vb2_buf, 0);

drivers/staging/media/sunxi/cedrus/cedrus_h265.c

453

num_entry_point_offsets != run->h265.entry_points_count)

drivers/staging/media/sunxi/cedrus/cedrus_h265.c

499

src_buf_addr = vb2_dma_contig_plane_dma_addr(&run->src->vb2_buf, 0);

drivers/staging/media/sunxi/cedrus/cedrus_h265.c

520

cedrus_h265_write_tiles(ctx, run, ctb_addr_x, ctb_addr_y);

drivers/staging/media/sunxi/cedrus/cedrus_h265.c

725

if (slice_params->slice_type != V4L2_HEVC_SLICE_TYPE_I && !cedrus_h265_is_low_delay(run))

drivers/staging/media/sunxi/cedrus/cedrus_h265.c

751

cedrus_h265_write_scaling_list(ctx, run);

drivers/staging/media/sunxi/cedrus/cedrus_h265.c

775

&run->dst->vb2_buf);

drivers/staging/media/sunxi/cedrus/cedrus_mpeg2.c

133

dst_luma_addr = cedrus_dst_buf_addr(ctx, &run->dst->vb2_buf, 0);

drivers/staging/media/sunxi/cedrus/cedrus_mpeg2.c

134

dst_chroma_addr = cedrus_dst_buf_addr(ctx, &run->dst->vb2_buf, 1);

drivers/staging/media/sunxi/cedrus/cedrus_mpeg2.c

143

reg = vb2_get_plane_payload(&run->src->vb2_buf, 0) * 8;

drivers/staging/media/sunxi/cedrus/cedrus_mpeg2.c

148

src_buf_addr = vb2_dma_contig_plane_dma_addr(&run->src->vb2_buf, 0);

drivers/staging/media/sunxi/cedrus/cedrus_mpeg2.c

157

reg = src_buf_addr + vb2_get_plane_payload(&run->src->vb2_buf, 0);

drivers/staging/media/sunxi/cedrus/cedrus_mpeg2.c

51

static int cedrus_mpeg2_setup(struct cedrus_ctx *ctx, struct cedrus_run *run)

drivers/staging/media/sunxi/cedrus/cedrus_mpeg2.c

63

seq = run->mpeg2.sequence;

drivers/staging/media/sunxi/cedrus/cedrus_mpeg2.c

64

pic = run->mpeg2.picture;

drivers/staging/media/sunxi/cedrus/cedrus_mpeg2.c

66

quantisation = run->mpeg2.quantisation;

drivers/staging/media/sunxi/cedrus/cedrus_vp8.c

654

static int cedrus_vp8_setup(struct cedrus_ctx *ctx, struct cedrus_run *run)

drivers/staging/media/sunxi/cedrus/cedrus_vp8.c

656

const struct v4l2_ctrl_vp8_frame *slice = run->vp8.frame_params;

drivers/staging/media/sunxi/cedrus/cedrus_vp8.c

658

struct vb2_buffer *src_buf = &run->src->vb2_buf;

drivers/staging/media/sunxi/cedrus/cedrus_vp8.c

806

luma_addr = cedrus_dst_buf_addr(ctx, &run->dst->vb2_buf, 0);

drivers/staging/media/sunxi/cedrus/cedrus_vp8.c

807

chroma_addr = cedrus_dst_buf_addr(ctx, &run->dst->vb2_buf, 1);

drivers/tty/tty_audit.c

238

size_t run;

drivers/tty/tty_audit.c

240

run = TTY_AUDIT_BUF_SIZE - buf->valid;

drivers/tty/tty_audit.c

241

if (run > size)

drivers/tty/tty_audit.c

242

run = size;

drivers/tty/tty_audit.c

243

memcpy(buf->data + buf->valid, data, run);

drivers/tty/tty_audit.c

244

buf->valid += run;

drivers/tty/tty_audit.c

245

data += run;

drivers/tty/tty_audit.c

246

size -= run;

fs/befs/datastream.c

102

err = befs_find_brun_direct(sb, data, fblock, run);

fs/befs/datastream.c

105

err = befs_find_brun_indirect(sb, data, fblock, run);

fs/befs/datastream.c

108

err = befs_find_brun_dblindirect(sb, data, fblock, run);

fs/befs/datastream.c

252

befs_blocknr_t blockno, befs_block_run *run)

fs/befs/datastream.c

26

befs_blocknr_t blockno, befs_block_run *run);

fs/befs/datastream.c

265

run->allocation_group = array[i].allocation_group;

fs/befs/datastream.c

266

run->start = array[i].start + offset;

fs/befs/datastream.c

267

run->len = array[i].len - offset;

fs/befs/datastream.c

308

befs_block_run *run)

fs/befs/datastream.c

31

befs_block_run *run);

fs/befs/datastream.c

344

run->allocation_group =

fs/befs/datastream.c

346

run->start =

fs/befs/datastream.c

348

run->len =

fs/befs/datastream.c

36

befs_block_run *run);

fs/befs/datastream.c

417

befs_block_run *run)

fs/befs/datastream.c

509

*run = fsrun_to_cpu(sb, iaddr_array[block_indx]);

fs/befs/datastream.c

517

run->start += offset;

fs/befs/datastream.c

518

run->len -= offset;

fs/befs/datastream.c

53

befs_block_run run;

fs/befs/datastream.c

61

if (befs_fblock2brun(sb, ds, block, &run) != BEFS_OK) {

fs/befs/datastream.c

67

bh = befs_bread_iaddr(sb, run);

fs/befs/datastream.c

96

befs_blocknr_t fblock, befs_block_run *run)

fs/befs/datastream.h

12

befs_blocknr_t fblock, befs_block_run *run);

fs/befs/debug.c

213

befs_dump_run(const struct super_block *sb, befs_disk_block_run run)

fs/befs/debug.c

217

befs_block_run n = fsrun_to_cpu(sb, run);

fs/befs/endian.h

100

run.len = cpu_to_be16(n.len);

fs/befs/endian.h

102

return run;

fs/befs/endian.h

74

befs_block_run run;

fs/befs/endian.h

77

run.allocation_group = le32_to_cpu((__force __le32)n.allocation_group);

fs/befs/endian.h

78

run.start = le16_to_cpu((__force __le16)n.start);

fs/befs/endian.h

79

run.len = le16_to_cpu((__force __le16)n.len);

fs/befs/endian.h

81

run.allocation_group = be32_to_cpu((__force __be32)n.allocation_group);

fs/befs/endian.h

82

run.start = be16_to_cpu((__force __be16)n.start);

fs/befs/endian.h

83

run.len = be16_to_cpu((__force __be16)n.len);

fs/befs/endian.h

85

return run;

fs/befs/endian.h

91

befs_disk_block_run run;

fs/befs/endian.h

94

run.allocation_group = cpu_to_le32(n.allocation_group);

fs/befs/endian.h

95

run.start = cpu_to_le16(n.start);

fs/befs/endian.h

96

run.len = cpu_to_le16(n.len);

fs/befs/endian.h

98

run.allocation_group = cpu_to_be32(n.allocation_group);

fs/befs/endian.h

99

run.start = cpu_to_be16(n.start);

fs/befs/linuxvfs.c

139

befs_block_run run = BAD_IADDR;

fs/befs/linuxvfs.c

152

res = befs_fblock2brun(sb, ds, block, &run);

fs/befs/linuxvfs.c

161

disk_off = (ulong) iaddr2blockno(sb, &run);

fs/gfs2/dir.c

1271

int run = 0;

fs/gfs2/dir.c

1293

if (*copied && !run)

fs/gfs2/dir.c

1295

run = 1;

fs/gfs2/dir.c

1297

run = 0;

fs/jbd2/commit.c

1089

stats.run.rs_logging = jbd2_time_diff(stats.run.rs_logging,

fs/jbd2/commit.c

1096

stats.run.rs_handle_count =

fs/jbd2/commit.c

1099

commit_transaction->t_tid, &stats.run);

fs/jbd2/commit.c

1150

journal->j_stats.run.rs_wait += stats.run.rs_wait;

fs/jbd2/commit.c

1151

journal->j_stats.run.rs_request_delay += stats.run.rs_request_delay;

fs/jbd2/commit.c

1152

journal->j_stats.run.rs_running += stats.run.rs_running;

fs/jbd2/commit.c

1153

journal->j_stats.run.rs_locked += stats.run.rs_locked;

fs/jbd2/commit.c

1154

journal->j_stats.run.rs_flushing += stats.run.rs_flushing;

fs/jbd2/commit.c

1155

journal->j_stats.run.rs_logging += stats.run.rs_logging;

fs/jbd2/commit.c

1156

journal->j_stats.run.rs_handle_count += stats.run.rs_handle_count;

fs/jbd2/commit.c

1157

journal->j_stats.run.rs_blocks += stats.run.rs_blocks;

fs/jbd2/commit.c

1158

journal->j_stats.run.rs_blocks_logged += stats.run.rs_blocks_logged;

fs/jbd2/commit.c

443

stats.run.rs_wait = commit_transaction->t_max_wait;

fs/jbd2/commit.c

444

stats.run.rs_request_delay = 0;

fs/jbd2/commit.c

445

stats.run.rs_locked = jiffies;

fs/jbd2/commit.c

447

stats.run.rs_request_delay =

fs/jbd2/commit.c

449

stats.run.rs_locked);

fs/jbd2/commit.c

450

stats.run.rs_running = jbd2_time_diff(commit_transaction->t_start,

fs/jbd2/commit.c

451

stats.run.rs_locked);

fs/jbd2/commit.c

528

stats.run.rs_flushing = jiffies;

fs/jbd2/commit.c

529

stats.run.rs_locked = jbd2_time_diff(stats.run.rs_locked,

fs/jbd2/commit.c

530

stats.run.rs_flushing);

fs/jbd2/commit.c

565

stats.run.rs_logging = jiffies;

fs/jbd2/commit.c

566

stats.run.rs_flushing = jbd2_time_diff(stats.run.rs_flushing,

fs/jbd2/commit.c

567

stats.run.rs_logging);

fs/jbd2/commit.c

568

stats.run.rs_blocks = commit_transaction->t_nr_buffers;

fs/jbd2/commit.c

569

stats.run.rs_blocks_logged = 0;

fs/jbd2/commit.c

814

stats.run.rs_blocks_logged++;

fs/jbd2/commit.c

860

stats.run.rs_blocks_logged++;

fs/jbd2/commit.c

882

stats.run.rs_blocks_logged++;

fs/jbd2/journal.c

1137

jiffies_to_msecs(s->stats->run.rs_wait / s->stats->ts_tid));

fs/jbd2/journal.c

1140

jiffies_to_msecs(s->stats->run.rs_request_delay /

fs/jbd2/journal.c

1143

jiffies_to_msecs(s->stats->run.rs_running / s->stats->ts_tid));

fs/jbd2/journal.c

1145

jiffies_to_msecs(s->stats->run.rs_locked / s->stats->ts_tid));

fs/jbd2/journal.c

1147

jiffies_to_msecs(s->stats->run.rs_flushing / s->stats->ts_tid));

fs/jbd2/journal.c

1149

jiffies_to_msecs(s->stats->run.rs_logging / s->stats->ts_tid));

fs/jbd2/journal.c

1153

s->stats->run.rs_handle_count / s->stats->ts_tid);

fs/jbd2/journal.c

1155

s->stats->run.rs_blocks / s->stats->ts_tid);

fs/jbd2/journal.c

1157

s->stats->run.rs_blocks_logged / s->stats->ts_tid);

fs/ntfs3/attrib.c

1000

struct runs_tree *run = &ni->file.run;

fs/ntfs3/attrib.c

1017

} else if (run_lookup_entry(run, vcn, lcn, len, NULL)) {

fs/ntfs3/attrib.c

104

if (!run_lookup_entry(run, vcn, &lcn, &clen, &idx)) {

fs/ntfs3/attrib.c

106

run_truncate(run, vcn0);

fs/ntfs3/attrib.c

1083

err = attr_load_runs(attr, ni, run, NULL);

fs/ntfs3/attrib.c

1089

&hint, run);

fs/ntfs3/attrib.c

1103

if (run_lookup_entry(run, vcn, lcn, len, NULL)) {

fs/ntfs3/attrib.c

1151

err = attr_load_runs(attr2, ni, run, NULL);

fs/ntfs3/attrib.c

1191

if (!run_add_entry(run, evcn1, SPARSE_LCN, vcn - evcn1,

fs/ntfs3/attrib.c

1196

} else if (vcn && !run_lookup_entry(run, vcn - 1, &hint, NULL, NULL)) {

fs/ntfs3/attrib.c

1201

err = attr_allocate_clusters(sbi, run, run_da, vcn, hint + 1, to_alloc,

fs/ntfs3/attrib.c

1216

if (!run_lookup_entry(run, vcn0, lcn, len, NULL)) {

fs/ntfs3/attrib.c

1232

err = mi_pack_runs(mi, attr, run, max(end, evcn1) - svcn);

fs/ntfs3/attrib.c

1334

err = attr_load_runs(attr, ni, run, &end);

fs/ntfs3/attrib.c

1340

err = mi_pack_runs(mi, attr, run, evcn1 - next_svcn);

fs/ntfs3/attrib.c

1351

err = ni_insert_nonresident(ni, ATTR_DATA, NULL, 0, run,

fs/ntfs3/attrib.c

1358

run_truncate_around(run, vcn);

fs/ntfs3/attrib.c

1372

if (run_deallocate_ex(sbi, run, vcn, *len, NULL, false, run_da) ||

fs/ntfs3/attrib.c

1373

!run_add_entry(run, vcn, SPARSE_LCN, *len, false) ||

fs/ntfs3/attrib.c

1374

mi_pack_runs(mi, attr, run, max(end, evcn1) - svcn)) {

fs/ntfs3/attrib.c

1414

const __le16 *name, u8 name_len, struct runs_tree *run,

fs/ntfs3/attrib.c

143

if (!run_get_entry(run, ++idx, &vcn, &lcn, &clen) ||

fs/ntfs3/attrib.c

1446

err = run_unpack_ex(run, ni->mi.sbi, ni->mi.rno, svcn, evcn, svcn,

fs/ntfs3/attrib.c

1457

const __le16 *name, u8 name_len, struct runs_tree *run,

fs/ntfs3/attrib.c

1469

if (run_lookup_entry(run, vcn, &lcn, &clen, NULL)) {

fs/ntfs3/attrib.c

1477

err = attr_load_runs_vcn(ni, type, name, name_len, run, vcn);

fs/ntfs3/attrib.c

1495

struct runs_tree *run, u64 frame, u64 frames,

fs/ntfs3/attrib.c

1580

ARRAY_SIZE(WOF_NAME), run,

fs/ntfs3/attrib.c

1585

err = ntfs_read_run(sbi, run, addr, from, to - from);

fs/ntfs3/attrib.c

160

int attr_allocate_clusters(struct ntfs_sb_info *sbi, struct runs_tree *run,

fs/ntfs3/attrib.c

1643

CLST frame, CLST *clst_data, struct runs_tree *run)

fs/ntfs3/attrib.c

1661

if (!run_lookup_entry(run, vcn, &lcn, &clen, &idx)) {

fs/ntfs3/attrib.c

1663

attr->name_len, run, vcn);

fs/ntfs3/attrib.c

1667

if (!run_lookup_entry(run, vcn, &lcn, &clen, &idx))

fs/ntfs3/attrib.c

168

size_t cnt = run->count;

fs/ntfs3/attrib.c

1696

if (!run_get_entry(run, ++idx, &vcn, &lcn, &clen) ||

fs/ntfs3/attrib.c

1700

attr->name_len, run, vcn_next);

fs/ntfs3/attrib.c

1705

if (!run_lookup_entry(run, vcn, &lcn, &clen, &idx))

fs/ntfs3/attrib.c

1748

struct runs_tree *run = &ni->file.run;

fs/ntfs3/attrib.c

1791

err = attr_load_runs(attr, ni, run, NULL);

fs/ntfs3/attrib.c

1795

err = attr_is_frame_compressed(ni, attr_b, frame, &clst_data, run);

fs/ntfs3/attrib.c

1807

err = run_deallocate_ex(sbi, run, vcn + len, clst_data - len,

fs/ntfs3/attrib.c

1812

if (!run_add_entry(run, vcn + len, SPARSE_LCN, clst_data - len,

fs/ntfs3/attrib.c

1823

!run_lookup_entry(run, vcn + clst_data - 1, &hint, NULL,

fs/ntfs3/attrib.c

1828

err = attr_allocate_clusters(sbi, run, NULL, vcn + clst_data,

fs/ntfs3/attrib.c

1842

err = mi_pack_runs(mi, attr, run, max(end, evcn1) - svcn);

fs/ntfs3/attrib.c

1927

err = attr_load_runs(attr, ni, run, &end);

fs/ntfs3/attrib.c

1933

err = mi_pack_runs(mi, attr, run, evcn1 - next_svcn);

fs/ntfs3/attrib.c

1945

err = ni_insert_nonresident(ni, ATTR_DATA, NULL, 0, run,

fs/ntfs3/attrib.c

1952

run_truncate_around(run, vcn);

fs/ntfs3/attrib.c

1974

struct runs_tree *run = &ni->file.run;

fs/ntfs3/attrib.c

199

if (!run_add_entry(run, vcn, lcn, flen, opt & ALLOCATE_MFT)) {

fs/ntfs3/attrib.c

2020

err = attr_set_size(ni, ATTR_DATA, NULL, 0, &ni->file.run, vbo,

fs/ntfs3/attrib.c

2044

err = attr_set_size_ex(ni, ATTR_DATA, NULL, 0, run,

fs/ntfs3/attrib.c

2116

run_truncate(run, 0);

fs/ntfs3/attrib.c

2117

err = attr_load_runs(attr, ni, run, &svcn);

fs/ntfs3/attrib.c

2124

err = run_deallocate_ex(sbi, run, vcn1, eat, &dealloc, true,

fs/ntfs3/attrib.c

2131

if (!run_collapse_range(run, vcn1, eat, done)) {

fs/ntfs3/attrib.c

2145

err = mi_pack_runs(mi, attr, run, evcn1 - svcn - eat);

fs/ntfs3/attrib.c

2152

ni, ATTR_DATA, NULL, 0, run, next_svcn,

fs/ntfs3/attrib.c

2163

run_truncate(run, 0);

fs/ntfs3/attrib.c

2261

struct runs_tree *run = &ni->file.run;

fs/ntfs3/attrib.c

229

(opt & ALLOCATE_ONE_FR) || (fr && run->count - cnt >= fr)) {

fs/ntfs3/attrib.c

2323

run_truncate(run, 0);

fs/ntfs3/attrib.c

2361

err = attr_load_runs(attr, ni, run, &svcn);

fs/ntfs3/attrib.c

2372

err = run_deallocate_ex(NULL, run, vcn1, zero, &hole2, false,

fs/ntfs3/attrib.c

2382

err = run_clone(run, &run2);

fs/ntfs3/attrib.c

2387

if (!run_add_entry(run, vcn1, SPARSE_LCN, zero, false)) {

fs/ntfs3/attrib.c

2393

err = mi_pack_runs(mi, attr, run, evcn1 - svcn);

fs/ntfs3/attrib.c

2399

err = ni_insert_nonresident(ni, ATTR_DATA, NULL, 0, run,

fs/ntfs3/attrib.c

240

run_deallocate_ex(sbi, run, vcn0, vcn - vcn0, NULL, false,

fs/ntfs3/attrib.c

2416

run_truncate(run, 0);

fs/ntfs3/attrib.c

242

run_truncate(run, vcn0);

fs/ntfs3/attrib.c

2481

struct runs_tree *run = &ni->file.run;

fs/ntfs3/attrib.c

2542

err = attr_set_size(ni, ATTR_DATA, NULL, 0, run,

fs/ntfs3/attrib.c

256

u64 new_size, struct runs_tree *run,

fs/ntfs3/attrib.c

2598

run_truncate(run, 0); /* clear cached values. */

fs/ntfs3/attrib.c

2599

err = attr_load_runs(attr, ni, run, NULL);

fs/ntfs3/attrib.c

2603

err = run_insert_range(run, vcn, len);

fs/ntfs3/attrib.c

2612

err = mi_pack_runs(mi, attr, run, evcn1 + len - svcn);

fs/ntfs3/attrib.c

2630

err = ni_insert_nonresident(ni, ATTR_DATA, NULL, 0, run,

fs/ntfs3/attrib.c

2670

run_truncate(run, 0); /* clear cached values. */

fs/ntfs3/attrib.c

2702

if (attr_load_runs(attr, ni, run, NULL))

fs/ntfs3/attrib.c

2705

if (!run_collapse_range(run, vcn, len, 0))

fs/ntfs3/attrib.c

2708

if (mi_pack_runs(mi, attr, run, evcn1 + len - svcn))

fs/ntfs3/attrib.c

2751

&ni->file.run, &attr, NULL);

fs/ntfs3/attrib.c

291

run_init(run);

fs/ntfs3/attrib.c

306

err = attr_allocate_clusters(sbi, run, NULL, 0, 0, len, NULL,

fs/ntfs3/attrib.c

315

err = ntfs_sb_write_run(sbi, run, 0, data, rsize, 0);

fs/ntfs3/attrib.c

346

attr_s->name_len, run, 0, alen,

fs/ntfs3/attrib.c

371

run_deallocate(sbi, run, false);

fs/ntfs3/attrib.c

372

run_close(run);

fs/ntfs3/attrib.c

384

u64 new_size, struct runs_tree *run,

fs/ntfs3/attrib.c

402

run, ins_attr, NULL);

fs/ntfs3/attrib.c

431

const __le16 *name, u8 name_len, struct runs_tree *run,

fs/ntfs3/attrib.c

449

struct runs_tree *run_da = run == &ni->file.run ? &ni->file.run_da :

fs/ntfs3/attrib.c

466

err = attr_set_size_res(ni, attr_b, le_b, mi_b, new_size, run,

fs/ntfs3/attrib.c

568

err = attr_load_runs(attr, ni, run, NULL);

fs/ntfs3/attrib.c

61

struct runs_tree *run, const CLST *vcn)

fs/ntfs3/attrib.c

610

!run_lookup_entry(run, vcn, &lcn, NULL, NULL)) {

fs/ntfs3/attrib.c

632

if (!run_add_entry(run, vcn, SPARSE_LCN, to_allocate,

fs/ntfs3/attrib.c

641

sbi, run, run_da, vcn, lcn, to_allocate,

fs/ntfs3/attrib.c

662

err = mi_pack_runs(mi, attr, run, vcn - svcn);

fs/ntfs3/attrib.c

69

if (svcn >= evcn + 1 || run_is_mapped_full(run, svcn, evcn))

fs/ntfs3/attrib.c

720

err = ni_insert_nonresident(ni, type, name, name_len, run,

fs/ntfs3/attrib.c

744

run_truncate_head(run, evcn + 1);

fs/ntfs3/attrib.c

775

err = mi_pack_runs(mi, attr, run, vcn - svcn);

fs/ntfs3/attrib.c

81

err = run_unpack_ex(run, ni->mi.sbi, ni->mi.rno, svcn, evcn,

fs/ntfs3/attrib.c

820

err = run_deallocate_ex(sbi, run, vcn, evcn - vcn + 1, &dlen,

fs/ntfs3/attrib.c

831

run_truncate(run, vcn);

fs/ntfs3/attrib.c

927

if (mi_pack_runs(mi, attr, run, evcn - svcn + 1))

fs/ntfs3/attrib.c

93

static int run_deallocate_ex(struct ntfs_sb_info *sbi, struct runs_tree *run,

fs/ntfs3/attrib.c

931

run_deallocate_ex(sbi, run, vcn, alen, NULL, false, run_da);

fs/ntfs3/attrib.c

933

run_truncate(run, vcn);

fs/ntfs3/attrib.c

968

} else if (run_lookup_entry(&ni->file.run, vcn, lcn, len, NULL)) {

fs/ntfs3/attrlist.c

109

err = ntfs_read_run_nb(ni->mi.sbi, &ni->attr_list.run, 0, le,

fs/ntfs3/attrlist.c

31

run_close(&ni->attr_list.run);

fs/ntfs3/attrlist.c

348

err = attr_set_size_ex(ni, ATTR_LIST, NULL, 0, &al->run, new_size,

fs/ntfs3/attrlist.c

360

err = ntfs_sb_write_run(ni->mi.sbi, &al->run, 0, al->le,

fs/ntfs3/attrlist.c

407

err = attr_set_size_ex(ni, ATTR_LIST, NULL, 0, &al->run, al->size, NULL,

fs/ntfs3/attrlist.c

415

err = ntfs_sb_write_run(ni->mi.sbi, &al->run, 0, al->le,

fs/ntfs3/attrlist.c

79

run_init(&ni->attr_list.run);

fs/ntfs3/attrlist.c

86

err = run_unpack_ex(&ni->attr_list.run, ni->mi.sbi, ni->mi.rno,

fs/ntfs3/bitmap.c

129

run_close(&wnd->run);

fs/ntfs3/bitmap.c

1372

err = ntfs_vbo_to_lbo(sbi, &wnd->run, vbo, &lbo, &bytes);

fs/ntfs3/bitmap.c

554

if (!run_lookup_entry(&wnd->run, vbo >> cluster_bits,

fs/ntfs3/bitmap.c

709

if (!run_lookup_entry(&wnd->run, vbo >> sbi->cluster_bits, &lcn, &clen,

fs/ntfs3/file.c

1417

err = attr_set_size(ni, ATTR_DATA, NULL, 0, &ni->file.run,

fs/ntfs3/file.c

415

err = attr_set_size_ex(ni, ATTR_DATA, NULL, 0, &ni->file.run, new_size,

fs/ntfs3/file.c

689

&ni->file.run, i_size, &ni->i_valid,

fs/ntfs3/frecord.c

1198

struct runs_tree *run = &ni->file.run;

fs/ntfs3/frecord.c

125

run_close(&ni->file.run);

fs/ntfs3/frecord.c

1255

err = run_pack(run, 0, svcn, Add2Ptr(attr, SIZEOF_NONRESIDENT),

fs/ntfs3/frecord.c

1275

err = run_pack(run, svcn, evcn + 1 - svcn, NULL, sbi->record_size,

fs/ntfs3/frecord.c

1310

run_pack(run, svcn, evcn + 1 - svcn, Add2Ptr(attr, SIZEOF_NONRESIDENT),

fs/ntfs3/frecord.c

1395

const struct runs_tree *run, CLST svcn, CLST len,

fs/ntfs3/frecord.c

1411

err = run_pack(run, svcn, len, NULL, sbi->max_bytes_per_attr - run_off,

fs/ntfs3/frecord.c

1441

run_pack(run, svcn, len, Add2Ptr(attr, run_off), run_size, &plen);

fs/ntfs3/frecord.c

1569

run_deallocate(ni->mi.sbi, &ni->attr_list.run, true);

fs/ntfs3/frecord.c

1768

struct runs_tree run;

fs/ntfs3/frecord.c

1770

run_init(&run);

fs/ntfs3/frecord.c

1772

if (!attr_load_runs_vcn(ni, ATTR_REPARSE, NULL, 0, &run, 0) &&

fs/ntfs3/frecord.c

1773

!ntfs_read_run_nb(ni->mi.sbi, &run, 0, buffer,

fs/ntfs3/frecord.c

1779

run_close(&run);

fs/ntfs3/frecord.c

2238

struct runs_tree *run = &ni->file.run;

fs/ntfs3/frecord.c

2320

run = NULL;

fs/ntfs3/frecord.c

2322

run = run_alloc();

fs/ntfs3/frecord.c

2323

if (!run) {

fs/ntfs3/frecord.c

2331

err = attr_wof_frame_info(ni, attr, run, frame64, frames,

fs/ntfs3/frecord.c

2363

ARRAY_SIZE(WOF_NAME), run, vbo_disk,

fs/ntfs3/frecord.c

2381

run_truncate_around(run, le64_to_cpu(attr->nres.svcn));

fs/ntfs3/frecord.c

2384

run);

fs/ntfs3/frecord.c

2400

err = ntfs_read_run(sbi, run, frame_mem, frame_vbo,

fs/ntfs3/frecord.c

2421

err = ntfs_read_run(sbi, run, frame_ondisk, vbo_disk, ondisk_size);

fs/ntfs3/frecord.c

2427

if (run != &ni->file.run) {

fs/ntfs3/frecord.c

2452

if (run != &ni->file.run)

fs/ntfs3/frecord.c

2453

run_free(run);

fs/ntfs3/frecord.c

2458

err = ntfs_write_run(sbi, &ni->file.run, frame_mem, frame_vbo,

fs/ntfs3/frecord.c

2516

&ni->file.run, &attr, pages[0]);

fs/ntfs3/frecord.c

2581

run_truncate_around(&ni->file.run, le64_to_cpu(attr->nres.svcn));

fs/ntfs3/frecord.c

2591

err = ntfs_write_run(sbi, &ni->file.run,

fs/ntfs3/frecord.c

3293

err = attr_set_size_ex(ni, ATTR_DATA, NULL, 0, &ni->file.run,

fs/ntfs3/frecord.c

487

struct runs_tree run;

fs/ntfs3/frecord.c

489

run_init(&run);

fs/ntfs3/frecord.c

525

run_close(&run);

fs/ntfs3/frecord.c

535

err = run_unpack(&run, sbi, ni->mi.rno, svcn, evcn, svcn,

fs/ntfs3/frecord.c

555

err = mi_pack_runs(mi_p, attr_p, &run, evcn + 1 - svcn_p);

fs/ntfs3/frecord.c

574

err = mi_pack_runs(mi, attr, &run,

fs/ntfs3/frecord.c

585

run_truncate_head(&run, next_svcn);

fs/ntfs3/frecord.c

595

mi_pack_runs(mi_p, attr_p, &run, evcn_p + 1 - svcn_p);

fs/ntfs3/frecord.c

598

run_close(&run);

fs/ntfs3/frecord.c

732

run_deallocate(sbi, &ni->attr_list.run, true);

fs/ntfs3/frecord.c

733

run_close(&ni->attr_list.run);

fs/ntfs3/fslog.c

1169

err = ntfs_read_run_nb_ra(ni->mi.sbi, &ni->file.run, page_vbo, page_buf,

fs/ntfs3/fslog.c

2215

&log->ni->file.run, off, page,

fs/ntfs3/fslog.c

4773

oa->run1 = &ni_oe->file.run;

fs/ntfs3/fslog.c

5175

err = ntfs_sb_write_run(sbi, &ni->file.run, 0, rh, log->page_size, 0);

fs/ntfs3/fslog.c

5177

err = ntfs_sb_write_run(sbi, &log->ni->file.run, log->page_size,

fs/ntfs3/fsntfs.c

1120

int ntfs_sb_write_run(struct ntfs_sb_info *sbi, const struct runs_tree *run,

fs/ntfs3/fsntfs.c

1130

if (!run_lookup_entry(run, vcn, &lcn, &clen, &idx))

fs/ntfs3/fsntfs.c

1151

if (!run_get_entry(run, ++idx, &vcn, &lcn, &clen) ||

fs/ntfs3/fsntfs.c

1169

const struct runs_tree *run, u64 vbo)

fs/ntfs3/fsntfs.c

1176

if (!run_lookup_entry(run, vbo >> cluster_bits, &lcn, NULL, NULL))

fs/ntfs3/fsntfs.c

1184

int ntfs_read_run_nb_ra(struct ntfs_sb_info *sbi, const struct runs_tree *run,

fs/ntfs3/fsntfs.c

1201

if (!run) {

fs/ntfs3/fsntfs.c

1211

} else if (!run_lookup_entry(run, vcn, &lcn, &clen, &idx)) {

fs/ntfs3/fsntfs.c

1282

if (!run) {

fs/ntfs3/fsntfs.c

1289

if (!run_get_entry(run, ++idx, &vcn, &lcn, &clen) ||

fs/ntfs3/fsntfs.c

1322

int ntfs_read_bh_ra(struct ntfs_sb_info *sbi, const struct runs_tree *run,

fs/ntfs3/fsntfs.c

1326

int err = ntfs_read_run_nb_ra(sbi, run, vbo, rhdr, bytes, nb, ra);

fs/ntfs3/fsntfs.c

1333

int ntfs_get_bh(struct ntfs_sb_info *sbi, const struct runs_tree *run, u64 vbo,

fs/ntfs3/fsntfs.c

1349

if (!run_lookup_entry(run, vcn, &lcn, &clen, &idx)) {

fs/ntfs3/fsntfs.c

1411

if (!run_get_entry(run, ++idx, &vcn, &lcn, &clen) ||

fs/ntfs3/fsntfs.c

1512

int ntfs_read_write_run(struct ntfs_sb_info *sbi, const struct runs_tree *run,

fs/ntfs3/fsntfs.c

1529

if (!run_lookup_entry(run, vcn, &lcn, &clen, &idx))

fs/ntfs3/fsntfs.c

1579

if (!run_get_entry(run, ++idx, &vcn, &lcn, &clen) ||

fs/ntfs3/fsntfs.c

1598

int ntfs_bio_fill_1(struct ntfs_sb_info *sbi, const struct runs_tree *run)

fs/ntfs3/fsntfs.c

1622

if (!run_lookup_entry(run, 0, &lcn, &clen, &run_idx)) {

fs/ntfs3/fsntfs.c

1654

} while (run_get_entry(run, ++run_idx, NULL, &lcn, &clen));

fs/ntfs3/fsntfs.c

1668

int ntfs_vbo_to_lbo(struct ntfs_sb_info *sbi, const struct runs_tree *run,

fs/ntfs3/fsntfs.c

1675

if (!run_lookup_entry(run, vbo >> cluster_bits, &lcn, &len, NULL))

fs/ntfs3/fsntfs.c

2041

err = ntfs_read_run_nb(sbi, &ni->file.run,

fs/ntfs3/fsntfs.c

2052

err = ntfs_read_run_nb(sbi, &ni->file.run,

fs/ntfs3/fsntfs.c

2149

err = ntfs_read_run_nb(sbi, &ni->file.run,

fs/ntfs3/fsntfs.c

2205

err = ntfs_sb_write_run(sbi, &ni->file.run, sbi->security.next_off,

fs/ntfs3/fsntfs.c

2216

ARRAY_SIZE(SDS_NAME), &ni->file.run,

fs/ntfs3/fsntfs.c

2223

err = ntfs_sb_write_run(sbi, &ni->file.run, mirr_off, d_security,

fs/ntfs3/fsntfs.c

2550

int run_deallocate(struct ntfs_sb_info *sbi, const struct runs_tree *run,

fs/ntfs3/fsntfs.c

2556

while (run_get_entry(run, idx++, NULL, &lcn, &len)) {

fs/ntfs3/fsntfs.c

341

err = ntfs_bio_fill_1(sbi, &ni->file.run);

fs/ntfs3/fsntfs.c

535

err = attr_set_size_ex(ni, ATTR_DATA, NULL, 0, &ni->file.run,

fs/ntfs3/fsntfs.c

550

err = attr_set_size(ni, ATTR_BITMAP, NULL, 0, &sbi->mft.bitmap.run,

fs/ntfs3/fsntfs.c

798

struct runs_tree *run;

fs/ntfs3/fsntfs.c

806

run = &ni->file.run;

fs/ntfs3/fsntfs.c

813

err = ntfs_get_bh(sbi, run, vbo, rs, &nb);

fs/ntfs3/fsntfs.c

850

if (!run_lookup_entry(&ni->file.run, vcn - 1, &lcn, &len, NULL))

fs/ntfs3/index.c

1041

struct runs_tree *run = &indx->alloc_run;

fs/ntfs3/index.c

1066

err = ntfs_read_bh_ra(sbi, run, vbo, &ib->rhdr, bytes, &in->nb, ra);

fs/ntfs3/index.c

1080

run, vbo, vbo + bytes);

fs/ntfs3/index.c

1086

err = ntfs_read_bh_ra(sbi, run, vbo, &ib->rhdr, bytes, &in->nb, ra);

fs/ntfs3/index.c

1445

struct runs_tree run;

fs/ntfs3/index.c

1447

run_init(&run);

fs/ntfs3/index.c

1449

err = attr_allocate_clusters(sbi, &run, NULL, 0, 0, len, NULL,

fs/ntfs3/index.c

1455

&run, 0, len, 0, &alloc, NULL, NULL);

fs/ntfs3/index.c

1471

memcpy(&indx->alloc_run, &run, sizeof(run));

fs/ntfs3/index.c

1481

run_deallocate(sbi, &run, false);

fs/ntfs3/index.c

366

struct runs_tree *run = &indx->bitmap_run;

fs/ntfs3/index.c

391

ok = run_lookup_entry(run, vcn, &lcn, &clen, &idx);

fs/ntfs3/index.c

401

name->name_len, run, vcn);

fs/ntfs3/index.c

406

ok = run_lookup_entry(run, vcn, &lcn, &clen, &idx);

fs/ntfs3/index.c

450

ok = run_get_entry(run, ++idx, &vcn, &lcn, &clen) && vcn == vcn_next;

fs/ntfs3/inode.c

122

run = NULL;

fs/ntfs3/inode.c

133

run = &ni->file.run;

fs/ntfs3/inode.c

1597

err = attr_allocate_clusters(sbi, &ni->file.run, NULL,

fs/ntfs3/inode.c

1604

err = run_pack(&ni->file.run, 0, clst,

fs/ntfs3/inode.c

1617

err = ntfs_sb_write_run(sbi, &ni->file.run, 0, rp,

fs/ntfs3/inode.c

1739

struct runs_tree run;

fs/ntfs3/inode.c

1740

run_init(&run);

fs/ntfs3/inode.c

1741

attr_set_size(ni, ATTR_EA, NULL, 0, &run, 0, NULL, false);

fs/ntfs3/inode.c

1742

run_close(&run);

fs/ntfs3/inode.c

1750

run_deallocate(sbi, &ni->file.run, false);

fs/ntfs3/inode.c

2010

err = ntfs_read_run_nb(sbi, &ni->file.run, 0, rp, size, NULL);

fs/ntfs3/inode.c

269

run = ino == MFT_REC_BITMAP ? &sbi->used.bitmap.run :

fs/ntfs3/inode.c

270

&ni->file.run;

fs/ntfs3/inode.c

311

run = &ni->dir.alloc_run;

fs/ntfs3/inode.c

323

run = &sbi->mft.bitmap.run;

fs/ntfs3/inode.c

329

run = &ni->dir.bitmap_run;

fs/ntfs3/inode.c

355

run_close(&ni->file.run);

fs/ntfs3/inode.c

360

run = &ni->file.run;

fs/ntfs3/inode.c

400

err = run_unpack_ex(run, sbi, ino, t64, le64_to_cpu(attr->nres.evcn),

fs/ntfs3/inode.c

47

struct runs_tree *run;

fs/ntfs3/inode.c

65

if (!run_add_entry(&ni->file.run, 0, t64, t32, true)) {

fs/ntfs3/inode.c

743

err = attr_set_size(ni, ATTR_DATA, NULL, 0, &ni->file.run, new_size,

fs/ntfs3/ntfs_fs.h

1002

static inline void run_close(struct runs_tree *run)

fs/ntfs3/ntfs_fs.h

1004

kvfree(run->runs);

fs/ntfs3/ntfs_fs.h

1005

memset(run, 0, sizeof(*run));

fs/ntfs3/ntfs_fs.h

1008

static inline void run_free(struct runs_tree *run)

fs/ntfs3/ntfs_fs.h

1010

if (run) {

fs/ntfs3/ntfs_fs.h

1011

kvfree(run->runs);

fs/ntfs3/ntfs_fs.h

1012

kfree(run);

fs/ntfs3/ntfs_fs.h

1016

static inline bool run_is_empty(struct runs_tree *run)

fs/ntfs3/ntfs_fs.h

1018

return !run->count;

fs/ntfs3/ntfs_fs.h

1242

struct runs_tree *run, CLST vcn)

fs/ntfs3/ntfs_fs.h

1245

attr->name_len, run, vcn);

fs/ntfs3/ntfs_fs.h

150

struct runs_tree run;

fs/ntfs3/ntfs_fs.h

403

struct runs_tree run;

fs/ntfs3/ntfs_fs.h

417

struct runs_tree run;

fs/ntfs3/ntfs_fs.h

448

int attr_allocate_clusters(struct ntfs_sb_info *sbi, struct runs_tree *run,

fs/ntfs3/ntfs_fs.h

455

u64 new_size, struct runs_tree *run,

fs/ntfs3/ntfs_fs.h

458

const __le16 *name, u8 name_len, struct runs_tree *run,

fs/ntfs3/ntfs_fs.h

463

struct runs_tree *run, u64 new_size,

fs/ntfs3/ntfs_fs.h

466

return attr_set_size_ex(ni, type, name, name_len, run, new_size,

fs/ntfs3/ntfs_fs.h

477

const __le16 *name, u8 name_len, struct runs_tree *run,

fs/ntfs3/ntfs_fs.h

480

const __le16 *name, u8 name_len, struct runs_tree *run,

fs/ntfs3/ntfs_fs.h

483

struct runs_tree *run, u64 frame, u64 frames,

fs/ntfs3/ntfs_fs.h

487

struct runs_tree *run);

fs/ntfs3/ntfs_fs.h

576

const struct runs_tree *run, CLST svcn, CLST len,

fs/ntfs3/ntfs_fs.h

657

int ntfs_sb_write_run(struct ntfs_sb_info *sbi, const struct runs_tree *run,

fs/ntfs3/ntfs_fs.h

660

const struct runs_tree *run, u64 vbo);

fs/ntfs3/ntfs_fs.h

661

int ntfs_read_run_nb_ra(struct ntfs_sb_info *sbi, const struct runs_tree *run,

fs/ntfs3/ntfs_fs.h

665

const struct runs_tree *run, u64 vbo,

fs/ntfs3/ntfs_fs.h

669

return ntfs_read_run_nb_ra(sbi, run, vbo, buf, bytes, nb, NULL);

fs/ntfs3/ntfs_fs.h

671

int ntfs_read_bh_ra(struct ntfs_sb_info *sbi, const struct runs_tree *run,

fs/ntfs3/ntfs_fs.h

675

const struct runs_tree *run, u64 vbo,

fs/ntfs3/ntfs_fs.h

679

return ntfs_read_bh_ra(sbi, run, vbo, rhdr, bytes, nb, NULL);

fs/ntfs3/ntfs_fs.h

682

int ntfs_get_bh(struct ntfs_sb_info *sbi, const struct runs_tree *run, u64 vbo,

fs/ntfs3/ntfs_fs.h

686

int ntfs_read_write_run(struct ntfs_sb_info *sbi, const struct runs_tree *run,

fs/ntfs3/ntfs_fs.h

689

const struct runs_tree *run, void *buf, u64 vbo,

fs/ntfs3/ntfs_fs.h

692

return ntfs_read_write_run(sbi, run, buf, vbo, bytes, 0);

fs/ntfs3/ntfs_fs.h

695

const struct runs_tree *run, void *buf,

fs/ntfs3/ntfs_fs.h

698

return ntfs_read_write_run(sbi, run, buf, vbo, bytes, 1);

fs/ntfs3/ntfs_fs.h

701

int ntfs_bio_fill_1(struct ntfs_sb_info *sbi, const struct runs_tree *run);

fs/ntfs3/ntfs_fs.h

702

int ntfs_vbo_to_lbo(struct ntfs_sb_info *sbi, const struct runs_tree *run,

fs/ntfs3/ntfs_fs.h

723

int run_deallocate(struct ntfs_sb_info *sbi, const struct runs_tree *run,

fs/ntfs3/ntfs_fs.h

830

const struct runs_tree *run, CLST len);

fs/ntfs3/ntfs_fs.h

858

bool run_lookup_entry(const struct runs_tree *run, CLST vcn, CLST *lcn,

fs/ntfs3/ntfs_fs.h

860

void run_truncate(struct runs_tree *run, CLST vcn);

fs/ntfs3/ntfs_fs.h

861

void run_truncate_head(struct runs_tree *run, CLST vcn);

fs/ntfs3/ntfs_fs.h

862

void run_truncate_around(struct runs_tree *run, CLST vcn);

fs/ntfs3/ntfs_fs.h

863

bool run_add_entry(struct runs_tree *run, CLST vcn, CLST lcn, CLST len,

fs/ntfs3/ntfs_fs.h

865

bool run_collapse_range(struct runs_tree *run, CLST vcn, CLST len, CLST sub);

fs/ntfs3/ntfs_fs.h

866

int run_insert_range(struct runs_tree *run, CLST vcn, CLST len);

fs/ntfs3/ntfs_fs.h

867

int run_insert_range_da(struct runs_tree *run, CLST vcn, CLST len);

fs/ntfs3/ntfs_fs.h

868

bool run_get_entry(const struct runs_tree *run, size_t index, CLST *vcn,

fs/ntfs3/ntfs_fs.h

870

bool run_is_mapped_full(const struct runs_tree *run, CLST svcn, CLST evcn);

fs/ntfs3/ntfs_fs.h

872

int run_pack(const struct runs_tree *run, CLST svcn, CLST len, u8 *run_buf,

fs/ntfs3/ntfs_fs.h

874

int run_unpack(struct runs_tree *run, struct ntfs_sb_info *sbi, CLST ino,

fs/ntfs3/ntfs_fs.h

879

int run_unpack_ex(struct runs_tree *run, struct ntfs_sb_info *sbi, CLST ino,

fs/ntfs3/ntfs_fs.h

886

int run_clone(const struct runs_tree *run, struct runs_tree *new_run);

fs/ntfs3/ntfs_fs.h

887

bool run_remove_range(struct runs_tree *run, CLST vcn, CLST len, CLST *done);

fs/ntfs3/ntfs_fs.h

888

CLST run_len(const struct runs_tree *run);

fs/ntfs3/ntfs_fs.h

889

CLST run_get_max_vcn(const struct runs_tree *run);

fs/ntfs3/ntfs_fs.h

990

static inline void run_init(struct runs_tree *run)

fs/ntfs3/ntfs_fs.h

992

run->runs = NULL;

fs/ntfs3/ntfs_fs.h

993

run->count = 0;

fs/ntfs3/ntfs_fs.h

994

run->allocated = 0;

fs/ntfs3/record.c

123

struct runs_tree *run = mft_ni ? &mft_ni->file.run : NULL;

fs/ntfs3/record.c

133

err = ntfs_read_bh(sbi, run, vbo, &rec->rhdr, bpr, &mi->nb);

fs/ntfs3/record.c

151

err = attr_load_runs_vcn(mft_ni, ATTR_DATA, NULL, 0, run,

fs/ntfs3/record.c

162

err = ntfs_read_bh(sbi, run, vbo, &rec->rhdr, bpr, &mi->nb);

fs/ntfs3/record.c

461

err = ntfs_get_bh(sbi, &ni->file.run, vbo, sbi->record_size,

fs/ntfs3/record.c

624

const struct runs_tree *run, CLST len)

fs/ntfs3/record.c

645

err = run_pack(run, svcn, len, Add2Ptr(attr, run_off), run_size + dsize,

fs/ntfs3/run.c

1067

if (!run)

fs/ntfs3/run.c

1069

else if (run == RUN_DEALLOCATE) {

fs/ntfs3/run.c

1077

if (!run_add_entry(run, vcn64, lcn, len, is_mft))

fs/ntfs3/run.c

1082

if (!run_add_entry(run, vcn, lcn + dlen, len - dlen,

fs/ntfs3/run.c

1106

int run_unpack_ex(struct runs_tree *run, struct ntfs_sb_info *sbi, CLST ino,

fs/ntfs3/run.c

1116

ret = run_unpack(run, sbi, ino, svcn, evcn, vcn, run_buf, run_buf_size);

fs/ntfs3/run.c

1120

if (!sbi->used.bitmap.sb || !run || run == RUN_DEALLOCATE)

fs/ntfs3/run.c

1129

for (ok = run_lookup_entry(run, vcn, &lcn, &len, &index);

fs/ntfs3/run.c

1131

ok = run_get_entry(run, ++index, &vcn, &lcn, &len)) {

fs/ntfs3/run.c

1231

int run_clone(const struct runs_tree *run, struct runs_tree *new_run)

fs/ntfs3/run.c

1233

size_t bytes = run->count * sizeof(struct ntfs_run);

fs/ntfs3/run.c

1246

memcpy(new_run->runs, run->runs, bytes);

fs/ntfs3/run.c

1247

new_run->count = run->count;

fs/ntfs3/run.c

1255

bool run_remove_range(struct runs_tree *run, CLST vcn, CLST len, CLST *done)

fs/ntfs3/run.c

1264

if (!run->count)

fs/ntfs3/run.c

1267

if (!run_lookup(run, vcn, &index) && index >= run->count) {

fs/ntfs3/run.c

1273

e = run->runs + run->count;

fs/ntfs3/run.c

1274

r = run->runs + index;

fs/ntfs3/run.c

1285

return run_add_entry(run, end, r->lcn, r_end - end,

fs/ntfs3/run.c

1318

run->count -= eat;

fs/ntfs3/run.c

1323

CLST run_len(const struct runs_tree *run)

fs/ntfs3/run.c

1328

for (r = run->runs, e = r + run->count; r < e; r++) {

fs/ntfs3/run.c

1335

CLST run_get_max_vcn(const struct runs_tree *run)

fs/ntfs3/run.c

1338

if (!run->count)

fs/ntfs3/run.c

1341

r = run->runs + run->count - 1;

fs/ntfs3/run.c

155

i = run->count - (index + 1);

fs/ntfs3/run.c

159

run->count -= 1;

fs/ntfs3/run.c

168

bool run_is_mapped_full(const struct runs_tree *run, CLST svcn, CLST evcn)

fs/ntfs3/run.c

174

if (!run_lookup(run, svcn, &i))

fs/ntfs3/run.c

177

end = run->runs + run->count;

fs/ntfs3/run.c

178

r = run->runs + i;

fs/ntfs3/run.c

193

bool run_lookup_entry(const struct runs_tree *run, CLST vcn, CLST *lcn,

fs/ntfs3/run.c

201

if (!run->runs)

fs/ntfs3/run.c

204

if (!run_lookup(run, vcn, &idx))

fs/ntfs3/run.c

207

r = run->runs + idx;

fs/ntfs3/run.c

229

void run_truncate_head(struct runs_tree *run, CLST vcn)

fs/ntfs3/run.c

234

if (run_lookup(run, vcn, &index)) {

fs/ntfs3/run.c

235

r = run->runs + index;

fs/ntfs3/run.c

249

r = run->runs;

fs/ntfs3/run.c

250

memmove(r, r + index, sizeof(*r) * (run->count - index));

fs/ntfs3/run.c

252

run->count -= index;

fs/ntfs3/run.c

254

if (!run->count) {

fs/ntfs3/run.c

255

kvfree(run->runs);

fs/ntfs3/run.c

256

run->runs = NULL;

fs/ntfs3/run.c

257

run->allocated = 0;

fs/ntfs3/run.c

264

void run_truncate(struct runs_tree *run, CLST vcn)

fs/ntfs3/run.c

274

if (run_lookup(run, vcn, &index)) {

fs/ntfs3/run.c

275

struct ntfs_run *r = run->runs + index;

fs/ntfs3/run.c

288

run->count = index;

fs/ntfs3/run.c

292

kvfree(run->runs);

fs/ntfs3/run.c

293

run->runs = NULL;

fs/ntfs3/run.c

294

run->allocated = 0;

fs/ntfs3/run.c

301

void run_truncate_around(struct runs_tree *run, CLST vcn)

fs/ntfs3/run.c

303

run_truncate_head(run, vcn);

fs/ntfs3/run.c

305

if (run->count >= NTFS3_RUN_MAX_BYTES / sizeof(struct ntfs_run) / 2)

fs/ntfs3/run.c

306

run_truncate(run, (run->runs + (run->count >> 1))->vcn);

fs/ntfs3/run.c

317

bool run_add_entry(struct runs_tree *run, CLST vcn, CLST lcn, CLST len,

fs/ntfs3/run.c

332

inrange = run_lookup(run, vcn, &index);

fs/ntfs3/run.c

342

struct ntfs_run *t = run->runs + index - 1;

fs/ntfs3/run.c

35

static bool run_lookup(const struct runs_tree *run, CLST vcn, size_t *index)

fs/ntfs3/run.c

364

used = run->count * sizeof(struct ntfs_run);

fs/ntfs3/run.c

371

if (run->allocated < used + sizeof(struct ntfs_run)) {

fs/ntfs3/run.c

379

if (is_power_of_2(run->allocated))

fs/ntfs3/run.c

380

bytes = run->allocated << 1;

fs/ntfs3/run.c

385

bytes = run->allocated + (16 * PAGE_SIZE);

fs/ntfs3/run.c

396

memcpy(new_ptr, run->runs,

fs/ntfs3/run.c

398

memcpy(r + 1, run->runs + index,

fs/ntfs3/run.c

399

sizeof(struct ntfs_run) * (run->count - index));

fs/ntfs3/run.c

40

if (!run->count) {

fs/ntfs3/run.c

401

kvfree(run->runs);

fs/ntfs3/run.c

402

run->runs = new_ptr;

fs/ntfs3/run.c

403

run->allocated = bytes;

fs/ntfs3/run.c

406

size_t i = run->count - index;

fs/ntfs3/run.c

408

r = run->runs + index;

fs/ntfs3/run.c

418

run->count += 1;

fs/ntfs3/run.c

420

r = run->runs + index;

fs/ntfs3/run.c

46

max_idx = run->count - 1;

fs/ntfs3/run.c

471

run_consolidate(run, index);

fs/ntfs3/run.c

472

run_consolidate(run, index + 1);

fs/ntfs3/run.c

479

!run_add_entry(run, tail_vcn, tail_lcn, tail_len, is_mft))

fs/ntfs3/run.c

49

r = run->runs;

fs/ntfs3/run.c

491

bool run_collapse_range(struct runs_tree *run, CLST vcn, CLST len, CLST sub)

fs/ntfs3/run.c

497

if (!run_lookup(run, vcn, &index) && index >= run->count) {

fs/ntfs3/run.c

501

e = run->runs + run->count;

fs/ntfs3/run.c

502

r = run->runs + index;

fs/ntfs3/run.c

514

if (!run_add_entry(run, vcn, SPARSE_LCN, len, false))

fs/ntfs3/run.c

516

return run_collapse_range(run, vcn, len, sub);

fs/ntfs3/run.c

548

run->count -= eat;

fs/ntfs3/run.c

552

for (r = run->runs; r < e; r++) {

fs/ntfs3/run.c

565

int run_insert_range(struct runs_tree *run, CLST vcn, CLST len)

fs/ntfs3/run.c

570

if (WARN_ON(!run_lookup(run, vcn, &index)))

fs/ntfs3/run.c

573

e = run->runs + run->count;

fs/ntfs3/run.c

574

r = run->runs + index;

fs/ntfs3/run.c

582

r = run->runs + index;

fs/ntfs3/run.c

592

if (!run_add_entry(run, vcn + len, lcn2, len2, false))

fs/ntfs3/run.c

596

if (!run_add_entry(run, vcn, SPARSE_LCN, len, false))

fs/ntfs3/run.c

607

int run_insert_range_da(struct runs_tree *run, CLST vcn, CLST len)

fs/ntfs3/run.c

609

struct ntfs_run *r, *r0 = NULL, *e = run->runs + run->count;

fs/ntfs3/run.c

612

for (r = run->runs; r < e; r++) {

fs/ntfs3/run.c

62

*index = run->count;

fs/ntfs3/run.c

631

if (!run_add_entry(run, vcn + len, SPARSE_LCN, len2, false))

fs/ntfs3/run.c

641

bool run_get_entry(const struct runs_tree *run, size_t index, CLST *vcn,

fs/ntfs3/run.c

646

if (index >= run->count)

fs/ntfs3/run.c

649

r = run->runs + index;

fs/ntfs3/run.c

73

r = run->runs + mid_idx;

fs/ntfs3/run.c

863

int run_pack(const struct runs_tree *run, CLST svcn, CLST len, u8 *run_buf,

fs/ntfs3/run.c

881

if (!run_lookup(run, svcn, &i))

fs/ntfs3/run.c

884

r_end = run->runs + run->count;

fs/ntfs3/run.c

885

r = run->runs + i;

fs/ntfs3/run.c

894

r = run->runs + i;

fs/ntfs3/run.c

94

static void run_consolidate(struct runs_tree *run, size_t index)

fs/ntfs3/run.c

966

int run_unpack(struct runs_tree *run, struct ntfs_sb_info *sbi, CLST ino,

fs/ntfs3/run.c

97

struct ntfs_run *r = run->runs + index;

fs/ntfs3/run.c

99

while (index + 1 < run->count) {

fs/ntfs3/super.c

1493

for (i = 0; run_get_entry(&ni->file.run, i, &vcn, &lcn, &len); i++) {

fs/ntfs3/xattr.c

123

struct runs_tree run;

fs/ntfs3/xattr.c

125

run_init(&run);

fs/ntfs3/xattr.c

127

err = attr_load_runs_range(ni, ATTR_EA, NULL, 0, &run, 0, size);

fs/ntfs3/xattr.c

129

err = ntfs_read_run_nb(sbi, &run, 0, ea_p, size, NULL);

fs/ntfs3/xattr.c

130

run_close(&run);

fs/omfs/bitmap.c

139

int i, run, bit;

fs/omfs/bitmap.c

151

run = count_run(&sbi->s_imap[i], bits_per_entry,

fs/omfs/bitmap.c

154

if (run >= min_request)

fs/omfs/bitmap.c

156

bit += run;

fs/omfs/bitmap.c

164

*return_size = run;

fs/omfs/bitmap.c

165

ret = set_run(sb, i, bits_per_entry, bit, run, 1);

fs/xfs/scrub/repair.c

64

struct xchk_stats_run *run)

fs/xfs/scrub/repair.c

76

run->repair_attempted = true;

fs/xfs/scrub/repair.c

80

run->repair_ns += xchk_stats_elapsed_ns(repair_start);

fs/xfs/scrub/repair.c

89

run->repair_succeeded = true;

fs/xfs/scrub/repair.c

93

run->retries++;

fs/xfs/scrub/repair.c

99

run->retries++;

fs/xfs/scrub/repair.h

196

struct xchk_stats_run *run)

fs/xfs/scrub/repair.h

23

int xrep_attempt(struct xfs_scrub *sc, struct xchk_stats_run *run);

fs/xfs/scrub/scrub.c

660

struct xchk_stats_run run = { };

fs/xfs/scrub/scrub.c

723

run.scrub_ns += xchk_stats_elapsed_ns(check_start);

fs/xfs/scrub/scrub.c

747

error = xrep_attempt(sc, &run);

fs/xfs/scrub/scrub.c

769

xchk_stats_merge(mp, sm, &run);

fs/xfs/scrub/scrub.c

783

run.retries++;

fs/xfs/scrub/scrub.c

795

run.retries++;

fs/xfs/scrub/stats.c

191

const struct xchk_stats_run *run)

fs/xfs/scrub/stats.c

217

css->retries += run->retries;

fs/xfs/scrub/stats.c

218

css->checktime_us += howmany_64(run->scrub_ns, NSEC_PER_USEC);

fs/xfs/scrub/stats.c

220

if (run->repair_attempted)

fs/xfs/scrub/stats.c

222

if (run->repair_succeeded)

fs/xfs/scrub/stats.c

224

css->repairtime_us += howmany_64(run->repair_ns, NSEC_PER_USEC);

fs/xfs/scrub/stats.c

233

const struct xchk_stats_run *run)

fs/xfs/scrub/stats.c

235

xchk_stats_merge_one(&global_stats, sm, run);

fs/xfs/scrub/stats.c

236

xchk_stats_merge_one(mp->m_scrub_stats, sm, run);

fs/xfs/scrub/stats.h

30

const struct xchk_stats_run *run);

fs/xfs/scrub/stats.h

56

# define xchk_stats_merge(mp, sm, run) ((void)0)

include/linux/arm_ffa.h

485

int (*run)(struct ffa_device *dev, u16 vcpu);

include/linux/jbd2.h

719

struct transaction_run_stats_s run;

include/linux/kvm_host.h

2454

vcpu->run->exit_reason = KVM_EXIT_INTR;

include/linux/kvm_host.h

2498

vcpu->run->exit_reason = KVM_EXIT_MEMORY_FAULT;

include/linux/kvm_host.h

2499

vcpu->run->memory_fault.gpa = gpa;

include/linux/kvm_host.h

2500

vcpu->run->memory_fault.size = size;

include/linux/kvm_host.h

2503

vcpu->run->memory_fault.flags = 0;

include/linux/kvm_host.h

2505

vcpu->run->memory_fault.flags |= KVM_MEMORY_EXIT_FLAG_PRIVATE;

include/linux/kvm_host.h

341

struct kvm_run *run;

include/linux/phy.h

2405

int (*run)(struct phy_device *));

include/linux/phy.h

2407

int (*run)(struct phy_device *));

include/net/libeth/xdp.h

1405

u32 (*run)(struct libeth_xdp_buff *xdp,

include/net/libeth/xdp.h

1417

act = run(xdp, bq);

include/net/libeth/xdp.h

1474

bool (*run)(struct libeth_xdp_buff *xdp,

include/net/libeth/xdp.h

1491

if (!bq || !run || !bq->prog)

include/net/libeth/xdp.h

1494

if (!run(xdp, bq))

include/net/libeth/xdp.h

1533

#define libeth_xdp_run_pass(xdp, bq, napi, ss, desc, run, populate) \

include/net/libeth/xdp.h

1535

run, populate)

include/net/libeth/xdp.h

1654

#define LIBETH_XDP_DEFINE_RUN_PASS(name, run, populate) \

include/net/libeth/xdp.h

1655

void __LIBETH_XDP_DEFINE_RUN_PASS(name, run, populate, xdp)

include/net/libeth/xdp.h

1657

#define __LIBETH_XDP_DEFINE_RUN_PASS(name, run, populate, pfx) \

include/net/libeth/xdp.h

1662

return libeth_##pfx##_run_pass(xdp, bq, napi, ss, desc, run, \

include/net/libeth/xdp.h

1673

#define LIBETH_XDP_DEFINE_RUN(name, run, flush, populate) \

include/net/libeth/xdp.h

1674

__LIBETH_XDP_DEFINE_RUN(name, run, flush, populate, XDP)

include/net/libeth/xdp.h

1676

#define __LIBETH_XDP_DEFINE_RUN(name, run, flush, populate, pfx) \

include/net/libeth/xdp.h

1677

LIBETH_##pfx##_DEFINE_RUN_PROG(static run, flush); \

include/net/libeth/xdp.h

1678

LIBETH_##pfx##_DEFINE_RUN_PASS(name, run, populate)

include/net/libeth/xsk.h

446

u32 (*run)(struct libeth_xdp_buff *xdp,

include/net/libeth/xsk.h

464

act = run(xdp, bq);

include/net/libeth/xsk.h

500

#define libeth_xsk_run_pass(xdp, bq, napi, rs, desc, run, populate) \

include/net/libeth/xsk.h

502

run, populate)

include/net/libeth/xsk.h

565

#define LIBETH_XSK_DEFINE_RUN_PASS(name, run, populate) \

include/net/libeth/xsk.h

566

bool __LIBETH_XDP_DEFINE_RUN_PASS(name, run, populate, xsk)

include/net/libeth/xsk.h

575

#define LIBETH_XSK_DEFINE_RUN(name, run, flush, populate) \

include/net/libeth/xsk.h

576

__LIBETH_XDP_DEFINE_RUN(name, run, flush, populate, XSK)

include/video/imx-ipu-image-convert.h

126

int ipu_image_convert_queue(struct ipu_image_convert_run *run);

include/video/imx-ipu-image-convert.h

40

typedef void (*ipu_image_convert_cb_t)(struct ipu_image_convert_run *run,

kernel/stop_machine.c

479

int run;

kernel/stop_machine.c

482

run = !list_empty(&stopper->works);

kernel/stop_machine.c

484

return run;

lib/dhry_run.c

23

module_param_cb(run, &run_ops, &dhry_run, 0200);

lib/dhry_run.c

24

MODULE_PARM_DESC(run, "Run the test (default: false)");

mm/ksm.c

3553

KSM_ATTR(run);

net/wireless/core.c

1749

bool run;

net/wireless/core.c

1754

run = !work || !list_empty(&work->entry);

net/wireless/core.c

1757

if (run)

sound/soc/qcom/qdsp6/q6asm.c

1006

struct asm_session_cmd_run_v2 *run;

sound/soc/qcom/qdsp6/q6asm.c

1008

int rc, pkt_size = APR_HDR_SIZE + sizeof(*run);

sound/soc/qcom/qdsp6/q6asm.c

1015

run = p + APR_HDR_SIZE;

sound/soc/qcom/qdsp6/q6asm.c

1020

run->flags = flags;

sound/soc/qcom/qdsp6/q6asm.c

1021

run->time_lsw = lsw_ts;

sound/soc/qcom/qdsp6/q6asm.c

1022

run->time_msw = msw_ts;

sound/soc/sof/amd/acp-common.c

217

.run = acp_sof_dsp_run,

sound/soc/sof/core.c

334

(!sof_ops(sdev)->run || !sof_ops(sdev)->block_read ||

sound/soc/sof/imx/imx-common.c

439

.run = imx_chip_core_kick,

sound/soc/sof/intel/apl.c

89

sof_apl_ops.run = hda_dsp_cl_boot_firmware;

sound/soc/sof/intel/bdw.c

569

.run = bdw_run,

sound/soc/sof/intel/byt.c

222

.run = atom_run,

sound/soc/sof/intel/byt.c

297

.run = atom_run,

sound/soc/sof/intel/cnl.c

439

sof_cnl_ops.run = hda_dsp_cl_boot_firmware;

sound/soc/sof/intel/hda-common-ops.c

70

.run = hda_dsp_cl_boot_firmware,

sound/soc/sof/intel/hda-loader-skl.c

140

u32 run = enable ? 0x1 : 0;

sound/soc/sof/intel/hda-loader-skl.c

144

HDA_CL_SD_CTL_RUN(1), HDA_CL_SD_CTL_RUN(run));

sound/soc/sof/intel/hda-stream.c

399

u32 run;

sound/soc/sof/intel/hda-stream.c

424

sd_offset, run,

sound/soc/sof/intel/hda-stream.c

425

((run & dma_start) == dma_start),

sound/soc/sof/intel/hda-stream.c

445

sd_offset, run,

sound/soc/sof/intel/hda-stream.c

446

!(run & dma_start),

sound/soc/sof/intel/hda-stream.c

565

u32 run;

sound/soc/sof/intel/hda-stream.c

592

sd_offset, run,

sound/soc/sof/intel/hda-stream.c

593

!(run & dma_start),

sound/soc/sof/intel/hda-stream.c

634

sd_offset, run,

sound/soc/sof/intel/hda-stream.c

635

!(run & dma_start),

sound/soc/sof/intel/icl.c

157

sof_icl_ops.run = hda_dsp_cl_boot_firmware_iccmax;

sound/soc/sof/intel/pci-tng.c

140

.run = atom_run,

sound/soc/sof/intel/skl.c

92

sof_skl_ops.run = hda_dsp_cl_boot_firmware_skl;

sound/soc/sof/intel/tgl.c

129

sof_tgl_ops.run = hda_dsp_cl_boot_firmware_iccmax;

sound/soc/sof/mediatek/mt8186/mt8186.c

389

.run = mt8186_run,

sound/soc/sof/mediatek/mt8195/mt8195.c

413

.run = mt8195_run,

sound/soc/sof/ops.h

82

return sof_ops(sdev)->run(sdev);

sound/soc/sof/sof-priv.h

175

int (*run)(struct snd_sof_dev *sof_dev); /* mandatory */

tools/firewire/nosy-dump.c

127

if (run == 1) {

tools/firewire/nosy-dump.c

128

run = 0;

tools/firewire/nosy-dump.c

36

static int run = 1;

tools/firewire/nosy-dump.c

973

while (run) {

tools/lib/perf/evsel.c

362

count->run = data[idx++];

tools/lib/perf/evsel.c

391

count->run = buf[n++];

tools/lib/perf/evsel.c

605

if (count->run == 0) {

tools/lib/perf/evsel.c

608

} else if (count->run < count->ena) {

tools/lib/perf/evsel.c

610

count->val = (u64)((double)count->val * count->ena / count->run);

tools/lib/perf/include/perf/event.h

438

__u64 run;

tools/lib/perf/include/perf/evsel.h

20

uint64_t run;

tools/lib/perf/mmap.c

494

count->run = READ_ONCE(pc->time_running);

tools/lib/perf/mmap.c

496

if (pc->cap_user_time && count->ena != count->run) {

tools/lib/perf/mmap.c

523

if (count->ena != count->run) {

tools/lib/perf/mmap.c

533

count->run += delta;

tools/lib/perf/tests/test-evlist.c

482

expected_counts.ena == expected_counts.run);

tools/lib/perf/tests/test-evlist.c

531

i, counts[i].val, counts[i].run, counts[i].ena);

tools/lib/perf/tests/test-evlist.c

537

(double)counts[i].run / (double)counts[i].ena * 100.0,

tools/lib/perf/tests/test-evlist.c

538

counts[i].run, counts[i].ena);

tools/lib/perf/tests/test-evsel.c

219

__T("failed to read TOTAL_TIME_RUNNING", counts.run);

tools/lib/perf/tests/test-evsel.c

265

__T("failed to read leader TOTAL_TIME_RUNNING", counts.run);

tools/lib/perf/tests/test-evsel.c

278

__T("failed to read member TOTAL_TIME_RUNNING", counts.run);

tools/perf/arch/x86/util/iostat.c

440

if (count && count->run && count->ena) {

tools/perf/arch/x86/util/iostat.c

449

((double) count->run / count->ena);

tools/perf/builtin-daemon.c

192

if (session->run)

tools/perf/builtin-daemon.c

193

same = !strcmp(session->run, value);

tools/perf/builtin-daemon.c

196

if (session->run) {

tools/perf/builtin-daemon.c

197

zfree(&session->run);

tools/perf/builtin-daemon.c

201

session->run = strdup(value);

tools/perf/builtin-daemon.c

202

if (!session->run)

tools/perf/builtin-daemon.c

345

session->name, session->pid, session->run);

tools/perf/builtin-daemon.c

384

daemon->perf, SESSION_CONTROL, SESSION_ACK, session->run);

tools/perf/builtin-daemon.c

715

csv_sep, session->run);

tools/perf/builtin-daemon.c

736

session->pid, session->name, session->run);

tools/perf/builtin-daemon.c

77

char *run;

tools/perf/builtin-daemon.c

928

zfree(&session->run);

tools/perf/builtin-script.c

2358

count->run = old_count->run + 1;

tools/perf/builtin-script.c

2592

counts->run,

tools/perf/builtin-stat.c

307

count->run = old_count->run + 1;

tools/perf/builtin-stat.c

310

count->run++;

tools/perf/builtin-stat.c

343

perf_counts(counter->counts, cpu_map_idx, thread)->run = 0;

tools/perf/builtin-stat.c

362

count->val, count->ena, count->run);

tools/perf/tests/builtin-test.c

647

for (unsigned int run = 0; run < runs_per_test; run++) {

tools/perf/tests/event-times.c

201

err = !(count.ena == count.run);

tools/perf/tests/event-times.c

205

count.ena, count.run);

tools/perf/tests/parse-metric.c

45

evsel->stats->aggr->counts.run = 1;

tools/perf/tests/stat.c

79

TEST_ASSERT_VAL("wrong ena", st->run == 300);

tools/perf/tests/stat.c

89

count.run = 300;

tools/perf/util/bpf_counter.c

306

counts->run = 0;

tools/perf/util/bpf_counter.c

328

counts->run += values[bpf_cpu].running;

tools/perf/util/bpf_counter.c

719

counts->run = values[entry.cpu].running;

tools/perf/util/bpf_counter.c

728

counts->run = values[cpu].running;

tools/perf/util/bpf_counter.c

735

counts->run = 0;

tools/perf/util/bpf_counter.c

740

counts->run += values[cpu].running;

tools/perf/util/bpf_counter_cgroup.c

303

counts->run = values[cpu.cpu].running;

tools/perf/util/drm_pmu.c

681

count->run = old_count->run + 1;

tools/perf/util/drm_pmu.c

685

count->run++;

tools/perf/util/evsel.c

1908

count->run = count->run - tmp.run;

tools/perf/util/evsel.c

1919

u64 val, u64 ena, u64 run, u64 lost)

tools/perf/util/evsel.c

1933

count->run = run;

tools/perf/util/evsel.c

1997

u64 nr, ena = 0, run = 0, lost = 0;

tools/perf/util/evsel.c

2008

run = *data++;

tools/perf/util/evsel.c

2021

evsel__set_count(counter, cpu_map_idx, thread, v->value, ena, run, lost);

tools/perf/util/hwmon_pmu.c

827

count->run = old_count->run + 1;

tools/perf/util/hwmon_pmu.c

831

count->run++;

tools/perf/util/intel-tpebs.c

632

count->run = old_count->run + 1;

tools/perf/util/intel-tpebs.c

636

count->run++;

tools/perf/util/python.c

1183

count_values->values.run -= old_count->run;

tools/perf/util/python.c

1344

double val, ena, run;

tools/perf/util/python.c

1388

run = new_count->run - old_count->run;

tools/perf/util/python.c

1390

if (ena != run && run != 0)

tools/perf/util/python.c

1391

val = val * ena / run;

tools/perf/util/python.c

877

counts_values_member_def(run, T_ULONG, "Time for which running"),

tools/perf/util/scripting-engines/trace-event-python.c

1687

tuple_set_u64(t, n++, count->run);

tools/perf/util/session.c

678

event->stat.run = bswap_64(event->stat.run);

tools/perf/util/stat-display.c

1006

printout(config, os, uval, run, ena, avg, aggr_idx);

tools/perf/util/stat-display.c

102

static void print_running_std(struct perf_stat_config *config, u64 run, u64 ena)

tools/perf/util/stat-display.c

104

if (run != ena)

tools/perf/util/stat-display.c

105

fprintf(config->output, " (%.2f%%)", 100.0 * run / ena);

tools/perf/util/stat-display.c

108

static void print_running_csv(struct perf_stat_config *config, u64 run, u64 ena)

tools/perf/util/stat-display.c

112

if (run != ena)

tools/perf/util/stat-display.c

113

enabled_percent = 100 * run / ena;

tools/perf/util/stat-display.c

1136

u64 ena, run, val;

tools/perf/util/stat-display.c

115

config->csv_sep, run, config->csv_sep, enabled_percent);

tools/perf/util/stat-display.c

1157

run = ps->aggr[aggr_idx].counts.run;

tools/perf/util/stat-display.c

1160

printout(config, os, uval, run, ena, 1.0, aggr_idx);

tools/perf/util/stat-display.c

1405

double run = (double) config->walltime_run[idx] / NSEC_PER_SEC;

tools/perf/util/stat-display.c

1406

int h, n = 1 + abs((int) (100.0 * (run - avg)/run) / 5);

tools/perf/util/stat-display.c

1408

fprintf(output, " %17.9f (%+.9f) ", run, run - avg);

tools/perf/util/stat-display.c

154

static void print_running_json(struct outstate *os, u64 run, u64 ena)

tools/perf/util/stat-display.c

158

if (run != ena)

tools/perf/util/stat-display.c

159

enabled_percent = 100 * run / ena;

tools/perf/util/stat-display.c

161

run, enabled_percent);

tools/perf/util/stat-display.c

165

u64 run, u64 ena, bool before_metric)

tools/perf/util/stat-display.c

169

print_running_json(os, run, ena);

tools/perf/util/stat-display.c

172

print_running_csv(config, run, ena);

tools/perf/util/stat-display.c

175

print_running_std(config, run, ena);

tools/perf/util/stat-display.c

798

double uval, u64 run, u64 ena, double noise, int aggr_idx)

tools/perf/util/stat-display.c

822

if (run == 0 || ena == 0 || counter->counts->scaled == -1) {

tools/perf/util/stat-display.c

842

print_running(config, os, run, ena, /*before_metric=*/true);

tools/perf/util/stat-display.c

864

print_running(config, os, run, ena,

tools/perf/util/stat-display.c

875

print_running(config, os, run, ena, /*before_metric=*/false);

tools/perf/util/stat-display.c

956

u64 ena, run, val;

tools/perf/util/stat-display.c

981

run = aggr->counts.run;

tools/perf/util/stat-shadow.c

97

if (aggr->counts.run == 0) {

tools/perf/util/stat.c

337

if (!(vals->run && vals->ena))

tools/perf/util/stat.c

379

if (count->ena != 0 && count->run != 0)

tools/perf/util/stat.c

420

aggr_counts->run += count->run;

tools/perf/util/stat.c

445

ps_aggr->counts.run = 0;

tools/perf/util/stat.c

452

ps_aggr->counts.run += count->run;

tools/perf/util/stat.c

533

aggr_counts_a->run += aggr_counts_b->run;

tools/perf/util/stat.c

595

counts.run += aggr->counts.run;

tools/perf/util/stat.c

608

aggr->counts.run = counts.run;

tools/perf/util/stat.c

659

count.run = st->run;

tools/perf/util/stat.c

690

st->val, st->ena, st->run);

tools/perf/util/synthetic-events.c

1436

event.run = count->run;

tools/perf/util/tool_pmu.c

460

count->run = old_count->run + 1;

tools/perf/util/tool_pmu.c

465

count->run++;

tools/testing/selftests/arm64/mte/check_buffer_fill.c

368

int run, fd;

tools/testing/selftests/arm64/mte/check_buffer_fill.c

372

for (run = 0; run < total; run++) {

tools/testing/selftests/arm64/mte/check_buffer_fill.c

374

ptr = (char *)mte_allocate_memory(sizes[run], mem_type, mapping, false);

tools/testing/selftests/arm64/mte/check_buffer_fill.c

375

if (check_allocated_memory(ptr, sizes[run], mem_type, false) != KSFT_PASS)

tools/testing/selftests/arm64/mte/check_buffer_fill.c

377

if (compare_memory_tags(ptr, sizes[run], 0) != KSFT_PASS) {

tools/testing/selftests/arm64/mte/check_buffer_fill.c

378

mte_free_memory((void *)ptr, sizes[run], mem_type, false);

tools/testing/selftests/arm64/mte/check_buffer_fill.c

381

mte_free_memory((void *)ptr, sizes[run], mem_type, false);

tools/testing/selftests/arm64/mte/check_buffer_fill.c

387

ptr = (char *)mte_allocate_file_memory(sizes[run], mem_type, mapping, false, fd);

tools/testing/selftests/arm64/mte/check_buffer_fill.c

388

if (check_allocated_memory(ptr, sizes[run], mem_type, false) != KSFT_PASS) {

tools/testing/selftests/arm64/mte/check_buffer_fill.c

392

if (compare_memory_tags(ptr, sizes[run], 0) != KSFT_PASS) {

tools/testing/selftests/arm64/mte/check_buffer_fill.c

393

mte_free_memory((void *)ptr, sizes[run], mem_type, false);

tools/testing/selftests/arm64/mte/check_buffer_fill.c

397

mte_free_memory((void *)ptr, sizes[run], mem_type, false);

tools/testing/selftests/arm64/mte/check_child_memory.c

109

int run, fd, map_size, result = KSFT_PASS;

tools/testing/selftests/arm64/mte/check_child_memory.c

113

for (run = 0; run < total; run++) {

tools/testing/selftests/arm64/mte/check_child_memory.c

118

map_size = sizes[run] + OVERFLOW + UNDERFLOW;

tools/testing/selftests/arm64/mte/check_child_memory.c

125

mte_initialize_current_context(mode, (uintptr_t)ptr, sizes[run]);

tools/testing/selftests/arm64/mte/check_child_memory.c

127

ptr = mte_insert_tags((void *)ptr, sizes[run]);

tools/testing/selftests/arm64/mte/check_child_memory.c

134

result = check_child_tag_inheritance(ptr, sizes[run], mode);

tools/testing/selftests/arm64/mte/check_child_memory.c

135

mte_clear_tags((void *)ptr, sizes[run]);

tools/testing/selftests/arm64/mte/check_child_memory.c

87

int run, result;

tools/testing/selftests/arm64/mte/check_child_memory.c

92

for (run = 0; run < item; run++) {

tools/testing/selftests/arm64/mte/check_child_memory.c

93

ptr = (char *)mte_allocate_memory_tag_range(sizes[run], mem_type, mapping,

tools/testing/selftests/arm64/mte/check_child_memory.c

95

if (check_allocated_memory_range(ptr, sizes[run], mem_type,

tools/testing/selftests/arm64/mte/check_child_memory.c

98

result = check_child_tag_inheritance(ptr, sizes[run], mode);

tools/testing/selftests/arm64/mte/check_child_memory.c

99

mte_free_memory_tag_range((void *)ptr, sizes[run], mem_type, UNDERFLOW, OVERFLOW);

tools/testing/selftests/arm64/mte/check_mmap_options.c

117

int run, result, map_size;

tools/testing/selftests/arm64/mte/check_mmap_options.c

124

for (run = 0; run < item; run++) {

tools/testing/selftests/arm64/mte/check_mmap_options.c

125

map_size = sizes[run] + OVERFLOW + UNDERFLOW;

tools/testing/selftests/arm64/mte/check_mmap_options.c

131

mte_initialize_current_context(mode, (uintptr_t)ptr, sizes[run]);

tools/testing/selftests/arm64/mte/check_mmap_options.c

133

ptr = mte_insert_tags((void *)ptr, sizes[run]);

tools/testing/selftests/arm64/mte/check_mmap_options.c

139

result = check_mte_memory(ptr, sizes[run], mode, tag_check, atag_check, tag_op);

tools/testing/selftests/arm64/mte/check_mmap_options.c

140

mte_clear_tags((void *)ptr, sizes[run]);

tools/testing/selftests/arm64/mte/check_mmap_options.c

152

int run, fd, map_size;

tools/testing/selftests/arm64/mte/check_mmap_options.c

160

for (run = 0; run < total; run++) {

tools/testing/selftests/arm64/mte/check_mmap_options.c

165

map_size = sizes[run] + UNDERFLOW + OVERFLOW;

tools/testing/selftests/arm64/mte/check_mmap_options.c

172

mte_initialize_current_context(mode, (uintptr_t)ptr, sizes[run]);

tools/testing/selftests/arm64/mte/check_mmap_options.c

174

ptr = mte_insert_tags((void *)ptr, sizes[run]);

tools/testing/selftests/arm64/mte/check_mmap_options.c

181

result = check_mte_memory(ptr, sizes[run], mode, tag_check, atag_check, tag_op);

tools/testing/selftests/arm64/mte/check_mmap_options.c

182

mte_clear_tags((void *)ptr, sizes[run]);

tools/testing/selftests/arm64/mte/check_mmap_options.c

194

int run, prot_flag, result, fd, map_size;

tools/testing/selftests/arm64/mte/check_mmap_options.c

199

for (run = 0; run < total; run++) {

tools/testing/selftests/arm64/mte/check_mmap_options.c

200

map_size = sizes[run] + OVERFLOW + UNDERFLOW;

tools/testing/selftests/arm64/mte/check_mmap_options.c

201

ptr = (char *)mte_allocate_memory_tag_range(sizes[run], mem_type, mapping,

tools/testing/selftests/arm64/mte/check_mmap_options.c

203

if (check_allocated_memory_range(ptr, sizes[run], mem_type,

tools/testing/selftests/arm64/mte/check_mmap_options.c

209

mte_free_memory_tag_range((void *)ptr, sizes[run], mem_type,

tools/testing/selftests/arm64/mte/check_mmap_options.c

214

result = check_mte_memory(ptr, sizes[run], mode, TAG_CHECK_ON, atag_check, TAG_OP_ALL);

tools/testing/selftests/arm64/mte/check_mmap_options.c

215

mte_free_memory_tag_range((void *)ptr, sizes[run], mem_type, UNDERFLOW, OVERFLOW);

tools/testing/selftests/arm64/mte/check_mmap_options.c

222

ptr = (char *)mte_allocate_file_memory_tag_range(sizes[run], mem_type, mapping,

tools/testing/selftests/arm64/mte/check_mmap_options.c

224

if (check_allocated_memory_range(ptr, sizes[run], mem_type,

tools/testing/selftests/arm64/mte/check_mmap_options.c

233

mte_free_memory_tag_range((void *)ptr, sizes[run], mem_type,

tools/testing/selftests/arm64/mte/check_mmap_options.c

238

result = check_mte_memory(ptr, sizes[run], mode, TAG_CHECK_ON, atag_check, TAG_OP_ALL);

tools/testing/selftests/arm64/mte/check_mmap_options.c

239

mte_free_memory_tag_range((void *)ptr, sizes[run], mem_type, UNDERFLOW, OVERFLOW);

tools/testing/selftests/arm64/mte/check_tags_inclusion.c

116

int run, ret, result = KSFT_PASS;

tools/testing/selftests/arm64/mte/check_tags_inclusion.c

127

for (run = 0; (run < RUNS) && (result == KSFT_PASS); run++) {

tools/testing/selftests/arm64/mte/check_tags_inclusion.c

142

int run, ret;

tools/testing/selftests/arm64/mte/check_tags_inclusion.c

152

for (run = 0; run < RUNS; run++) {

tools/testing/selftests/arm64/mte/check_tags_inclusion.c

52

int tag, run, ret, result = KSFT_PASS;

tools/testing/selftests/arm64/mte/check_tags_inclusion.c

64

for (run = 0; (run < RUNS) && (result == KSFT_PASS); run++) {

tools/testing/selftests/arm64/mte/check_tags_inclusion.c

84

int tag, run, result = KSFT_PASS;

tools/testing/selftests/arm64/mte/check_tags_inclusion.c

96

for (run = 0; (run < RUNS) && (result == KSFT_PASS); run++) {

tools/testing/selftests/arm64/signal/test_signals.h

107

int (*run)(struct tdescr *td, siginfo_t *si, ucontext_t *uc);

tools/testing/selftests/arm64/signal/test_signals_utils.c

118

td->run(td, si, uc);

tools/testing/selftests/arm64/signal/test_signals_utils.c

390

assert(td->run);

tools/testing/selftests/arm64/signal/test_signals_utils.c

407

return td->run(td, NULL, NULL);

tools/testing/selftests/arm64/signal/testcases/fake_sigreturn_bad_magic.c

51

.run = fake_sigreturn_bad_magic_run,

tools/testing/selftests/arm64/signal/testcases/fake_sigreturn_bad_size.c

76

.run = fake_sigreturn_bad_size_run,

tools/testing/selftests/arm64/signal/testcases/fake_sigreturn_bad_size_for_magic0.c

45

.run = fake_sigreturn_bad_size_for_magic0_run,

tools/testing/selftests/arm64/signal/testcases/fake_sigreturn_duplicated_fpsimd.c

49

.run = fake_sigreturn_duplicated_fpsimd_run,

tools/testing/selftests/arm64/signal/testcases/fake_sigreturn_misaligned_sp.c

36

.run = fake_sigreturn_misaligned_run,

tools/testing/selftests/arm64/signal/testcases/fake_sigreturn_missing_fpsimd.c

49

.run = fake_sigreturn_missing_fpsimd_run,

tools/testing/selftests/arm64/signal/testcases/fake_sigreturn_sme_change_vl.c

75

.run = fake_sigreturn_ssve_change_vl,

tools/testing/selftests/arm64/signal/testcases/fake_sigreturn_sve_change_vl.c

75

.run = fake_sigreturn_sve_change_vl,

tools/testing/selftests/arm64/signal/testcases/fpmr_siginfo.c

81

.run = fpmr_present,

tools/testing/selftests/arm64/signal/testcases/gcs_exception_fault.c

61

.run = gcs_op_fault_signal,

tools/testing/selftests/arm64/signal/testcases/gcs_frame.c

87

.run = gcs_regs,

tools/testing/selftests/arm64/signal/testcases/gcs_prot_none_fault.c

75

.run = gcs_prot_none_fault_signal,

tools/testing/selftests/arm64/signal/testcases/gcs_write_fault.c

66

.run = gcs_write_fault_signal,

tools/testing/selftests/arm64/signal/testcases/mangle_pstate_invalid_compat_toggle.c

30

.run = mangle_invalid_pstate_run,

tools/testing/selftests/arm64/signal/testcases/mangle_pstate_invalid_daif_bits.c

34

.run = mangle_invalid_pstate_run,

tools/testing/selftests/arm64/signal/testcases/mangle_pstate_invalid_mode_template.h

27

.run = mangle_invalid_pstate_run, \

tools/testing/selftests/arm64/signal/testcases/poe_siginfo.c

85

.run = poe_present,

tools/testing/selftests/arm64/signal/testcases/sme_trap_no_sm.c

36

.run = sme_trap_no_sm_run,

tools/testing/selftests/arm64/signal/testcases/sme_trap_non_streaming.c

43

.run = sme_trap_non_streaming_run,

tools/testing/selftests/arm64/signal/testcases/sme_trap_za.c

34

.run = sme_trap_za_run,

tools/testing/selftests/arm64/signal/testcases/sme_vl.c

67

.run = sme_vl,

tools/testing/selftests/arm64/signal/testcases/ssve_regs.c

116

.run = sme_regs,

tools/testing/selftests/arm64/signal/testcases/ssve_za_regs.c

140

.run = sme_regs,

tools/testing/selftests/arm64/signal/testcases/sve_regs.c

104

.run = sve_regs,

tools/testing/selftests/arm64/signal/testcases/sve_vl.c

67

.run = sve_vl,

tools/testing/selftests/arm64/signal/testcases/tpidr2_restore.c

84

.run = modify_tpidr2,

tools/testing/selftests/arm64/signal/testcases/tpidr2_siginfo.c

89

.run = tpidr2_present,

tools/testing/selftests/arm64/signal/testcases/za_no_regs.c

102

.run = sme_regs,

tools/testing/selftests/arm64/signal/testcases/za_regs.c

122

.run = sme_regs,

tools/testing/selftests/arm64/signal/testcases/zt_no_regs.c

50

.run = zt_no_regs_run,

tools/testing/selftests/arm64/signal/testcases/zt_regs.c

85

.run = zt_regs_run,

tools/testing/selftests/bpf/prog_tests/btf_skc_cls_ingress.c

236

void (*run)(struct test_btf_skc_cls_ingress *skel);

tools/testing/selftests/bpf/prog_tests/btf_skc_cls_ingress.c

267

tests[i].run(skel);

tools/testing/selftests/bpf/prog_tests/tcp_hdr_options.c

518

void (*run)(void);

tools/testing/selftests/bpf/prog_tests/tcp_hdr_options.c

554

tests[i].run();

tools/testing/selftests/bpf/test_sockmap.c

1056

goto run;

tools/testing/selftests/bpf/test_sockmap.c

1104

run:

tools/testing/selftests/kvm/arm64/debug-exceptions.c

470

struct kvm_run *run;

tools/testing/selftests/kvm/arm64/debug-exceptions.c

477

run = vcpu->run;

tools/testing/selftests/kvm/arm64/debug-exceptions.c

482

if (run->exit_reason != KVM_EXIT_DEBUG) {

tools/testing/selftests/kvm/arm64/external_aborts.c

127

struct kvm_run *run = vcpu->run;

tools/testing/selftests/kvm/arm64/external_aborts.c

131

TEST_ASSERT_EQ(run->mmio.phys_addr, MMIO_ADDR);

tools/testing/selftests/kvm/arm64/external_aborts.c

132

TEST_ASSERT_EQ(run->mmio.len, sizeof(unsigned long));

tools/testing/selftests/kvm/arm64/external_aborts.c

133

TEST_ASSERT(!run->mmio.is_write, "Expected MMIO read");

tools/testing/selftests/kvm/arm64/external_aborts.c

178

struct kvm_run *run = vcpu->run;

tools/testing/selftests/kvm/arm64/external_aborts.c

184

TEST_ASSERT_EQ(run->arm_nisv.fault_ipa, MMIO_ADDR);

tools/testing/selftests/kvm/arm64/external_aborts.c

336

struct kvm_run *run = vcpu->run;

tools/testing/selftests/kvm/arm64/external_aborts.c

353

TEST_ASSERT_EQ(run->mmio.phys_addr, MMIO_ADDR);

tools/testing/selftests/kvm/arm64/external_aborts.c

354

TEST_ASSERT_EQ(run->mmio.len, sizeof(unsigned long));

tools/testing/selftests/kvm/arm64/external_aborts.c

355

TEST_ASSERT(!run->mmio.is_write, "Expected MMIO read");

tools/testing/selftests/kvm/arm64/page_fault_test.c

425

static void mmio_on_test_gpa_handler(struct kvm_vm *vm, struct kvm_run *run)

tools/testing/selftests/kvm/arm64/page_fault_test.c

433

TEST_ASSERT_EQ(run->mmio.phys_addr, region->region.guest_phys_addr);

tools/testing/selftests/kvm/arm64/page_fault_test.c

435

memcpy(hva, run->mmio.data, run->mmio.len);

tools/testing/selftests/kvm/arm64/page_fault_test.c

439

static void mmio_no_handler(struct kvm_vm *vm, struct kvm_run *run)

tools/testing/selftests/kvm/arm64/page_fault_test.c

443

memcpy(&data, run->mmio.data, sizeof(data));

tools/testing/selftests/kvm/arm64/page_fault_test.c

445

run->mmio.phys_addr, run->mmio.len,

tools/testing/selftests/kvm/arm64/page_fault_test.c

446

run->mmio.is_write, data);

tools/testing/selftests/kvm/arm64/page_fault_test.c

60

void (*mmio_handler)(struct kvm_vm *vm, struct kvm_run *run);

tools/testing/selftests/kvm/arm64/page_fault_test.c

659

struct kvm_run *run;

tools/testing/selftests/kvm/arm64/page_fault_test.c

663

run = vcpu->run;

tools/testing/selftests/kvm/arm64/page_fault_test.c

685

if (run->exit_reason == KVM_EXIT_MMIO)

tools/testing/selftests/kvm/arm64/page_fault_test.c

686

test->mmio_handler(vm, run);

tools/testing/selftests/kvm/arm64/psci_test.c

182

struct kvm_run *run;

tools/testing/selftests/kvm/arm64/psci_test.c

189

run = source->run;

tools/testing/selftests/kvm/arm64/psci_test.c

194

TEST_ASSERT(run->system_event.type == KVM_SYSTEM_EVENT_SUSPEND,

tools/testing/selftests/kvm/arm64/psci_test.c

196

run->system_event.type, KVM_SYSTEM_EVENT_SUSPEND);

tools/testing/selftests/kvm/arm64/psci_test.c

243

struct kvm_run *run;

tools/testing/selftests/kvm/arm64/psci_test.c

256

run = source->run;

tools/testing/selftests/kvm/arm64/psci_test.c

259

while (run->exit_reason == KVM_EXIT_SYSTEM_EVENT) {

tools/testing/selftests/kvm/arm64/psci_test.c

260

TEST_ASSERT(run->system_event.type == KVM_SYSTEM_EVENT_SHUTDOWN,

tools/testing/selftests/kvm/arm64/psci_test.c

262

run->system_event.type, KVM_SYSTEM_EVENT_SHUTDOWN);

tools/testing/selftests/kvm/arm64/psci_test.c

263

TEST_ASSERT(run->system_event.ndata >= 1,

tools/testing/selftests/kvm/arm64/psci_test.c

265

run->system_event.ndata);

tools/testing/selftests/kvm/arm64/psci_test.c

266

TEST_ASSERT(run->system_event.data[0] & KVM_SYSTEM_EVENT_SHUTDOWN_FLAG_PSCI_OFF2,

tools/testing/selftests/kvm/arm64/psci_test.c

268

run->system_event.data[0], KVM_SYSTEM_EVENT_SHUTDOWN_FLAG_PSCI_OFF2);

tools/testing/selftests/kvm/arm64/sea_to_user.c

192

struct kvm_run *run = vcpu->run;

tools/testing/selftests/kvm/arm64/sea_to_user.c

199

exit_reason_str(run->exit_reason));

tools/testing/selftests/kvm/arm64/sea_to_user.c

201

run->arm_sea.esr, run->arm_sea.flags);

tools/testing/selftests/kvm/arm64/sea_to_user.c

203

run->arm_sea.gva, run->arm_sea.gpa);

tools/testing/selftests/kvm/arm64/sea_to_user.c

207

esr = run->arm_sea.esr;

tools/testing/selftests/kvm/arm64/sea_to_user.c

216

TEST_ASSERT_EQ(run->arm_sea.gva, EINJ_GVA);

tools/testing/selftests/kvm/arm64/sea_to_user.c

219

if (run->arm_sea.flags & KVM_EXIT_ARM_SEA_FLAG_GPA_VALID) {

tools/testing/selftests/kvm/arm64/sea_to_user.c

221

TEST_ASSERT_EQ(run->arm_sea.gpa, einj_gpa & PAGE_ADDR_MASK);

tools/testing/selftests/kvm/arm64/smccc_filter.c

223

struct kvm_run *run = vcpu->run;

tools/testing/selftests/kvm/arm64/smccc_filter.c

225

TEST_ASSERT(run->exit_reason == KVM_EXIT_HYPERCALL,

tools/testing/selftests/kvm/arm64/smccc_filter.c

226

"Unexpected exit reason: %u", run->exit_reason);

tools/testing/selftests/kvm/arm64/smccc_filter.c

227

TEST_ASSERT(run->hypercall.nr == func_id,

tools/testing/selftests/kvm/arm64/smccc_filter.c

228

"Unexpected SMCCC function: %llu", run->hypercall.nr);

tools/testing/selftests/kvm/arm64/smccc_filter.c

231

TEST_ASSERT(run->hypercall.flags & KVM_HYPERCALL_EXIT_SMC,

tools/testing/selftests/kvm/arm64/smccc_filter.c

234

TEST_ASSERT(!(run->hypercall.flags & KVM_HYPERCALL_EXIT_SMC),

tools/testing/selftests/kvm/coalesced_io_test.c

106

(want_pio ? io->pio_port : io->mmio_gpa) + io->ring_size - 1, run->exit_reason,

tools/testing/selftests/kvm/coalesced_io_test.c

107

run->exit_reason == KVM_EXIT_MMIO ? "MMIO" : run->exit_reason == KVM_EXIT_IO ? "PIO" : "other",

tools/testing/selftests/kvm/coalesced_io_test.c

108

run->mmio.phys_addr, run->mmio.is_write, run->mmio.len, *(uint64_t *)run->mmio.data,

tools/testing/selftests/kvm/coalesced_io_test.c

109

run->io.port, run->io.direction, run->io.size, run->io.count, pio_value);

tools/testing/selftests/kvm/coalesced_io_test.c

206

.ring = (void *)vcpu->run +

tools/testing/selftests/kvm/coalesced_io_test.c

78

struct kvm_run *run = vcpu->run;

tools/testing/selftests/kvm/coalesced_io_test.c

90

if (run->exit_reason == KVM_EXIT_IO)

tools/testing/selftests/kvm/coalesced_io_test.c

91

pio_value = *(uint32_t *)((void *)run + run->io.data_offset);

tools/testing/selftests/kvm/coalesced_io_test.c

95

TEST_ASSERT((!want_pio && (run->exit_reason == KVM_EXIT_MMIO && run->mmio.is_write &&

tools/testing/selftests/kvm/coalesced_io_test.c

96

run->mmio.phys_addr == io->mmio_gpa && run->mmio.len == 8 &&

tools/testing/selftests/kvm/coalesced_io_test.c

97

*(uint64_t *)run->mmio.data == io->mmio_gpa + io->ring_size - 1)) ||

tools/testing/selftests/kvm/coalesced_io_test.c

98

(want_pio && (run->exit_reason == KVM_EXIT_IO && run->io.port == io->pio_port &&

tools/testing/selftests/kvm/coalesced_io_test.c

99

run->io.direction == KVM_EXIT_IO_OUT && run->io.count == 1 &&

tools/testing/selftests/kvm/demand_paging_test.c

36

struct kvm_run *run = vcpu->run;

tools/testing/selftests/kvm/demand_paging_test.c

49

exit_reason_str(run->exit_reason));

tools/testing/selftests/kvm/dirty_log_perf_test.c

41

struct kvm_run *run;

tools/testing/selftests/kvm/dirty_log_perf_test.c

48

run = vcpu->run;

tools/testing/selftests/kvm/dirty_log_perf_test.c

60

exit_reason_str(run->exit_reason));

tools/testing/selftests/kvm/dirty_log_test.c

283

struct kvm_run *run = vcpu->run;

tools/testing/selftests/kvm/dirty_log_test.c

287

exit_reason_str(run->exit_reason));

tools/testing/selftests/kvm/dirty_log_test.c

384

struct kvm_run *run = vcpu->run;

tools/testing/selftests/kvm/dirty_log_test.c

389

} else if (run->exit_reason == KVM_EXIT_DIRTY_RING_FULL) {

tools/testing/selftests/kvm/dirty_log_test.c

395

exit_reason_str(run->exit_reason));

tools/testing/selftests/kvm/guest_print_test.c

128

struct kvm_run *run = vcpu->run;

tools/testing/selftests/kvm/guest_print_test.c

134

TEST_ASSERT(run->exit_reason == UCALL_EXIT_REASON,

tools/testing/selftests/kvm/guest_print_test.c

136

run->exit_reason, exit_reason_str(run->exit_reason));

tools/testing/selftests/kvm/guest_print_test.c

171

struct kvm_run *run;

tools/testing/selftests/kvm/guest_print_test.c

176

run = vcpu->run;

tools/testing/selftests/kvm/guest_print_test.c

179

TEST_ASSERT(run->exit_reason == UCALL_EXIT_REASON,

tools/testing/selftests/kvm/guest_print_test.c

181

run->exit_reason, exit_reason_str(run->exit_reason));

tools/testing/selftests/kvm/hardware_disable_test.c

112

pr_debug("%s: [%d] all threads launched\n", __func__, run);

tools/testing/selftests/kvm/hardware_disable_test.c

117

TEST_ASSERT(false, "%s: [%d] child escaped the ninja", __func__, run);

tools/testing/selftests/kvm/hardware_disable_test.c

36

struct kvm_run *run = vcpu->run;

tools/testing/selftests/kvm/hardware_disable_test.c

41

__func__, run->exit_reason,

tools/testing/selftests/kvm/hardware_disable_test.c

42

exit_reason_str(run->exit_reason));

tools/testing/selftests/kvm/hardware_disable_test.c

83

static void run_test(uint32_t run)

tools/testing/selftests/kvm/hardware_disable_test.c

99

pr_debug("%s: [%d] start vcpus\n", __func__, run);

tools/testing/selftests/kvm/include/kvm_util.h

64

struct kvm_run *run;

tools/testing/selftests/kvm/include/s390/debug_print.h

43

static inline void print_psw(struct kvm_run *run, struct kvm_s390_sie_block *sie_block)

tools/testing/selftests/kvm/include/s390/debug_print.h

46

run->flags,

tools/testing/selftests/kvm/include/s390/debug_print.h

47

run->psw_mask, run->psw_addr,

tools/testing/selftests/kvm/include/s390/debug_print.h

48

run->exit_reason, exit_reason_str(run->exit_reason));

tools/testing/selftests/kvm/include/s390/debug_print.h

53

static inline void print_run(struct kvm_run *run, struct kvm_s390_sie_block *sie_block)

tools/testing/selftests/kvm/include/s390/debug_print.h

55

print_hex_bytes("run", (u64)run, 0x150);

tools/testing/selftests/kvm/include/s390/debug_print.h

57

print_psw(run, sie_block);

tools/testing/selftests/kvm/include/s390/debug_print.h

60

static inline void print_regs(struct kvm_run *run)

tools/testing/selftests/kvm/include/s390/debug_print.h

62

struct kvm_sync_regs *sync_regs = &run->s.regs;

tools/testing/selftests/kvm/include/test_util.h

70

__u32 exit_reason = (vcpu)->run->exit_reason; \

tools/testing/selftests/kvm/kvm_page_table_test.c

208

exit_reason_str(vcpu->run->exit_reason));

tools/testing/selftests/kvm/lib/arm64/ucall.c

24

struct kvm_run *run = vcpu->run;

tools/testing/selftests/kvm/lib/arm64/ucall.c

26

if (run->exit_reason == KVM_EXIT_MMIO &&

tools/testing/selftests/kvm/lib/arm64/ucall.c

27

run->mmio.phys_addr == vcpu->vm->ucall_mmio_addr) {

tools/testing/selftests/kvm/lib/arm64/ucall.c

28

TEST_ASSERT(run->mmio.is_write && run->mmio.len == sizeof(uint64_t),

tools/testing/selftests/kvm/lib/arm64/ucall.c

30

return (void *)(*((uint64_t *)run->mmio.data));

tools/testing/selftests/kvm/lib/kvm_util.c

1359

TEST_ASSERT(vcpu_mmap_sz() >= sizeof(*vcpu->run), "vcpu mmap size "

tools/testing/selftests/kvm/lib/kvm_util.c

1361

vcpu_mmap_sz(), sizeof(*vcpu->run));

tools/testing/selftests/kvm/lib/kvm_util.c

1362

vcpu->run = kvm_mmap(vcpu_mmap_sz(), PROT_READ | PROT_WRITE,

tools/testing/selftests/kvm/lib/kvm_util.c

1761

vcpu->run->immediate_exit = 1;

tools/testing/selftests/kvm/lib/kvm_util.c

1763

vcpu->run->immediate_exit = 0;

tools/testing/selftests/kvm/lib/kvm_util.c

778

kvm_munmap(vcpu->run, vcpu_mmap_sz());

tools/testing/selftests/kvm/lib/loongarch/ucall.c

27

struct kvm_run *run = vcpu->run;

tools/testing/selftests/kvm/lib/loongarch/ucall.c

29

if (run->exit_reason == KVM_EXIT_MMIO &&

tools/testing/selftests/kvm/lib/loongarch/ucall.c

30

run->mmio.phys_addr == vcpu->vm->ucall_mmio_addr) {

tools/testing/selftests/kvm/lib/loongarch/ucall.c

31

TEST_ASSERT(run->mmio.is_write && run->mmio.len == sizeof(uint64_t),

tools/testing/selftests/kvm/lib/loongarch/ucall.c

34

return (void *)(*((uint64_t *)run->mmio.data));

tools/testing/selftests/kvm/lib/riscv/ucall.c

16

struct kvm_run *run = vcpu->run;

tools/testing/selftests/kvm/lib/riscv/ucall.c

18

if (run->exit_reason == KVM_EXIT_RISCV_SBI &&

tools/testing/selftests/kvm/lib/riscv/ucall.c

19

run->riscv_sbi.extension_id == KVM_RISCV_SELFTESTS_SBI_EXT) {

tools/testing/selftests/kvm/lib/riscv/ucall.c

20

switch (run->riscv_sbi.function_id) {

tools/testing/selftests/kvm/lib/riscv/ucall.c

22

return (void *)run->riscv_sbi.args[0];

tools/testing/selftests/kvm/lib/s390/diag318_test_handler.c

30

struct kvm_run *run;

tools/testing/selftests/kvm/lib/s390/diag318_test_handler.c

36

run = vcpu->run;

tools/testing/selftests/kvm/lib/s390/diag318_test_handler.c

39

TEST_ASSERT(run->s390_sieic.icptcode == ICPT_INSTRUCTION,

tools/testing/selftests/kvm/lib/s390/diag318_test_handler.c

40

"Unexpected intercept code: 0x%x", run->s390_sieic.icptcode);

tools/testing/selftests/kvm/lib/s390/diag318_test_handler.c

41

TEST_ASSERT((run->s390_sieic.ipa & 0xff00) == IPA0_DIAG,

tools/testing/selftests/kvm/lib/s390/diag318_test_handler.c

42

"Unexpected IPA0 code: 0x%x", (run->s390_sieic.ipa & 0xff00));

tools/testing/selftests/kvm/lib/s390/diag318_test_handler.c

44

reg = (run->s390_sieic.ipa & 0x00f0) >> 4;

tools/testing/selftests/kvm/lib/s390/diag318_test_handler.c

45

diag318_info = run->s.regs.gprs[reg];

tools/testing/selftests/kvm/lib/s390/processor.c

160

vcpu->run->psw_addr = (uintptr_t)guest_code;

tools/testing/selftests/kvm/lib/s390/processor.c

190

vcpu->run->psw_mask = 0x0400000180000000ULL; /* DAT enabled + 64 bit mode */

tools/testing/selftests/kvm/lib/s390/processor.c

218

indent, "", vcpu->run->psw_mask, vcpu->run->psw_addr);

tools/testing/selftests/kvm/lib/s390/ucall.c

11

struct kvm_run *run = vcpu->run;

tools/testing/selftests/kvm/lib/s390/ucall.c

13

if (run->exit_reason == KVM_EXIT_S390_SIEIC &&

tools/testing/selftests/kvm/lib/s390/ucall.c

14

run->s390_sieic.icptcode == 4 &&

tools/testing/selftests/kvm/lib/s390/ucall.c

15

(run->s390_sieic.ipa >> 8) == 0x83 && /* 0x83 means DIAGNOSE */

tools/testing/selftests/kvm/lib/s390/ucall.c

16

(run->s390_sieic.ipb >> 16) == 0x501) {

tools/testing/selftests/kvm/lib/s390/ucall.c

17

int reg = run->s390_sieic.ipa & 0xf;

tools/testing/selftests/kvm/lib/s390/ucall.c

19

return (void *)run->s.regs.gprs[reg];

tools/testing/selftests/kvm/lib/x86/ucall.c

47

struct kvm_run *run = vcpu->run;

tools/testing/selftests/kvm/lib/x86/ucall.c

49

if (run->exit_reason == KVM_EXIT_IO && run->io.port == UCALL_PIO_PORT) {

tools/testing/selftests/kvm/memslot_modification_stress_test.c

38

struct kvm_run *run;

tools/testing/selftests/kvm/memslot_modification_stress_test.c

41

run = vcpu->run;

tools/testing/selftests/kvm/memslot_modification_stress_test.c

53

exit_reason_str(run->exit_reason));

tools/testing/selftests/kvm/memslot_perf_test.c

128

static void check_mmio_access(struct vm_data *data, struct kvm_run *run)

tools/testing/selftests/kvm/memslot_perf_test.c

131

TEST_ASSERT(run->mmio.is_write, "Unexpected mmio read");

tools/testing/selftests/kvm/memslot_perf_test.c

132

TEST_ASSERT(run->mmio.len == 8,

tools/testing/selftests/kvm/memslot_perf_test.c

133

"Unexpected exit mmio size = %u", run->mmio.len);

tools/testing/selftests/kvm/memslot_perf_test.c

134

TEST_ASSERT(run->mmio.phys_addr >= data->mmio_gpa_min &&

tools/testing/selftests/kvm/memslot_perf_test.c

135

run->mmio.phys_addr <= data->mmio_gpa_max,

tools/testing/selftests/kvm/memslot_perf_test.c

137

run->mmio.phys_addr);

tools/testing/selftests/kvm/memslot_perf_test.c

144

struct kvm_run *run = vcpu->run;

tools/testing/selftests/kvm/memslot_perf_test.c

158

if (run->exit_reason == KVM_EXIT_MMIO)

tools/testing/selftests/kvm/memslot_perf_test.c

159

check_mmio_access(data, run);

tools/testing/selftests/kvm/mmu_stress_test.c

171

vcpu->run->kvm_valid_regs = KVM_SYNC_X86_REGS;

tools/testing/selftests/kvm/mmu_stress_test.c

179

WRITE_ONCE(vcpu->run->kvm_dirty_regs, KVM_SYNC_X86_REGS);

tools/testing/selftests/kvm/mmu_stress_test.c

180

vcpu->run->s.regs.regs.rip += 3;

tools/testing/selftests/kvm/pre_fault_memory_test.c

170

struct kvm_run *run;

tools/testing/selftests/kvm/pre_fault_memory_test.c

200

run = vcpu->run;

tools/testing/selftests/kvm/pre_fault_memory_test.c

201

TEST_ASSERT(run->exit_reason == KVM_EXIT_IO,

tools/testing/selftests/kvm/pre_fault_memory_test.c

203

run->exit_reason, exit_reason_str(run->exit_reason));

tools/testing/selftests/kvm/s390/cmma_test.c

266

TEST_ASSERT_EQ(vcpu->run->exit_reason, 13);

tools/testing/selftests/kvm/s390/cmma_test.c

267

TEST_ASSERT_EQ(vcpu->run->s390_sieic.icptcode, 4);

tools/testing/selftests/kvm/s390/cmma_test.c

268

TEST_ASSERT_EQ(vcpu->run->s390_sieic.ipa, 0x8300);

tools/testing/selftests/kvm/s390/cmma_test.c

269

TEST_ASSERT_EQ(vcpu->run->s390_sieic.ipb, 0x5010000);

tools/testing/selftests/kvm/s390/cmma_test.c

291

orig_psw = vcpu->run->psw_addr;

tools/testing/selftests/kvm/s390/cmma_test.c

317

vcpu->run->psw_addr = orig_psw;

tools/testing/selftests/kvm/s390/cmma_test.c

338

vcpu->run->psw_addr = orig_psw;

tools/testing/selftests/kvm/s390/cmma_test.c

363

vcpu->run->psw_addr = orig_psw;

tools/testing/selftests/kvm/s390/cmma_test.c

514

orig_psw = vcpu->run->psw_addr;

tools/testing/selftests/kvm/s390/cmma_test.c

530

vcpu->run->psw_addr = orig_psw;

tools/testing/selftests/kvm/s390/debug_test.c

29

new_psw[0] = (*vcpu)->run->psw_mask;

tools/testing/selftests/kvm/s390/debug_test.c

50

TEST_ASSERT_EQ(vcpu->run->psw_mask, new_psw[0]);

tools/testing/selftests/kvm/s390/debug_test.c

51

TEST_ASSERT_EQ(vcpu->run->psw_addr, new_psw[1]);

tools/testing/selftests/kvm/s390/debug_test.c

88

TEST_ASSERT_EQ(vcpu->run->s390_sieic.icptcode, ICPT_INST);

tools/testing/selftests/kvm/s390/debug_test.c

89

TEST_ASSERT_EQ(vcpu->run->s390_sieic.ipa & 0xff00, IPA0_DIAG);

tools/testing/selftests/kvm/s390/debug_test.c

93

TEST_ASSERT_EQ(vcpu->run->psw_mask, new_psw[0]);

tools/testing/selftests/kvm/s390/debug_test.c

94

TEST_ASSERT_EQ(vcpu->run->psw_addr, new_psw[1]);

tools/testing/selftests/kvm/s390/memop.c

1027

t.run->psw_mask &= ~(3UL << (63 - 17));

tools/testing/selftests/kvm/s390/memop.c

1028

t.run->psw_mask |= 1UL << (63 - 17); /* Enable AR mode */

tools/testing/selftests/kvm/s390/memop.c

1032

t.run->psw_mask &= ~(3UL << (63 - 17)); /* Disable AR mode */

tools/testing/selftests/kvm/s390/memop.c

240

struct kvm_run *run;

tools/testing/selftests/kvm/s390/memop.c

253

t.run = vcpu->run;

tools/testing/selftests/kvm/s390/memop.c

384

t.run->psw_mask &= ~(3UL << (63 - 17));

tools/testing/selftests/kvm/s390/memop.c

385

t.run->psw_mask |= 1UL << (63 - 17); /* Enable AR mode */

tools/testing/selftests/kvm/s390/memop.c

736

t.run->s.regs.crs[0] |= CR0_STORAGE_PROTECTION_OVERRIDE;

tools/testing/selftests/kvm/s390/memop.c

737

t.run->kvm_dirty_regs = KVM_SYNC_CRS;

tools/testing/selftests/kvm/s390/memop.c

830

prefix = t.run->s.regs.prefix;

tools/testing/selftests/kvm/s390/memop.c

831

psw[0] = t.run->psw_mask;

tools/testing/selftests/kvm/s390/memop.c

832

psw[1] = t.run->psw_addr;

tools/testing/selftests/kvm/s390/memop.c

847

t.run->s.regs.crs[0] |= CR0_STORAGE_PROTECTION_OVERRIDE;

tools/testing/selftests/kvm/s390/memop.c

848

t.run->kvm_dirty_regs = KVM_SYNC_CRS;

tools/testing/selftests/kvm/s390/memop.c

891

t.run->s.regs.crs[0] |= CR0_FETCH_PROTECTION_OVERRIDE;

tools/testing/selftests/kvm/s390/memop.c

892

t.run->kvm_dirty_regs = KVM_SYNC_CRS;

tools/testing/selftests/kvm/s390/memop.c

950

t.run->s.regs.crs[0] |= CR0_FETCH_PROTECTION_OVERRIDE;

tools/testing/selftests/kvm/s390/memop.c

951

t.run->kvm_dirty_regs = KVM_SYNC_CRS;

tools/testing/selftests/kvm/s390/resets.c

114

struct kvm_sync_regs *sync_regs = &vcpu->run->s.regs;

tools/testing/selftests/kvm/s390/resets.c

131

struct kvm_sync_regs *sync_regs = &vcpu->run->s.regs;

tools/testing/selftests/kvm/s390/resets.c

159

TEST_ASSERT(vcpu->run->psw_addr == 0, "psw_addr == 0 (kvm_run)");

tools/testing/selftests/kvm/s390/resets.c

160

TEST_ASSERT(vcpu->run->psw_mask == 0, "psw_mask == 0 (kvm_run)");

tools/testing/selftests/kvm/s390/resets.c

174

struct kvm_sync_regs *sync_regs = &vcpu->run->s.regs;

tools/testing/selftests/kvm/s390/resets.c

185

TEST_ASSERT(vcpu->run->s.regs.pft == KVM_S390_PFAULT_TOKEN_INVALID,

tools/testing/selftests/kvm/s390/resets.c

87

struct kvm_sync_regs *sync_regs = &vcpu->run->s.regs;

tools/testing/selftests/kvm/s390/sync_regs_test.c

101

run->kvm_dirty_regs = INVALID_SYNC_FIELD;

tools/testing/selftests/kvm/s390/sync_regs_test.c

106

run->kvm_dirty_regs = 0;

tools/testing/selftests/kvm/s390/sync_regs_test.c

108

run->kvm_dirty_regs = INVALID_SYNC_FIELD | TEST_SYNC_FIELDS;

tools/testing/selftests/kvm/s390/sync_regs_test.c

113

run->kvm_dirty_regs = 0;

tools/testing/selftests/kvm/s390/sync_regs_test.c

118

struct kvm_run *run = vcpu->run;

tools/testing/selftests/kvm/s390/sync_regs_test.c

124

run->kvm_valid_regs = TEST_SYNC_FIELDS;

tools/testing/selftests/kvm/s390/sync_regs_test.c

128

TEST_ASSERT(run->s390_sieic.icptcode == 4 &&

tools/testing/selftests/kvm/s390/sync_regs_test.c

129

(run->s390_sieic.ipa >> 8) == 0x83 &&

tools/testing/selftests/kvm/s390/sync_regs_test.c

130

(run->s390_sieic.ipb >> 16) == 0x501,

tools/testing/selftests/kvm/s390/sync_regs_test.c

132

run->s390_sieic.icptcode, run->s390_sieic.ipa,

tools/testing/selftests/kvm/s390/sync_regs_test.c

133

run->s390_sieic.ipb);

tools/testing/selftests/kvm/s390/sync_regs_test.c

136

compare_regs(&regs, &run->s.regs);

tools/testing/selftests/kvm/s390/sync_regs_test.c

139

compare_sregs(&sregs, &run->s.regs);

tools/testing/selftests/kvm/s390/sync_regs_test.c

144

struct kvm_run *run = vcpu->run;

tools/testing/selftests/kvm/s390/sync_regs_test.c

150

run->s.regs.gprs[11] = 0xBAD1DEA;

tools/testing/selftests/kvm/s390/sync_regs_test.c

151

run->s.regs.acrs[0] = 1 << 11;

tools/testing/selftests/kvm/s390/sync_regs_test.c

153

run->kvm_valid_regs = TEST_SYNC_FIELDS;

tools/testing/selftests/kvm/s390/sync_regs_test.c

154

run->kvm_dirty_regs = KVM_SYNC_GPRS | KVM_SYNC_ACRS;

tools/testing/selftests/kvm/s390/sync_regs_test.c

157

run->s.regs.diag318 = get_diag318_info();

tools/testing/selftests/kvm/s390/sync_regs_test.c

158

run->kvm_dirty_regs |= KVM_SYNC_DIAG318;

tools/testing/selftests/kvm/s390/sync_regs_test.c

164

TEST_ASSERT(run->s.regs.gprs[11] == 0xBAD1DEA + 1,

tools/testing/selftests/kvm/s390/sync_regs_test.c

166

run->s.regs.gprs[11]);

tools/testing/selftests/kvm/s390/sync_regs_test.c

167

TEST_ASSERT(run->s.regs.acrs[0] == 1 << 11,

tools/testing/selftests/kvm/s390/sync_regs_test.c

169

run->s.regs.acrs[0]);

tools/testing/selftests/kvm/s390/sync_regs_test.c

170

TEST_ASSERT(run->s.regs.diag318 == get_diag318_info(),

tools/testing/selftests/kvm/s390/sync_regs_test.c

172

run->s.regs.diag318);

tools/testing/selftests/kvm/s390/sync_regs_test.c

175

compare_regs(&regs, &run->s.regs);

tools/testing/selftests/kvm/s390/sync_regs_test.c

178

compare_sregs(&sregs, &run->s.regs);

tools/testing/selftests/kvm/s390/sync_regs_test.c

183

struct kvm_run *run = vcpu->run;

tools/testing/selftests/kvm/s390/sync_regs_test.c

189

run->kvm_valid_regs = TEST_SYNC_FIELDS;

tools/testing/selftests/kvm/s390/sync_regs_test.c

190

run->kvm_dirty_regs = 0;

tools/testing/selftests/kvm/s390/sync_regs_test.c

191

run->s.regs.gprs[11] = 0xDEADBEEF;

tools/testing/selftests/kvm/s390/sync_regs_test.c

192

run->s.regs.diag318 = 0x4B1D;

tools/testing/selftests/kvm/s390/sync_regs_test.c

196

TEST_ASSERT(run->s.regs.gprs[11] != 0xDEADBEEF,

tools/testing/selftests/kvm/s390/sync_regs_test.c

198

run->s.regs.gprs[11]);

tools/testing/selftests/kvm/s390/sync_regs_test.c

199

TEST_ASSERT(run->s.regs.diag318 != 0x4B1D,

tools/testing/selftests/kvm/s390/sync_regs_test.c

201

run->s.regs.diag318);

tools/testing/selftests/kvm/s390/sync_regs_test.c

76

struct kvm_run *run = vcpu->run;

tools/testing/selftests/kvm/s390/sync_regs_test.c

80

run->kvm_valid_regs = INVALID_SYNC_FIELD;

tools/testing/selftests/kvm/s390/sync_regs_test.c

85

run->kvm_valid_regs = 0;

tools/testing/selftests/kvm/s390/sync_regs_test.c

87

run->kvm_valid_regs = INVALID_SYNC_FIELD | TEST_SYNC_FIELDS;

tools/testing/selftests/kvm/s390/sync_regs_test.c

92

run->kvm_valid_regs = 0;

tools/testing/selftests/kvm/s390/sync_regs_test.c

97

struct kvm_run *run = vcpu->run;

tools/testing/selftests/kvm/s390/tprot.c

209

struct kvm_run *run;

tools/testing/selftests/kvm/s390/tprot.c

216

run = vcpu->run;

tools/testing/selftests/kvm/s390/tprot.c

233

run->s.regs.crs[0] |= CR0_FETCH_PROTECTION_OVERRIDE;

tools/testing/selftests/kvm/s390/tprot.c

234

run->kvm_dirty_regs = KVM_SYNC_CRS;

tools/testing/selftests/kvm/s390/tprot.c

237

run->s.regs.crs[0] |= CR0_STORAGE_PROTECTION_OVERRIDE;

tools/testing/selftests/kvm/s390/tprot.c

238

run->kvm_dirty_regs = KVM_SYNC_CRS;

tools/testing/selftests/kvm/s390/ucontrol_test.c

108

struct kvm_run *run;

tools/testing/selftests/kvm/s390/ucontrol_test.c

145

self->run = kvm_mmap(self->kvm_run_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/kvm/s390/ucontrol_test.c

157

TH_LOG("VM created %p %p", self->run, self->sie_block);

tools/testing/selftests/kvm/s390/ucontrol_test.c

188

kvm_munmap(self->run, self->kvm_run_size);

tools/testing/selftests/kvm/s390/ucontrol_test.c

306

struct kvm_run *run = self->run;

tools/testing/selftests/kvm/s390/ucontrol_test.c

310

TEST_ASSERT_EQ(KVM_EXIT_S390_UCONTROL, run->exit_reason);

tools/testing/selftests/kvm/s390/ucontrol_test.c

311

switch (run->s390_ucontrol.pgm_code) {

tools/testing/selftests/kvm/s390/ucontrol_test.c

313

seg_addr = run->s390_ucontrol.trans_exc_code & ~(SZ_1M - 1);

tools/testing/selftests/kvm/s390/ucontrol_test.c

315

run->s390_ucontrol.trans_exc_code, seg_addr);

tools/testing/selftests/kvm/s390/ucontrol_test.c

321

TEST_FAIL("UNEXPECTED PGM CODE %d", run->s390_ucontrol.pgm_code);

tools/testing/selftests/kvm/s390/ucontrol_test.c

348

struct kvm_run *run = self->run;

tools/testing/selftests/kvm/s390/ucontrol_test.c

350

switch (run->s390_sieic.ipa) {

tools/testing/selftests/kvm/s390/ucontrol_test.c

357

run->psw_addr = run->psw_addr - ilen;

tools/testing/selftests/kvm/s390/ucontrol_test.c

358

pr_info("rewind guest addr to 0x%.16llx\n", run->psw_addr);

tools/testing/selftests/kvm/s390/ucontrol_test.c

373

struct kvm_run *run = self->run;

tools/testing/selftests/kvm/s390/ucontrol_test.c

377

run->s390_sieic.icptcode,

tools/testing/selftests/kvm/s390/ucontrol_test.c

378

run->s390_sieic.ipa,

tools/testing/selftests/kvm/s390/ucontrol_test.c

379

run->s390_sieic.ipb);

tools/testing/selftests/kvm/s390/ucontrol_test.c

380

switch (run->s390_sieic.icptcode) {

tools/testing/selftests/kvm/s390/ucontrol_test.c

392

TEST_FAIL("UNEXPECTED SIEIC CODE %d", run->s390_sieic.icptcode);

tools/testing/selftests/kvm/s390/ucontrol_test.c

400

struct kvm_run *run = self->run;

tools/testing/selftests/kvm/s390/ucontrol_test.c

402

switch (run->exit_reason) {

tools/testing/selftests/kvm/s390/ucontrol_test.c

412

pr_info("exit_reason %2d not handled\n", run->exit_reason);

tools/testing/selftests/kvm/s390/ucontrol_test.c

423

print_run(self->run, self->sie_block);

tools/testing/selftests/kvm/s390/ucontrol_test.c

424

print_regs(self->run);

tools/testing/selftests/kvm/s390/ucontrol_test.c

434

TEST_ASSERT_EQ(KVM_EXIT_S390_SIEIC, self->run->exit_reason);

tools/testing/selftests/kvm/s390/ucontrol_test.c

468

struct kvm_sync_regs *sync_regs = &self->run->s.regs;

tools/testing/selftests/kvm/s390/ucontrol_test.c

469

struct kvm_run *run = self->run;

tools/testing/selftests/kvm/s390/ucontrol_test.c

479

run->psw_mask = 0x0000000180000000ULL;

tools/testing/selftests/kvm/s390/ucontrol_test.c

480

run->psw_addr = self->code_gpa;

tools/testing/selftests/kvm/s390/ucontrol_test.c

486

run->kvm_dirty_regs |= KVM_SYNC_GPRS;

tools/testing/selftests/kvm/s390/ucontrol_test.c

491

ASSERT_EQ(KVM_EXIT_S390_UCONTROL, run->exit_reason);

tools/testing/selftests/kvm/s390/ucontrol_test.c

493

ASSERT_EQ(PGM_SEGMENT_TRANSLATION, run->s390_ucontrol.pgm_code);

tools/testing/selftests/kvm/s390/ucontrol_test.c

494

ASSERT_EQ(self->base_gpa + VM_MEM_SIZE, run->s390_ucontrol.trans_exc_code);

tools/testing/selftests/kvm/s390/ucontrol_test.c

521

ASSERT_EQ(KVM_EXIT_S390_UCONTROL, run->exit_reason);

tools/testing/selftests/kvm/s390/ucontrol_test.c

522

ASSERT_EQ(PGM_SEGMENT_TRANSLATION, run->s390_ucontrol.pgm_code);

tools/testing/selftests/kvm/s390/ucontrol_test.c

529

struct kvm_sync_regs *sync_regs = &self->run->s.regs;

tools/testing/selftests/kvm/s390/ucontrol_test.c

530

struct kvm_run *run = self->run;

tools/testing/selftests/kvm/s390/ucontrol_test.c

536

run->kvm_dirty_regs |= KVM_SYNC_GPRS;

tools/testing/selftests/kvm/s390/ucontrol_test.c

544

run->psw_mask = 0x0000000180000000ULL;

tools/testing/selftests/kvm/s390/ucontrol_test.c

545

run->psw_addr = self->code_gpa;

tools/testing/selftests/kvm/s390/ucontrol_test.c

573

struct kvm_sync_regs *sync_regs = &self->run->s.regs;

tools/testing/selftests/kvm/s390/ucontrol_test.c

575

struct kvm_run *run = self->run;

tools/testing/selftests/kvm/s390/ucontrol_test.c

587

run->kvm_dirty_regs |= KVM_SYNC_GPRS;

tools/testing/selftests/kvm/s390/ucontrol_test.c

590

run->psw_mask = 0x0000000180000000ULL;

tools/testing/selftests/kvm/s390/ucontrol_test.c

591

run->psw_addr = self->code_gpa;

tools/testing/selftests/kvm/s390/ucontrol_test.c

599

run->kvm_dirty_regs |= KVM_SYNC_GPRS;

tools/testing/selftests/kvm/s390/ucontrol_test.c

609

TEST_ASSERT_EQ(KVM_EXIT_S390_SIEIC, self->run->exit_reason);

tools/testing/selftests/kvm/s390/ucontrol_test.c

621

run->kvm_dirty_regs |= KVM_SYNC_GPRS;

tools/testing/selftests/kvm/s390/user_operexec.c

106

TEST_ASSERT_EQ(vcpu->run->s390_sieic.icptcode, ICPT_OPEREXC);

tools/testing/selftests/kvm/s390/user_operexec.c

107

TEST_ASSERT_EQ(vcpu->run->s390_sieic.ipa, 0x0807);

tools/testing/selftests/kvm/s390/user_operexec.c

33

TEST_ASSERT_EQ(vcpu->run->s390_sieic.icptcode, ICPT_OPEREXC);

tools/testing/selftests/kvm/s390/user_operexec.c

34

TEST_ASSERT_EQ(vcpu->run->s390_sieic.ipa, 0);

tools/testing/selftests/kvm/s390/user_operexec.c

56

TEST_ASSERT_EQ(vcpu->run->s390_sieic.icptcode, ICPT_OPEREXC);

tools/testing/selftests/kvm/s390/user_operexec.c

57

TEST_ASSERT_EQ(vcpu->run->s390_sieic.ipa, 0x0807);

tools/testing/selftests/kvm/s390/user_operexec.c

71

TEST_ASSERT_EQ(vcpu->run->s390_sieic.icptcode, ICPT_OPEREXC);

tools/testing/selftests/kvm/s390/user_operexec.c

72

TEST_ASSERT_EQ(vcpu->run->s390_sieic.ipa, 0);

tools/testing/selftests/kvm/s390/user_operexec.c

92

TEST_ASSERT_EQ(vcpu->run->s390_sieic.icptcode, ICPT_OPEREXC);

tools/testing/selftests/kvm/s390/user_operexec.c

93

TEST_ASSERT_EQ(vcpu->run->s390_sieic.ipa, 0x0807);

tools/testing/selftests/kvm/set_memory_region_test.c

277

struct kvm_run *run;

tools/testing/selftests/kvm/set_memory_region_test.c

307

run = vcpu->run;

tools/testing/selftests/kvm/set_memory_region_test.c

309

TEST_ASSERT(run->exit_reason == KVM_EXIT_SHUTDOWN ||

tools/testing/selftests/kvm/set_memory_region_test.c

310

run->exit_reason == KVM_EXIT_INTERNAL_ERROR,

tools/testing/selftests/kvm/set_memory_region_test.c

311

"Unexpected exit reason = %d", run->exit_reason);

tools/testing/selftests/kvm/set_memory_region_test.c

319

if (run->exit_reason == KVM_EXIT_INTERNAL_ERROR)

tools/testing/selftests/kvm/set_memory_region_test.c

55

struct kvm_run *run = vcpu->run;

tools/testing/selftests/kvm/set_memory_region_test.c

578

struct kvm_run *run;

tools/testing/selftests/kvm/set_memory_region_test.c

587

run = vcpu->run;

tools/testing/selftests/kvm/set_memory_region_test.c

591

TEST_ASSERT(run->internal.suberror == KVM_INTERNAL_ERROR_DELIVERY_EV,

tools/testing/selftests/kvm/set_memory_region_test.c

592

"Unexpected suberror = %d", vcpu->run->internal.suberror);

tools/testing/selftests/kvm/set_memory_region_test.c

593

TEST_ASSERT(run->internal.ndata != 4, "Unexpected internal error data array size = %d",

tools/testing/selftests/kvm/set_memory_region_test.c

594

run->internal.ndata);

tools/testing/selftests/kvm/set_memory_region_test.c

599

TEST_ASSERT(run->internal.data[3] == expected_gpa,

tools/testing/selftests/kvm/set_memory_region_test.c

601

vcpu->run->internal.data[3], expected_gpa);

tools/testing/selftests/kvm/set_memory_region_test.c

67

if (run->exit_reason == KVM_EXIT_IO) {

tools/testing/selftests/kvm/set_memory_region_test.c

76

if (run->exit_reason != KVM_EXIT_MMIO)

tools/testing/selftests/kvm/set_memory_region_test.c

79

TEST_ASSERT(!run->mmio.is_write, "Unexpected exit mmio write");

tools/testing/selftests/kvm/set_memory_region_test.c

80

TEST_ASSERT(run->mmio.len == 8,

tools/testing/selftests/kvm/set_memory_region_test.c

81

"Unexpected exit mmio size = %u", run->mmio.len);

tools/testing/selftests/kvm/set_memory_region_test.c

83

TEST_ASSERT(run->mmio.phys_addr == MEM_REGION_GPA,

tools/testing/selftests/kvm/set_memory_region_test.c

85

run->mmio.phys_addr);

tools/testing/selftests/kvm/set_memory_region_test.c

86

memcpy(run->mmio.data, &MMIO_VAL, 8);

tools/testing/selftests/kvm/set_memory_region_test.c

89

if (run->exit_reason == KVM_EXIT_IO && cmd == UCALL_ABORT)

tools/testing/selftests/kvm/steal_time.c

432

exit_reason_str(vcpu->run->exit_reason));

tools/testing/selftests/kvm/x86/cpuid_test.c

139

exit_reason_str(vcpu->run->exit_reason));

tools/testing/selftests/kvm/x86/cr4_cpuid_sync_test.c

77

if (vcpu->run->io.port == MAGIC_HYPERCALL_PORT &&

tools/testing/selftests/kvm/x86/cr4_cpuid_sync_test.c

78

vcpu->run->io.direction == KVM_EXIT_IO_OUT) {

tools/testing/selftests/kvm/x86/debug_regs.c

104

run = vcpu->run;

tools/testing/selftests/kvm/x86/debug_regs.c

111

TEST_ASSERT(run->exit_reason == KVM_EXIT_DEBUG &&

tools/testing/selftests/kvm/x86/debug_regs.c

112

run->debug.arch.exception == BP_VECTOR &&

tools/testing/selftests/kvm/x86/debug_regs.c

113

run->debug.arch.pc == CAST_TO_RIP(sw_bp),

tools/testing/selftests/kvm/x86/debug_regs.c

115

run->exit_reason, run->debug.arch.exception,

tools/testing/selftests/kvm/x86/debug_regs.c

116

run->debug.arch.pc, CAST_TO_RIP(sw_bp));

tools/testing/selftests/kvm/x86/debug_regs.c

128

TEST_ASSERT(run->exit_reason == KVM_EXIT_DEBUG &&

tools/testing/selftests/kvm/x86/debug_regs.c

129

run->debug.arch.exception == DB_VECTOR &&

tools/testing/selftests/kvm/x86/debug_regs.c

130

run->debug.arch.pc == CAST_TO_RIP(hw_bp) &&

tools/testing/selftests/kvm/x86/debug_regs.c

131

run->debug.arch.dr6 == target_dr6,

tools/testing/selftests/kvm/x86/debug_regs.c

134

i, run->exit_reason, run->debug.arch.exception,

tools/testing/selftests/kvm/x86/debug_regs.c

135

run->debug.arch.pc, CAST_TO_RIP(hw_bp),

tools/testing/selftests/kvm/x86/debug_regs.c

136

run->debug.arch.dr6, target_dr6);

tools/testing/selftests/kvm/x86/debug_regs.c

151

TEST_ASSERT(run->exit_reason == KVM_EXIT_DEBUG &&

tools/testing/selftests/kvm/x86/debug_regs.c

152

run->debug.arch.exception == DB_VECTOR &&

tools/testing/selftests/kvm/x86/debug_regs.c

153

run->debug.arch.pc == CAST_TO_RIP(write_data) &&

tools/testing/selftests/kvm/x86/debug_regs.c

154

run->debug.arch.dr6 == target_dr6,

tools/testing/selftests/kvm/x86/debug_regs.c

157

i, run->exit_reason, run->debug.arch.exception,

tools/testing/selftests/kvm/x86/debug_regs.c

158

run->debug.arch.pc, CAST_TO_RIP(write_data),

tools/testing/selftests/kvm/x86/debug_regs.c

159

run->debug.arch.dr6, target_dr6);

tools/testing/selftests/kvm/x86/debug_regs.c

177

TEST_ASSERT(run->exit_reason == KVM_EXIT_DEBUG &&

tools/testing/selftests/kvm/x86/debug_regs.c

178

run->debug.arch.exception == DB_VECTOR &&

tools/testing/selftests/kvm/x86/debug_regs.c

179

run->debug.arch.pc == target_rip &&

tools/testing/selftests/kvm/x86/debug_regs.c

180

run->debug.arch.dr6 == target_dr6,

tools/testing/selftests/kvm/x86/debug_regs.c

183

i, run->exit_reason, run->debug.arch.exception,

tools/testing/selftests/kvm/x86/debug_regs.c

184

run->debug.arch.pc, target_rip, run->debug.arch.dr6,

tools/testing/selftests/kvm/x86/debug_regs.c

195

TEST_ASSERT(run->exit_reason == KVM_EXIT_DEBUG &&

tools/testing/selftests/kvm/x86/debug_regs.c

196

run->debug.arch.exception == DB_VECTOR &&

tools/testing/selftests/kvm/x86/debug_regs.c

197

run->debug.arch.pc == CAST_TO_RIP(bd_start) &&

tools/testing/selftests/kvm/x86/debug_regs.c

198

run->debug.arch.dr6 == target_dr6,

tools/testing/selftests/kvm/x86/debug_regs.c

201

run->exit_reason, run->debug.arch.exception,

tools/testing/selftests/kvm/x86/debug_regs.c

202

run->debug.arch.pc, target_rip, run->debug.arch.dr6,

tools/testing/selftests/kvm/x86/debug_regs.c

86

struct kvm_run *run;

tools/testing/selftests/kvm/x86/fix_hypercall_test.c

105

uc.cmd, run->exit_reason, exit_reason_str(run->exit_reason));

tools/testing/selftests/kvm/x86/fix_hypercall_test.c

91

struct kvm_run *run = vcpu->run;

tools/testing/selftests/kvm/x86/flds_emulation.h

22

struct kvm_run *run = vcpu->run;

tools/testing/selftests/kvm/x86/flds_emulation.h

29

TEST_ASSERT(run->emulation_failure.suberror == KVM_INTERNAL_ERROR_EMULATION,

tools/testing/selftests/kvm/x86/flds_emulation.h

31

run->emulation_failure.suberror);

tools/testing/selftests/kvm/x86/flds_emulation.h

33

flags = run->emulation_failure.flags;

tools/testing/selftests/kvm/x86/flds_emulation.h

34

TEST_ASSERT(run->emulation_failure.ndata >= 3 &&

tools/testing/selftests/kvm/x86/flds_emulation.h

38

TEST_ASSERT(run->emulation_failure.insn_size >= 2,

tools/testing/selftests/kvm/x86/flds_emulation.h

40

run->emulation_failure.insn_size);

tools/testing/selftests/kvm/x86/flds_emulation.h

42

insn_bytes = run->emulation_failure.insn_bytes;

tools/testing/selftests/kvm/x86/hyperv_extended_hypercalls.c

41

struct kvm_run *run;

tools/testing/selftests/kvm/x86/hyperv_extended_hypercalls.c

56

run = vcpu->run;

tools/testing/selftests/kvm/x86/hyperv_extended_hypercalls.c

72

TEST_ASSERT(run->exit_reason == KVM_EXIT_HYPERV,

tools/testing/selftests/kvm/x86/hyperv_extended_hypercalls.c

74

run->exit_reason, exit_reason_str(run->exit_reason));

tools/testing/selftests/kvm/x86/hyperv_extended_hypercalls.c

76

outval = addr_gpa2hva(vm, run->hyperv.u.hcall.params[1]);

tools/testing/selftests/kvm/x86/hyperv_extended_hypercalls.c

78

run->hyperv.u.hcall.result = HV_STATUS_SUCCESS;

tools/testing/selftests/kvm/x86/hyperv_extended_hypercalls.c

82

TEST_ASSERT(run->exit_reason == KVM_EXIT_IO,

tools/testing/selftests/kvm/x86/hyperv_extended_hypercalls.c

84

run->exit_reason, exit_reason_str(run->exit_reason));

tools/testing/selftests/kvm/x86/kvm_buslock_test.c

102

if (run->exit_reason == KVM_EXIT_IO) {

tools/testing/selftests/kvm/x86/kvm_buslock_test.c

78

struct kvm_run *run;

tools/testing/selftests/kvm/x86/kvm_buslock_test.c

95

run = vcpu->run;

tools/testing/selftests/kvm/x86/nested_close_kvm_test.c

87

volatile struct kvm_run *run = vcpu->run;

tools/testing/selftests/kvm/x86/nested_close_kvm_test.c

93

if (run->io.port == PORT_L0_EXIT)

tools/testing/selftests/kvm/x86/nested_exceptions_test.c

243

vcpu->run->immediate_exit = true;

tools/testing/selftests/kvm/x86/nested_exceptions_test.c

259

vcpu->run->immediate_exit = false;

tools/testing/selftests/kvm/x86/private_mem_conversions_test.c

291

struct kvm_run *run = vcpu->run;

tools/testing/selftests/kvm/x86/private_mem_conversions_test.c

292

uint64_t gpa = run->hypercall.args[0];

tools/testing/selftests/kvm/x86/private_mem_conversions_test.c

293

uint64_t size = run->hypercall.args[1] * PAGE_SIZE;

tools/testing/selftests/kvm/x86/private_mem_conversions_test.c

294

bool set_attributes = run->hypercall.args[2] & MAP_GPA_SET_ATTRIBUTES;

tools/testing/selftests/kvm/x86/private_mem_conversions_test.c

295

bool map_shared = run->hypercall.args[2] & MAP_GPA_SHARED;

tools/testing/selftests/kvm/x86/private_mem_conversions_test.c

296

bool do_fallocate = run->hypercall.args[2] & MAP_GPA_DO_FALLOCATE;

tools/testing/selftests/kvm/x86/private_mem_conversions_test.c

299

TEST_ASSERT(run->hypercall.nr == KVM_HC_MAP_GPA_RANGE,

tools/testing/selftests/kvm/x86/private_mem_conversions_test.c

301

KVM_HC_MAP_GPA_RANGE, run->hypercall.nr);

tools/testing/selftests/kvm/x86/private_mem_conversions_test.c

309

run->hypercall.ret = 0;

tools/testing/selftests/kvm/x86/private_mem_conversions_test.c

317

struct kvm_run *run = vcpu->run;

tools/testing/selftests/kvm/x86/private_mem_conversions_test.c

327

if (run->exit_reason == KVM_EXIT_HYPERCALL) {

tools/testing/selftests/kvm/x86/private_mem_conversions_test.c

332

TEST_ASSERT(run->exit_reason == KVM_EXIT_IO,

tools/testing/selftests/kvm/x86/private_mem_conversions_test.c

334

run->exit_reason, exit_reason_str(run->exit_reason));

tools/testing/selftests/kvm/x86/private_mem_kvm_exits_test.c

107

TEST_ASSERT_EQ(vcpu->run->memory_fault.flags, KVM_MEMORY_EXIT_FLAG_PRIVATE);

tools/testing/selftests/kvm/x86/private_mem_kvm_exits_test.c

108

TEST_ASSERT_EQ(vcpu->run->memory_fault.gpa, EXITS_TEST_GPA);

tools/testing/selftests/kvm/x86/private_mem_kvm_exits_test.c

109

TEST_ASSERT_EQ(vcpu->run->memory_fault.size, EXITS_TEST_SIZE);

tools/testing/selftests/kvm/x86/private_mem_kvm_exits_test.c

37

TEST_ASSERT_EQ(vcpu->run->exit_reason, KVM_EXIT_MEMORY_FAULT);

tools/testing/selftests/kvm/x86/private_mem_kvm_exits_test.c

39

return vcpu->run->exit_reason;

tools/testing/selftests/kvm/x86/private_mem_kvm_exits_test.c

78

TEST_ASSERT_EQ(vcpu->run->memory_fault.flags, KVM_MEMORY_EXIT_FLAG_PRIVATE);

tools/testing/selftests/kvm/x86/private_mem_kvm_exits_test.c

79

TEST_ASSERT_EQ(vcpu->run->memory_fault.gpa, EXITS_TEST_GPA);

tools/testing/selftests/kvm/x86/private_mem_kvm_exits_test.c

80

TEST_ASSERT_EQ(vcpu->run->memory_fault.size, EXITS_TEST_SIZE);

tools/testing/selftests/kvm/x86/set_boot_cpu_id.c

84

exit_reason_str(vcpu->run->exit_reason));

tools/testing/selftests/kvm/x86/sev_smoke_test.c

141

TEST_ASSERT(vcpu->run->exit_reason == KVM_EXIT_SYSTEM_EVENT,

tools/testing/selftests/kvm/x86/sev_smoke_test.c

143

exit_reason_str(vcpu->run->exit_reason));

tools/testing/selftests/kvm/x86/sev_smoke_test.c

144

TEST_ASSERT_EQ(vcpu->run->system_event.type, KVM_SYSTEM_EVENT_SEV_TERM);

tools/testing/selftests/kvm/x86/sev_smoke_test.c

145

TEST_ASSERT_EQ(vcpu->run->system_event.ndata, 1);

tools/testing/selftests/kvm/x86/sev_smoke_test.c

146

TEST_ASSERT_EQ(vcpu->run->system_event.data[0], GHCB_MSR_TERM_REQ);

tools/testing/selftests/kvm/x86/sev_smoke_test.c

168

TEST_ASSERT(vcpu->run->exit_reason == KVM_EXIT_SYSTEM_EVENT,

tools/testing/selftests/kvm/x86/sev_smoke_test.c

170

exit_reason_str(vcpu->run->exit_reason));

tools/testing/selftests/kvm/x86/sev_smoke_test.c

171

TEST_ASSERT_EQ(vcpu->run->system_event.type, KVM_SYSTEM_EVENT_SEV_TERM);

tools/testing/selftests/kvm/x86/sev_smoke_test.c

172

TEST_ASSERT_EQ(vcpu->run->system_event.ndata, 1);

tools/testing/selftests/kvm/x86/sev_smoke_test.c

173

TEST_ASSERT_EQ(vcpu->run->system_event.data[0], GHCB_MSR_TERM_REQ);

tools/testing/selftests/kvm/x86/sev_smoke_test.c

186

exit_reason_str(vcpu->run->exit_reason));

tools/testing/selftests/kvm/x86/sev_smoke_test.c

214

TEST_ASSERT(vcpu->run->exit_reason == KVM_EXIT_SHUTDOWN,

tools/testing/selftests/kvm/x86/sev_smoke_test.c

216

exit_reason_str(vcpu->run->exit_reason));

tools/testing/selftests/kvm/x86/sync_regs_test.c

115

struct kvm_run *run = (struct kvm_run *)arg;

tools/testing/selftests/kvm/x86/sync_regs_test.c

116

struct kvm_vcpu_events *events = &run->s.regs.events;

tools/testing/selftests/kvm/x86/sync_regs_test.c

119

WRITE_ONCE(run->kvm_dirty_regs, KVM_SYNC_X86_EVENTS);

tools/testing/selftests/kvm/x86/sync_regs_test.c

137

struct kvm_run *run = (struct kvm_run *)arg;

tools/testing/selftests/kvm/x86/sync_regs_test.c

138

__u64 *cr4 = &run->s.regs.sregs.cr4;

tools/testing/selftests/kvm/x86/sync_regs_test.c

143

WRITE_ONCE(run->kvm_dirty_regs, KVM_SYNC_X86_SREGS);

tools/testing/selftests/kvm/x86/sync_regs_test.c

161

struct kvm_run *run;

tools/testing/selftests/kvm/x86/sync_regs_test.c

165

run = vcpu->run;

tools/testing/selftests/kvm/x86/sync_regs_test.c

167

run->kvm_valid_regs = KVM_SYNC_X86_SREGS;

tools/testing/selftests/kvm/x86/sync_regs_test.c

169

run->kvm_valid_regs = 0;

tools/testing/selftests/kvm/x86/sync_regs_test.c

178

TEST_ASSERT((run->s.regs.sregs.cr4 & X86_CR4_PAE) &&

tools/testing/selftests/kvm/x86/sync_regs_test.c

179

(run->s.regs.sregs.efer & EFER_LME),

tools/testing/selftests/kvm/x86/sync_regs_test.c

181

!!(run->s.regs.sregs.cr4 & X86_CR4_PAE),

tools/testing/selftests/kvm/x86/sync_regs_test.c

182

!!(run->s.regs.sregs.efer & EFER_LME));

tools/testing/selftests/kvm/x86/sync_regs_test.c

184

TEST_ASSERT_EQ(pthread_create(&thread, NULL, racer, (void *)run), 0);

tools/testing/selftests/kvm/x86/sync_regs_test.c

193

if (!__vcpu_run(vcpu) && run->exit_reason == KVM_EXIT_SHUTDOWN)

tools/testing/selftests/kvm/x86/sync_regs_test.c

210

struct kvm_run *run = vcpu->run;

tools/testing/selftests/kvm/x86/sync_regs_test.c

214

run->kvm_valid_regs = INVALID_SYNC_FIELD;

tools/testing/selftests/kvm/x86/sync_regs_test.c

219

run->kvm_valid_regs = 0;

tools/testing/selftests/kvm/x86/sync_regs_test.c

221

run->kvm_valid_regs = INVALID_SYNC_FIELD | TEST_SYNC_FIELDS;

tools/testing/selftests/kvm/x86/sync_regs_test.c

226

run->kvm_valid_regs = 0;

tools/testing/selftests/kvm/x86/sync_regs_test.c

231

struct kvm_run *run = vcpu->run;

tools/testing/selftests/kvm/x86/sync_regs_test.c

235

run->kvm_dirty_regs = INVALID_SYNC_FIELD;

tools/testing/selftests/kvm/x86/sync_regs_test.c

240

run->kvm_dirty_regs = 0;

tools/testing/selftests/kvm/x86/sync_regs_test.c

242

run->kvm_dirty_regs = INVALID_SYNC_FIELD | TEST_SYNC_FIELDS;

tools/testing/selftests/kvm/x86/sync_regs_test.c

247

run->kvm_dirty_regs = 0;

tools/testing/selftests/kvm/x86/sync_regs_test.c

252

struct kvm_run *run = vcpu->run;

tools/testing/selftests/kvm/x86/sync_regs_test.c

259

run->kvm_valid_regs = TEST_SYNC_FIELDS;

tools/testing/selftests/kvm/x86/sync_regs_test.c

264

compare_regs(&regs, &run->s.regs.regs);

tools/testing/selftests/kvm/x86/sync_regs_test.c

267

compare_sregs(&sregs, &run->s.regs.sregs);

tools/testing/selftests/kvm/x86/sync_regs_test.c

270

compare_vcpu_events(&events, &run->s.regs.events);

tools/testing/selftests/kvm/x86/sync_regs_test.c

275

struct kvm_run *run = vcpu->run;

tools/testing/selftests/kvm/x86/sync_regs_test.c

281

run->kvm_valid_regs = TEST_SYNC_FIELDS;

tools/testing/selftests/kvm/x86/sync_regs_test.c

286

run->s.regs.regs.rbx = 0xBAD1DEA;

tools/testing/selftests/kvm/x86/sync_regs_test.c

287

run->s.regs.sregs.apic_base = 1 << 11;

tools/testing/selftests/kvm/x86/sync_regs_test.c

290

run->kvm_valid_regs = TEST_SYNC_FIELDS;

tools/testing/selftests/kvm/x86/sync_regs_test.c

291

run->kvm_dirty_regs = KVM_SYNC_X86_REGS | KVM_SYNC_X86_SREGS;

tools/testing/selftests/kvm/x86/sync_regs_test.c

294

TEST_ASSERT(run->s.regs.regs.rbx == 0xBAD1DEA + 1,

tools/testing/selftests/kvm/x86/sync_regs_test.c

296

run->s.regs.regs.rbx);

tools/testing/selftests/kvm/x86/sync_regs_test.c

297

TEST_ASSERT(run->s.regs.sregs.apic_base == 1 << 11,

tools/testing/selftests/kvm/x86/sync_regs_test.c

299

run->s.regs.sregs.apic_base);

tools/testing/selftests/kvm/x86/sync_regs_test.c

302

compare_regs(&regs, &run->s.regs.regs);

tools/testing/selftests/kvm/x86/sync_regs_test.c

305

compare_sregs(&sregs, &run->s.regs.sregs);

tools/testing/selftests/kvm/x86/sync_regs_test.c

308

compare_vcpu_events(&events, &run->s.regs.events);

tools/testing/selftests/kvm/x86/sync_regs_test.c

313

struct kvm_run *run = vcpu->run;

tools/testing/selftests/kvm/x86/sync_regs_test.c

318

run->kvm_valid_regs = TEST_SYNC_FIELDS;

tools/testing/selftests/kvm/x86/sync_regs_test.c

319

run->kvm_dirty_regs = 0;

tools/testing/selftests/kvm/x86/sync_regs_test.c

320

run->s.regs.regs.rbx = 0xDEADBEEF;

tools/testing/selftests/kvm/x86/sync_regs_test.c

323

TEST_ASSERT(run->s.regs.regs.rbx != 0xDEADBEEF,

tools/testing/selftests/kvm/x86/sync_regs_test.c

325

run->s.regs.regs.rbx);

tools/testing/selftests/kvm/x86/sync_regs_test.c

330

struct kvm_run *run = vcpu->run;

tools/testing/selftests/kvm/x86/sync_regs_test.c

334

run->kvm_valid_regs = TEST_SYNC_FIELDS;

tools/testing/selftests/kvm/x86/sync_regs_test.c

342

run->kvm_valid_regs = 0;

tools/testing/selftests/kvm/x86/sync_regs_test.c

343

run->kvm_dirty_regs = 0;

tools/testing/selftests/kvm/x86/sync_regs_test.c

344

run->s.regs.regs.rbx = 0xAAAA;

tools/testing/selftests/kvm/x86/sync_regs_test.c

350

TEST_ASSERT(run->s.regs.regs.rbx == 0xAAAA,

tools/testing/selftests/kvm/x86/sync_regs_test.c

352

run->s.regs.regs.rbx);

tools/testing/selftests/kvm/x86/sync_regs_test.c

361

struct kvm_run *run = vcpu->run;

tools/testing/selftests/kvm/x86/sync_regs_test.c

365

run->kvm_valid_regs = TEST_SYNC_FIELDS;

tools/testing/selftests/kvm/x86/sync_regs_test.c

373

run->kvm_valid_regs = 0;

tools/testing/selftests/kvm/x86/sync_regs_test.c

374

run->kvm_dirty_regs = TEST_SYNC_FIELDS;

tools/testing/selftests/kvm/x86/sync_regs_test.c

375

run->s.regs.regs.rbx = 0xBBBB;

tools/testing/selftests/kvm/x86/sync_regs_test.c

378

TEST_ASSERT(run->s.regs.regs.rbx == 0xBBBB,

tools/testing/selftests/kvm/x86/sync_regs_test.c

380

run->s.regs.regs.rbx);

tools/testing/selftests/kvm/x86/sync_regs_test.c

92

struct kvm_run *run = (struct kvm_run *)arg;

tools/testing/selftests/kvm/x86/sync_regs_test.c

93

struct kvm_vcpu_events *events = &run->s.regs.events;

tools/testing/selftests/kvm/x86/sync_regs_test.c

98

WRITE_ONCE(run->kvm_dirty_regs, KVM_SYNC_X86_EVENTS);

tools/testing/selftests/kvm/x86/triple_fault_event_test.c

100

run->immediate_exit = true;

tools/testing/selftests/kvm/x86/triple_fault_event_test.c

62

struct kvm_run *run;

tools/testing/selftests/kvm/x86/triple_fault_event_test.c

89

run = vcpu->run;

tools/testing/selftests/kvm/x86/triple_fault_event_test.c

93

TEST_ASSERT(run->io.port == ARBITRARY_IO_PORT,

tools/testing/selftests/kvm/x86/triple_fault_event_test.c

95

ARBITRARY_IO_PORT, run->io.port);

tools/testing/selftests/kvm/x86/tsc_msrs_test.c

90

exit_reason_str(vcpu->run->exit_reason));

tools/testing/selftests/kvm/x86/userspace_io_test.c

57

struct kvm_run *run;

tools/testing/selftests/kvm/x86/userspace_io_test.c

62

run = vcpu->run;

tools/testing/selftests/kvm/x86/userspace_io_test.c

73

TEST_ASSERT(run->io.port == 0x80,

tools/testing/selftests/kvm/x86/userspace_io_test.c

74

"Expected I/O at port 0x80, got port 0x%x", run->io.port);

tools/testing/selftests/kvm/x86/userspace_io_test.c

88

memset((void *)run + run->io.data_offset, 0xaa, PAGE_SIZE);

tools/testing/selftests/kvm/x86/userspace_msr_exit_test.c

388

if (vcpu->run->exit_reason == KVM_EXIT_IO &&

tools/testing/selftests/kvm/x86/userspace_msr_exit_test.c

396

struct kvm_run *run = vcpu->run;

tools/testing/selftests/kvm/x86/userspace_msr_exit_test.c

401

TEST_ASSERT(run->msr.index == msr_index,

tools/testing/selftests/kvm/x86/userspace_msr_exit_test.c

403

run->msr.index, msr_index);

tools/testing/selftests/kvm/x86/userspace_msr_exit_test.c

405

switch (run->msr.index) {

tools/testing/selftests/kvm/x86/userspace_msr_exit_test.c

407

run->msr.data = 0;

tools/testing/selftests/kvm/x86/userspace_msr_exit_test.c

410

run->msr.error = 1;

tools/testing/selftests/kvm/x86/userspace_msr_exit_test.c

413

run->msr.data = msr_non_existent_data;

tools/testing/selftests/kvm/x86/userspace_msr_exit_test.c

416

run->msr.data = MSR_FS_BASE;

tools/testing/selftests/kvm/x86/userspace_msr_exit_test.c

419

run->msr.data = MSR_GS_BASE;

tools/testing/selftests/kvm/x86/userspace_msr_exit_test.c

422

TEST_ASSERT(false, "Unexpected MSR: 0x%04x", run->msr.index);

tools/testing/selftests/kvm/x86/userspace_msr_exit_test.c

428

struct kvm_run *run = vcpu->run;

tools/testing/selftests/kvm/x86/userspace_msr_exit_test.c

433

TEST_ASSERT(run->msr.index == msr_index,

tools/testing/selftests/kvm/x86/userspace_msr_exit_test.c

435

run->msr.index, msr_index);

tools/testing/selftests/kvm/x86/userspace_msr_exit_test.c

437

switch (run->msr.index) {

tools/testing/selftests/kvm/x86/userspace_msr_exit_test.c

439

if (run->msr.data != 0)

tools/testing/selftests/kvm/x86/userspace_msr_exit_test.c

440

run->msr.error = 1;

tools/testing/selftests/kvm/x86/userspace_msr_exit_test.c

443

if (run->msr.data != 1)

tools/testing/selftests/kvm/x86/userspace_msr_exit_test.c

444

run->msr.error = 1;

tools/testing/selftests/kvm/x86/userspace_msr_exit_test.c

447

msr_non_existent_data = run->msr.data;

tools/testing/selftests/kvm/x86/userspace_msr_exit_test.c

450

TEST_ASSERT(false, "Unexpected MSR: 0x%04x", run->msr.index);

tools/testing/selftests/kvm/x86/userspace_msr_exit_test.c

595

static void handle_rdmsr(struct kvm_run *run)

tools/testing/selftests/kvm/x86/userspace_msr_exit_test.c

597

run->msr.data = run->msr.index;

tools/testing/selftests/kvm/x86/userspace_msr_exit_test.c

600

if (run->msr.index == MSR_SYSCALL_MASK ||

tools/testing/selftests/kvm/x86/userspace_msr_exit_test.c

601

run->msr.index == MSR_GS_BASE) {

tools/testing/selftests/kvm/x86/userspace_msr_exit_test.c

602

TEST_ASSERT(run->msr.reason == KVM_MSR_EXIT_REASON_FILTER,

tools/testing/selftests/kvm/x86/userspace_msr_exit_test.c

606

if (run->msr.index == 0xdeadbeef) {

tools/testing/selftests/kvm/x86/userspace_msr_exit_test.c

607

TEST_ASSERT(run->msr.reason == KVM_MSR_EXIT_REASON_UNKNOWN,

tools/testing/selftests/kvm/x86/userspace_msr_exit_test.c

612

static void handle_wrmsr(struct kvm_run *run)

tools/testing/selftests/kvm/x86/userspace_msr_exit_test.c

617

if (run->msr.index == MSR_IA32_POWER_CTL) {

tools/testing/selftests/kvm/x86/userspace_msr_exit_test.c

618

TEST_ASSERT(run->msr.data == 0x1234,

tools/testing/selftests/kvm/x86/userspace_msr_exit_test.c

620

TEST_ASSERT(run->msr.reason == KVM_MSR_EXIT_REASON_FILTER,

tools/testing/selftests/kvm/x86/userspace_msr_exit_test.c

624

if (run->msr.index == 0xdeadbeef) {

tools/testing/selftests/kvm/x86/userspace_msr_exit_test.c

625

TEST_ASSERT(run->msr.data == 0x1234,

tools/testing/selftests/kvm/x86/userspace_msr_exit_test.c

627

TEST_ASSERT(run->msr.reason == KVM_MSR_EXIT_REASON_UNKNOWN,

tools/testing/selftests/kvm/x86/userspace_msr_exit_test.c

635

struct kvm_run *run = vcpu->run;

tools/testing/selftests/kvm/x86/userspace_msr_exit_test.c

653

switch (run->exit_reason) {

tools/testing/selftests/kvm/x86/userspace_msr_exit_test.c

655

handle_rdmsr(run);

tools/testing/selftests/kvm/x86/userspace_msr_exit_test.c

658

handle_wrmsr(run);

tools/testing/selftests/kvm/x86/vmx_apic_access_test.c

100

TEST_ASSERT(run->internal.suberror ==

tools/testing/selftests/kvm/x86/vmx_apic_access_test.c

103

run->internal.suberror);

tools/testing/selftests/kvm/x86/vmx_apic_access_test.c

94

volatile struct kvm_run *run = vcpu->run;

tools/testing/selftests/kvm/x86/vmx_exception_with_invalid_guest_state.c

25

struct kvm_run *run = vcpu->run;

tools/testing/selftests/kvm/x86/vmx_exception_with_invalid_guest_state.c

30

TEST_ASSERT(run->emulation_failure.suberror == KVM_INTERNAL_ERROR_EMULATION,

tools/testing/selftests/kvm/x86/vmx_exception_with_invalid_guest_state.c

32

run->emulation_failure.suberror);

tools/testing/selftests/kvm/x86/vmx_invalid_nested_guest_state.c

58

struct kvm_run *run;

tools/testing/selftests/kvm/x86/vmx_invalid_nested_guest_state.c

71

run = vcpu->run;

tools/testing/selftests/kvm/x86/vmx_invalid_nested_guest_state.c

79

TEST_ASSERT(run->io.port == ARBITRARY_IO_PORT,

tools/testing/selftests/kvm/x86/vmx_invalid_nested_guest_state.c

81

ARBITRARY_IO_PORT, run->io.port);

tools/testing/selftests/kvm/x86/xcr0_cpuid_test.c

108

struct kvm_run *run;

tools/testing/selftests/kvm/x86/xcr0_cpuid_test.c

115

run = vcpu->run;

tools/testing/selftests/kvm/x86/xcr0_cpuid_test.c

120

TEST_ASSERT(run->exit_reason == KVM_EXIT_IO,

tools/testing/selftests/kvm/x86/xcr0_cpuid_test.c

122

run->exit_reason,

tools/testing/selftests/kvm/x86/xcr0_cpuid_test.c

123

exit_reason_str(run->exit_reason));

tools/testing/selftests/kvm/x86/xen_vmcall_test.c

106

volatile struct kvm_run *run = vcpu->run;

tools/testing/selftests/kvm/x86/xen_vmcall_test.c

111

if (run->exit_reason == KVM_EXIT_XEN) {

tools/testing/selftests/kvm/x86/xen_vmcall_test.c

112

TEST_ASSERT_EQ(run->xen.type, KVM_EXIT_XEN_HCALL);

tools/testing/selftests/kvm/x86/xen_vmcall_test.c

113

TEST_ASSERT_EQ(run->xen.u.hcall.cpl, 0);

tools/testing/selftests/kvm/x86/xen_vmcall_test.c

114

TEST_ASSERT_EQ(run->xen.u.hcall.longmode, 1);

tools/testing/selftests/kvm/x86/xen_vmcall_test.c

115

TEST_ASSERT_EQ(run->xen.u.hcall.input, INPUTVALUE);

tools/testing/selftests/kvm/x86/xen_vmcall_test.c

116

TEST_ASSERT_EQ(run->xen.u.hcall.params[0], ARGVALUE(1));

tools/testing/selftests/kvm/x86/xen_vmcall_test.c

117

TEST_ASSERT_EQ(run->xen.u.hcall.params[1], ARGVALUE(2));

tools/testing/selftests/kvm/x86/xen_vmcall_test.c

118

TEST_ASSERT_EQ(run->xen.u.hcall.params[2], ARGVALUE(3));

tools/testing/selftests/kvm/x86/xen_vmcall_test.c

119

TEST_ASSERT_EQ(run->xen.u.hcall.params[3], ARGVALUE(4));

tools/testing/selftests/kvm/x86/xen_vmcall_test.c

120

TEST_ASSERT_EQ(run->xen.u.hcall.params[4], ARGVALUE(5));

tools/testing/selftests/kvm/x86/xen_vmcall_test.c

121

TEST_ASSERT_EQ(run->xen.u.hcall.params[5], ARGVALUE(6));

tools/testing/selftests/kvm/x86/xen_vmcall_test.c

122

run->xen.u.hcall.result = RETVALUE;

tools/testing/selftests/mm/ksm_tests.c

295

ksm_read_sysfs(KSM_FP("run"), &ksm_sysfs->run) ||

tools/testing/selftests/mm/ksm_tests.c

310

ksm_write_sysfs(KSM_FP("run"), ksm_sysfs->run) ||

tools/testing/selftests/mm/ksm_tests.c

34

unsigned long run;

tools/testing/selftests/rseq/slice_test.c

108

while (RSEQ_READ_ONCE(p->run)) {

tools/testing/selftests/rseq/slice_test.c

147

self->noise_params.run = 1;

tools/testing/selftests/rseq/slice_test.c

154

self->noise_params.run = 0;

tools/testing/selftests/rseq/slice_test.c

50

int64_t run;

tools/testing/selftests/sched_ext/allowed_cpus.c

81

.run = run,

tools/testing/selftests/sched_ext/create_dsq.c

54

.run = run,

tools/testing/selftests/sched_ext/cyclic_kick_wait.c

191

.run = run,

tools/testing/selftests/sched_ext/ddsp_bogus_dsq_fail.c

57

.run = run,

tools/testing/selftests/sched_ext/ddsp_vtimelocal_fail.c

56

.run = run,

tools/testing/selftests/sched_ext/dsp_local_on.c

57

.run = run,

tools/testing/selftests/sched_ext/enq_last_no_enq_fails.c

61

.run = run,

tools/testing/selftests/sched_ext/enq_select_cpu.c

85

.run = run,

tools/testing/selftests/sched_ext/exit.c

62

.run = run,

tools/testing/selftests/sched_ext/hotplug.c

166

.run = run,

tools/testing/selftests/sched_ext/init_enable_count.c

168

.run = run,

tools/testing/selftests/sched_ext/maximal.c

51

.run = run,

tools/testing/selftests/sched_ext/maybe_null.c

47

.run = run,

tools/testing/selftests/sched_ext/minimal.c

55

.run = run,

tools/testing/selftests/sched_ext/numa.c

56

.run = run,

tools/testing/selftests/sched_ext/peek_dsq.c

221

.run = run,

tools/testing/selftests/sched_ext/prog_run.c

75

.run = run,

tools/testing/selftests/sched_ext/reload_loop.c

71

.run = run,

tools/testing/selftests/sched_ext/rt_stall.c

285

.run = run,

tools/testing/selftests/sched_ext/runner.c

125

if (!test->run) {

tools/testing/selftests/sched_ext/runner.c

99

status = test->run(context);

tools/testing/selftests/sched_ext/scx_test.h

58

enum scx_test_status (*run)(void *ctx);

tools/testing/selftests/sched_ext/select_cpu_dfl.c

72

.run = run,

tools/testing/selftests/sched_ext/select_cpu_dfl_nodispatch.c

72

.run = run,

tools/testing/selftests/sched_ext/select_cpu_dispatch.c

70

.run = run,

tools/testing/selftests/sched_ext/select_cpu_dispatch_bad_dsq.c

56

.run = run,

tools/testing/selftests/sched_ext/select_cpu_dispatch_dbl_dsp.c

56

.run = run,

tools/testing/selftests/sched_ext/select_cpu_vtime.c

59

.run = run,

tools/testing/selftests/sched_ext/test_example.c

46

.run = run,

tools/testing/selftests/sched_ext/total_bw.c

278

.run = run,

tools/testing/selftests/sgx/main.c

1020

self->run.exception_vector = 0;

tools/testing/selftests/sgx/main.c

1021

self->run.exception_error_code = 0;

tools/testing/selftests/sgx/main.c

1022

self->run.exception_addr = 0;

tools/testing/selftests/sgx/main.c

1038

EXPECT_EQ(ENCL_CALL(&put_addr_op, &self->run, true), 0);

tools/testing/selftests/sgx/main.c

1040

EXPECT_EQ(self->run.function, ERESUME);

tools/testing/selftests/sgx/main.c

1041

EXPECT_EQ(self->run.exception_vector, 14);

tools/testing/selftests/sgx/main.c

1042

EXPECT_EQ(self->run.exception_addr, (unsigned long)addr);

tools/testing/selftests/sgx/main.c

1044

if (self->run.exception_error_code == 0x6) {

tools/testing/selftests/sgx/main.c

1049

EXPECT_EQ(self->run.exception_error_code, 0x8007);

tools/testing/selftests/sgx/main.c

1051

self->run.exception_vector = 0;

tools/testing/selftests/sgx/main.c

1052

self->run.exception_error_code = 0;

tools/testing/selftests/sgx/main.c

1053

self->run.exception_addr = 0;

tools/testing/selftests/sgx/main.c

1056

self->run.tcs = self->encl.encl_base + PAGE_SIZE;

tools/testing/selftests/sgx/main.c

1063

EXPECT_EQ(ENCL_CALL(&eaccept_op, &self->run, true), 0);

tools/testing/selftests/sgx/main.c

1065

EXPECT_EEXIT(&self->run);

tools/testing/selftests/sgx/main.c

1066

EXPECT_EQ(self->run.exception_vector, 0);

tools/testing/selftests/sgx/main.c

1067

EXPECT_EQ(self->run.exception_error_code, 0);

tools/testing/selftests/sgx/main.c

1068

EXPECT_EQ(self->run.exception_addr, 0);

tools/testing/selftests/sgx/main.c

1072

self->run.tcs = self->encl.encl_base;

tools/testing/selftests/sgx/main.c

1076

&self->run),

tools/testing/selftests/sgx/main.c

1079

EXPECT_EEXIT(&self->run);

tools/testing/selftests/sgx/main.c

1080

EXPECT_EQ(self->run.exception_vector, 0);

tools/testing/selftests/sgx/main.c

1081

EXPECT_EQ(self->run.exception_error_code, 0);

tools/testing/selftests/sgx/main.c

1082

EXPECT_EQ(self->run.exception_addr, 0);

tools/testing/selftests/sgx/main.c

1092

EXPECT_EQ(ENCL_CALL(&get_addr_op, &self->run, true), 0);

tools/testing/selftests/sgx/main.c

1095

EXPECT_EEXIT(&self->run);

tools/testing/selftests/sgx/main.c

1096

EXPECT_EQ(self->run.exception_vector, 0);

tools/testing/selftests/sgx/main.c

1097

EXPECT_EQ(self->run.exception_error_code, 0);

tools/testing/selftests/sgx/main.c

1098

EXPECT_EQ(self->run.exception_addr, 0);

tools/testing/selftests/sgx/main.c

1121

memset(&self->run, 0, sizeof(self->run));

tools/testing/selftests/sgx/main.c

1122

self->run.tcs = self->encl.encl_base;

tools/testing/selftests/sgx/main.c

1151

self->run.exception_vector = 0;

tools/testing/selftests/sgx/main.c

1152

self->run.exception_error_code = 0;

tools/testing/selftests/sgx/main.c

1153

self->run.exception_addr = 0;

tools/testing/selftests/sgx/main.c

1164

EXPECT_EQ(ENCL_CALL(&eaccept_op, &self->run, true), 0);

tools/testing/selftests/sgx/main.c

1166

if (self->run.exception_vector == 14 &&

tools/testing/selftests/sgx/main.c

1167

self->run.exception_error_code == 4 &&

tools/testing/selftests/sgx/main.c

1168

self->run.exception_addr == self->encl.encl_base + total_size) {

tools/testing/selftests/sgx/main.c

1173

EXPECT_EEXIT(&self->run);

tools/testing/selftests/sgx/main.c

1174

EXPECT_EQ(self->run.exception_vector, 0);

tools/testing/selftests/sgx/main.c

1175

EXPECT_EQ(self->run.exception_error_code, 0);

tools/testing/selftests/sgx/main.c

1176

EXPECT_EQ(self->run.exception_addr, 0);

tools/testing/selftests/sgx/main.c

1187

EXPECT_EQ(ENCL_CALL(&put_addr_op, &self->run, true), 0);

tools/testing/selftests/sgx/main.c

1189

EXPECT_EEXIT(&self->run);

tools/testing/selftests/sgx/main.c

1190

EXPECT_EQ(self->run.exception_vector, 0);

tools/testing/selftests/sgx/main.c

1191

EXPECT_EQ(self->run.exception_error_code, 0);

tools/testing/selftests/sgx/main.c

1192

EXPECT_EQ(self->run.exception_addr, 0);

tools/testing/selftests/sgx/main.c

1202

EXPECT_EQ(ENCL_CALL(&get_addr_op, &self->run, true), 0);

tools/testing/selftests/sgx/main.c

1205

EXPECT_EEXIT(&self->run);

tools/testing/selftests/sgx/main.c

1206

EXPECT_EQ(self->run.exception_vector, 0);

tools/testing/selftests/sgx/main.c

1207

EXPECT_EQ(self->run.exception_error_code, 0);

tools/testing/selftests/sgx/main.c

1208

EXPECT_EQ(self->run.exception_addr, 0);

tools/testing/selftests/sgx/main.c

1243

memset(&self->run, 0, sizeof(self->run));

tools/testing/selftests/sgx/main.c

1244

self->run.tcs = self->encl.encl_base;

tools/testing/selftests/sgx/main.c

1295

self->run.exception_vector = 0;

tools/testing/selftests/sgx/main.c

1296

self->run.exception_error_code = 0;

tools/testing/selftests/sgx/main.c

1297

self->run.exception_addr = 0;

tools/testing/selftests/sgx/main.c

1313

EXPECT_EQ(ENCL_CALL(&eaccept_op, &self->run, true), 0);

tools/testing/selftests/sgx/main.c

1315

if (self->run.exception_vector == 14 &&

tools/testing/selftests/sgx/main.c

1316

self->run.exception_error_code == 4 &&

tools/testing/selftests/sgx/main.c

1317

self->run.exception_addr == (unsigned long)stack_end) {

tools/testing/selftests/sgx/main.c

1322

EXPECT_EEXIT(&self->run);

tools/testing/selftests/sgx/main.c

1323

EXPECT_EQ(self->run.exception_vector, 0);

tools/testing/selftests/sgx/main.c

1324

EXPECT_EQ(self->run.exception_error_code, 0);

tools/testing/selftests/sgx/main.c

1325

EXPECT_EQ(self->run.exception_addr, 0);

tools/testing/selftests/sgx/main.c

1330

EXPECT_EQ(ENCL_CALL(&eaccept_op, &self->run, true), 0);

tools/testing/selftests/sgx/main.c

1332

EXPECT_EEXIT(&self->run);

tools/testing/selftests/sgx/main.c

1333

EXPECT_EQ(self->run.exception_vector, 0);

tools/testing/selftests/sgx/main.c

1334

EXPECT_EQ(self->run.exception_error_code, 0);

tools/testing/selftests/sgx/main.c

1335

EXPECT_EQ(self->run.exception_addr, 0);

tools/testing/selftests/sgx/main.c

1340

EXPECT_EQ(ENCL_CALL(&eaccept_op, &self->run, true), 0);

tools/testing/selftests/sgx/main.c

1342

EXPECT_EEXIT(&self->run);

tools/testing/selftests/sgx/main.c

1343

EXPECT_EQ(self->run.exception_vector, 0);

tools/testing/selftests/sgx/main.c

1344

EXPECT_EQ(self->run.exception_error_code, 0);

tools/testing/selftests/sgx/main.c

1345

EXPECT_EQ(self->run.exception_addr, 0);

tools/testing/selftests/sgx/main.c

1367

EXPECT_EQ(ENCL_CALL(&init_tcs_page_op, &self->run, true), 0);

tools/testing/selftests/sgx/main.c

1369

EXPECT_EEXIT(&self->run);

tools/testing/selftests/sgx/main.c

1370

EXPECT_EQ(self->run.exception_vector, 0);

tools/testing/selftests/sgx/main.c

1371

EXPECT_EQ(self->run.exception_error_code, 0);

tools/testing/selftests/sgx/main.c

1372

EXPECT_EQ(self->run.exception_addr, 0);

tools/testing/selftests/sgx/main.c

1395

EXPECT_EQ(ENCL_CALL(&eaccept_op, &self->run, true), 0);

tools/testing/selftests/sgx/main.c

1397

EXPECT_EEXIT(&self->run);

tools/testing/selftests/sgx/main.c

1398

EXPECT_EQ(self->run.exception_vector, 0);

tools/testing/selftests/sgx/main.c

1399

EXPECT_EQ(self->run.exception_error_code, 0);

tools/testing/selftests/sgx/main.c

1400

EXPECT_EQ(self->run.exception_addr, 0);

tools/testing/selftests/sgx/main.c

1404

self->run.tcs = (unsigned long)tcs;

tools/testing/selftests/sgx/main.c

1412

EXPECT_EQ(ENCL_CALL(&put_buf_op, &self->run, true), 0);

tools/testing/selftests/sgx/main.c

1414

EXPECT_EEXIT(&self->run);

tools/testing/selftests/sgx/main.c

1415

EXPECT_EQ(self->run.exception_vector, 0);

tools/testing/selftests/sgx/main.c

1416

EXPECT_EQ(self->run.exception_error_code, 0);

tools/testing/selftests/sgx/main.c

1417

EXPECT_EQ(self->run.exception_addr, 0);

tools/testing/selftests/sgx/main.c

1422

EXPECT_EQ(ENCL_CALL(&get_buf_op, &self->run, true), 0);

tools/testing/selftests/sgx/main.c

1425

EXPECT_EEXIT(&self->run);

tools/testing/selftests/sgx/main.c

1426

EXPECT_EQ(self->run.exception_vector, 0);

tools/testing/selftests/sgx/main.c

1427

EXPECT_EQ(self->run.exception_error_code, 0);

tools/testing/selftests/sgx/main.c

1428

EXPECT_EQ(self->run.exception_addr, 0);

tools/testing/selftests/sgx/main.c

1456

self->run.tcs = self->encl.encl_base;

tools/testing/selftests/sgx/main.c

1463

EXPECT_EQ(ENCL_CALL(&eaccept_op, &self->run, true), 0);

tools/testing/selftests/sgx/main.c

1465

EXPECT_EEXIT(&self->run);

tools/testing/selftests/sgx/main.c

1466

EXPECT_EQ(self->run.exception_vector, 0);

tools/testing/selftests/sgx/main.c

1467

EXPECT_EQ(self->run.exception_error_code, 0);

tools/testing/selftests/sgx/main.c

1468

EXPECT_EQ(self->run.exception_addr, 0);

tools/testing/selftests/sgx/main.c

1474

EXPECT_EQ(ENCL_CALL(&eaccept_op, &self->run, true), 0);

tools/testing/selftests/sgx/main.c

1476

EXPECT_EEXIT(&self->run);

tools/testing/selftests/sgx/main.c

1477

EXPECT_EQ(self->run.exception_vector, 0);

tools/testing/selftests/sgx/main.c

1478

EXPECT_EQ(self->run.exception_error_code, 0);

tools/testing/selftests/sgx/main.c

1479

EXPECT_EQ(self->run.exception_addr, 0);

tools/testing/selftests/sgx/main.c

1485

EXPECT_EQ(ENCL_CALL(&eaccept_op, &self->run, true), 0);

tools/testing/selftests/sgx/main.c

1487

EXPECT_EEXIT(&self->run);

tools/testing/selftests/sgx/main.c

1488

EXPECT_EQ(self->run.exception_vector, 0);

tools/testing/selftests/sgx/main.c

1489

EXPECT_EQ(self->run.exception_error_code, 0);

tools/testing/selftests/sgx/main.c

1490

EXPECT_EQ(self->run.exception_addr, 0);

tools/testing/selftests/sgx/main.c

1515

EXPECT_EQ(ENCL_CALL(&eaccept_op, &self->run, true), 0);

tools/testing/selftests/sgx/main.c

1517

EXPECT_EEXIT(&self->run);

tools/testing/selftests/sgx/main.c

1518

EXPECT_EQ(self->run.exception_vector, 0);

tools/testing/selftests/sgx/main.c

1519

EXPECT_EQ(self->run.exception_error_code, 0);

tools/testing/selftests/sgx/main.c

1520

EXPECT_EQ(self->run.exception_addr, 0);

tools/testing/selftests/sgx/main.c

1530

EXPECT_EQ(ENCL_CALL(&put_addr_op, &self->run, true), 0);

tools/testing/selftests/sgx/main.c

1532

EXPECT_EEXIT(&self->run);

tools/testing/selftests/sgx/main.c

1533

EXPECT_EQ(self->run.exception_vector, 0);

tools/testing/selftests/sgx/main.c

1534

EXPECT_EQ(self->run.exception_error_code, 0);

tools/testing/selftests/sgx/main.c

1535

EXPECT_EQ(self->run.exception_addr, 0);

tools/testing/selftests/sgx/main.c

1545

EXPECT_EQ(ENCL_CALL(&get_addr_op, &self->run, true), 0);

tools/testing/selftests/sgx/main.c

1548

EXPECT_EEXIT(&self->run);

tools/testing/selftests/sgx/main.c

1549

EXPECT_EQ(self->run.exception_vector, 0);

tools/testing/selftests/sgx/main.c

1550

EXPECT_EQ(self->run.exception_error_code, 0);

tools/testing/selftests/sgx/main.c

1551

EXPECT_EQ(self->run.exception_addr, 0);

tools/testing/selftests/sgx/main.c

1573

memset(&self->run, 0, sizeof(self->run));

tools/testing/selftests/sgx/main.c

1574

self->run.tcs = self->encl.encl_base;

tools/testing/selftests/sgx/main.c

1615

EXPECT_EQ(ENCL_CALL(&put_addr_op, &self->run, true), 0);

tools/testing/selftests/sgx/main.c

1617

EXPECT_EEXIT(&self->run);

tools/testing/selftests/sgx/main.c

1618

EXPECT_EQ(self->run.exception_vector, 0);

tools/testing/selftests/sgx/main.c

1619

EXPECT_EQ(self->run.exception_error_code, 0);

tools/testing/selftests/sgx/main.c

1620

EXPECT_EQ(self->run.exception_addr, 0);

tools/testing/selftests/sgx/main.c

1630

EXPECT_EQ(ENCL_CALL(&get_addr_op, &self->run, true), 0);

tools/testing/selftests/sgx/main.c

1633

EXPECT_EEXIT(&self->run);

tools/testing/selftests/sgx/main.c

1634

EXPECT_EQ(self->run.exception_vector, 0);

tools/testing/selftests/sgx/main.c

1635

EXPECT_EQ(self->run.exception_error_code, 0);

tools/testing/selftests/sgx/main.c

1636

EXPECT_EQ(self->run.exception_addr, 0);

tools/testing/selftests/sgx/main.c

1684

memset(&self->run, 0, sizeof(self->run));

tools/testing/selftests/sgx/main.c

1685

self->run.tcs = self->encl.encl_base;

tools/testing/selftests/sgx/main.c

172

struct sgx_enclave_run run;

tools/testing/selftests/sgx/main.c

1726

EXPECT_EQ(ENCL_CALL(&put_addr_op, &self->run, true), 0);

tools/testing/selftests/sgx/main.c

1728

EXPECT_EEXIT(&self->run);

tools/testing/selftests/sgx/main.c

1729

EXPECT_EQ(self->run.exception_vector, 0);

tools/testing/selftests/sgx/main.c

1730

EXPECT_EQ(self->run.exception_error_code, 0);

tools/testing/selftests/sgx/main.c

1731

EXPECT_EQ(self->run.exception_addr, 0);

tools/testing/selftests/sgx/main.c

1741

EXPECT_EQ(ENCL_CALL(&get_addr_op, &self->run, true), 0);

tools/testing/selftests/sgx/main.c

1744

EXPECT_EEXIT(&self->run);

tools/testing/selftests/sgx/main.c

1745

EXPECT_EQ(self->run.exception_vector, 0);

tools/testing/selftests/sgx/main.c

1746

EXPECT_EQ(self->run.exception_error_code, 0);

tools/testing/selftests/sgx/main.c

1747

EXPECT_EQ(self->run.exception_addr, 0);

tools/testing/selftests/sgx/main.c

1769

EXPECT_EQ(ENCL_CALL(&get_addr_op, &self->run, true), 0);

tools/testing/selftests/sgx/main.c

1777

EXPECT_EQ(self->run.function, ERESUME);

tools/testing/selftests/sgx/main.c

1778

EXPECT_EQ(self->run.exception_vector, 14);

tools/testing/selftests/sgx/main.c

1779

EXPECT_EQ(self->run.exception_error_code, 0x8005);

tools/testing/selftests/sgx/main.c

1780

EXPECT_EQ(self->run.exception_addr, data_start);

tools/testing/selftests/sgx/main.c

1799

memset(&self->run, 0, sizeof(self->run));

tools/testing/selftests/sgx/main.c

1800

self->run.tcs = self->encl.encl_base;

tools/testing/selftests/sgx/main.c

1841

EXPECT_EQ(ENCL_CALL(&put_addr_op, &self->run, true), 0);

tools/testing/selftests/sgx/main.c

1843

EXPECT_EEXIT(&self->run);

tools/testing/selftests/sgx/main.c

1844

EXPECT_EQ(self->run.exception_vector, 0);

tools/testing/selftests/sgx/main.c

1845

EXPECT_EQ(self->run.exception_error_code, 0);

tools/testing/selftests/sgx/main.c

1846

EXPECT_EQ(self->run.exception_addr, 0);

tools/testing/selftests/sgx/main.c

1856

EXPECT_EQ(ENCL_CALL(&get_addr_op, &self->run, true), 0);

tools/testing/selftests/sgx/main.c

1859

EXPECT_EEXIT(&self->run);

tools/testing/selftests/sgx/main.c

1860

EXPECT_EQ(self->run.exception_vector, 0);

tools/testing/selftests/sgx/main.c

1861

EXPECT_EQ(self->run.exception_error_code, 0);

tools/testing/selftests/sgx/main.c

1862

EXPECT_EQ(self->run.exception_addr, 0);

tools/testing/selftests/sgx/main.c

1884

EXPECT_EQ(ENCL_CALL(&eaccept_op, &self->run, true), 0);

tools/testing/selftests/sgx/main.c

1886

EXPECT_EEXIT(&self->run);

tools/testing/selftests/sgx/main.c

1887

EXPECT_EQ(self->run.exception_vector, 0);

tools/testing/selftests/sgx/main.c

1888

EXPECT_EQ(self->run.exception_error_code, 0);

tools/testing/selftests/sgx/main.c

1889

EXPECT_EQ(self->run.exception_addr, 0);

tools/testing/selftests/sgx/main.c

1899

EXPECT_EQ(ENCL_CALL(&get_addr_op, &self->run, true), 0);

tools/testing/selftests/sgx/main.c

1907

EXPECT_EQ(self->run.function, ERESUME);

tools/testing/selftests/sgx/main.c

1908

EXPECT_EQ(self->run.exception_vector, 14);

tools/testing/selftests/sgx/main.c

1909

EXPECT_EQ(self->run.exception_error_code, 0x8005);

tools/testing/selftests/sgx/main.c

1910

EXPECT_EQ(self->run.exception_addr, data_start);

tools/testing/selftests/sgx/main.c

1945

memset(&self->run, 0, sizeof(self->run));

tools/testing/selftests/sgx/main.c

1946

self->run.tcs = self->encl.encl_base;

tools/testing/selftests/sgx/main.c

1974

EXPECT_EQ(ENCL_CALL(&eaccept_op, &self->run, true), 0);

tools/testing/selftests/sgx/main.c

1975

EXPECT_EEXIT(&self->run);

tools/testing/selftests/sgx/main.c

1976

EXPECT_EQ(self->run.exception_vector, 0);

tools/testing/selftests/sgx/main.c

1977

EXPECT_EQ(self->run.exception_error_code, 0);

tools/testing/selftests/sgx/main.c

1978

EXPECT_EQ(self->run.exception_addr, 0);

tools/testing/selftests/sgx/main.c

262

#define ENCL_CALL(op, run, clobbered) \

tools/testing/selftests/sgx/main.c

267

EENTER, 0, 0, (run)); \

tools/testing/selftests/sgx/main.c

270

(run)); \

tools/testing/selftests/sgx/main.c

274

#define EXPECT_EEXIT(run) \

tools/testing/selftests/sgx/main.c

276

EXPECT_EQ((run)->function, EEXIT); \

tools/testing/selftests/sgx/main.c

277

if ((run)->function != EEXIT) \

tools/testing/selftests/sgx/main.c

278

TH_LOG("0x%02x 0x%02x 0x%016llx", (run)->exception_vector, \

tools/testing/selftests/sgx/main.c

279

(run)->exception_error_code, (run)->exception_addr); \

tools/testing/selftests/sgx/main.c

289

memset(&self->run, 0, sizeof(self->run));

tools/testing/selftests/sgx/main.c

290

self->run.tcs = self->encl.encl_base;

tools/testing/selftests/sgx/main.c

295

EXPECT_EQ(ENCL_CALL(&put_op, &self->run, false), 0);

tools/testing/selftests/sgx/main.c

297

EXPECT_EEXIT(&self->run);

tools/testing/selftests/sgx/main.c

298

EXPECT_EQ(self->run.user_data, 0);

tools/testing/selftests/sgx/main.c

303

EXPECT_EQ(ENCL_CALL(&get_op, &self->run, false), 0);

tools/testing/selftests/sgx/main.c

306

EXPECT_EEXIT(&self->run);

tools/testing/selftests/sgx/main.c

307

EXPECT_EQ(self->run.user_data, 0);

tools/testing/selftests/sgx/main.c

362

memset(&self->run, 0, sizeof(self->run));

tools/testing/selftests/sgx/main.c

363

self->run.tcs = self->encl.encl_base;

tools/testing/selftests/sgx/main.c

368

EXPECT_EQ(ENCL_CALL(&put_op, &self->run, false), 0);

tools/testing/selftests/sgx/main.c

370

EXPECT_EEXIT(&self->run);

tools/testing/selftests/sgx/main.c

371

EXPECT_EQ(self->run.user_data, 0);

tools/testing/selftests/sgx/main.c

376

EXPECT_EQ(ENCL_CALL(&get_op, &self->run, false), 0);

tools/testing/selftests/sgx/main.c

379

EXPECT_EEXIT(&self->run);

tools/testing/selftests/sgx/main.c

380

EXPECT_EQ(self->run.user_data, 0);

tools/testing/selftests/sgx/main.c

428

memset(&self->run, 0, sizeof(self->run));

tools/testing/selftests/sgx/main.c

429

self->run.tcs = self->encl.encl_base;

tools/testing/selftests/sgx/main.c

436

EXPECT_EQ(ENCL_CALL(&put_op, &self->run, false), 0);

tools/testing/selftests/sgx/main.c

438

EXPECT_EEXIT(&self->run);

tools/testing/selftests/sgx/main.c

439

EXPECT_EQ(self->run.user_data, 0);

tools/testing/selftests/sgx/main.c

444

EXPECT_EQ(ENCL_CALL(&get_op, &self->run, false), 0);

tools/testing/selftests/sgx/main.c

447

EXPECT_EEXIT(&self->run);

tools/testing/selftests/sgx/main.c

448

EXPECT_EQ(self->run.user_data, 0);

tools/testing/selftests/sgx/main.c

479

EXPECT_EQ(ENCL_CALL(&eaccept_op, &self->run, true), 0);

tools/testing/selftests/sgx/main.c

481

EXPECT_EQ(self->run.exception_vector, 0);

tools/testing/selftests/sgx/main.c

482

EXPECT_EQ(self->run.exception_error_code, 0);

tools/testing/selftests/sgx/main.c

483

EXPECT_EQ(self->run.exception_addr, 0);

tools/testing/selftests/sgx/main.c

485

ASSERT_EQ(self->run.function, EEXIT);

tools/testing/selftests/sgx/main.c

511

memset(&self->run, 0, sizeof(self->run));

tools/testing/selftests/sgx/main.c

512

self->run.tcs = self->encl.encl_base;

tools/testing/selftests/sgx/main.c

517

EXPECT_EQ(ENCL_CALL(&put_op, &self->run, true), 0);

tools/testing/selftests/sgx/main.c

519

EXPECT_EEXIT(&self->run);

tools/testing/selftests/sgx/main.c

520

EXPECT_EQ(self->run.user_data, 0);

tools/testing/selftests/sgx/main.c

525

EXPECT_EQ(ENCL_CALL(&get_op, &self->run, true), 0);

tools/testing/selftests/sgx/main.c

528

EXPECT_EEXIT(&self->run);

tools/testing/selftests/sgx/main.c

529

EXPECT_EQ(self->run.user_data, 0);

tools/testing/selftests/sgx/main.c

533

struct sgx_enclave_run *run)

tools/testing/selftests/sgx/main.c

535

run->user_data = 0;

tools/testing/selftests/sgx/main.c

547

memset(&self->run, 0, sizeof(self->run));

tools/testing/selftests/sgx/main.c

548

self->run.tcs = self->encl.encl_base;

tools/testing/selftests/sgx/main.c

550

self->run.user_handler = (__u64)test_handler;

tools/testing/selftests/sgx/main.c

551

self->run.user_data = 0xdeadbeef;

tools/testing/selftests/sgx/main.c

556

EXPECT_EQ(ENCL_CALL(&put_op, &self->run, true), 0);

tools/testing/selftests/sgx/main.c

558

EXPECT_EEXIT(&self->run);

tools/testing/selftests/sgx/main.c

559

EXPECT_EQ(self->run.user_data, 0);

tools/testing/selftests/sgx/main.c

564

EXPECT_EQ(ENCL_CALL(&get_op, &self->run, true), 0);

tools/testing/selftests/sgx/main.c

567

EXPECT_EEXIT(&self->run);

tools/testing/selftests/sgx/main.c

568

EXPECT_EQ(self->run.user_data, 0);

tools/testing/selftests/sgx/main.c

580

memset(&self->run, 0, sizeof(self->run));

tools/testing/selftests/sgx/main.c

581

self->run.tcs = self->encl.encl_base;

tools/testing/selftests/sgx/main.c

585

EXPECT_EQ(ENCL_CALL(&op, &self->run, true), 0);

tools/testing/selftests/sgx/main.c

587

EXPECT_EEXIT(&self->run);

tools/testing/selftests/sgx/main.c

588

EXPECT_EQ(self->run.exception_vector, 0);

tools/testing/selftests/sgx/main.c

589

EXPECT_EQ(self->run.exception_error_code, 0);

tools/testing/selftests/sgx/main.c

590

EXPECT_EQ(self->run.exception_addr, 0);

tools/testing/selftests/sgx/main.c

593

self->run.tcs = self->encl.encl_base + PAGE_SIZE;

tools/testing/selftests/sgx/main.c

595

EXPECT_EQ(ENCL_CALL(&op, &self->run, true), 0);

tools/testing/selftests/sgx/main.c

597

EXPECT_EEXIT(&self->run);

tools/testing/selftests/sgx/main.c

598

EXPECT_EQ(self->run.exception_vector, 0);

tools/testing/selftests/sgx/main.c

599

EXPECT_EQ(self->run.exception_error_code, 0);

tools/testing/selftests/sgx/main.c

600

EXPECT_EQ(self->run.exception_addr, 0);

tools/testing/selftests/sgx/main.c

625

memset(&self->run, 0, sizeof(self->run));

tools/testing/selftests/sgx/main.c

626

self->run.tcs = self->encl.encl_base;

tools/testing/selftests/sgx/main.c

642

EXPECT_EQ(ENCL_CALL(&put_addr_op, &self->run, true), 0);

tools/testing/selftests/sgx/main.c

644

EXPECT_EEXIT(&self->run);

tools/testing/selftests/sgx/main.c

645

EXPECT_EQ(self->run.exception_vector, 0);

tools/testing/selftests/sgx/main.c

646

EXPECT_EQ(self->run.exception_error_code, 0);

tools/testing/selftests/sgx/main.c

647

EXPECT_EQ(self->run.exception_addr, 0);

tools/testing/selftests/sgx/main.c

657

EXPECT_EQ(ENCL_CALL(&get_addr_op, &self->run, true), 0);

tools/testing/selftests/sgx/main.c

660

EXPECT_EEXIT(&self->run);

tools/testing/selftests/sgx/main.c

661

EXPECT_EQ(self->run.exception_vector, 0);

tools/testing/selftests/sgx/main.c

662

EXPECT_EQ(self->run.exception_error_code, 0);

tools/testing/selftests/sgx/main.c

663

EXPECT_EQ(self->run.exception_addr, 0);

tools/testing/selftests/sgx/main.c

678

EXPECT_EQ(ENCL_CALL(&put_addr_op, &self->run, true), 0);

tools/testing/selftests/sgx/main.c

680

EXPECT_EQ(self->run.exception_vector, 14);

tools/testing/selftests/sgx/main.c

681

EXPECT_EQ(self->run.exception_error_code, 0x7);

tools/testing/selftests/sgx/main.c

682

EXPECT_EQ(self->run.exception_addr, data_start);

tools/testing/selftests/sgx/main.c

684

self->run.exception_vector = 0;

tools/testing/selftests/sgx/main.c

685

self->run.exception_error_code = 0;

tools/testing/selftests/sgx/main.c

686

self->run.exception_addr = 0;

tools/testing/selftests/sgx/main.c

698

0, ERESUME, 0, 0, &self->run),

tools/testing/selftests/sgx/main.c

701

EXPECT_EEXIT(&self->run);

tools/testing/selftests/sgx/main.c

702

EXPECT_EQ(self->run.exception_vector, 0);

tools/testing/selftests/sgx/main.c

703

EXPECT_EQ(self->run.exception_error_code, 0);

tools/testing/selftests/sgx/main.c

704

EXPECT_EQ(self->run.exception_addr, 0);

tools/testing/selftests/sgx/main.c

708

EXPECT_EQ(ENCL_CALL(&get_addr_op, &self->run, true), 0);

tools/testing/selftests/sgx/main.c

711

EXPECT_EEXIT(&self->run);

tools/testing/selftests/sgx/main.c

712

EXPECT_EQ(self->run.exception_vector, 0);

tools/testing/selftests/sgx/main.c

713

EXPECT_EQ(self->run.exception_error_code, 0);

tools/testing/selftests/sgx/main.c

714

EXPECT_EQ(self->run.exception_addr, 0);

tools/testing/selftests/sgx/main.c

727

memset(&self->run, 0, sizeof(self->run));

tools/testing/selftests/sgx/main.c

728

self->run.tcs = self->encl.encl_base;

tools/testing/selftests/sgx/main.c

790

memset(&self->run, 0, sizeof(self->run));

tools/testing/selftests/sgx/main.c

791

self->run.tcs = self->encl.encl_base;

tools/testing/selftests/sgx/main.c

838

EXPECT_EQ(ENCL_CALL(&put_addr_op, &self->run, true), 0);

tools/testing/selftests/sgx/main.c

840

EXPECT_EEXIT(&self->run);

tools/testing/selftests/sgx/main.c

841

EXPECT_EQ(self->run.exception_vector, 0);

tools/testing/selftests/sgx/main.c

842

EXPECT_EQ(self->run.exception_error_code, 0);

tools/testing/selftests/sgx/main.c

843

EXPECT_EQ(self->run.exception_addr, 0);

tools/testing/selftests/sgx/main.c

853

EXPECT_EQ(ENCL_CALL(&get_addr_op, &self->run, true), 0);

tools/testing/selftests/sgx/main.c

856

EXPECT_EEXIT(&self->run);

tools/testing/selftests/sgx/main.c

857

EXPECT_EQ(self->run.exception_vector, 0);

tools/testing/selftests/sgx/main.c

858

EXPECT_EQ(self->run.exception_error_code, 0);

tools/testing/selftests/sgx/main.c

859

EXPECT_EQ(self->run.exception_addr, 0);

tools/testing/selftests/sgx/main.c

888

EXPECT_EQ(ENCL_CALL(&eaccept_op, &self->run, true), 0);

tools/testing/selftests/sgx/main.c

890

EXPECT_EEXIT(&self->run);

tools/testing/selftests/sgx/main.c

891

EXPECT_EQ(self->run.exception_vector, 0);

tools/testing/selftests/sgx/main.c

892

EXPECT_EQ(self->run.exception_error_code, 0);

tools/testing/selftests/sgx/main.c

893

EXPECT_EQ(self->run.exception_addr, 0);

tools/testing/selftests/sgx/main.c

902

EXPECT_EQ(ENCL_CALL(&put_addr_op, &self->run, true), 0);

tools/testing/selftests/sgx/main.c

904

EXPECT_EQ(self->run.function, ERESUME);

tools/testing/selftests/sgx/main.c

905

EXPECT_EQ(self->run.exception_vector, 14);

tools/testing/selftests/sgx/main.c

906

EXPECT_EQ(self->run.exception_error_code, 0x8007);

tools/testing/selftests/sgx/main.c

907

EXPECT_EQ(self->run.exception_addr, data_start);

tools/testing/selftests/sgx/main.c

909

self->run.exception_vector = 0;

tools/testing/selftests/sgx/main.c

910

self->run.exception_error_code = 0;

tools/testing/selftests/sgx/main.c

911

self->run.exception_addr = 0;

tools/testing/selftests/sgx/main.c

918

self->run.tcs = self->encl.encl_base + PAGE_SIZE;

tools/testing/selftests/sgx/main.c

930

EXPECT_EQ(ENCL_CALL(&emodpe_op, &self->run, true), 0);

tools/testing/selftests/sgx/main.c

932

EXPECT_EEXIT(&self->run);

tools/testing/selftests/sgx/main.c

933

EXPECT_EQ(self->run.exception_vector, 0);

tools/testing/selftests/sgx/main.c

934

EXPECT_EQ(self->run.exception_error_code, 0);

tools/testing/selftests/sgx/main.c

935

EXPECT_EQ(self->run.exception_addr, 0);

tools/testing/selftests/sgx/main.c

941

self->run.tcs = self->encl.encl_base;

tools/testing/selftests/sgx/main.c

948

self->run.tcs = self->encl.encl_base;

tools/testing/selftests/sgx/main.c

952

&self->run),

tools/testing/selftests/sgx/main.c

955

EXPECT_EEXIT(&self->run);

tools/testing/selftests/sgx/main.c

956

EXPECT_EQ(self->run.exception_vector, 0);

tools/testing/selftests/sgx/main.c

957

EXPECT_EQ(self->run.exception_error_code, 0);

tools/testing/selftests/sgx/main.c

958

EXPECT_EQ(self->run.exception_addr, 0);

tools/testing/selftests/sgx/main.c

962

EXPECT_EQ(ENCL_CALL(&get_addr_op, &self->run, true), 0);

tools/testing/selftests/sgx/main.c

965

EXPECT_EEXIT(&self->run);

tools/testing/selftests/sgx/main.c

966

EXPECT_EQ(self->run.user_data, 0);

tools/testing/selftests/sgx/main.c

967

EXPECT_EQ(self->run.exception_vector, 0);

tools/testing/selftests/sgx/main.c

968

EXPECT_EQ(self->run.exception_error_code, 0);

tools/testing/selftests/sgx/main.c

969

EXPECT_EQ(self->run.exception_addr, 0);

tools/testing/selftests/sgx/main.c

991

memset(&self->run, 0, sizeof(self->run));

tools/testing/selftests/sgx/main.c

992

self->run.tcs = self->encl.encl_base;

tools/testing/selftests/sgx/main.h

44

struct sgx_enclave_run *run);

tools/testing/selftests/ublk/kublk.c

1418

goto run;

tools/testing/selftests/ublk/kublk.c

1447

run:

tools/testing/selftests/x86/syscall_numbering.c

232

run("Checking for x32 by calling x32 getpid()\n");

tools/testing/selftests/x86/syscall_numbering.c

254

run("Checking some common syscalls as 64 bit\n");

tools/testing/selftests/x86/syscall_numbering.c

258

run("Checking some 64-bit only syscalls as 64 bit\n");

tools/testing/selftests/x86/syscall_numbering.c

262

run("Checking out of range system calls\n");

tools/testing/selftests/x86/syscall_numbering.c

281

run("Checking x32 syscalls as 64 bit\n");

tools/testing/selftests/x86/syscall_numbering.c

284

run("Checking some common syscalls as x32\n");

tools/testing/selftests/x86/syscall_numbering.c

288

run("Checking some x32 syscalls as x32\n");

tools/testing/selftests/x86/syscall_numbering.c

292

run("Checking some 64-bit syscalls as x32\n");

tools/testing/selftests/x86/syscall_numbering.c

300

run("Checking for absence of x32 system calls\n");

tools/testing/selftests/x86/syscall_numbering.c

319

run("Checking system calls with msb = %d (0x%x)\n",

tools/testing/selftests/x86/syscall_numbering.c

348

run("Running tests under ptrace: %s\n", ptrace_pass_name[pass]);

tools/testing/selftests/x86/syscall_numbering.c

469

run("Running tests without ptrace...\n");

tools/testing/vsock/util.c

474

void (*run)(const struct test_opts *opts);

tools/testing/vsock/util.c

505

run = test_cases[i].run_client;

tools/testing/vsock/util.c

507

run = test_cases[i].run_server;

tools/testing/vsock/util.c

509

if (run)

tools/testing/vsock/util.c

510

run(opts);

tools/verification/rv/src/rv.c

126

run += ikm_run_monitor(monitor_name, argc-1, &argv[1]);

tools/verification/rv/src/rv.c

128

if (!run)

tools/verification/rv/src/rv.c

130

exit(!run);

tools/verification/rv/src/rv.c

89

int i, run = 0;

virt/kvm/dirty_ring.c

254

vcpu->run->exit_reason = KVM_EXIT_DIRTY_RING_FULL;

virt/kvm/kvm_main.c

4059

page = virt_to_page(vcpu->run);

virt/kvm/kvm_main.c

4203

vcpu->run = page_address(page);

virt/kvm/kvm_main.c

4268

free_page((unsigned long)vcpu->run);

virt/kvm/kvm_main.c

4475

vcpu->wants_to_run = !READ_ONCE(vcpu->run->immediate_exit__unsafe);

virt/kvm/kvm_main.c

4485

trace_kvm_userspace_exit(vcpu->run->exit_reason, r);

virt/kvm/kvm_main.c

479

free_page((unsigned long)vcpu->run);