int main() { int rc = 0; printf("tstVMStructSize: TESTING\n"); printf("info: struct VM: %d bytes\n", (int)sizeof(VM)); #define CHECK_PADDING_VM(align, member) \ do \ { \ CHECK_PADDING(VM, member, align); \ CHECK_MEMBER_ALIGNMENT(VM, member, align); \ VM *p = NULL; NOREF(p); \ if (sizeof(p->member.padding) >= (ssize_t)sizeof(p->member.s) + 128 + sizeof(p->member.s) / 20) \ printf("warning: VM::%-8s: padding=%-5d s=%-5d -> %-4d suggest=%-5u\n", \ #member, (int)sizeof(p->member.padding), (int)sizeof(p->member.s), \ (int)sizeof(p->member.padding) - (int)sizeof(p->member.s), \ (int)RT_ALIGN_Z(sizeof(p->member.s), (align))); \ } while (0) #define CHECK_PADDING_VMCPU(align, member) \ do \ { \ CHECK_PADDING(VMCPU, member, align); \ CHECK_MEMBER_ALIGNMENT(VMCPU, member, align); \ VMCPU *p = NULL; NOREF(p); \ if (sizeof(p->member.padding) >= (ssize_t)sizeof(p->member.s) + 128 + sizeof(p->member.s) / 20) \ printf("warning: VMCPU::%-8s: padding=%-5d s=%-5d -> %-4d suggest=%-5u\n", \ #member, (int)sizeof(p->member.padding), (int)sizeof(p->member.s), \ (int)sizeof(p->member.padding) - (int)sizeof(p->member.s), \ (int)RT_ALIGN_Z(sizeof(p->member.s), (align))); \ } while (0) #define CHECK_CPUMCTXCORE(member) \ do { \ unsigned off1 = RT_OFFSETOF(CPUMCTX, member) - RT_OFFSETOF(CPUMCTX, rax); \ unsigned off2 = RT_OFFSETOF(CPUMCTXCORE, member); \ if (off1 != off2) \ { \ printf("error! CPUMCTX/CORE:: %s! (%#x vs %#x (ctx))\n", #member, off1, off2); \ rc++; \ } \ } while (0) #define CHECK_PADDING_UVM(align, member) \ do \ { \ CHECK_PADDING(UVM, member, align); \ CHECK_MEMBER_ALIGNMENT(UVM, member, align); \ UVM *p = NULL; NOREF(p); \ if (sizeof(p->member.padding) >= (ssize_t)sizeof(p->member.s) + 128 + sizeof(p->member.s) / 20) \ printf("warning: UVM::%-8s: padding=%-5d s=%-5d -> %-4d suggest=%-5u\n", \ #member, (int)sizeof(p->member.padding), (int)sizeof(p->member.s), \ (int)sizeof(p->member.padding) - (int)sizeof(p->member.s), \ (int)RT_ALIGN_Z(sizeof(p->member.s), (align))); \ } while (0) #define CHECK_PADDING_UVMCPU(align, member) \ do \ { \ CHECK_PADDING(UVMCPU, member, align); \ CHECK_MEMBER_ALIGNMENT(UVMCPU, member, align); \ UVMCPU *p = NULL; NOREF(p); \ if (sizeof(p->member.padding) >= (ssize_t)sizeof(p->member.s) + 128 + sizeof(p->member.s) / 20) \ printf("warning: UVMCPU::%-8s: padding=%-5d s=%-5d -> %-4d suggest=%-5u\n", \ #member, (int)sizeof(p->member.padding), (int)sizeof(p->member.s), \ (int)sizeof(p->member.padding) - (int)sizeof(p->member.s), \ (int)RT_ALIGN_Z(sizeof(p->member.s), (align))); \ } while (0) #define CHECK_PADDING_GVM(align, member) \ do \ { \ CHECK_PADDING(GVM, member, align); \ CHECK_MEMBER_ALIGNMENT(GVM, member, align); \ GVM *p = NULL; NOREF(p); \ if (sizeof(p->member.padding) >= (ssize_t)sizeof(p->member.s) + 128 + sizeof(p->member.s) / 20) \ printf("warning: GVM::%-8s: padding=%-5d s=%-5d -> %-4d suggest=%-5u\n", \ #member, (int)sizeof(p->member.padding), (int)sizeof(p->member.s), \ (int)sizeof(p->member.padding) - (int)sizeof(p->member.s), \ (int)RT_ALIGN_Z(sizeof(p->member.s), (align))); \ } while (0) #define CHECK_PADDING_GVMCPU(align, member) \ do \ { \ CHECK_PADDING(GVMCPU, member, align); \ CHECK_MEMBER_ALIGNMENT(GVMCPU, member, align); \ GVMCPU *p = NULL; NOREF(p); \ if (sizeof(p->member.padding) >= (ssize_t)sizeof(p->member.s) + 128 + sizeof(p->member.s) / 20) \ printf("warning: GVMCPU::%-8s: padding=%-5d s=%-5d -> %-4d suggest=%-5u\n", \ #member, (int)sizeof(p->member.padding), (int)sizeof(p->member.s), \ (int)sizeof(p->member.padding) - (int)sizeof(p->member.s), \ (int)RT_ALIGN_Z(sizeof(p->member.s), (align))); \ } while (0) #define PRINT_OFFSET(strct, member) \ do \ { \ printf("info: %10s::%-24s offset %#6x (%6d) sizeof %4d\n", #strct, #member, (int)RT_OFFSETOF(strct, member), (int)RT_OFFSETOF(strct, member), (int)RT_SIZEOFMEMB(strct, member)); \ } while (0) CHECK_SIZE(uint128_t, 128/8); CHECK_SIZE(int128_t, 128/8); CHECK_SIZE(uint64_t, 64/8); CHECK_SIZE(int64_t, 64/8); CHECK_SIZE(uint32_t, 32/8); CHECK_SIZE(int32_t, 32/8); CHECK_SIZE(uint16_t, 16/8); CHECK_SIZE(int16_t, 16/8); CHECK_SIZE(uint8_t, 8/8); CHECK_SIZE(int8_t, 8/8); CHECK_SIZE(X86DESC, 8); CHECK_SIZE(X86DESC64, 16); CHECK_SIZE(VBOXIDTE, 8); CHECK_SIZE(VBOXIDTR, 10); CHECK_SIZE(VBOXGDTR, 10); CHECK_SIZE(VBOXTSS, 136); CHECK_SIZE(X86FXSTATE, 512); CHECK_SIZE(RTUUID, 16); CHECK_SIZE(X86PTE, 4); CHECK_SIZE(X86PD, PAGE_SIZE); CHECK_SIZE(X86PDE, 4); CHECK_SIZE(X86PT, PAGE_SIZE); CHECK_SIZE(X86PTEPAE, 8); CHECK_SIZE(X86PTPAE, PAGE_SIZE); CHECK_SIZE(X86PDEPAE, 8); CHECK_SIZE(X86PDPAE, PAGE_SIZE); CHECK_SIZE(X86PDPE, 8); CHECK_SIZE(X86PDPT, PAGE_SIZE); CHECK_SIZE(X86PML4E, 8); CHECK_SIZE(X86PML4, PAGE_SIZE); PRINT_OFFSET(VM, cpum); CHECK_PADDING_VM(64, cpum); CHECK_PADDING_VM(64, vmm); PRINT_OFFSET(VM, pgm); PRINT_OFFSET(VM, pgm.s.CritSectX); CHECK_PADDING_VM(64, pgm); PRINT_OFFSET(VM, hm); CHECK_PADDING_VM(64, hm); CHECK_PADDING_VM(64, trpm); CHECK_PADDING_VM(64, selm); CHECK_PADDING_VM(64, mm); CHECK_PADDING_VM(64, pdm); CHECK_PADDING_VM(64, iom); #ifdef VBOX_WITH_RAW_MODE CHECK_PADDING_VM(64, patm); CHECK_PADDING_VM(64, csam); #endif CHECK_PADDING_VM(64, em); /*CHECK_PADDING_VM(64, iem);*/ CHECK_PADDING_VM(64, tm); CHECK_PADDING_VM(64, dbgf); CHECK_PADDING_VM(64, ssm); CHECK_PADDING_VM(64, rem); CHECK_PADDING_VM(8, vm); CHECK_PADDING_VM(8, cfgm); PRINT_OFFSET(VMCPU, cpum); CHECK_PADDING_VMCPU(64, cpum); CHECK_PADDING_VMCPU(64, hm); CHECK_PADDING_VMCPU(64, em); CHECK_PADDING_VMCPU(64, iem); CHECK_PADDING_VMCPU(64, trpm); CHECK_PADDING_VMCPU(64, tm); CHECK_PADDING_VMCPU(64, vmm); CHECK_PADDING_VMCPU(64, pdm); CHECK_PADDING_VMCPU(64, iom); CHECK_PADDING_VMCPU(64, dbgf); #if 0 PRINT_OFFSET(VMCPU, abAlignment2); #endif PRINT_OFFSET(VMCPU, pgm); CHECK_PADDING_VMCPU(4096, pgm); #ifdef VBOX_WITH_STATISTICS PRINT_OFFSET(VMCPU, pgm.s.pStatTrap0eAttributionRC); #endif CHECK_MEMBER_ALIGNMENT(VM, selm.s.Tss, 16); PRINT_OFFSET(VM, selm.s.Tss); PVM pVM = NULL; NOREF(pVM); if ((RT_OFFSETOF(VM, selm.s.Tss) & PAGE_OFFSET_MASK) > PAGE_SIZE - sizeof(pVM->selm.s.Tss)) { printf("error! SELM:Tss is crossing a page!\n"); rc++; } PRINT_OFFSET(VM, selm.s.TssTrap08); if ((RT_OFFSETOF(VM, selm.s.TssTrap08) & PAGE_OFFSET_MASK) > PAGE_SIZE - sizeof(pVM->selm.s.TssTrap08)) { printf("error! SELM:TssTrap08 is crossing a page!\n"); rc++; } CHECK_MEMBER_ALIGNMENT(VM, trpm.s.aIdt, 16); CHECK_MEMBER_ALIGNMENT(VM, aCpus[0], PAGE_SIZE); CHECK_MEMBER_ALIGNMENT(VM, aCpus[1], PAGE_SIZE); CHECK_MEMBER_ALIGNMENT(VM, aCpus[0].cpum.s.Host, 64); CHECK_MEMBER_ALIGNMENT(VM, aCpus[0].cpum.s.Guest, 64); CHECK_MEMBER_ALIGNMENT(VM, aCpus[1].cpum.s.Host, 64); CHECK_MEMBER_ALIGNMENT(VM, aCpus[1].cpum.s.Guest, 64); CHECK_MEMBER_ALIGNMENT(VM, aCpus[0].cpum.s.Hyper, 64); CHECK_MEMBER_ALIGNMENT(VM, aCpus[1].cpum.s.Hyper, 64); #ifdef VBOX_WITH_VMMR0_DISABLE_LAPIC_NMI CHECK_MEMBER_ALIGNMENT(VM, cpum.s.pvApicBase, 8); #endif CHECK_MEMBER_ALIGNMENT(VMCPU, vmm.s.u64CallRing3Arg, 8); #if defined(RT_OS_WINDOWS) && defined(RT_ARCH_AMD64) CHECK_MEMBER_ALIGNMENT(VMCPU, vmm.s.CallRing3JmpBufR0, 16); CHECK_MEMBER_ALIGNMENT(VMCPU, vmm.s.CallRing3JmpBufR0.xmm6, 16); #endif CHECK_MEMBER_ALIGNMENT(VM, vmm.s.u64LastYield, 8); CHECK_MEMBER_ALIGNMENT(VM, vmm.s.StatRunRC, 8); CHECK_MEMBER_ALIGNMENT(VM, StatTotalQemuToGC, 8); CHECK_MEMBER_ALIGNMENT(VM, rem.s.uPendingExcptCR2, 8); CHECK_MEMBER_ALIGNMENT(VM, rem.s.StatsInQEMU, 8); CHECK_MEMBER_ALIGNMENT(VM, rem.s.Env, 64); /* the VMCPUs are page aligned TLB hit reasons. */ CHECK_MEMBER_ALIGNMENT(VM, aCpus, 4096); CHECK_SIZE_ALIGNMENT(VMCPU, 4096); /* cpumctx */ CHECK_MEMBER_ALIGNMENT(CPUMCTX, fpu, 32); CHECK_MEMBER_ALIGNMENT(CPUMCTX, rax, 32); CHECK_MEMBER_ALIGNMENT(CPUMCTX, idtr.pIdt, 8); CHECK_MEMBER_ALIGNMENT(CPUMCTX, gdtr.pGdt, 8); CHECK_MEMBER_ALIGNMENT(CPUMCTX, SysEnter, 8); CHECK_CPUMCTXCORE(rax); CHECK_CPUMCTXCORE(rcx); CHECK_CPUMCTXCORE(rdx); CHECK_CPUMCTXCORE(rbx); CHECK_CPUMCTXCORE(rsp); CHECK_CPUMCTXCORE(rbp); CHECK_CPUMCTXCORE(rsi); CHECK_CPUMCTXCORE(rdi); CHECK_CPUMCTXCORE(r8); CHECK_CPUMCTXCORE(r9); CHECK_CPUMCTXCORE(r10); CHECK_CPUMCTXCORE(r11); CHECK_CPUMCTXCORE(r12); CHECK_CPUMCTXCORE(r13); CHECK_CPUMCTXCORE(r14); CHECK_CPUMCTXCORE(r15); CHECK_CPUMCTXCORE(es); CHECK_CPUMCTXCORE(ss); CHECK_CPUMCTXCORE(cs); CHECK_CPUMCTXCORE(ds); CHECK_CPUMCTXCORE(fs); CHECK_CPUMCTXCORE(gs); CHECK_CPUMCTXCORE(rip); CHECK_CPUMCTXCORE(rflags); #if HC_ARCH_BITS == 32 /* CPUMHOSTCTX - lss pair */ if (RT_OFFSETOF(CPUMHOSTCTX, esp) + 4 != RT_OFFSETOF(CPUMHOSTCTX, ss)) { printf("error! CPUMHOSTCTX lss has been split up!\n"); rc++; } #endif CHECK_SIZE_ALIGNMENT(CPUMCTX, 64); CHECK_SIZE_ALIGNMENT(CPUMHOSTCTX, 64); CHECK_SIZE_ALIGNMENT(CPUMCTXMSRS, 64); /* pdm */ PRINT_OFFSET(PDMDEVINS, Internal); PRINT_OFFSET(PDMDEVINS, achInstanceData); CHECK_MEMBER_ALIGNMENT(PDMDEVINS, achInstanceData, 64); CHECK_PADDING(PDMDEVINS, Internal, 1); PRINT_OFFSET(PDMUSBINS, Internal); PRINT_OFFSET(PDMUSBINS, achInstanceData); CHECK_MEMBER_ALIGNMENT(PDMUSBINS, achInstanceData, 32); CHECK_PADDING(PDMUSBINS, Internal, 1); PRINT_OFFSET(PDMDRVINS, Internal); PRINT_OFFSET(PDMDRVINS, achInstanceData); CHECK_MEMBER_ALIGNMENT(PDMDRVINS, achInstanceData, 32); CHECK_PADDING(PDMDRVINS, Internal, 1); CHECK_PADDING2(PDMCRITSECT); CHECK_PADDING2(PDMCRITSECTRW); /* pgm */ #if defined(VBOX_WITH_2X_4GB_ADDR_SPACE) || defined(VBOX_WITH_RAW_MODE) CHECK_MEMBER_ALIGNMENT(PGMCPU, AutoSet, 8); #endif CHECK_MEMBER_ALIGNMENT(PGMCPU, GCPhysCR3, sizeof(RTGCPHYS)); CHECK_MEMBER_ALIGNMENT(PGMCPU, aGCPhysGstPaePDs, sizeof(RTGCPHYS)); CHECK_MEMBER_ALIGNMENT(PGMCPU, DisState, 8); CHECK_MEMBER_ALIGNMENT(PGMCPU, cPoolAccessHandler, 8); CHECK_MEMBER_ALIGNMENT(PGMPOOLPAGE, idx, sizeof(uint16_t)); CHECK_MEMBER_ALIGNMENT(PGMPOOLPAGE, pvPageR3, sizeof(RTHCPTR)); CHECK_MEMBER_ALIGNMENT(PGMPOOLPAGE, GCPhys, sizeof(RTGCPHYS)); CHECK_SIZE(PGMPAGE, 16); CHECK_MEMBER_ALIGNMENT(PGMRAMRANGE, aPages, 16); CHECK_MEMBER_ALIGNMENT(PGMMMIO2RANGE, RamRange, 16); /* rem */ CHECK_MEMBER_ALIGNMENT(REM, aGCPtrInvalidatedPages, 8); CHECK_PADDING3(REMHANDLERNOTIFICATION, u.PhysicalRegister, u.padding); CHECK_PADDING3(REMHANDLERNOTIFICATION, u.PhysicalDeregister, u.padding); CHECK_PADDING3(REMHANDLERNOTIFICATION, u.PhysicalModify, u.padding); CHECK_SIZE_ALIGNMENT(REMHANDLERNOTIFICATION, 8); CHECK_MEMBER_ALIGNMENT(REMHANDLERNOTIFICATION, u.PhysicalDeregister.GCPhys, 8); /* TM */ CHECK_MEMBER_ALIGNMENT(TM, TimerCritSect, sizeof(uintptr_t)); CHECK_MEMBER_ALIGNMENT(TM, VirtualSyncLock, sizeof(uintptr_t)); /* misc */ CHECK_PADDING3(EMCPU, u.FatalLongJump, u.achPaddingFatalLongJump); CHECK_SIZE_ALIGNMENT(VMMR0JMPBUF, 8); #ifdef VBOX_WITH_RAW_MODE CHECK_SIZE_ALIGNMENT(PATCHINFO, 8); #endif #if 0 PRINT_OFFSET(VM, fForcedActions); PRINT_OFFSET(VM, StatQemuToGC); PRINT_OFFSET(VM, StatGCToQemu); #endif CHECK_MEMBER_ALIGNMENT(IOM, CritSect, sizeof(uintptr_t)); #ifdef VBOX_WITH_REM CHECK_MEMBER_ALIGNMENT(EM, CritSectREM, sizeof(uintptr_t)); #endif CHECK_MEMBER_ALIGNMENT(PGM, CritSectX, sizeof(uintptr_t)); CHECK_MEMBER_ALIGNMENT(PDM, CritSect, sizeof(uintptr_t)); CHECK_MEMBER_ALIGNMENT(MMHYPERHEAP, Lock, sizeof(uintptr_t)); /* hm - 32-bit gcc won't align uint64_t naturally, so check. */ CHECK_MEMBER_ALIGNMENT(HM, uMaxAsid, 8); CHECK_MEMBER_ALIGNMENT(HM, vmx.hostCR4, 8); CHECK_MEMBER_ALIGNMENT(HM, vmx.msr.feature_ctrl, 8); CHECK_MEMBER_ALIGNMENT(HM, StatTprPatchSuccess, 8); CHECK_MEMBER_ALIGNMENT(HMCPU, StatEntry, 8); CHECK_MEMBER_ALIGNMENT(HMCPU, vmx.HCPhysVmcs, sizeof(RTHCPHYS)); CHECK_MEMBER_ALIGNMENT(HMCPU, vmx.u32PinCtls, 8); CHECK_MEMBER_ALIGNMENT(HMCPU, DisState, 8); CHECK_MEMBER_ALIGNMENT(HMCPU, Event.u64IntrInfo, 8); /* Make sure the set is large enough and has the correct size. */ CHECK_SIZE(VMCPUSET, 32); if (sizeof(VMCPUSET) * 8 < VMM_MAX_CPU_COUNT) { printf("error! VMCPUSET is too small for VMM_MAX_CPU_COUNT=%u!\n", VMM_MAX_CPU_COUNT); rc++; } printf("info: struct UVM: %d bytes\n", (int)sizeof(UVM)); CHECK_PADDING_UVM(32, vm); CHECK_PADDING_UVM(32, mm); CHECK_PADDING_UVM(32, pdm); CHECK_PADDING_UVM(32, stam); printf("info: struct UVMCPU: %d bytes\n", (int)sizeof(UVMCPU)); CHECK_PADDING_UVMCPU(32, vm); #ifdef VBOX_WITH_RAW_MODE /* * Compare HC and RC. */ printf("tstVMStructSize: Comparing HC and RC...\n"); # include "tstVMStructRC.h" #endif /* VBOX_WITH_RAW_MODE */ CHECK_PADDING_GVM(4, gvmm); CHECK_PADDING_GVM(4, gmm); CHECK_PADDING_GVMCPU(4, gvmm); /* * Check that the optimized access macros for PGMPAGE works correctly. */ PGMPAGE Page; PGM_PAGE_CLEAR(&Page); CHECK_EXPR(PGM_PAGE_GET_HNDL_PHYS_STATE(&Page) == PGM_PAGE_HNDL_PHYS_STATE_NONE); CHECK_EXPR(PGM_PAGE_HAS_ANY_HANDLERS(&Page) == false); CHECK_EXPR(PGM_PAGE_HAS_ACTIVE_HANDLERS(&Page) == false); CHECK_EXPR(PGM_PAGE_HAS_ACTIVE_ALL_HANDLERS(&Page) == false); PGM_PAGE_SET_HNDL_PHYS_STATE(&Page, PGM_PAGE_HNDL_PHYS_STATE_ALL); CHECK_EXPR(PGM_PAGE_GET_HNDL_PHYS_STATE(&Page) == PGM_PAGE_HNDL_PHYS_STATE_ALL); CHECK_EXPR(PGM_PAGE_HAS_ANY_HANDLERS(&Page) == true); CHECK_EXPR(PGM_PAGE_HAS_ACTIVE_HANDLERS(&Page) == true); CHECK_EXPR(PGM_PAGE_HAS_ACTIVE_ALL_HANDLERS(&Page) == true); PGM_PAGE_SET_HNDL_PHYS_STATE(&Page, PGM_PAGE_HNDL_PHYS_STATE_WRITE); CHECK_EXPR(PGM_PAGE_GET_HNDL_PHYS_STATE(&Page) == PGM_PAGE_HNDL_PHYS_STATE_WRITE); CHECK_EXPR(PGM_PAGE_HAS_ANY_HANDLERS(&Page) == true); CHECK_EXPR(PGM_PAGE_HAS_ACTIVE_HANDLERS(&Page) == true); CHECK_EXPR(PGM_PAGE_HAS_ACTIVE_ALL_HANDLERS(&Page) == false); PGM_PAGE_CLEAR(&Page); PGM_PAGE_SET_HNDL_VIRT_STATE(&Page, PGM_PAGE_HNDL_VIRT_STATE_ALL); CHECK_EXPR(PGM_PAGE_GET_HNDL_VIRT_STATE(&Page) == PGM_PAGE_HNDL_VIRT_STATE_ALL); CHECK_EXPR(PGM_PAGE_HAS_ANY_HANDLERS(&Page) == true); CHECK_EXPR(PGM_PAGE_HAS_ACTIVE_HANDLERS(&Page) == true); CHECK_EXPR(PGM_PAGE_HAS_ACTIVE_ALL_HANDLERS(&Page) == true); PGM_PAGE_SET_HNDL_VIRT_STATE(&Page, PGM_PAGE_HNDL_VIRT_STATE_WRITE); CHECK_EXPR(PGM_PAGE_GET_HNDL_VIRT_STATE(&Page) == PGM_PAGE_HNDL_VIRT_STATE_WRITE); CHECK_EXPR(PGM_PAGE_HAS_ANY_HANDLERS(&Page) == true); CHECK_EXPR(PGM_PAGE_HAS_ACTIVE_HANDLERS(&Page) == true); CHECK_EXPR(PGM_PAGE_HAS_ACTIVE_ALL_HANDLERS(&Page) == false); PGM_PAGE_CLEAR(&Page); PGM_PAGE_SET_HNDL_PHYS_STATE(&Page, PGM_PAGE_HNDL_PHYS_STATE_ALL); PGM_PAGE_SET_HNDL_VIRT_STATE(&Page, PGM_PAGE_HNDL_VIRT_STATE_WRITE); CHECK_EXPR(PGM_PAGE_GET_HNDL_PHYS_STATE(&Page) == PGM_PAGE_HNDL_PHYS_STATE_ALL); CHECK_EXPR(PGM_PAGE_GET_HNDL_VIRT_STATE(&Page) == PGM_PAGE_HNDL_VIRT_STATE_WRITE); CHECK_EXPR(PGM_PAGE_HAS_ANY_HANDLERS(&Page) == true); CHECK_EXPR(PGM_PAGE_HAS_ACTIVE_HANDLERS(&Page) == true); CHECK_EXPR(PGM_PAGE_HAS_ACTIVE_ALL_HANDLERS(&Page) == true); PGM_PAGE_SET_HNDL_PHYS_STATE(&Page, PGM_PAGE_HNDL_PHYS_STATE_WRITE); PGM_PAGE_SET_HNDL_VIRT_STATE(&Page, PGM_PAGE_HNDL_VIRT_STATE_ALL); CHECK_EXPR(PGM_PAGE_GET_HNDL_PHYS_STATE(&Page) == PGM_PAGE_HNDL_PHYS_STATE_WRITE); CHECK_EXPR(PGM_PAGE_GET_HNDL_VIRT_STATE(&Page) == PGM_PAGE_HNDL_VIRT_STATE_ALL); CHECK_EXPR(PGM_PAGE_HAS_ANY_HANDLERS(&Page) == true); CHECK_EXPR(PGM_PAGE_HAS_ACTIVE_HANDLERS(&Page) == true); CHECK_EXPR(PGM_PAGE_HAS_ACTIVE_ALL_HANDLERS(&Page) == true); PGM_PAGE_SET_HNDL_PHYS_STATE(&Page, PGM_PAGE_HNDL_PHYS_STATE_WRITE); PGM_PAGE_SET_HNDL_VIRT_STATE(&Page, PGM_PAGE_HNDL_VIRT_STATE_WRITE); CHECK_EXPR(PGM_PAGE_GET_HNDL_PHYS_STATE(&Page) == PGM_PAGE_HNDL_PHYS_STATE_WRITE); CHECK_EXPR(PGM_PAGE_GET_HNDL_VIRT_STATE(&Page) == PGM_PAGE_HNDL_VIRT_STATE_WRITE); CHECK_EXPR(PGM_PAGE_HAS_ANY_HANDLERS(&Page) == true); CHECK_EXPR(PGM_PAGE_HAS_ACTIVE_HANDLERS(&Page) == true); CHECK_EXPR(PGM_PAGE_HAS_ACTIVE_ALL_HANDLERS(&Page) == false); PGM_PAGE_SET_HNDL_VIRT_STATE(&Page, PGM_PAGE_HNDL_VIRT_STATE_NONE); CHECK_EXPR(PGM_PAGE_GET_HNDL_PHYS_STATE(&Page) == PGM_PAGE_HNDL_PHYS_STATE_WRITE); CHECK_EXPR(PGM_PAGE_GET_HNDL_VIRT_STATE(&Page) == PGM_PAGE_HNDL_VIRT_STATE_NONE); CHECK_EXPR(PGM_PAGE_HAS_ANY_HANDLERS(&Page) == true); CHECK_EXPR(PGM_PAGE_HAS_ACTIVE_HANDLERS(&Page) == true); CHECK_EXPR(PGM_PAGE_HAS_ACTIVE_ALL_HANDLERS(&Page) == false); #undef AssertFatal #define AssertFatal(expr) do { } while (0) #undef Assert #define Assert(expr) do { } while (0) PGM_PAGE_CLEAR(&Page); CHECK_EXPR(PGM_PAGE_GET_HCPHYS_NA(&Page) == 0); PGM_PAGE_SET_HCPHYS(NULL, &Page, UINT64_C(0x0000fffeff1ff000)); CHECK_EXPR(PGM_PAGE_GET_HCPHYS_NA(&Page) == UINT64_C(0x0000fffeff1ff000)); PGM_PAGE_SET_HCPHYS(NULL, &Page, UINT64_C(0x0000000000001000)); CHECK_EXPR(PGM_PAGE_GET_HCPHYS_NA(&Page) == UINT64_C(0x0000000000001000)); PGM_PAGE_INIT(&Page, UINT64_C(0x0000feedfacef000), UINT32_C(0x12345678), PGMPAGETYPE_RAM, PGM_PAGE_STATE_ALLOCATED); CHECK_EXPR(PGM_PAGE_GET_HCPHYS_NA(&Page) == UINT64_C(0x0000feedfacef000)); CHECK_EXPR(PGM_PAGE_GET_PAGEID(&Page) == UINT32_C(0x12345678)); CHECK_EXPR(PGM_PAGE_GET_TYPE_NA(&Page) == PGMPAGETYPE_RAM); CHECK_EXPR(PGM_PAGE_GET_STATE_NA(&Page) == PGM_PAGE_STATE_ALLOCATED); /* * Report result. */ if (rc) printf("tstVMStructSize: FAILURE - %d errors\n", rc); else printf("tstVMStructSize: SUCCESS\n"); return rc; }
RTDECL(uint64_t) RTTimeSystemNanoTS(void) { return fibGetMsCount() * UINT64_C(10000000); }
int main(int argc, char *argv[]) { uint32_t outlen = OUTLEN_DEF; uint32_t m_cost = 1 << LOG_M_COST_DEF; uint32_t t_cost = T_COST_DEF; uint32_t lanes = LANES_DEF; uint32_t threads = THREADS_DEF; argon2_type type = Argon2_i; /* Argon2i is the default type */ int types_specified = 0; int encoded_only = 0; int raw_only = 0; uint32_t version = ARGON2_VERSION_NUMBER; int i; size_t n; char pwd[MAX_PASS_LEN], *salt; if (argc < 2) { usage(argv[0]); return ARGON2_MISSING_ARGS; } else if (argc >= 2 && strcmp(argv[1], "-h") == 0) { usage(argv[0]); return 1; } /* get password from stdin */ n = fread(pwd, 1, sizeof pwd - 1, stdin); if(n < 1) { fatal("no password read"); } if(n == MAX_PASS_LEN-1) { fatal("Provided password longer than supported in command line utility"); } pwd[n] = '\0'; if (pwd[n - 1] == '\n') { pwd[n - 1] = '\0'; } salt = argv[1]; /* parse options */ for (i = 2; i < argc; i++) { const char *a = argv[i]; unsigned long input = 0; if (!strcmp(a, "-h")) { usage(argv[0]); return 1; } else if (!strcmp(a, "-m")) { if (i < argc - 1) { i++; input = strtoul(argv[i], NULL, 10); if (input == 0 || input == ULONG_MAX || input > ARGON2_MAX_MEMORY_BITS) { fatal("bad numeric input for -m"); } m_cost = ARGON2_MIN(UINT64_C(1) << input, UINT32_C(0xFFFFFFFF)); if (m_cost > ARGON2_MAX_MEMORY) { fatal("m_cost overflow"); } continue; } else { fatal("missing -m argument"); } } else if (!strcmp(a, "-t")) { if (i < argc - 1) { i++; input = strtoul(argv[i], NULL, 10); if (input == 0 || input == ULONG_MAX || input > ARGON2_MAX_TIME) { fatal("bad numeric input for -t"); } t_cost = input; continue; } else { fatal("missing -t argument"); } } else if (!strcmp(a, "-p")) { if (i < argc - 1) { i++; input = strtoul(argv[i], NULL, 10); if (input == 0 || input == ULONG_MAX || input > ARGON2_MAX_THREADS || input > ARGON2_MAX_LANES) { fatal("bad numeric input for -p"); } threads = input; lanes = threads; continue; } else { fatal("missing -p argument"); } } else if (!strcmp(a, "-l")) { if (i < argc - 1) { i++; input = strtoul(argv[i], NULL, 10); outlen = input; continue; } else { fatal("missing -l argument"); } } else if (!strcmp(a, "-i")) { type = Argon2_i; ++types_specified; } else if (!strcmp(a, "-d")) { type = Argon2_d; ++types_specified; } else if (!strcmp(a, "-id")) { type = Argon2_id; ++types_specified; } else if (!strcmp(a, "-e")) { encoded_only = 1; } else if (!strcmp(a, "-r")) { raw_only = 1; } else if (!strcmp(a, "-v")) { if (i < argc - 1) { i++; if (!strcmp(argv[i], "10")) { version = ARGON2_VERSION_10; } else if (!strcmp(argv[i], "13")) { version = ARGON2_VERSION_13; } else { fatal("invalid Argon2 version"); } } else { fatal("missing -v argument"); } } else { fatal("unknown argument"); } } if (types_specified > 1) { fatal("cannot specify multiple Argon2 types"); } if(encoded_only && raw_only) fatal("cannot provide both -e and -r"); if(!encoded_only && !raw_only) { printf("Type:\t\t%s\n", argon2_type2string(type, 1)); printf("Iterations:\t%" PRIu32 " \n", t_cost); printf("Memory:\t\t%" PRIu32 " KiB\n", m_cost); printf("Parallelism:\t%" PRIu32 " \n", lanes); } run(outlen, pwd, salt, t_cost, m_cost, lanes, threads, type, encoded_only, raw_only, version); return ARGON2_OK; }
static unsigned menu_input_frame_build(retro_input_t trigger_input) { settings_t *settings = config_get_ptr(); unsigned ret = MENU_ACTION_NOOP; if (trigger_input.state & (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_UP)) ret = MENU_ACTION_UP; else if (trigger_input.state & (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_DOWN)) ret = MENU_ACTION_DOWN; else if (trigger_input.state & (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_LEFT)) ret = MENU_ACTION_LEFT; else if (trigger_input.state & (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_RIGHT)) ret = MENU_ACTION_RIGHT; else if (trigger_input.state & (UINT64_C(1) << settings->menu_scroll_up_btn)) ret = MENU_ACTION_SCROLL_UP; else if (trigger_input.state & (UINT64_C(1) << settings->menu_scroll_down_btn)) ret = MENU_ACTION_SCROLL_DOWN; else if (trigger_input.state & (UINT64_C(1) << settings->menu_cancel_btn)) ret = MENU_ACTION_CANCEL; else if (trigger_input.state & (UINT64_C(1) << settings->menu_ok_btn)) ret = MENU_ACTION_OK; else if (trigger_input.state & (UINT64_C(1) << settings->menu_search_btn)) ret = MENU_ACTION_SEARCH; else if (trigger_input.state & (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_Y)) ret = MENU_ACTION_SCAN; else if (trigger_input.state & (UINT64_C(1) << settings->menu_default_btn)) ret = MENU_ACTION_START; else if (trigger_input.state & (UINT64_C(1) << settings->menu_info_btn)) ret = MENU_ACTION_INFO; else if (trigger_input.state & (UINT64_C(1) << RARCH_MENU_TOGGLE)) ret = MENU_ACTION_TOGGLE; return menu_input_frame_pointer(&ret); }
/** * input_overlay_poll: * @out : Polled output data. * @norm_x : Normalized X coordinate. * @norm_y : Normalized Y coordinate. * * Polls input overlay. * * @norm_x and @norm_y are the result of * input_translate_coord_viewport(). **/ static void input_overlay_poll( input_overlay_t *ol, input_overlay_state_t *out, int16_t norm_x, int16_t norm_y) { size_t i; float x, y; memset(out, 0, sizeof(*out)); if (!ol->enable) { ol->blocked = false; return; } /* norm_x and norm_y is in [-0x7fff, 0x7fff] range, * like RETRO_DEVICE_POINTER. */ x = (float)(norm_x + 0x7fff) / 0xffff; y = (float)(norm_y + 0x7fff) / 0xffff; x -= ol->active->mod_x; y -= ol->active->mod_y; x /= ol->active->mod_w; y /= ol->active->mod_h; for (i = 0; i < ol->active->size; i++) { float x_dist, y_dist; struct overlay_desc *desc = &ol->active->descs[i]; if (!inside_hitbox(desc, x, y)) continue; desc->updated = true; x_dist = x - desc->x; y_dist = y - desc->y; switch (desc->type) { case OVERLAY_TYPE_BUTTONS: { uint64_t mask = desc->key_mask; out->buttons |= mask; if (mask & (UINT64_C(1) << RARCH_OVERLAY_NEXT)) ol->next_index = desc->next_index; } break; case OVERLAY_TYPE_KEYBOARD: if (desc->key_mask < RETROK_LAST) OVERLAY_SET_KEY(out, desc->key_mask); break; default: { float x_val = x_dist / desc->range_x; float y_val = y_dist / desc->range_y; float x_val_sat = x_val / desc->analog_saturate_pct; float y_val_sat = y_val / desc->analog_saturate_pct; unsigned int base = (desc->type == OVERLAY_TYPE_ANALOG_RIGHT) ? 2 : 0; out->analog[base + 0] = clamp_float(x_val_sat, -1.0f, 1.0f) * 32767.0f; out->analog[base + 1] = clamp_float(y_val_sat, -1.0f, 1.0f) * 32767.0f; } break; } if (desc->movable) { desc->delta_x = clamp_float(x_dist, -desc->range_x, desc->range_x) * ol->active->mod_w; desc->delta_y = clamp_float(y_dist, -desc->range_y, desc->range_y) * ol->active->mod_h; } } if (!out->buttons) ol->blocked = false; else if (ol->blocked) memset(out, 0, sizeof(*out)); }
int main(int argc, char *argv[]) { _cleanup_(manager_freep) Manager *m = NULL; const char *user = "******"; uid_t uid; gid_t gid; int r; log_set_target(LOG_TARGET_AUTO); log_parse_environment(); log_open(); if (argc != 1) { log_error("This program takes no arguments."); r = -EINVAL; goto finish; } umask(0022); r = mac_selinux_init(); if (r < 0) { log_error_errno(r, "SELinux setup failed: %m"); goto finish; } r = get_user_creds(&user, &uid, &gid, NULL, NULL); if (r < 0) { log_error_errno(r, "Cannot resolve user name %s: %m", user); goto finish; } /* Always create the directory where resolv.conf will live */ r = mkdir_safe_label("/run/systemd/resolve", 0755, uid, gid, false); if (r < 0) { log_error_errno(r, "Could not create runtime directory: %m"); goto finish; } /* Drop privileges, but only if we have been started as root. If we are not running as root we assume all * privileges are already dropped. */ if (getuid() == 0) { /* Drop privileges, but keep three caps. Note that we drop those too, later on (see below) */ r = drop_privileges(uid, gid, (UINT64_C(1) << CAP_NET_RAW)| /* needed for SO_BINDTODEVICE */ (UINT64_C(1) << CAP_NET_BIND_SERVICE)| /* needed to bind on port 53 */ (UINT64_C(1) << CAP_SETPCAP) /* needed in order to drop the caps later */); if (r < 0) goto finish; } assert_se(sigprocmask_many(SIG_BLOCK, NULL, SIGTERM, SIGINT, SIGUSR1, SIGUSR2, SIGRTMIN+1, -1) >= 0); r = manager_new(&m); if (r < 0) { log_error_errno(r, "Could not create manager: %m"); goto finish; } r = manager_start(m); if (r < 0) { log_error_errno(r, "Failed to start manager: %m"); goto finish; } /* Write finish default resolv.conf to avoid a dangling symlink */ (void) manager_write_resolv_conf(m); /* Let's drop the remaining caps now */ r = capability_bounding_set_drop(0, true); if (r < 0) { log_error_errno(r, "Failed to drop remaining caps: %m"); goto finish; } sd_notify(false, "READY=1\n" "STATUS=Processing requests..."); r = sd_event_loop(m->event); if (r < 0) { log_error_errno(r, "Event loop failed: %m"); goto finish; } sd_event_get_exit_code(m->event, &r); finish: sd_notify(false, "STOPPING=1\n" "STATUS=Shutting down..."); return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS; }
* You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #include <config.h> #include <stdint.h> #include <inttypes.h> #include "libusbi.h" #include "wince_usb.h" // Global variables uint64_t hires_frequency, hires_ticks_to_ps; const uint64_t epoch_time = UINT64_C(116444736000000000); // 1970.01.01 00:00:000 in MS Filetime int windows_version = WINDOWS_CE; static int concurrent_usage = -1; HANDLE driver_handle = INVALID_HANDLE_VALUE; /* * Converts a windows error to human readable string * uses retval as errorcode, or, if 0, use GetLastError() */ #if defined(ENABLE_LOGGING) static char* windows_error_str(uint32_t retval) { static TCHAR wErr_string[ERR_BUFFER_SIZE]; static char err_string[ERR_BUFFER_SIZE]; DWORD size;
/* * Monotonic and real time functions */ unsigned __stdcall wince_clock_gettime_threaded(void* param) { LARGE_INTEGER hires_counter, li_frequency; LONG nb_responses; int timer_index; // Init - find out if we have access to a monotonic (hires) timer if (!QueryPerformanceFrequency(&li_frequency)) { usbi_dbg("no hires timer available on this platform"); hires_frequency = 0; hires_ticks_to_ps = UINT64_C(0); } else { hires_frequency = li_frequency.QuadPart; // The hires frequency can go as high as 4 GHz, so we'll use a conversion // to picoseconds to compute the tv_nsecs part in clock_gettime hires_ticks_to_ps = UINT64_C(1000000000000) / hires_frequency; usbi_dbg("hires timer available (Frequency: %"PRIu64" Hz)", hires_frequency); } // Signal wince_init() that we're ready to service requests if (ReleaseSemaphore(timer_response, 1, NULL) == 0) { usbi_dbg("unable to release timer semaphore: %s", windows_error_str(0)); } // Main loop - wait for requests while (1) { timer_index = WaitForMultipleObjects(2, timer_request, FALSE, INFINITE) - WAIT_OBJECT_0; if ( (timer_index != 0) && (timer_index != 1) ) { usbi_dbg("failure to wait on requests: %s", windows_error_str(0)); continue; } if (request_count[timer_index] == 0) { // Request already handled ResetEvent(timer_request[timer_index]); // There's still a possiblity that a thread sends a request between the // time we test request_count[] == 0 and we reset the event, in which case // the request would be ignored. The simple solution to that is to test // request_count again and process requests if non zero. if (request_count[timer_index] == 0) continue; } switch (timer_index) { case 0: WaitForSingleObject(timer_mutex, INFINITE); // Requests to this thread are for hires always if (QueryPerformanceCounter(&hires_counter) != 0) { timer_tp.tv_sec = (long)(hires_counter.QuadPart / hires_frequency); timer_tp.tv_nsec = (long)(((hires_counter.QuadPart % hires_frequency)/1000) * hires_ticks_to_ps); } else { // Fallback to real-time if we can't get monotonic value // Note that real-time clock does not wait on the mutex or this thread. wince_clock_gettime(USBI_CLOCK_REALTIME, &timer_tp); } ReleaseMutex(timer_mutex); nb_responses = InterlockedExchange((LONG*)&request_count[0], 0); if ( (nb_responses) && (ReleaseSemaphore(timer_response, nb_responses, NULL) == 0) ) { usbi_dbg("unable to release timer semaphore: %s", windows_error_str(0)); } continue; case 1: // time to quit usbi_dbg("timer thread quitting"); return 0; } } usbi_dbg("ERROR: broken timer thread"); return 1; }
RTDECL(uint64_t) RTTimeSystemNanoTS(void) { /** @remark OS/2 Ring-0: will wrap after 48 days. */ return g_pGIS->msecs * UINT64_C(1000000); }
change_string_list (code_rate_vlc, code_rate_user, NULL) change_safe () add_integer ("dvb-c-count", 0, SEGMENT_COUNT_C_TEXT, NULL, true) change_integer_range (0, 13) change_safe () add_integer ("dvb-c-interleaving", 0, TIME_INTERLEAVING_C_TEXT, NULL, true) change_integer_range (0, 3) change_safe () set_section (N_("Cable and satellite reception parameters"), NULL) add_string ("dvb-modulation", NULL, MODULATION_TEXT, MODULATION_LONGTEXT, false) change_string_list (modulation_vlc, modulation_user, NULL) change_safe () add_integer ("dvb-srate", 0, SRATE_TEXT, SRATE_LONGTEXT, false) change_integer_range (0, UINT64_C(0xffffffff)) change_safe () add_string ("dvb-fec", "", CODE_RATE_TEXT, CODE_RATE_LONGTEXT, true) change_string_list (code_rate_vlc, code_rate_user, NULL) change_safe () set_section (N_("DVB-S2 parameters"), NULL) add_integer ("dvb-pilot", -1, PILOT_TEXT, PILOT_TEXT, true) change_integer_list (auto_off_on_vlc, auto_off_on_user) change_safe () add_integer ("dvb-rolloff", -1, ROLLOFF_TEXT, ROLLOFF_TEXT, true) change_integer_list (rolloff_vlc, rolloff_user) change_safe () set_section (N_("ISDB-S parameters"), NULL) add_integer ("dvb-ts-id", 0, TS_ID_TEXT, TS_ID_TEXT, false)
/* vim: set filetype=c : */ /* vim: set noet ts=8 sw=8 cinoptions=+4,(4: */ #include "tests.h" #include "position.h" static const struct { const char *FEN; const uint64_t polyglot_key; } data[] = { {"rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1", UINT64_C(0x463b96181691fc9c)}, {"rnbqkbnr/pppppppp/8/8/4P3/8/PPPP1PPP/RNBQKBNR b KQkq e3 0 1", UINT64_C(0x823c9b50fd114196)}, {"rnbqkbnr/ppp1pppp/8/3p4/4P3/8/PPPP1PPP/RNBQKBNR w KQkq d6 0 2", UINT64_C(0x0756b94461c50fb0)}, {"rnbqkbnr/ppp1pppp/8/3pP3/8/8/PPPP1PPP/RNBQKBNR b KQkq - 0 2", UINT64_C(0x662fafb965db29d4)}, {"rnbqkbnr/ppp1p1pp/8/3pPp2/8/8/PPPP1PPP/RNBQKBNR w KQkq f6 0 3", UINT64_C(0x22a48b5a8e47ff78)}, {"rnbqkbnr/ppp1p1pp/8/3pPp2/8/8/PPPPKPPP/RNBQ1BNR b kq - 0 3", UINT64_C(0x652a607ca3f242c1)}, {"rnbq1bnr/ppp1pkpp/8/3pPp2/8/8/PPPPKPPP/RNBQ1BNR w - - 0 4", UINT64_C(0x00fdd303c946bdd9)}, {"rnbqkbnr/p1pppppp/8/8/PpP4P/8/1P1PPPP1/RNBQKBNR b KQkq c3 0 3", UINT64_C(0x3c8123ea7b067637)}, {"rnbqkbnr/p1pppppp/8/8/P6P/R1p5/1P1PPPP1/1NBQKBNR b Kkq - 0 4", UINT64_C(0x5c3f9b829b279560)} };
static int scan (guestfs_h *g, const char *prefix, FILE *fp) { size_t i, j; size_t alignment; uint64_t start; int err; CLEANUP_FREE_STRING_LIST char **devices = guestfs_list_devices (g); if (devices == NULL) return -1; for (i = 0; devices[i] != NULL; ++i) { CLEANUP_FREE char *name = NULL; CLEANUP_FREE_PARTITION_LIST struct guestfs_partition_list *parts = guestfs_part_list (g, devices[i]); if (parts == NULL) return -1; /* Canonicalize the name of the device for printing. */ name = guestfs_canonical_device_name (g, devices[i]); if (name == NULL) return -1; for (j = 0; j < parts->len; ++j) { /* Start offset of the partition in bytes. */ start = parts->val[j].part_start; if (!quiet) { if (prefix) fprintf (fp, "%s:", prefix); fprintf (fp, "%s%d %12" PRIu64 " ", name, (int) parts->val[j].part_num, start); } /* What's the alignment? */ if (start == 0) /* Probably not possible, but anyway. */ alignment = 64; else for (alignment = 0; (start & 1) == 0; alignment++, start /= 2) ; if (!quiet) { if (alignment < 10) fprintf (fp, "%12" PRIu64 " ", UINT64_C(1) << alignment); else if (alignment < 64) fprintf (fp, "%12" PRIu64 "K ", UINT64_C(1) << (alignment - 10)); else fprintf (fp, "- "); } err = pthread_mutex_lock (&worst_alignment_mutex); assert (err == 0); if (alignment < worst_alignment) worst_alignment = alignment; err = pthread_mutex_unlock (&worst_alignment_mutex); assert (err == 0); if (alignment < 12) { /* Bad in general: < 4K alignment */ if (!quiet) fprintf (fp, "bad (%s)\n", _("alignment < 4K")); } else if (alignment < 16) { /* Bad on NetApps: < 64K alignment */ if (!quiet) fprintf (fp, "bad (%s)\n", _("alignment < 64K")); } else { if (!quiet) fprintf (fp, "ok\n"); } } } return 0; }
void scan (size_t *worst_alignment, const char *prefix) { char **devices, *p; size_t i, j; size_t alignment; uint64_t start; struct guestfs_partition_list *parts; devices = guestfs_list_devices (g); if (devices == NULL) exit (EXIT_FAILURE); for (i = 0; devices[i] != NULL; ++i) { parts = guestfs_part_list (g, devices[i]); if (parts == NULL) exit (EXIT_FAILURE); /* Canonicalize the name of the device for printing. */ p = guestfs_canonical_device_name (g, devices[i]); if (p == NULL) exit (EXIT_FAILURE); free (devices[i]); devices[i] = p; for (j = 0; j < parts->len; ++j) { /* Start offset of the partition in bytes. */ start = parts->val[j].part_start; if (!quiet) { if (prefix) printf ("%s:", prefix); printf ("%s%d %12" PRIu64 " ", devices[i], (int) parts->val[j].part_num, start); } /* What's the alignment? */ if (start == 0) /* Probably not possible, but anyway. */ alignment = 64; else for (alignment = 0; (start & 1) == 0; alignment++, start /= 2) ; if (!quiet) { if (alignment < 10) printf ("%12" PRIu64 " ", UINT64_C(1) << alignment); else if (alignment < 64) printf ("%12" PRIu64 "K ", UINT64_C(1) << (alignment - 10)); else printf ("- "); } if (alignment < *worst_alignment) *worst_alignment = alignment; if (alignment < 12) { /* Bad in general: < 4K alignment */ if (!quiet) printf ("bad (%s)\n", _("alignment < 4K")); } else if (alignment < 16) { /* Bad on NetApps: < 64K alignment */ if (!quiet) printf ("bad (%s)\n", _("alignment < 64K")); } else { if (!quiet) printf ("ok\n"); } } guestfs_free_partition_list (parts); free (devices[i]); } free (devices); }
double __remquo (double x, double y, int *quo) { int64_t hx, hy; uint64_t sx, qs; int cquo; EXTRACT_WORDS64 (hx, x); EXTRACT_WORDS64 (hy, y); sx = hx & UINT64_C(0x8000000000000000); qs = sx ^ (hy & UINT64_C(0x8000000000000000)); hy &= UINT64_C(0x7fffffffffffffff); hx &= UINT64_C(0x7fffffffffffffff); /* Purge off exception values. */ if (__builtin_expect (hy == 0, 0)) return (x * y) / (x * y); /* y = 0 */ if (__builtin_expect (hx >= UINT64_C(0x7ff0000000000000) /* x not finite */ || hy > UINT64_C(0x7ff0000000000000), 0))/* y is NaN */ return (x * y) / (x * y); if (hy <= UINT64_C(0x7fbfffffffffffff)) x = __ieee754_fmod (x, 8 * y); /* now x < 8y */ if (__builtin_expect (hx == hy, 0)) { *quo = qs ? -1 : 1; return zero * x; } INSERT_WORDS64 (x, hx); INSERT_WORDS64 (y, hy); cquo = 0; if (x >= 4 * y) { x -= 4 * y; cquo += 4; } if (x >= 2 * y) { x -= 2 * y; cquo += 2; } if (hy < UINT64_C(0x0020000000000000)) { if (x + x > y) { x -= y; ++cquo; if (x + x >= y) { x -= y; ++cquo; } } } else { double y_half = 0.5 * y; if (x > y_half) { x -= y; ++cquo; if (x >= y_half) { x -= y; ++cquo; } } } *quo = qs ? -cquo : cquo; if (sx) x = -x; return x; }
#include <upipe/upump_blocker.h> #include <upump-ev/upump_ev.h> #include <stdio.h> #include <string.h> #include <unistd.h> #include <fcntl.h> #include <errno.h> #include <assert.h> #include <ev.h> #define UPUMP_POOL 1 #define UPUMP_BLOCKER_POOL 1 static uint64_t timeout = UINT64_C(27000000); /* 1 s */ static const char *padding = "This is an initialized bit of space used to pad sufficiently !"; /* This is an arbitrarily large number that is just supposed to be bigger than * the buffer space of a pipe. */ #define MIN_READ (128*1024) static struct ev_loop *loop; static int pipefd[2]; static struct upump_mgr *mgr; static struct upump *write_idler; static struct upump *read_timer; static struct upump *write_watcher; static struct upump *read_watcher; static struct upump_blocker *blocker = NULL; static ssize_t bytes_written = 0, bytes_read = 0;
int main(int argc, char *argv[]) { struct devbuf db = { MTXINITVAL, NULL }; struct buftab buf = { (void *)0xb4b4b4b4, 0 }; fprintf(stderr, "LVLBITS: %ld:%ld:%ld:%ld\n", NLVL0BIT, NLVL1BIT, NLVL2BIT, NLVL3BIT); devbufblk(&db, UINT64_C(0), &buf); fprintf(stderr, "RET: %p (%p)\n", devgetblk(&db, UINT64_C(0)), &buf); devbufblk(&db, UINT64_C(0xffff), &buf); fprintf(stderr, "RET: %p (%p)\n", devgetblk(&db, UINT64_C(0xffff)), &buf); devbufblk(&db, UINT64_C(0xffffffff), &buf); fprintf(stderr, "RET: %p (%p)\n", devgetblk(&db, UINT64_C(0xffffffff)), &buf); devbufblk(&db, UINT64_C(0xffffffffffff), &buf); fprintf(stderr, "RET: %p (%p)\n", devgetblk(&db, UINT64_C(0xffffffffffff)), &buf); #if (NBUFBLKBIT == 64) devbufblk(&db, UINT64_C(0xffffffffffffffff), &buf); fprintf(stderr, "RET: %p (%p)\n", devgetblk(&db, UINT64_C(0xffffffffffffffff)), &buf); #endif #if (NBUFBLKBIT == 64) devfreeblk(&db, UINT64_C(0xffffffffffffffff)); #endif devfreeblk(&db, UINT64_C(0xffffffffffff)); devfreeblk(&db, UINT64_C(0xffffffff)); devfreeblk(&db, UINT64_C(0xffff)); devfreeblk(&db, UINT64_C(0)); fprintf(stderr, "RET: %p (%p)\n", devgetblk(&db, UINT64_C(0xffffffffffff)), &buf); return 0; }
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include <stdint.h> #include <string.h> #include "../bits.h" #include "sha3.h" #include "sha3_transform.h" static const uint64_t RC[24] = { UINT64_C(0x0000000000000001), UINT64_C(0x0000000000008082), UINT64_C(0x800000000000808a), UINT64_C(0x8000000080008000), UINT64_C(0x000000000000808b), UINT64_C(0x0000000080000001), UINT64_C(0x8000000080008081), UINT64_C(0x8000000000008009), UINT64_C(0x000000000000008a), UINT64_C(0x0000000000000088), UINT64_C(0x0000000080008009), UINT64_C(0x000000008000000a), UINT64_C(0x000000008000808b), UINT64_C(0x800000000000008b), UINT64_C(0x8000000000008089), UINT64_C(0x8000000000008003), UINT64_C(0x8000000000008002), UINT64_C(0x8000000000000080), UINT64_C(0x000000000000800a), UINT64_C(0x800000008000000a), UINT64_C(0x8000000080008081), UINT64_C(0x8000000000008080), UINT64_C(0x0000000080000001), UINT64_C(0x8000000080008008) }; static const uint32_t RO[25] = {
/* * Calibrate card (some boards are overclocked and need scaling) */ static void auich_calibrate(struct auich_softc *sc) { struct timeval t1, t2; uint8_t ociv, nciv; uint64_t wait_us; uint32_t actual_48k_rate, bytes, ac97rate; void *temp_buffer; struct auich_dma *p; u_int rate; /* * Grab audio from input for fixed interval and compare how * much we actually get with what we expect. Interval needs * to be sufficiently short that no interrupts are * generated. */ /* Force the codec to a known state first. */ sc->codec_if->vtbl->set_clock(sc->codec_if, 48000); rate = sc->sc_ac97_clock = 48000; sc->codec_if->vtbl->set_rate(sc->codec_if, AC97_REG_PCM_LR_ADC_RATE, &rate); /* Setup a buffer */ bytes = 64000; temp_buffer = auich_allocm(sc, AUMODE_RECORD, bytes, M_DEVBUF, M_WAITOK); for (p = sc->sc_dmas; p && KERNADDR(p) != temp_buffer; p = p->next) continue; if (p == NULL) { printf("auich_calibrate: bad address %p\n", temp_buffer); return; } sc->pcmi.dmalist[0].base = DMAADDR(p); sc->pcmi.dmalist[0].len = (bytes >> sc->sc_sample_shift); /* * our data format is stereo, 16 bit so each sample is 4 bytes. * assuming we get 48000 samples per second, we get 192000 bytes/sec. * we're going to start recording with interrupts disabled and measure * the time taken for one block to complete. we know the block size, * we know the time in microseconds, we calculate the sample rate: * * actual_rate [bps] = bytes / (time [s] * 4) * actual_rate [bps] = (bytes * 1000000) / (time [us] * 4) * actual_rate [Hz] = (bytes * 250000) / time [us] */ /* prepare */ ociv = bus_space_read_1(sc->iot, sc->aud_ioh, ICH_PCMI + ICH_CIV); bus_space_write_4(sc->iot, sc->aud_ioh, ICH_PCMI + ICH_BDBAR, sc->sc_cddma + ICH_PCMI_OFF(0)); bus_space_write_1(sc->iot, sc->aud_ioh, ICH_PCMI + ICH_LVI, (0 - 1) & ICH_LVI_MASK); /* start */ microtime(&t1); bus_space_write_1(sc->iot, sc->aud_ioh, ICH_PCMI + ICH_CTRL, ICH_RPBM); /* wait */ nciv = ociv; do { microtime(&t2); if (t2.tv_sec - t1.tv_sec > 1) break; nciv = bus_space_read_1(sc->iot, sc->aud_ioh, ICH_PCMI + ICH_CIV); } while (nciv == ociv); microtime(&t2); /* stop */ bus_space_write_1(sc->iot, sc->aud_ioh, ICH_PCMI + ICH_CTRL, 0); /* reset */ DELAY(100); bus_space_write_1(sc->iot, sc->aud_ioh, ICH_PCMI + ICH_CTRL, ICH_RR); /* turn time delta into us */ wait_us = ((t2.tv_sec - t1.tv_sec) * 1000000) + t2.tv_usec - t1.tv_usec; auich_freem(sc, temp_buffer, M_DEVBUF); if (nciv == ociv) { printf("%s: ac97 link rate calibration timed out after %" PRIu64 " us\n", device_xname(sc->sc_dev), wait_us); return; } actual_48k_rate = (bytes * UINT64_C(250000)) / wait_us; if (actual_48k_rate < 50000) ac97rate = 48000; else ac97rate = ((actual_48k_rate + 500) / 1000) * 1000; printf("%s: measured ac97 link rate at %d Hz", device_xname(sc->sc_dev), actual_48k_rate); if (ac97rate != actual_48k_rate) printf(", will use %d Hz", ac97rate); printf("\n"); sc->sc_ac97_clock = ac97rate; }
static void ps3_joypad_poll(void) { unsigned port; CellPadInfo2 pad_info; cellPadGetInfo2(&pad_info); for (port = 0; port < MAX_PADS; port++) { CellPadData state_tmp; if (pad_info.port_status[port] & CELL_PAD_STATUS_ASSIGN_CHANGES) { if ( (pad_info.port_status[port] & CELL_PAD_STATUS_CONNECTED) == 0 ) { input_config_autoconfigure_disconnect(port, ps3_joypad.ident); pads_connected[port] = 0; } else if ((pad_info.port_status[port] & CELL_PAD_STATUS_CONNECTED) > 0 ) { pads_connected[port] = 1; ps3_joypad_autodetect_add(port); } } if (pads_connected[port] == 0) continue; cellPadGetData(port, &state_tmp); if (state_tmp.len != 0) { uint64_t *state_cur = &pad_state[port]; *state_cur = 0; #ifdef __PSL1GHT__ *state_cur |= (state_tmp.BTN_LEFT) ? (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_LEFT) : 0; *state_cur |= (state_tmp.BTN_DOWN) ? (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_DOWN) : 0; *state_cur |= (state_tmp.BTN_RIGHT) ? (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_RIGHT) : 0; *state_cur |= (state_tmp.BTN_UP) ? (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_UP) : 0; *state_cur |= (state_tmp.BTN_START) ? (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_START) : 0; *state_cur |= (state_tmp.BTN_R3) ? (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_R3) : 0; *state_cur |= (state_tmp.BTN_L3) ? (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_L3) : 0; *state_cur |= (state_tmp.BTN_SELECT) ? (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_SELECT) : 0; *state_cur |= (state_tmp.BTN_TRIANGLE) ? (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_X) : 0; *state_cur |= (state_tmp.BTN_SQUARE) ? (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_Y) : 0; *state_cur |= (state_tmp.BTN_CROSS) ? (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_B) : 0; *state_cur |= (state_tmp.BTN_CIRCLE) ? (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_A) : 0; *state_cur |= (state_tmp.BTN_R1) ? (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_R) : 0; *state_cur |= (state_tmp.BTN_L1) ? (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_L) : 0; *state_cur |= (state_tmp.BTN_R2) ? (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_R2) : 0; *state_cur |= (state_tmp.BTN_L2) ? (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_L2) : 0; #else *state_cur |= (state_tmp.button[CELL_PAD_BTN_OFFSET_DIGITAL1] & CELL_PAD_CTRL_LEFT) ? (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_LEFT) : 0; *state_cur |= (state_tmp.button[CELL_PAD_BTN_OFFSET_DIGITAL1] & CELL_PAD_CTRL_DOWN) ? (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_DOWN) : 0; *state_cur |= (state_tmp.button[CELL_PAD_BTN_OFFSET_DIGITAL1] & CELL_PAD_CTRL_RIGHT) ? (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_RIGHT) : 0; *state_cur |= (state_tmp.button[CELL_PAD_BTN_OFFSET_DIGITAL1] & CELL_PAD_CTRL_UP) ? (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_UP) : 0; *state_cur |= (state_tmp.button[CELL_PAD_BTN_OFFSET_DIGITAL1] & CELL_PAD_CTRL_START) ? (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_START) : 0; *state_cur |= (state_tmp.button[CELL_PAD_BTN_OFFSET_DIGITAL1] & CELL_PAD_CTRL_R3) ? (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_R3) : 0; *state_cur |= (state_tmp.button[CELL_PAD_BTN_OFFSET_DIGITAL1] & CELL_PAD_CTRL_L3) ? (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_L3) : 0; *state_cur |= (state_tmp.button[CELL_PAD_BTN_OFFSET_DIGITAL1] & CELL_PAD_CTRL_SELECT) ? (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_SELECT) : 0; *state_cur |= (state_tmp.button[CELL_PAD_BTN_OFFSET_DIGITAL2] & CELL_PAD_CTRL_TRIANGLE) ? (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_X) : 0; *state_cur |= (state_tmp.button[CELL_PAD_BTN_OFFSET_DIGITAL2] & CELL_PAD_CTRL_SQUARE) ? (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_Y) : 0; if (menu_driver_ctl(RARCH_MENU_CTL_IS_ALIVE, NULL)) { int value = 0; if (cellSysutilGetSystemParamInt(CELL_SYSUTIL_SYSTEMPARAM_ID_ENTER_BUTTON_ASSIGN, &value) == 0) { if (state_tmp.button[CELL_PAD_BTN_OFFSET_DIGITAL2] & CELL_PAD_CTRL_CROSS) *state_cur |= (value == CELL_SYSUTIL_ENTER_BUTTON_ASSIGN_CROSS) ? (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_A) : (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_B); if (state_tmp.button[CELL_PAD_BTN_OFFSET_DIGITAL2] & CELL_PAD_CTRL_CIRCLE) *state_cur |= (value == CELL_SYSUTIL_ENTER_BUTTON_ASSIGN_CIRCLE) ? (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_A) : (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_B); } } else { *state_cur |= (state_tmp.button[CELL_PAD_BTN_OFFSET_DIGITAL2] & CELL_PAD_CTRL_CROSS) ? (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_B) : 0; *state_cur |= (state_tmp.button[CELL_PAD_BTN_OFFSET_DIGITAL2] & CELL_PAD_CTRL_CIRCLE) ? (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_A) : 0; } *state_cur |= (state_tmp.button[CELL_PAD_BTN_OFFSET_DIGITAL2] & CELL_PAD_CTRL_R1) ? (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_R) : 0; *state_cur |= (state_tmp.button[CELL_PAD_BTN_OFFSET_DIGITAL2] & CELL_PAD_CTRL_L1) ? (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_L) : 0; *state_cur |= (state_tmp.button[CELL_PAD_BTN_OFFSET_DIGITAL2] & CELL_PAD_CTRL_R2) ? (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_R2) : 0; *state_cur |= (state_tmp.button[CELL_PAD_BTN_OFFSET_DIGITAL2] & CELL_PAD_CTRL_L2) ? (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_L2) : 0; *state_cur |= (state_tmp.button[CELL_PAD_BTN_OFFSET_DIGITAL2] & CELL_PAD_CTRL_L2) ? (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_L2) : 0; //RARCH_LOG("lsx : %d (%hd) lsy : %d (%hd) rsx : %d (%hd) rsy : %d (%hd)\n", lsx, ls_x, lsy, ls_y, rsx, rs_x, rsy, rs_y); uint8_t lsx = (uint8_t)(state_tmp.button[CELL_PAD_BTN_OFFSET_ANALOG_LEFT_X]); uint8_t lsy = (uint8_t)(state_tmp.button[CELL_PAD_BTN_OFFSET_ANALOG_LEFT_Y]); uint8_t rsx = (uint8_t)(state_tmp.button[CELL_PAD_BTN_OFFSET_ANALOG_RIGHT_X]); uint8_t rsy = (uint8_t)(state_tmp.button[CELL_PAD_BTN_OFFSET_ANALOG_RIGHT_Y]); analog_state[port][RETRO_DEVICE_INDEX_ANALOG_LEFT ][RETRO_DEVICE_ID_ANALOG_X] = convert_u8_to_s16(lsx); analog_state[port][RETRO_DEVICE_INDEX_ANALOG_LEFT ][RETRO_DEVICE_ID_ANALOG_Y] = convert_u8_to_s16(lsy); analog_state[port][RETRO_DEVICE_INDEX_ANALOG_RIGHT][RETRO_DEVICE_ID_ANALOG_X] = convert_u8_to_s16(rsx); analog_state[port][RETRO_DEVICE_INDEX_ANALOG_RIGHT][RETRO_DEVICE_ID_ANALOG_Y] = convert_u8_to_s16(rsy); #if 0 accelerometer_state[port].x = state_tmp.button[CELL_PAD_BTN_OFFSET_SENSOR_X]; accelerometer_state[port].y = state_tmp.button[CELL_PAD_BTN_OFFSET_SENSOR_Y]; accelerometer_state[port].z = state_tmp.button[CELL_PAD_BTN_OFFSET_SENSOR_Z]; #endif #endif } for (int i = 0; i < 2; i++) for (int j = 0; j < 2; j++) if (analog_state[port][i][j] == -0x8000) analog_state[port][i][j] = -0x7fff; } }
#include <stdbool.h> #include <stdint.h> #include "random.h" #include "genCases.h" struct sequence { int term1Num, term2Num; bool done; }; union ui64_i64 { uint64_t ui; int64_t i; }; enum { i64NumP1 = 252 }; static const uint64_t i64P1[ i64NumP1 ] = { UINT64_C( 0x0000000000000000 ), UINT64_C( 0x0000000000000001 ), UINT64_C( 0x0000000000000002 ), UINT64_C( 0x0000000000000004 ), UINT64_C( 0x0000000000000008 ), UINT64_C( 0x0000000000000010 ), UINT64_C( 0x0000000000000020 ), UINT64_C( 0x0000000000000040 ), UINT64_C( 0x0000000000000080 ), UINT64_C( 0x0000000000000100 ), UINT64_C( 0x0000000000000200 ), UINT64_C( 0x0000000000000400 ), UINT64_C( 0x0000000000000800 ), UINT64_C( 0x0000000000001000 ), UINT64_C( 0x0000000000002000 ), UINT64_C( 0x0000000000004000 ),
// Internal API functions static int wince_init(struct libusb_context *ctx) { int r = LIBUSB_ERROR_OTHER; HANDLE semaphore; LARGE_INTEGER li_frequency; TCHAR sem_name[11+1+8]; // strlen(libusb_init)+'\0'+(32-bit hex PID) _stprintf(sem_name, _T("libusb_init%08X"), (unsigned int)GetCurrentProcessId()&0xFFFFFFFF); semaphore = CreateSemaphore(NULL, 1, 1, sem_name); if (semaphore == NULL) { usbi_err(ctx, "could not create semaphore: %s", windows_error_str(0)); return LIBUSB_ERROR_NO_MEM; } // A successful wait brings our semaphore count to 0 (unsignaled) // => any concurent wait stalls until the semaphore's release if (WaitForSingleObject(semaphore, INFINITE) != WAIT_OBJECT_0) { usbi_err(ctx, "failure to access semaphore: %s", windows_error_str(0)); CloseHandle(semaphore); return LIBUSB_ERROR_NO_MEM; } // NB: concurrent usage supposes that init calls are equally balanced with // exit calls. If init is called more than exit, we will not exit properly if ( ++concurrent_usage == 0 ) { // First init? // Initialize pollable file descriptors init_polling(); // Load DLL imports if (init_dllimports() != LIBUSB_SUCCESS) { usbi_err(ctx, "could not resolve DLL functions"); r = LIBUSB_ERROR_NOT_SUPPORTED; goto init_exit; } // try to open a handle to the driver driver_handle = UkwOpenDriver(); if (driver_handle == INVALID_HANDLE_VALUE) { usbi_err(ctx, "could not connect to driver"); r = LIBUSB_ERROR_NOT_SUPPORTED; goto init_exit; } // find out if we have access to a monotonic (hires) timer if (QueryPerformanceFrequency(&li_frequency)) { hires_frequency = li_frequency.QuadPart; // The hires frequency can go as high as 4 GHz, so we'll use a conversion // to picoseconds to compute the tv_nsecs part in clock_gettime hires_ticks_to_ps = UINT64_C(1000000000000) / hires_frequency; usbi_dbg("hires timer available (Frequency: %"PRIu64" Hz)", hires_frequency); } else { usbi_dbg("no hires timer available on this platform"); hires_frequency = 0; hires_ticks_to_ps = UINT64_C(0); } } // At this stage, either we went through full init successfully, or didn't need to r = LIBUSB_SUCCESS; init_exit: // Holds semaphore here. if (!concurrent_usage && r != LIBUSB_SUCCESS) { // First init failed? if (driver_handle != INVALID_HANDLE_VALUE) { UkwCloseDriver(driver_handle); driver_handle = INVALID_HANDLE_VALUE; } } if (r != LIBUSB_SUCCESS) --concurrent_usage; // Not expected to call libusb_exit if we failed. ReleaseSemaphore(semaphore, 1, NULL); // increase count back to 1 CloseHandle(semaphore); return r; }
/* Get resolution of clock. */ int clock_getres (clockid_t clock_id, struct timespec *res) { int retval = -1; switch (clock_id) { case CLOCK_REALTIME: { long int clk_tck = sysconf (_SC_CLK_TCK); if (__builtin_expect (clk_tck != -1, 1)) { /* This implementation assumes that the realtime clock has a resolution higher than 1 second. This is the case for any reasonable implementation. */ res->tv_sec = 0; res->tv_nsec = 1000000000 / clk_tck; retval = 0; } } break; #if HP_TIMING_AVAIL case CLOCK_PROCESS_CPUTIME_ID: case CLOCK_THREAD_CPUTIME_ID: { if (__builtin_expect (nsec == 0, 0)) { hp_timing_t freq; /* This can only happen if we haven't initialized the `freq' variable yet. Do this now. We don't have to protect this code against multiple execution since all of them should lead to the same result. */ freq = __get_clockfreq (); if (__builtin_expect (freq == 0, 0)) /* Something went wrong. */ break; nsec = MAX (UINT64_C (1000000000) / freq, 1); } /* File in the values. The seconds are always zero (unless we have a 1Hz machine). */ res->tv_sec = 0; res->tv_nsec = nsec; retval = 0; } break; #endif default: __set_errno (EINVAL); break; } return retval; }
unsigned menu_input_frame_retropad(retro_input_t input, retro_input_t trigger_input) { menu_animation_ctx_delta_t delta; float delta_time; static bool initial_held = true; static bool first_held = false; bool set_scroll = false; size_t new_scroll_accel = 0; menu_input_t *menu_input = menu_input_get_ptr(); if (!menu_input) return 0; core_poll(); /* don't run anything first frame, only capture held inputs * for old_input_state. */ if (input.state) { if (!first_held) { first_held = true; menu_input->delay.timer = initial_held ? 12 : 6; menu_input->delay.count = 0; } if (menu_input->delay.count >= menu_input->delay.timer) { retro_input_t input_repeat = {0}; BIT32_SET(input_repeat.state, RETRO_DEVICE_ID_JOYPAD_UP); BIT32_SET(input_repeat.state, RETRO_DEVICE_ID_JOYPAD_DOWN); BIT32_SET(input_repeat.state, RETRO_DEVICE_ID_JOYPAD_LEFT); BIT32_SET(input_repeat.state, RETRO_DEVICE_ID_JOYPAD_RIGHT); BIT32_SET(input_repeat.state, RETRO_DEVICE_ID_JOYPAD_B); BIT32_SET(input_repeat.state, RETRO_DEVICE_ID_JOYPAD_A); BIT32_SET(input_repeat.state, RETRO_DEVICE_ID_JOYPAD_L); BIT32_SET(input_repeat.state, RETRO_DEVICE_ID_JOYPAD_R); set_scroll = true; first_held = false; trigger_input.state |= input.state & input_repeat.state; menu_navigation_ctl(MENU_NAVIGATION_CTL_GET_SCROLL_ACCEL, &new_scroll_accel); new_scroll_accel = MIN(new_scroll_accel + 1, 64); } initial_held = false; } else { set_scroll = true; first_held = false; initial_held = true; } if (set_scroll) menu_navigation_ctl(MENU_NAVIGATION_CTL_SET_SCROLL_ACCEL, &new_scroll_accel); menu_animation_ctl(MENU_ANIMATION_CTL_DELTA_TIME, &delta_time); delta.current = delta_time; if (menu_animation_ctl(MENU_ANIMATION_CTL_IDEAL_DELTA_TIME_GET, &delta)) menu_input->delay.count += delta.ideal; if (menu_input->keyboard.display) { static unsigned ti_char = 64; static bool ti_next = false; if (trigger_input.state & (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_DOWN)) { if (ti_char > 32) ti_char--; if (! ti_next) input_keyboard_event(true, '\x7f', '\x7f', 0, RETRO_DEVICE_KEYBOARD); input_keyboard_event(true, ti_char, ti_char, 0, RETRO_DEVICE_KEYBOARD); ti_next = false; } if (trigger_input.state & (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_UP)) { if (ti_char < 125) ti_char++; if (! ti_next) input_keyboard_event(true, '\x7f', '\x7f', 0, RETRO_DEVICE_KEYBOARD); input_keyboard_event(true, ti_char, ti_char, 0, RETRO_DEVICE_KEYBOARD); ti_next = false; } if (trigger_input.state & (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_A)) { ti_char = 64; ti_next = true; } if (trigger_input.state & (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_B)) { input_keyboard_event(true, '\x7f', '\x7f', 0, RETRO_DEVICE_KEYBOARD); ti_char = 64; ti_next = false; } /* send return key to close keyboard input window */ if (trigger_input.state & (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_START)) input_keyboard_event(true, '\n', '\n', 0, RETRO_DEVICE_KEYBOARD); trigger_input.state = 0; } return menu_input_frame_build(trigger_input); }
/** * Construct the DMI table. * * @returns VBox status code. * @param pDevIns The device instance. * @param pTable Where to create the DMI table. * @param cbMax The maximum size of the DMI table. * @param pUuid Pointer to the UUID to use if the DmiUuid * configuration string isn't present. * @param pCfg The handle to our config node. * @param cCpus Number of VCPUs. * @param pcbDmiTables Size of DMI data in bytes. * @param pcNumDmiTables Number of DMI tables. */ int FwCommonPlantDMITable(PPDMDEVINS pDevIns, uint8_t *pTable, unsigned cbMax, PCRTUUID pUuid, PCFGMNODE pCfg, uint16_t cCpus, uint16_t *pcbDmiTables, uint16_t *pcNumDmiTables) { /* * CFGM Hint! * * The macros below makes it a bit hard to figure out the config options * available here. To get a quick hint, take a look a the CFGM * validation in the calling code (DevEFI.cpp and DevPcBios.cpp). * * 32-bit signed integer CFGM options are read by DMI_READ_CFG_S32, the 2nd * parameter is the CFGM value name. * * Strings are read by DMI_READ_CFG_STR and DMI_READ_CFG_STR_DEF, the 2nd parameter is * the CFGM value name. */ #define DMI_CHECK_SIZE(cbWant) \ { \ size_t cbNeed = (size_t)(pszStr + cbWant - (char *)pTable) + 5; /* +1 for strtab terminator +4 for end-of-table entry */ \ if (cbNeed > cbMax) \ { \ if (fHideErrors) \ { \ LogRel(("One of the DMI strings is too long -- using default DMI data!\n")); \ continue; \ } \ return PDMDevHlpVMSetError(pDevIns, VERR_TOO_MUCH_DATA, RT_SRC_POS, \ N_("One of the DMI strings is too long. Check all bios/Dmi* configuration entries. At least %zu bytes are needed but there is no space for more than %d bytes"), cbNeed, cbMax); \ } \ } #define DMI_READ_CFG_STR_DEF(variable, name, default_value) \ { \ if (fForceDefault) \ pszTmp = default_value; \ else \ { \ rc = CFGMR3QueryStringDef(pCfg, name, szBuf, sizeof(szBuf), default_value); \ if (RT_FAILURE(rc)) \ { \ if (fHideErrors) \ { \ LogRel(("Configuration error: Querying \"" name "\" as a string failed -- using default DMI data!\n")); \ continue; \ } \ return PDMDevHlpVMSetError(pDevIns, rc, RT_SRC_POS, \ N_("Configuration error: Querying \"" name "\" as a string failed")); \ } \ else if (!strcmp(szBuf, "<EMPTY>")) \ pszTmp = ""; \ else \ pszTmp = szBuf; \ } \ if (!pszTmp[0]) \ variable = 0; /* empty string */ \ else \ { \ variable = iStrNr++; \ size_t cStr = strlen(pszTmp) + 1; \ DMI_CHECK_SIZE(cStr); \ memcpy(pszStr, pszTmp, cStr); \ pszStr += cStr ; \ } \ } #define DMI_READ_CFG_STR(variable, name) \ DMI_READ_CFG_STR_DEF(variable, # name, g_pszDef ## name) #define DMI_READ_CFG_S32(variable, name) \ { \ if (fForceDefault) \ variable = g_iDef ## name; \ else \ { \ rc = CFGMR3QueryS32Def(pCfg, # name, & variable, g_iDef ## name); \ if (RT_FAILURE(rc)) \ { \ if (fHideErrors) \ { \ LogRel(("Configuration error: Querying \"" # name "\" as an int failed -- using default DMI data!\n")); \ continue; \ } \ return PDMDevHlpVMSetError(pDevIns, rc, RT_SRC_POS, \ N_("Configuration error: Querying \"" # name "\" as an int failed")); \ } \ } \ } #define DMI_START_STRUCT(tbl) \ pszStr = (char *)(tbl + 1); \ iStrNr = 1; #define DMI_TERM_STRUCT \ { \ *pszStr++ = '\0'; /* terminate set of text strings */ \ if (iStrNr == 1) \ *pszStr++ = '\0'; /* terminate a structure without strings */ \ } bool fForceDefault = false; #ifdef VBOX_BIOS_DMI_FALLBACK /* * There will be two passes. If an error occurs during the first pass, a * message will be written to the release log and we fall back to default * DMI data and start a second pass. */ bool fHideErrors = true; #else /* * There will be one pass, every error is fatal and will prevent the VM * from starting. */ bool fHideErrors = false; #endif uint8_t fDmiUseHostInfo; int rc = CFGMR3QueryU8Def(pCfg, "DmiUseHostInfo", &fDmiUseHostInfo, 0); if (RT_FAILURE (rc)) return PDMDEV_SET_ERROR(pDevIns, rc, N_("Configuration error: Failed to read \"DmiUseHostInfo\"")); /* Sync up with host default DMI values */ if (fDmiUseHostInfo) fwCommonUseHostDMIStrings(); uint8_t fDmiExposeMemoryTable; rc = CFGMR3QueryU8Def(pCfg, "DmiExposeMemoryTable", &fDmiExposeMemoryTable, 0); if (RT_FAILURE (rc)) return PDMDEV_SET_ERROR(pDevIns, rc, N_("Configuration error: Failed to read \"DmiExposeMemoryTable\"")); uint8_t fDmiExposeProcessorInf; rc = CFGMR3QueryU8Def(pCfg, "DmiExposeProcInf", &fDmiExposeProcessorInf, 0); if (RT_FAILURE (rc)) return PDMDEV_SET_ERROR(pDevIns, rc, N_("Configuration error: Failed to read \"DmiExposeProcInf\"")); for (;; fForceDefault = true, fHideErrors = false) { int iStrNr; char szBuf[256]; char *pszStr = (char *)pTable; char szDmiSystemUuid[64]; char *pszDmiSystemUuid; const char *pszTmp; if (fForceDefault) pszDmiSystemUuid = NULL; else { rc = CFGMR3QueryString(pCfg, "DmiSystemUuid", szDmiSystemUuid, sizeof(szDmiSystemUuid)); if (rc == VERR_CFGM_VALUE_NOT_FOUND) pszDmiSystemUuid = NULL; else if (RT_FAILURE(rc)) { if (fHideErrors) { LogRel(("Configuration error: Querying \"DmiSystemUuid\" as a string failed, using default DMI data\n")); continue; } return PDMDevHlpVMSetError(pDevIns, rc, RT_SRC_POS, N_("Configuration error: Querying \"DmiSystemUuid\" as a string failed")); } else pszDmiSystemUuid = szDmiSystemUuid; } /********************************* * DMI BIOS information (Type 0) * *********************************/ PDMIBIOSINF pBIOSInf = (PDMIBIOSINF)pszStr; DMI_CHECK_SIZE(sizeof(*pBIOSInf)); pszStr = (char *)&pBIOSInf->u8ReleaseMajor; pBIOSInf->header.u8Length = RT_OFFSETOF(DMIBIOSINF, u8ReleaseMajor); /* don't set these fields by default for legacy compatibility */ int iDmiBIOSReleaseMajor, iDmiBIOSReleaseMinor; DMI_READ_CFG_S32(iDmiBIOSReleaseMajor, DmiBIOSReleaseMajor); DMI_READ_CFG_S32(iDmiBIOSReleaseMinor, DmiBIOSReleaseMinor); if (iDmiBIOSReleaseMajor != 0 || iDmiBIOSReleaseMinor != 0) { pszStr = (char *)&pBIOSInf->u8FirmwareMajor; pBIOSInf->header.u8Length = RT_OFFSETOF(DMIBIOSINF, u8FirmwareMajor); pBIOSInf->u8ReleaseMajor = iDmiBIOSReleaseMajor; pBIOSInf->u8ReleaseMinor = iDmiBIOSReleaseMinor; int iDmiBIOSFirmwareMajor, iDmiBIOSFirmwareMinor; DMI_READ_CFG_S32(iDmiBIOSFirmwareMajor, DmiBIOSFirmwareMajor); DMI_READ_CFG_S32(iDmiBIOSFirmwareMinor, DmiBIOSFirmwareMinor); if (iDmiBIOSFirmwareMajor != 0 || iDmiBIOSFirmwareMinor != 0) { pszStr = (char *)(pBIOSInf + 1); pBIOSInf->header.u8Length = sizeof(DMIBIOSINF); pBIOSInf->u8FirmwareMajor = iDmiBIOSFirmwareMajor; pBIOSInf->u8FirmwareMinor = iDmiBIOSFirmwareMinor; } } iStrNr = 1; pBIOSInf->header.u8Type = 0; /* BIOS Information */ pBIOSInf->header.u16Handle = 0x0000; DMI_READ_CFG_STR(pBIOSInf->u8Vendor, DmiBIOSVendor); DMI_READ_CFG_STR(pBIOSInf->u8Version, DmiBIOSVersion); pBIOSInf->u16Start = 0xE000; DMI_READ_CFG_STR(pBIOSInf->u8Release, DmiBIOSReleaseDate); pBIOSInf->u8ROMSize = 1; /* 128K */ pBIOSInf->u64Characteristics = RT_BIT(4) /* ISA is supported */ | RT_BIT(7) /* PCI is supported */ | RT_BIT(15) /* Boot from CD is supported */ | RT_BIT(16) /* Selectable Boot is supported */ | RT_BIT(27) /* Int 9h, 8042 Keyboard services supported */ | RT_BIT(30) /* Int 10h, CGA/Mono Video Services supported */ /* any more?? */ ; pBIOSInf->u8CharacteristicsByte1 = RT_BIT(0) /* ACPI is supported */ /* any more?? */ ; pBIOSInf->u8CharacteristicsByte2 = 0 /* any more?? */ ; DMI_TERM_STRUCT; /*********************************** * DMI system information (Type 1) * ***********************************/ PDMISYSTEMINF pSystemInf = (PDMISYSTEMINF)pszStr; DMI_CHECK_SIZE(sizeof(*pSystemInf)); DMI_START_STRUCT(pSystemInf); pSystemInf->header.u8Type = 1; /* System Information */ pSystemInf->header.u8Length = sizeof(*pSystemInf); pSystemInf->header.u16Handle = 0x0001; DMI_READ_CFG_STR(pSystemInf->u8Manufacturer, DmiSystemVendor); DMI_READ_CFG_STR(pSystemInf->u8ProductName, DmiSystemProduct); DMI_READ_CFG_STR(pSystemInf->u8Version, DmiSystemVersion); DMI_READ_CFG_STR(pSystemInf->u8SerialNumber, DmiSystemSerial); RTUUID uuid; if (pszDmiSystemUuid) { rc = RTUuidFromStr(&uuid, pszDmiSystemUuid); if (RT_FAILURE(rc)) { if (fHideErrors) { LogRel(("Configuration error: Invalid UUID for DMI tables specified, using default DMI data\n")); continue; } return PDMDevHlpVMSetError(pDevIns, rc, RT_SRC_POS, N_("Configuration error: Invalid UUID for DMI tables specified")); } uuid.Gen.u32TimeLow = RT_H2BE_U32(uuid.Gen.u32TimeLow); uuid.Gen.u16TimeMid = RT_H2BE_U16(uuid.Gen.u16TimeMid); uuid.Gen.u16TimeHiAndVersion = RT_H2BE_U16(uuid.Gen.u16TimeHiAndVersion); pUuid = &uuid; } memcpy(pSystemInf->au8Uuid, pUuid, sizeof(RTUUID)); pSystemInf->u8WakeupType = 6; /* Power Switch */ DMI_READ_CFG_STR(pSystemInf->u8SKUNumber, DmiSystemSKU); DMI_READ_CFG_STR(pSystemInf->u8Family, DmiSystemFamily); DMI_TERM_STRUCT; /********************************** * DMI board information (Type 2) * **********************************/ PDMIBOARDINF pBoardInf = (PDMIBOARDINF)pszStr; DMI_CHECK_SIZE(sizeof(*pBoardInf)); DMI_START_STRUCT(pBoardInf); int iDmiBoardBoardType; pBoardInf->header.u8Type = 2; /* Board Information */ pBoardInf->header.u8Length = sizeof(*pBoardInf); pBoardInf->header.u16Handle = 0x0008; DMI_READ_CFG_STR(pBoardInf->u8Manufacturer, DmiBoardVendor); DMI_READ_CFG_STR(pBoardInf->u8Product, DmiBoardProduct); DMI_READ_CFG_STR(pBoardInf->u8Version, DmiBoardVersion); DMI_READ_CFG_STR(pBoardInf->u8SerialNumber, DmiBoardSerial); DMI_READ_CFG_STR(pBoardInf->u8AssetTag, DmiBoardAssetTag); pBoardInf->u8FeatureFlags = RT_BIT(0) /* hosting board, e.g. motherboard */ ; DMI_READ_CFG_STR(pBoardInf->u8LocationInChass, DmiBoardLocInChass); pBoardInf->u16ChassisHandle = 0x0003; /* see type 3 */ DMI_READ_CFG_S32(iDmiBoardBoardType, DmiBoardBoardType); pBoardInf->u8BoardType = iDmiBoardBoardType; pBoardInf->u8cObjectHandles = 0; DMI_TERM_STRUCT; /******************************************** * DMI System Enclosure or Chassis (Type 3) * ********************************************/ PDMICHASSIS pChassis = (PDMICHASSIS)pszStr; DMI_CHECK_SIZE(sizeof(*pChassis)); pszStr = (char*)&pChassis->u32OEMdefined; iStrNr = 1; #ifdef VBOX_WITH_DMI_CHASSIS pChassis->header.u8Type = 3; /* System Enclosure or Chassis */ #else pChassis->header.u8Type = 0x7e; /* inactive */ #endif pChassis->header.u8Length = RT_OFFSETOF(DMICHASSIS, u32OEMdefined); pChassis->header.u16Handle = 0x0003; DMI_READ_CFG_STR(pChassis->u8Manufacturer, DmiChassisVendor); int iDmiChassisType; DMI_READ_CFG_S32(iDmiChassisType, DmiChassisType); pChassis->u8Type = iDmiChassisType; DMI_READ_CFG_STR(pChassis->u8Version, DmiChassisVersion); DMI_READ_CFG_STR(pChassis->u8SerialNumber, DmiChassisSerial); DMI_READ_CFG_STR(pChassis->u8AssetTag, DmiChassisAssetTag); pChassis->u8BootupState = 0x03; /* safe */ pChassis->u8PowerSupplyState = 0x03; /* safe */ pChassis->u8ThermalState = 0x03; /* safe */ pChassis->u8SecurityStatus = 0x03; /* none XXX */ # if 0 /* v2.3+, currently not supported */ pChassis->u32OEMdefined = 0; pChassis->u8Height = 0; /* unspecified */ pChassis->u8NumPowerChords = 0; /* unspecified */ pChassis->u8ContElems = 0; /* no contained elements */ pChassis->u8ContElemRecLen = 0; /* no contained elements */ # endif DMI_TERM_STRUCT; /************************************** * DMI Processor Information (Type 4) * **************************************/ /* * This is just a dummy processor. Should we expose the real guest CPU features * here? Accessing this information at this point is difficult. */ char szSocket[32]; PDMIPROCESSORINF pProcessorInf = (PDMIPROCESSORINF)pszStr; DMI_CHECK_SIZE(sizeof(*pProcessorInf)); DMI_START_STRUCT(pProcessorInf); if (fDmiExposeProcessorInf) pProcessorInf->header.u8Type = 4; /* Processor Information */ else pProcessorInf->header.u8Type = 126; /* inactive structure */ pProcessorInf->header.u8Length = sizeof(*pProcessorInf); pProcessorInf->header.u16Handle = 0x0007; RTStrPrintf(szSocket, sizeof(szSocket), "Socket #%u", 0); pProcessorInf->u8SocketDesignation = iStrNr++; { size_t cStr = strlen(szSocket) + 1; DMI_CHECK_SIZE(cStr); memcpy(pszStr, szSocket, cStr); pszStr += cStr; } pProcessorInf->u8ProcessorType = 0x03; /* Central Processor */ pProcessorInf->u8ProcessorFamily = 0xB1; /* Pentium III with Intel SpeedStep(TM) */ DMI_READ_CFG_STR(pProcessorInf->u8ProcessorManufacturer, DmiProcManufacturer); pProcessorInf->u64ProcessorID = UINT64_C(0x0FEBFBFF00010676); /* Ext Family ID = 0 * Ext Model ID = 2 * Processor Type = 0 * Family ID = 6 * Model = 7 * Stepping = 6 * Features: FPU, VME, DE, PSE, TSC, MSR, PAE, MCE, CX8, * APIC, SEP, MTRR, PGE, MCA, CMOV, PAT, PSE-36, * CFLSH, DS, ACPI, MMX, FXSR, SSE, SSE2, SS */ DMI_READ_CFG_STR(pProcessorInf->u8ProcessorVersion, DmiProcVersion); pProcessorInf->u8Voltage = 0x02; /* 3.3V */ pProcessorInf->u16ExternalClock = 0x00; /* unknown */ pProcessorInf->u16MaxSpeed = 3000; /* 3GHz */ pProcessorInf->u16CurrentSpeed = 3000; /* 3GHz */ pProcessorInf->u8Status = RT_BIT(6) /* CPU socket populated */ | RT_BIT(0) /* CPU enabled */ ; pProcessorInf->u8ProcessorUpgrade = 0x04; /* ZIF Socket */ pProcessorInf->u16L1CacheHandle = 0xFFFF; /* not specified */ pProcessorInf->u16L2CacheHandle = 0xFFFF; /* not specified */ pProcessorInf->u16L3CacheHandle = 0xFFFF; /* not specified */ pProcessorInf->u8SerialNumber = 0; /* not specified */ pProcessorInf->u8AssetTag = 0; /* not specified */ pProcessorInf->u8PartNumber = 0; /* not specified */ pProcessorInf->u8CoreCount = cCpus; /* */ pProcessorInf->u8CoreEnabled = cCpus; pProcessorInf->u8ThreadCount = 1; pProcessorInf->u16ProcessorCharacteristics = RT_BIT(2); /* 64-bit capable */ pProcessorInf->u16ProcessorFamily2 = 0; DMI_TERM_STRUCT; /*************************************** * DMI Physical Memory Array (Type 16) * ***************************************/ uint64_t u64RamSize; rc = CFGMR3QueryU64(pCfg, "RamSize", &u64RamSize); if (RT_FAILURE (rc)) return PDMDEV_SET_ERROR(pDevIns, rc, N_("Configuration error: Failed to read \"RamSize\"")); PDMIRAMARRAY pMemArray = (PDMIRAMARRAY)pszStr; DMI_CHECK_SIZE(sizeof(*pMemArray)); DMI_START_STRUCT(pMemArray); if (fDmiExposeMemoryTable) pMemArray->header.u8Type = 16; /* Physical Memory Array */ else pMemArray->header.u8Type = 126; /* inactive structure */ pMemArray->header.u8Length = sizeof(*pMemArray); pMemArray->header.u16Handle = 0x0005; pMemArray->u8Location = 0x03; /* Motherboard */ pMemArray->u8Use = 0x03; /* System memory */ pMemArray->u8MemErrorCorrection = 0x01; /* Other */ pMemArray->u32MaxCapacity = (uint32_t)(u64RamSize / _1K); /* RAM size in K */ pMemArray->u16MemErrorHandle = 0xfffe; /* No error info structure */ pMemArray->u16NumberOfMemDevices = 1; DMI_TERM_STRUCT; /*************************************** * DMI Memory Device (Type 17) * ***************************************/ PDMIMEMORYDEV pMemDev = (PDMIMEMORYDEV)pszStr; DMI_CHECK_SIZE(sizeof(*pMemDev)); DMI_START_STRUCT(pMemDev); if (fDmiExposeMemoryTable) pMemDev->header.u8Type = 17; /* Memory Device */ else pMemDev->header.u8Type = 126; /* inactive structure */ pMemDev->header.u8Length = sizeof(*pMemDev); pMemDev->header.u16Handle = 0x0006; pMemDev->u16PhysMemArrayHandle = 0x0005; /* handle of array we belong to */ pMemDev->u16MemErrHandle = 0xfffe; /* system doesn't provide this information */ pMemDev->u16TotalWidth = 0xffff; /* Unknown */ pMemDev->u16DataWidth = 0xffff; /* Unknown */ int16_t u16RamSizeM = (uint16_t)(u64RamSize / _1M); if (u16RamSizeM == 0) u16RamSizeM = 0x400; /* 1G */ pMemDev->u16Size = u16RamSizeM; /* RAM size */ pMemDev->u8FormFactor = 0x09; /* DIMM */ pMemDev->u8DeviceSet = 0x00; /* Not part of a device set */ DMI_READ_CFG_STR_DEF(pMemDev->u8DeviceLocator, " ", "DIMM 0"); DMI_READ_CFG_STR_DEF(pMemDev->u8BankLocator, " ", "Bank 0"); pMemDev->u8MemoryType = 0x03; /* DRAM */ pMemDev->u16TypeDetail = 0; /* Nothing special */ pMemDev->u16Speed = 1600; /* Unknown, shall be speed in MHz */ DMI_READ_CFG_STR(pMemDev->u8Manufacturer, DmiSystemVendor); DMI_READ_CFG_STR_DEF(pMemDev->u8SerialNumber, " ", "00000000"); DMI_READ_CFG_STR_DEF(pMemDev->u8AssetTag, " ", "00000000"); DMI_READ_CFG_STR_DEF(pMemDev->u8PartNumber, " ", "00000000"); pMemDev->u8Attributes = 0; /* Unknown */ DMI_TERM_STRUCT; /***************************** * DMI OEM strings (Type 11) * *****************************/ PDMIOEMSTRINGS pOEMStrings = (PDMIOEMSTRINGS)pszStr; DMI_CHECK_SIZE(sizeof(*pOEMStrings)); DMI_START_STRUCT(pOEMStrings); #ifdef VBOX_WITH_DMI_OEMSTRINGS pOEMStrings->header.u8Type = 0xb; /* OEM Strings */ #else pOEMStrings->header.u8Type = 126; /* inactive structure */ #endif pOEMStrings->header.u8Length = sizeof(*pOEMStrings); pOEMStrings->header.u16Handle = 0x0002; pOEMStrings->u8Count = 2; char szTmp[64]; RTStrPrintf(szTmp, sizeof(szTmp), "vboxVer_%u.%u.%u", RTBldCfgVersionMajor(), RTBldCfgVersionMinor(), RTBldCfgVersionBuild()); DMI_READ_CFG_STR_DEF(pOEMStrings->u8VBoxVersion, "DmiOEMVBoxVer", szTmp); RTStrPrintf(szTmp, sizeof(szTmp), "vboxRev_%u", RTBldCfgRevision()); DMI_READ_CFG_STR_DEF(pOEMStrings->u8VBoxRevision, "DmiOEMVBoxRev", szTmp); DMI_TERM_STRUCT; /************************************* * DMI OEM specific table (Type 128) * ************************************/ PDMIOEMSPECIFIC pOEMSpecific = (PDMIOEMSPECIFIC)pszStr; DMI_CHECK_SIZE(sizeof(*pOEMSpecific)); DMI_START_STRUCT(pOEMSpecific); pOEMSpecific->header.u8Type = 0x80; /* OEM specific */ pOEMSpecific->header.u8Length = sizeof(*pOEMSpecific); pOEMSpecific->header.u16Handle = 0x0008; /* Just next free handle */ pOEMSpecific->u32CpuFreqKHz = RT_H2LE_U32((uint32_t)((uint64_t)TMCpuTicksPerSecond(PDMDevHlpGetVM(pDevIns)) / 1000)); DMI_TERM_STRUCT; /* End-of-table marker - includes padding to account for fixed table size. */ PDMIHDR pEndOfTable = (PDMIHDR)pszStr; pszStr = (char *)(pEndOfTable + 1); pEndOfTable->u8Type = 0x7f; pEndOfTable->u8Length = sizeof(*pEndOfTable); pEndOfTable->u16Handle = 0xFEFF; *pcbDmiTables = ((uintptr_t)pszStr - (uintptr_t)pTable) + 2; /* We currently plant 10 DMI tables. Update this if tables number changed. */ *pcNumDmiTables = 10; /* If more fields are added here, fix the size check in DMI_READ_CFG_STR */ /* Success! */ break; } #undef DMI_READ_CFG_STR #undef DMI_READ_CFG_S32 #undef DMI_CHECK_SIZE return VINF_SUCCESS; }
DECL_FORCE_INLINE(int) rtSemMutexRequest(RTSEMMUTEX hMutexSem, RTMSINTERVAL cMillies, bool fAutoResume, PCRTLOCKVALSRCPOS pSrcPos) { /* * Validate input. */ struct RTSEMMUTEXINTERNAL *pThis = hMutexSem; AssertPtrReturn(pThis, VERR_INVALID_HANDLE); AssertReturn(pThis->u32Magic == RTSEMMUTEX_MAGIC, VERR_INVALID_HANDLE); /* * Check if nested request. */ pthread_t Self = pthread_self(); if ( pThis->Owner == Self && pThis->cNestings > 0) { #ifdef RTSEMMUTEX_STRICT int rc9 = RTLockValidatorRecExclRecursion(&pThis->ValidatorRec, pSrcPos); if (RT_FAILURE(rc9)) return rc9; #endif ASMAtomicIncU32(&pThis->cNestings); return VINF_SUCCESS; } #ifdef RTSEMMUTEX_STRICT RTTHREAD hThreadSelf = RTThreadSelfAutoAdopt(); if (cMillies) { int rc9 = RTLockValidatorRecExclCheckOrder(&pThis->ValidatorRec, hThreadSelf, pSrcPos, cMillies); if (RT_FAILURE(rc9)) return rc9; } #else RTTHREAD hThreadSelf = RTThreadSelf(); #endif /* * Convert timeout value. */ struct timespec ts; struct timespec *pTimeout = NULL; uint64_t u64End = 0; /* shut up gcc */ if (cMillies != RT_INDEFINITE_WAIT) { ts.tv_sec = cMillies / 1000; ts.tv_nsec = (cMillies % 1000) * UINT32_C(1000000); u64End = RTTimeSystemNanoTS() + cMillies * UINT64_C(1000000); pTimeout = &ts; } /* * Lock the mutex. * Optimize for the uncontended case (makes 1-2 ns difference). */ if (RT_UNLIKELY(!ASMAtomicCmpXchgS32(&pThis->iState, 1, 0))) { for (;;) { int32_t iOld = ASMAtomicXchgS32(&pThis->iState, 2); /* * Was the lock released in the meantime? This is unlikely (but possible) */ if (RT_UNLIKELY(iOld == 0)) break; /* * Go to sleep. */ if (pTimeout && ( pTimeout->tv_sec || pTimeout->tv_nsec )) { #ifdef RTSEMMUTEX_STRICT int rc9 = RTLockValidatorRecExclCheckBlocking(&pThis->ValidatorRec, hThreadSelf, pSrcPos, true, cMillies, RTTHREADSTATE_MUTEX, true); if (RT_FAILURE(rc9)) return rc9; #else RTThreadBlocking(hThreadSelf, RTTHREADSTATE_MUTEX, true); #endif } long rc = sys_futex(&pThis->iState, FUTEX_WAIT, 2, pTimeout, NULL, 0); RTThreadUnblocked(hThreadSelf, RTTHREADSTATE_MUTEX); if (RT_UNLIKELY(pThis->u32Magic != RTSEMMUTEX_MAGIC)) return VERR_SEM_DESTROYED; /* * Act on the wakup code. */ if (rc == -ETIMEDOUT) { Assert(pTimeout); return VERR_TIMEOUT; } if (rc == 0) /* we'll leave the loop now unless another thread is faster */; else if (rc == -EWOULDBLOCK) /* retry with new value. */; else if (rc == -EINTR) { if (!fAutoResume) return VERR_INTERRUPTED; } else { /* this shouldn't happen! */ AssertMsgFailed(("rc=%ld errno=%d\n", rc, errno)); return RTErrConvertFromErrno(rc); } /* adjust the relative timeout */ if (pTimeout) { int64_t i64Diff = u64End - RTTimeSystemNanoTS(); if (i64Diff < 1000) { rc = VERR_TIMEOUT; break; } ts.tv_sec = (uint64_t)i64Diff / UINT32_C(1000000000); ts.tv_nsec = (uint64_t)i64Diff % UINT32_C(1000000000); } } /* * When leaving this loop, iState is set to 2. This means that we gained the * lock and there are _possibly_ some waiters. We don't know exactly as another * thread might entered this loop at nearly the same time. Therefore we will * call futex_wakeup once too often (if _no_ other thread entered this loop). * The key problem is the simple futex_wait test for x != y (iState != 2) in * our case). */ } /* * Set the owner and nesting. */ pThis->Owner = Self; ASMAtomicWriteU32(&pThis->cNestings, 1); #ifdef RTSEMMUTEX_STRICT RTLockValidatorRecExclSetOwner(&pThis->ValidatorRec, hThreadSelf, pSrcPos, true); #endif return VINF_SUCCESS; }
int main (void) { // This isn't what we're testing exactly, but we need to know if it's // working or not to interpret other results. term_io_init (); PFP ("\n"); PFP ("\n"); PFP ("term_io_init() worked.\n"); PFP ("\n"); owm_init (); // Initialize the 1-wire interface master end PFP ("Trying owm_touch_reset()... "); uint8_t slave_presence = owm_touch_reset (); PFP_ASSERT (slave_presence); PFP ("ok, got slave presence pulse.\n"); #ifdef TEST_CONDITION_SINGLE_SLAVE // All the tests are re-run forever. This can be convenient when checking // for effects of line lenght, etc. that don't crop up every time. for ( ; ; ) { PFP ("Trying DS18B20 initialization... "); uint64_t slave_rid = ds18b20_init_and_rom_command (); PFP ("ok, succeeded. Slave ID: "); print_slave_id (slave_rid); PFP ("\n"); uint64_t rid; // ROM ID (of slave) // We can use owm_read_id() because we know we have exactly one slave. PFP ("Trying owm_read_id()... "); OWM_CHECK (owm_read_id ((uint8_t *) &rid)); // One-wire Master Result PFP_ASSERT (rid == slave_rid); // Should be the same as last time PFP ("ok, found slave with previously discovered ID.\n"); PFP ("Trying owm_first()... "); OWM_CHECK (owm_first ((uint8_t *) &rid)); PFP_ASSERT (rid == slave_rid); // Should be the same as last time PFP ("ok, found slave with previously discovered ID.\n"); // Verify that owm_next() (following the owm_first() call above) returns // OWM_RESULT_NO_SUCH_SLAVE, since there is only one slave on the bus. PFP ("Trying owm_next()... "); owm_result_t result = owm_next ((uint8_t *) &rid); if ( result != OWM_RESULT_NO_SUCH_SLAVE ) { PFP ( "failed: returned %s instead of OWM_RESULT_NO_SUCH_SLAVE\n", owm_result_as_string (result, result_buf) ); PFP_ASSERT_NOT_REACHED (); } PFP ("ok, no next slave found.\n"); // The normal test arrangement doesn't feature any alarmed slaves. Its kind // of a pain to program the alarm condition on real DS18B20 devices and // I haven't done so. The one_wire_slave_test.c program contains a line // that can be uncommented to cause and slave created using that interface // to consider itself alarmed, however. PFP ("Trying owm_first_alarmed()... "); result = owm_first_alarmed ((uint8_t *) &rid); if ( result == OWM_RESULT_NO_SUCH_SLAVE ) { PFP ("no alarmed slaves found (usually ok, see source).\n"); } else if ( result == OWM_RESULT_SUCCESS ) { PFP ("found alarmed slave (ID: "); print_slave_id (slave_rid); PFP (").\n"); } else { PFP ( "failed: returned %s instead of OWM_RESULT_NO_SUCH_SLAVE or " "OWM_RESULT_SUCCESS\n", owm_result_as_string (result, result_buf) ); PFP_ASSERT_NOT_REACHED (); } if ( result == OWM_RESULT_SUCCESS ) { // If owm_first_alarmed() found an alarmed slave, its reasonable to look // for another one, which we try here. PFP ("Trying own_next_alarmed()... "); result = owm_next_alarmed ((uint8_t *) &rid); if ( result != OWM_RESULT_NO_SUCH_SLAVE ) { PFP ( "failed: returned %s instead of OWM_RESULT_NO_SUCH_SLAVE\n", owm_result_as_string (result, result_buf) ); PFP_ASSERT_NOT_REACHED (); } PFP ("ok, no next alarmed slave found.\n"); } // owm_verify() should work with either a single or multiple slaves. PFP ("Trying owm_verify() with previously discoved ID... "); OWM_CHECK (owm_verify ((uint8_t *) &rid)); PFP ("ok, ID verified.\n"); // Verify that owm_verify() works as expected when given a nonexistend RID. PFP ("Trying owm_verify() with nonexistent ID... "); uint64_t nerid = rid + 42; // NonExistent RID result = owm_verify ((uint8_t *) &nerid); if ( result != OWM_RESULT_NO_SUCH_SLAVE ) { PFP ( "failed: returned %s instead of OWM_RESULT_NO_SUCH_SLAVE\n", owm_result_as_string (result, result_buf) ); PFP_ASSERT_NOT_REACHED (); } PFP ("ok, no such slave found.\n"); PFP ("Trying owm_scan_bus()... "); uint64_t **rom_ids; OWM_CHECK (owm_scan_bus ((uint8_t ***) (&rom_ids))); PFP_ASSERT (*(rom_ids[0]) == rid); PFP_ASSERT (rom_ids[1] == NULL); PFP ("ok.\n"); // Repeatedly doing owm_scan_bus() and owm_free_rom_ids_list() has also // been tried to check for leaks. PFP ("Trying owm_free_rom_ids_list()... "); owm_free_rom_ids_list ((uint8_t **) rom_ids); PFP ("seemed to work.\n"); PFP ("Starting temperature conversion... "); // NOTE: the DS18B20 doesn't seem to require an addressing command before // the "Convert T" command here, which is contrary to its own datasheet. // I guess if there's only one slave on the bus it works ok, but its sort of // weird, so we go ahead and do the addressing again. uint64_t slave_rid_2nd_reading = ds18b20_init_and_rom_command (); PFP_ASSERT (slave_rid_2nd_reading == slave_rid); owm_write_byte (DS18B20_COMMANDS_CONVERT_T_COMMAND); // The DS18B20 is now supposed to respond with a stream of 0 bits until // the conversion completes, after which it's supposed to send 1 bits. // Note that this is probably a typical behavior for busy 1-wire slaves. uint8_t conversion_complete = 0; while ( ! (conversion_complete = owm_read_bit ()) ) { ; } PFP ("conversion complete.\n"); // Now we try the conversion command a few more times using different // flavors of the highest-level, generic transaction initiation routine. // Of course, after all these conversions the temperature should // still come out the same. If it doesn't, that could indicate that // owm_start_transaction() isn't working right. PFP ("Trying owm_start_transaction() with READ_ROM... "); uint64_t slave_rid_3rd_reading; OWM_CHECK ( owm_start_transaction ( OWC_READ_ROM_COMMAND, (uint8_t *) &slave_rid_3rd_reading, DS18B20_COMMANDS_CONVERT_T_COMMAND ) ); PFP_ASSERT (slave_rid_3rd_reading == slave_rid); conversion_complete = 0; while ( ! (conversion_complete = owm_read_bit ()) ) { ; } PFP ("seemed ok.\n"); PFP ("Trying owm_start_transaction() with MATCH_ROM... "); OWM_CHECK ( owm_start_transaction ( OWC_MATCH_ROM_COMMAND, (uint8_t *) &slave_rid, DS18B20_COMMANDS_CONVERT_T_COMMAND ) ); conversion_complete = 0; while ( ! (conversion_complete = owm_read_bit ()) ) { ; } PFP ("seemed ok.\n"); PFP ("Trying owm_start_transaction() with SKIP_ROM... "); OWM_CHECK ( owm_start_transaction ( OWC_SKIP_ROM_COMMAND, NULL, DS18B20_COMMANDS_CONVERT_T_COMMAND ) ); conversion_complete = 0; while ( ! (conversion_complete = owm_read_bit ()) ) { ; } PFP ("seemed ok.\n"); // We can now read the slave scratchpad memory. This requires us to first // perform the initialization and read rom commands again as described // in the DS18B20 datasheet. The slave ROM code better be the same on // second reading :) PFP ("Reading DS18B20 scratchpad memory... "); uint64_t slave_rid_4th_reading = ds18b20_init_and_rom_command (); PFP_ASSERT (slave_rid_4th_reading == slave_rid); ds18b20_get_scratchpad_contents (); PFP ("done.\n"); // Convenient names for the temperature bytes uint8_t t_lsb = spb[DS18B20_SCRATCHPAD_T_LSB]; uint8_t t_msb = spb[DS18B20_SCRATCHPAD_T_MSB]; uint8_t tin = (t_msb & B10000000); // Temperature Is Negative // Absolute value of temperature (in degrees C) times 2^4. This is just // what the DS18B20 likes to spit out. See Fig. 2 of the DS18B20 datasheet. int16_t atemp_t2tt4 = (((int16_t) t_msb) << BITS_PER_BYTE) | t_lsb; if ( tin ) { // If negative... // ...just make it positive (it's 2's compliment) atemp_t2tt4 = (~atemp_t2tt4) + 1; } // Uncomment some of this to test the the 2's compliment features // themselves, ignoring the real sensor output (but assuming we make it // to this point :). Table 1 of the DS18B20 datasheet has a number of // example values. // //atemp_t2tt4 = INT16_C (0xFF5E); // Means -10.125 (blinks out 101250) //atemp_t2tt4 = (~atemp_t2tt4) + 1; // Knowns to be negative so abs it // //atemp_t2tt4 = INT16_C (0x0191); // Means 25.0625 (blinks out 250625) // Absolute value of temperature, in degrees C. These factors of 2.0 are // due to the meaning the DS18B20 assigns to the individual field bits. double atemp = atemp_t2tt4 / (2.0 * 2.0 * 2.0 * 2.0); // NOTE: I think avrlibc doesn't suppor the # printf flag. No big loss, but // it means the blinked-out output might have a different number of digits PFP ( "Temperature reading: %#.6g degrees C (subject to rounding issues).\n", (tin ? -1.0 : 1.0) * atemp); PFP ("All tests passed (assuming temperature looks sane :).\n"); PFP ("\n"); double const dbi = 2.42; // Delay between iterations _delay_ms (dbi); } #endif #ifdef TEST_CONDITION_MULTIPLE_SLAVES #ifndef FIRST_SLAVE_ID # error FIRST_SLAVE_ID is not defined #endif #ifndef SECOND_SLAVE_ID # error SECOND_SLAVE_ID is not defined #endif // Account for endianness by swapping the bytes of the literal ID values. uint64_t first_slave_id = __builtin_bswap64 (UINT64_C (FIRST_SLAVE_ID)); uint64_t second_slave_id = __builtin_bswap64 (UINT64_C (SECOND_SLAVE_ID)); uint64_t rid; // ROM ID PFP ("Trying owm_first()... "); OWM_CHECK (owm_first ((uint8_t *) &rid)); // One-wire Master Result if ( rid != first_slave_id ) { PFP ("failed: discovered first slave ID was "); print_slave_id (rid); PFP (", not the expected "); print_slave_id (first_slave_id); PFP ("\n"); PFP_ASSERT_NOT_REACHED (); } PFP ("ok, found 1st slave with expected ID "); print_slave_id (rid); PFP (".\n"); PFP ("Trying owm_next()... "); OWM_CHECK (owm_next ((uint8_t *) &rid)); if ( rid != second_slave_id ) { PFP ("failed: discovered second slave ID was "); print_slave_id (rid); PFP (", not the expected "); print_slave_id (second_slave_id); PFP_ASSERT_NOT_REACHED (); } PFP ("ok, found 2nd slave with expected ID "); print_slave_id (rid); PFP (".\n"); // Verify that owm_next() (following the owm_first() call above) returns // false, since there are only two slaves on the bus. PFP ("Trying owm_next() again... "); owm_result_t result = owm_next ((uint8_t *) &rid); if ( result != OWM_RESULT_NO_SUCH_SLAVE ) { PFP ( "failed: returned %s instead of OWM_RESULT_NO_SUCH_SLAVE\n", owm_result_as_string (result, result_buf) ); PFP_ASSERT_NOT_REACHED (); } PFP ("ok, no next slave found.\n"); PFP("Trying owm_verify(first_slave_id)... "); OWM_CHECK (owm_verify ((uint8_t *) &first_slave_id)); PFP ("ok, found it.\n"); PFP("Trying owm_verify(second_slave_id)... "); OWM_CHECK (owm_verify ((uint8_t *) &second_slave_id)); PFP ("ok, found it.\n"); PFP ("All tests passed.\n"); PFP ("\n"); #endif }
static void psp_joypad_poll(void) { int32_t ret; unsigned i, j; SceCtrlData state_tmp; #ifdef PSP sceCtrlSetSamplingCycle(0); #endif sceCtrlSetSamplingMode(DEFAULT_SAMPLING_MODE); ret = CtrlPeekBufferPositive(0, &state_tmp, 1); #ifdef HAVE_KERNEL_PRX state_tmp.Buttons = (state_tmp.Buttons&0x0000FFFF)|(read_system_buttons()&0xFFFF0000); #endif (void)ret; analog_state[0][0][0] = analog_state[0][0][1] = analog_state[0][1][0] = analog_state[0][1][1] = 0; pad_state = 0; pad_state |= (STATE_BUTTON(state_tmp) & PSP_CTRL_LEFT) ? (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_LEFT) : 0; pad_state |= (STATE_BUTTON(state_tmp) & PSP_CTRL_DOWN) ? (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_DOWN) : 0; pad_state |= (STATE_BUTTON(state_tmp) & PSP_CTRL_RIGHT) ? (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_RIGHT) : 0; pad_state |= (STATE_BUTTON(state_tmp) & PSP_CTRL_UP) ? (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_UP) : 0; pad_state |= (STATE_BUTTON(state_tmp) & PSP_CTRL_START) ? (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_START) : 0; pad_state |= (STATE_BUTTON(state_tmp) & PSP_CTRL_SELECT) ? (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_SELECT) : 0; pad_state |= (STATE_BUTTON(state_tmp) & PSP_CTRL_TRIANGLE) ? (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_X) : 0; pad_state |= (STATE_BUTTON(state_tmp) & PSP_CTRL_SQUARE) ? (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_Y) : 0; pad_state |= (STATE_BUTTON(state_tmp) & PSP_CTRL_CROSS) ? (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_B) : 0; pad_state |= (STATE_BUTTON(state_tmp) & PSP_CTRL_CIRCLE) ? (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_A) : 0; pad_state |= (STATE_BUTTON(state_tmp) & PSP_CTRL_R) ? (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_R) : 0; pad_state |= (STATE_BUTTON(state_tmp) & PSP_CTRL_L) ? (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_L) : 0; analog_state[0][RETRO_DEVICE_INDEX_ANALOG_LEFT] [RETRO_DEVICE_ID_ANALOG_X] = (int16_t)(STATE_ANALOGLX(state_tmp)-128) * 256; analog_state[0][RETRO_DEVICE_INDEX_ANALOG_LEFT] [RETRO_DEVICE_ID_ANALOG_Y] = (int16_t)(STATE_ANALOGLY(state_tmp)-128) * 256; #ifdef SN_TARGET_PSP2 analog_state[0][RETRO_DEVICE_INDEX_ANALOG_RIGHT][RETRO_DEVICE_ID_ANALOG_X] = (int16_t)(STATE_ANALOGRX(state_tmp)-128) * 256; analog_state[0][RETRO_DEVICE_INDEX_ANALOG_RIGHT][RETRO_DEVICE_ID_ANALOG_Y] = (int16_t)(STATE_ANALOGRY(state_tmp)-128) * 256; #endif for (i = 0; i < 2; i++) for (j = 0; j < 2; j++) if (analog_state[0][i][j] == -0x8000) analog_state[0][i][j] = -0x7fff; BIT64_CLEAR(lifecycle_state, RARCH_MENU_TOGGLE); #ifdef HAVE_KERNEL_PRX if (STATE_BUTTON(state_tmp) & PSP_CTRL_NOTE) #else if ( (pad_state & (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_L)) && (pad_state & (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_R)) && (pad_state & (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_SELECT)) && (pad_state & (UINT64_C(1) << RETRO_DEVICE_ID_JOYPAD_START)) ) #endif BIT64_SET(lifecycle_state, RARCH_MENU_TOGGLE); }
float64_t f64_mul( float64_t a, float64_t b ) { union ui64_f64 uA; uint_fast64_t uiA; bool signA; int_fast16_t expA; uint_fast64_t sigA; union ui64_f64 uB; uint_fast64_t uiB; bool signB; int_fast16_t expB; uint_fast64_t sigB; bool signZ; uint_fast64_t magBits; struct exp16_sig64 normExpSig; int_fast16_t expZ; struct uint128 sigZ128; uint_fast64_t sigZ, uiZ; union ui64_f64 uZ; uA.f = a; uiA = uA.ui; signA = signF64UI( uiA ); expA = expF64UI( uiA ); sigA = fracF64UI( uiA ); uB.f = b; uiB = uB.ui; signB = signF64UI( uiB ); expB = expF64UI( uiB ); sigB = fracF64UI( uiB ); signZ = signA ^ signB; if ( expA == 0x7FF ) { if ( sigA || ( ( expB == 0x7FF ) && sigB ) ) goto propagateNaN; magBits = expB | sigB; goto infArg; } if ( expB == 0x7FF ) { if ( sigB ) goto propagateNaN; magBits = expA | sigA; goto infArg; } if ( ! expA ) { if ( ! sigA ) goto zero; normExpSig = softfloat_normSubnormalF64Sig( sigA ); expA = normExpSig.exp; sigA = normExpSig.sig; } if ( ! expB ) { if ( ! sigB ) goto zero; normExpSig = softfloat_normSubnormalF64Sig( sigB ); expB = normExpSig.exp; sigB = normExpSig.sig; } expZ = expA + expB - 0x3FF; sigA = ( sigA | UINT64_C( 0x0010000000000000 ) )<<10; sigB = ( sigB | UINT64_C( 0x0010000000000000 ) )<<11; sigZ128 = softfloat_mul64To128( sigA, sigB ); sigZ = sigZ128.v64 | ( sigZ128.v0 != 0 ); if ( sigZ < UINT64_C( 0x4000000000000000 ) ) { --expZ; sigZ <<= 1; } return softfloat_roundPackToF64( signZ, expZ, sigZ ); propagateNaN: uiZ = softfloat_propagateNaNF64UI( uiA, uiB ); goto uiZ; infArg: if ( ! magBits ) { softfloat_raiseFlags( softfloat_flag_invalid ); uiZ = defaultNaNF64UI; } else { uiZ = packToF64UI( signZ, 0x7FF, 0 ); } goto uiZ; zero: uiZ = packToF64UI( signZ, 0, 0 ); uiZ: uZ.ui = uiZ; return uZ.f; }
/** * Service request callback function. * * @returns VBox status code. * @param pSession The caller's session. * @param u64Arg 64-bit integer argument. * @param pReqHdr The request header. Input / Output. Optional. */ DECLEXPORT(int) TSTR0ThreadPreemptionSrvReqHandler(PSUPDRVSESSION pSession, uint32_t uOperation, uint64_t u64Arg, PSUPR0SERVICEREQHDR pReqHdr) { if (u64Arg) return VERR_INVALID_PARAMETER; if (!VALID_PTR(pReqHdr)) return VERR_INVALID_PARAMETER; char *pszErr = (char *)(pReqHdr + 1); size_t cchErr = pReqHdr->cbReq - sizeof(*pReqHdr); if (cchErr < 32 || cchErr >= 0x10000) return VERR_INVALID_PARAMETER; *pszErr = '\0'; /* * The big switch. */ switch (uOperation) { case TSTR0THREADPREMEPTION_SANITY_OK: break; case TSTR0THREADPREMEPTION_SANITY_FAILURE: RTStrPrintf(pszErr, cchErr, "!42failure42%1024s", ""); break; case TSTR0THREADPREMEPTION_BASIC: { if (!ASMIntAreEnabled()) RTStrPrintf(pszErr, cchErr, "!Interrupts disabled"); else if (!RTThreadPreemptIsEnabled(NIL_RTTHREAD)) RTStrPrintf(pszErr, cchErr, "!RTThreadPreemptIsEnabled returns false by default"); else { RTTHREADPREEMPTSTATE State = RTTHREADPREEMPTSTATE_INITIALIZER; RTThreadPreemptDisable(&State); if (RTThreadPreemptIsEnabled(NIL_RTTHREAD)) RTStrPrintf(pszErr, cchErr, "!RTThreadPreemptIsEnabled returns true after RTThreadPreemptDisable"); else if (!ASMIntAreEnabled()) RTStrPrintf(pszErr, cchErr, "!Interrupts disabled"); RTThreadPreemptRestore(&State); } break; } case TSTR0THREADPREMEPTION_IS_PENDING: { RTTHREADPREEMPTSTATE State = RTTHREADPREEMPTSTATE_INITIALIZER; RTThreadPreemptDisable(&State); if (!RTThreadPreemptIsEnabled(NIL_RTTHREAD)) { if (ASMIntAreEnabled()) { uint64_t u64StartTS = RTTimeNanoTS(); uint64_t u64StartSysTS = RTTimeSystemNanoTS(); uint64_t cLoops = 0; uint64_t cNanosSysElapsed; uint64_t cNanosElapsed; bool fPending; do { fPending = RTThreadPreemptIsPending(NIL_RTTHREAD); cNanosElapsed = RTTimeNanoTS() - u64StartTS; cNanosSysElapsed = RTTimeSystemNanoTS() - u64StartSysTS; cLoops++; } while ( !fPending && cNanosElapsed < UINT64_C(2)*1000U*1000U*1000U && cNanosSysElapsed < UINT64_C(2)*1000U*1000U*1000U && cLoops < 100U*_1M); if (!fPending) RTStrPrintf(pszErr, cchErr, "!Preempt not pending after %'llu loops / %'llu ns / %'llu ns (sys)", cLoops, cNanosElapsed, cNanosSysElapsed); else if (cLoops == 1) RTStrPrintf(pszErr, cchErr, "!cLoops=1\n"); else RTStrPrintf(pszErr, cchErr, "RTThreadPreemptIsPending returned true after %'llu loops / %'llu ns / %'llu ns (sys)", cLoops, cNanosElapsed, cNanosSysElapsed); } else RTStrPrintf(pszErr, cchErr, "!Interrupts disabled"); } else RTStrPrintf(pszErr, cchErr, "!RTThreadPreemptIsEnabled returns true after RTThreadPreemptDisable"); RTThreadPreemptRestore(&State); break; } case TSTR0THREADPREMEPTION_NESTED: { bool const fDefault = RTThreadPreemptIsEnabled(NIL_RTTHREAD); RTTHREADPREEMPTSTATE State1 = RTTHREADPREEMPTSTATE_INITIALIZER; RTThreadPreemptDisable(&State1); if (!RTThreadPreemptIsEnabled(NIL_RTTHREAD)) { RTTHREADPREEMPTSTATE State2 = RTTHREADPREEMPTSTATE_INITIALIZER; RTThreadPreemptDisable(&State2); if (!RTThreadPreemptIsEnabled(NIL_RTTHREAD)) { RTTHREADPREEMPTSTATE State3 = RTTHREADPREEMPTSTATE_INITIALIZER; RTThreadPreemptDisable(&State3); if (RTThreadPreemptIsEnabled(NIL_RTTHREAD)) RTStrPrintf(pszErr, cchErr, "!RTThreadPreemptIsEnabled returns true after 3rd RTThreadPreemptDisable"); RTThreadPreemptRestore(&State3); if (RTThreadPreemptIsEnabled(NIL_RTTHREAD) && !*pszErr) RTStrPrintf(pszErr, cchErr, "!RTThreadPreemptIsEnabled returns true after 1st RTThreadPreemptRestore"); } else RTStrPrintf(pszErr, cchErr, "!RTThreadPreemptIsEnabled returns true after 2nd RTThreadPreemptDisable"); RTThreadPreemptRestore(&State2); if (RTThreadPreemptIsEnabled(NIL_RTTHREAD) && !*pszErr) RTStrPrintf(pszErr, cchErr, "!RTThreadPreemptIsEnabled returns true after 2nd RTThreadPreemptRestore"); } else RTStrPrintf(pszErr, cchErr, "!RTThreadPreemptIsEnabled returns true after 1st RTThreadPreemptDisable"); RTThreadPreemptRestore(&State1); if (RTThreadPreemptIsEnabled(NIL_RTTHREAD) != fDefault && !*pszErr) RTStrPrintf(pszErr, cchErr, "!RTThreadPreemptIsEnabled returns false after 3rd RTThreadPreemptRestore"); break; } default: RTStrPrintf(pszErr, cchErr, "!Unknown test #%d", uOperation); break; } /* The error indicator is the '!' in the message buffer. */ return VINF_SUCCESS; }
{ switch (alloc) { case ALLOC_CONTIGUOUS: return 'c'; case ALLOC_CLING: return 'l'; case ALLOC_NORMAL: return 'n'; case ALLOC_ANYWHERE: return 'a'; default: return 'i'; } } static const uint64_t _minusone = UINT64_C(-1); /* * Data-munging functions to prepare each data type for display and sorting */ static int _string_disp(struct dm_report *rh, struct dm_pool *mem __attribute((unused)), struct dm_report_field *field, const void *data, void *private __attribute((unused))) { return dm_report_field_string(rh, field, (const char **) data); } static int _dev_name_disp(struct dm_report *rh, struct dm_pool *mem __attribute((unused)), struct dm_report_field *field, const void *data, void *private __attribute((unused))) {