Index: vendor/compiler-rt/dist-release_90/lib/asan/asan_posix.cc =================================================================== --- vendor/compiler-rt/dist-release_90/lib/asan/asan_posix.cc (revision 351306) +++ vendor/compiler-rt/dist-release_90/lib/asan/asan_posix.cc (revision 351307) @@ -1,117 +1,117 @@ //===-- asan_posix.cc -----------------------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is a part of AddressSanitizer, an address sanity checker. // // Posix-specific details. //===----------------------------------------------------------------------===// #include "sanitizer_common/sanitizer_platform.h" #if SANITIZER_POSIX #include "asan_internal.h" #include "asan_interceptors.h" #include "asan_mapping.h" #include "asan_report.h" #include "asan_stack.h" #include "sanitizer_common/sanitizer_libc.h" #include "sanitizer_common/sanitizer_posix.h" #include "sanitizer_common/sanitizer_procmaps.h" #include #include #include #include #include namespace __asan { void AsanOnDeadlySignal(int signo, void *siginfo, void *context) { StartReportDeadlySignal(); SignalContext sig(siginfo, context); ReportDeadlySignal(sig); } // ---------------------- TSD ---------------- {{{1 -#if SANITIZER_NETBSD || SANITIZER_FREEBSD -// Thread Static Data cannot be used in early init on NetBSD and FreeBSD. +#if SANITIZER_NETBSD && !ASAN_DYNAMIC +// Thread Static Data cannot be used in early static ASan init on NetBSD. // Reuse the Asan TSD API for compatibility with existing code // with an alternative implementation. static void (*tsd_destructor)(void *tsd) = nullptr; struct tsd_key { tsd_key() : key(nullptr) {} ~tsd_key() { CHECK(tsd_destructor); if (key) (*tsd_destructor)(key); } void *key; }; static thread_local struct tsd_key key; void AsanTSDInit(void (*destructor)(void *tsd)) { CHECK(!tsd_destructor); tsd_destructor = destructor; } void *AsanTSDGet() { CHECK(tsd_destructor); return key.key; } void AsanTSDSet(void *tsd) { CHECK(tsd_destructor); CHECK(tsd); CHECK(!key.key); key.key = tsd; } void PlatformTSDDtor(void *tsd) { CHECK(tsd_destructor); CHECK_EQ(key.key, tsd); key.key = nullptr; // Make sure that signal handler can not see a stale current thread pointer. atomic_signal_fence(memory_order_seq_cst); AsanThread::TSDDtor(tsd); } #else static pthread_key_t tsd_key; static bool tsd_key_inited = false; void AsanTSDInit(void (*destructor)(void *tsd)) { CHECK(!tsd_key_inited); tsd_key_inited = true; CHECK_EQ(0, pthread_key_create(&tsd_key, destructor)); } void *AsanTSDGet() { CHECK(tsd_key_inited); return pthread_getspecific(tsd_key); } void AsanTSDSet(void *tsd) { CHECK(tsd_key_inited); pthread_setspecific(tsd_key, tsd); } void PlatformTSDDtor(void *tsd) { AsanThreadContext *context = (AsanThreadContext*)tsd; if (context->destructor_iterations > 1) { context->destructor_iterations--; CHECK_EQ(0, pthread_setspecific(tsd_key, tsd)); return; } AsanThread::TSDDtor(tsd); } #endif } // namespace __asan #endif // SANITIZER_POSIX Index: vendor/compiler-rt/dist-release_90/lib/builtins/cpu_model.c =================================================================== --- vendor/compiler-rt/dist-release_90/lib/builtins/cpu_model.c (revision 351306) +++ vendor/compiler-rt/dist-release_90/lib/builtins/cpu_model.c (revision 351307) @@ -1,689 +1,689 @@ //===-- cpu_model.c - Support for __cpu_model builtin ------------*- C -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is based on LLVM's lib/Support/Host.cpp. // It implements the operating system Host concept and builtin // __cpu_model for the compiler_rt library, for x86 only. // //===----------------------------------------------------------------------===// #if (defined(__i386__) || defined(_M_IX86) || defined(__x86_64__) || \ defined(_M_X64)) && \ (defined(__GNUC__) || defined(__clang__) || defined(_MSC_VER)) #include #define bool int #define true 1 #define false 0 #ifdef _MSC_VER #include #endif #ifndef __has_attribute #define __has_attribute(attr) 0 #endif enum VendorSignatures { SIG_INTEL = 0x756e6547, // Genu SIG_AMD = 0x68747541, // Auth }; enum ProcessorVendors { VENDOR_INTEL = 1, VENDOR_AMD, VENDOR_OTHER, VENDOR_MAX }; enum ProcessorTypes { INTEL_BONNELL = 1, INTEL_CORE2, INTEL_COREI7, AMDFAM10H, AMDFAM15H, INTEL_SILVERMONT, INTEL_KNL, AMD_BTVER1, AMD_BTVER2, AMDFAM17H, INTEL_KNM, INTEL_GOLDMONT, INTEL_GOLDMONT_PLUS, INTEL_TREMONT, CPU_TYPE_MAX }; enum ProcessorSubtypes { INTEL_COREI7_NEHALEM = 1, INTEL_COREI7_WESTMERE, INTEL_COREI7_SANDYBRIDGE, AMDFAM10H_BARCELONA, AMDFAM10H_SHANGHAI, AMDFAM10H_ISTANBUL, AMDFAM15H_BDVER1, AMDFAM15H_BDVER2, AMDFAM15H_BDVER3, AMDFAM15H_BDVER4, AMDFAM17H_ZNVER1, INTEL_COREI7_IVYBRIDGE, INTEL_COREI7_HASWELL, INTEL_COREI7_BROADWELL, INTEL_COREI7_SKYLAKE, INTEL_COREI7_SKYLAKE_AVX512, INTEL_COREI7_CANNONLAKE, INTEL_COREI7_ICELAKE_CLIENT, INTEL_COREI7_ICELAKE_SERVER, AMDFAM17H_ZNVER2, INTEL_COREI7_CASCADELAKE, CPU_SUBTYPE_MAX }; enum ProcessorFeatures { FEATURE_CMOV = 0, FEATURE_MMX, FEATURE_POPCNT, FEATURE_SSE, FEATURE_SSE2, FEATURE_SSE3, FEATURE_SSSE3, FEATURE_SSE4_1, FEATURE_SSE4_2, FEATURE_AVX, FEATURE_AVX2, FEATURE_SSE4_A, FEATURE_FMA4, FEATURE_XOP, FEATURE_FMA, FEATURE_AVX512F, FEATURE_BMI, FEATURE_BMI2, FEATURE_AES, FEATURE_PCLMUL, FEATURE_AVX512VL, FEATURE_AVX512BW, FEATURE_AVX512DQ, FEATURE_AVX512CD, FEATURE_AVX512ER, FEATURE_AVX512PF, FEATURE_AVX512VBMI, FEATURE_AVX512IFMA, FEATURE_AVX5124VNNIW, FEATURE_AVX5124FMAPS, FEATURE_AVX512VPOPCNTDQ, FEATURE_AVX512VBMI2, FEATURE_GFNI, FEATURE_VPCLMULQDQ, FEATURE_AVX512VNNI, FEATURE_AVX512BITALG }; // The check below for i386 was copied from clang's cpuid.h (__get_cpuid_max). // Check motivated by bug reports for OpenSSL crashing on CPUs without CPUID // support. Consequently, for i386, the presence of CPUID is checked first // via the corresponding eflags bit. static bool isCpuIdSupported() { #if defined(__GNUC__) || defined(__clang__) #if defined(__i386__) int __cpuid_supported; __asm__(" pushfl\n" " popl %%eax\n" " movl %%eax,%%ecx\n" " xorl $0x00200000,%%eax\n" " pushl %%eax\n" " popfl\n" " pushfl\n" " popl %%eax\n" " movl $0,%0\n" " cmpl %%eax,%%ecx\n" " je 1f\n" " movl $1,%0\n" "1:" : "=r"(__cpuid_supported) : : "eax", "ecx"); if (!__cpuid_supported) return false; #endif return true; #endif return true; } // This code is copied from lib/Support/Host.cpp. // Changes to either file should be mirrored in the other. /// getX86CpuIDAndInfo - Execute the specified cpuid and return the 4 values in /// the specified arguments. If we can't run cpuid on the host, return true. static bool getX86CpuIDAndInfo(unsigned value, unsigned *rEAX, unsigned *rEBX, unsigned *rECX, unsigned *rEDX) { #if defined(__GNUC__) || defined(__clang__) #if defined(__x86_64__) // gcc doesn't know cpuid would clobber ebx/rbx. Preserve it manually. // FIXME: should we save this for Clang? __asm__("movq\t%%rbx, %%rsi\n\t" "cpuid\n\t" "xchgq\t%%rbx, %%rsi\n\t" : "=a"(*rEAX), "=S"(*rEBX), "=c"(*rECX), "=d"(*rEDX) : "a"(value)); return false; #elif defined(__i386__) __asm__("movl\t%%ebx, %%esi\n\t" "cpuid\n\t" "xchgl\t%%ebx, %%esi\n\t" : "=a"(*rEAX), "=S"(*rEBX), "=c"(*rECX), "=d"(*rEDX) : "a"(value)); return false; #else return true; #endif #elif defined(_MSC_VER) // The MSVC intrinsic is portable across x86 and x64. int registers[4]; __cpuid(registers, value); *rEAX = registers[0]; *rEBX = registers[1]; *rECX = registers[2]; *rEDX = registers[3]; return false; #else return true; #endif } /// getX86CpuIDAndInfoEx - Execute the specified cpuid with subleaf and return /// the 4 values in the specified arguments. If we can't run cpuid on the host, /// return true. static bool getX86CpuIDAndInfoEx(unsigned value, unsigned subleaf, unsigned *rEAX, unsigned *rEBX, unsigned *rECX, unsigned *rEDX) { #if defined(__GNUC__) || defined(__clang__) #if defined(__x86_64__) // gcc doesn't know cpuid would clobber ebx/rbx. Preserve it manually. // FIXME: should we save this for Clang? __asm__("movq\t%%rbx, %%rsi\n\t" "cpuid\n\t" "xchgq\t%%rbx, %%rsi\n\t" : "=a"(*rEAX), "=S"(*rEBX), "=c"(*rECX), "=d"(*rEDX) : "a"(value), "c"(subleaf)); return false; #elif defined(__i386__) __asm__("movl\t%%ebx, %%esi\n\t" "cpuid\n\t" "xchgl\t%%ebx, %%esi\n\t" : "=a"(*rEAX), "=S"(*rEBX), "=c"(*rECX), "=d"(*rEDX) : "a"(value), "c"(subleaf)); return false; #else return true; #endif #elif defined(_MSC_VER) int registers[4]; __cpuidex(registers, value, subleaf); *rEAX = registers[0]; *rEBX = registers[1]; *rECX = registers[2]; *rEDX = registers[3]; return false; #else return true; #endif } // Read control register 0 (XCR0). Used to detect features such as AVX. static bool getX86XCR0(unsigned *rEAX, unsigned *rEDX) { #if defined(__GNUC__) || defined(__clang__) // Check xgetbv; this uses a .byte sequence instead of the instruction // directly because older assemblers do not include support for xgetbv and // there is no easy way to conditionally compile based on the assembler used. __asm__(".byte 0x0f, 0x01, 0xd0" : "=a"(*rEAX), "=d"(*rEDX) : "c"(0)); return false; #elif defined(_MSC_FULL_VER) && defined(_XCR_XFEATURE_ENABLED_MASK) unsigned long long Result = _xgetbv(_XCR_XFEATURE_ENABLED_MASK); *rEAX = Result; *rEDX = Result >> 32; return false; #else return true; #endif } static void detectX86FamilyModel(unsigned EAX, unsigned *Family, unsigned *Model) { *Family = (EAX >> 8) & 0xf; // Bits 8 - 11 *Model = (EAX >> 4) & 0xf; // Bits 4 - 7 if (*Family == 6 || *Family == 0xf) { if (*Family == 0xf) // Examine extended family ID if family ID is F. *Family += (EAX >> 20) & 0xff; // Bits 20 - 27 // Examine extended model ID if family ID is 6 or F. *Model += ((EAX >> 16) & 0xf) << 4; // Bits 16 - 19 } } static void getIntelProcessorTypeAndSubtype(unsigned Family, unsigned Model, unsigned Brand_id, unsigned Features, unsigned Features2, unsigned *Type, unsigned *Subtype) { if (Brand_id != 0) return; switch (Family) { case 6: switch (Model) { case 0x0f: // Intel Core 2 Duo processor, Intel Core 2 Duo mobile // processor, Intel Core 2 Quad processor, Intel Core 2 Quad // mobile processor, Intel Core 2 Extreme processor, Intel // Pentium Dual-Core processor, Intel Xeon processor, model // 0Fh. All processors are manufactured using the 65 nm process. case 0x16: // Intel Celeron processor model 16h. All processors are // manufactured using the 65 nm process case 0x17: // Intel Core 2 Extreme processor, Intel Xeon processor, model // 17h. All processors are manufactured using the 45 nm process. // // 45nm: Penryn , Wolfdale, Yorkfield (XE) case 0x1d: // Intel Xeon processor MP. All processors are manufactured using // the 45 nm process. *Type = INTEL_CORE2; // "penryn" break; case 0x1a: // Intel Core i7 processor and Intel Xeon processor. All // processors are manufactured using the 45 nm process. case 0x1e: // Intel(R) Core(TM) i7 CPU 870 @ 2.93GHz. // As found in a Summer 2010 model iMac. case 0x1f: case 0x2e: // Nehalem EX *Type = INTEL_COREI7; // "nehalem" *Subtype = INTEL_COREI7_NEHALEM; break; case 0x25: // Intel Core i7, laptop version. case 0x2c: // Intel Core i7 processor and Intel Xeon processor. All // processors are manufactured using the 32 nm process. case 0x2f: // Westmere EX *Type = INTEL_COREI7; // "westmere" *Subtype = INTEL_COREI7_WESTMERE; break; case 0x2a: // Intel Core i7 processor. All processors are manufactured // using the 32 nm process. case 0x2d: *Type = INTEL_COREI7; //"sandybridge" *Subtype = INTEL_COREI7_SANDYBRIDGE; break; case 0x3a: case 0x3e: // Ivy Bridge EP *Type = INTEL_COREI7; // "ivybridge" *Subtype = INTEL_COREI7_IVYBRIDGE; break; // Haswell: case 0x3c: case 0x3f: case 0x45: case 0x46: *Type = INTEL_COREI7; // "haswell" *Subtype = INTEL_COREI7_HASWELL; break; // Broadwell: case 0x3d: case 0x47: case 0x4f: case 0x56: *Type = INTEL_COREI7; // "broadwell" *Subtype = INTEL_COREI7_BROADWELL; break; // Skylake: case 0x4e: // Skylake mobile case 0x5e: // Skylake desktop case 0x8e: // Kaby Lake mobile case 0x9e: // Kaby Lake desktop *Type = INTEL_COREI7; // "skylake" *Subtype = INTEL_COREI7_SKYLAKE; break; // Skylake Xeon: case 0x55: *Type = INTEL_COREI7; if (Features2 & (1 << (FEATURE_AVX512VNNI - 32))) *Subtype = INTEL_COREI7_CASCADELAKE; // "cascadelake" else *Subtype = INTEL_COREI7_SKYLAKE_AVX512; // "skylake-avx512" break; // Cannonlake: case 0x66: *Type = INTEL_COREI7; *Subtype = INTEL_COREI7_CANNONLAKE; // "cannonlake" break; // Icelake: case 0x7d: case 0x7e: *Type = INTEL_COREI7; *Subtype = INTEL_COREI7_ICELAKE_CLIENT; // "icelake-client" break; // Icelake Xeon: case 0x6a: case 0x6c: *Type = INTEL_COREI7; *Subtype = INTEL_COREI7_ICELAKE_SERVER; // "icelake-server" break; case 0x1c: // Most 45 nm Intel Atom processors case 0x26: // 45 nm Atom Lincroft case 0x27: // 32 nm Atom Medfield case 0x35: // 32 nm Atom Midview case 0x36: // 32 nm Atom Midview *Type = INTEL_BONNELL; break; // "bonnell" // Atom Silvermont codes from the Intel software optimization guide. case 0x37: case 0x4a: case 0x4d: case 0x5a: case 0x5d: case 0x4c: // really airmont *Type = INTEL_SILVERMONT; break; // "silvermont" // Goldmont: case 0x5c: // Apollo Lake case 0x5f: // Denverton *Type = INTEL_GOLDMONT; break; // "goldmont" case 0x7a: *Type = INTEL_GOLDMONT_PLUS; break; case 0x86: *Type = INTEL_TREMONT; break; case 0x57: *Type = INTEL_KNL; // knl break; case 0x85: *Type = INTEL_KNM; // knm break; default: // Unknown family 6 CPU. break; break; } default: break; // Unknown. } } static void getAMDProcessorTypeAndSubtype(unsigned Family, unsigned Model, unsigned Features, unsigned Features2, unsigned *Type, unsigned *Subtype) { // FIXME: this poorly matches the generated SubtargetFeatureKV table. There // appears to be no way to generate the wide variety of AMD-specific targets // from the information returned from CPUID. switch (Family) { case 16: *Type = AMDFAM10H; // "amdfam10" switch (Model) { case 2: *Subtype = AMDFAM10H_BARCELONA; break; case 4: *Subtype = AMDFAM10H_SHANGHAI; break; case 8: *Subtype = AMDFAM10H_ISTANBUL; break; } break; case 20: *Type = AMD_BTVER1; break; // "btver1"; case 21: *Type = AMDFAM15H; if (Model >= 0x60 && Model <= 0x7f) { *Subtype = AMDFAM15H_BDVER4; break; // "bdver4"; 60h-7Fh: Excavator } if (Model >= 0x30 && Model <= 0x3f) { *Subtype = AMDFAM15H_BDVER3; break; // "bdver3"; 30h-3Fh: Steamroller } if ((Model >= 0x10 && Model <= 0x1f) || Model == 0x02) { *Subtype = AMDFAM15H_BDVER2; break; // "bdver2"; 02h, 10h-1Fh: Piledriver } if (Model <= 0x0f) { *Subtype = AMDFAM15H_BDVER1; break; // "bdver1"; 00h-0Fh: Bulldozer } break; case 22: *Type = AMD_BTVER2; break; // "btver2" case 23: *Type = AMDFAM17H; if (Model >= 0x30 && Model <= 0x3f) { *Subtype = AMDFAM17H_ZNVER2; break; // "znver2"; 30h-3fh: Zen2 } if (Model <= 0x0f) { *Subtype = AMDFAM17H_ZNVER1; break; // "znver1"; 00h-0Fh: Zen1 } break; default: break; // "generic" } } static void getAvailableFeatures(unsigned ECX, unsigned EDX, unsigned MaxLeaf, unsigned *FeaturesOut, unsigned *Features2Out) { unsigned Features = 0; unsigned Features2 = 0; unsigned EAX, EBX; #define setFeature(F) \ do { \ if (F < 32) \ Features |= 1U << (F & 0x1f); \ else if (F < 64) \ Features2 |= 1U << ((F - 32) & 0x1f); \ } while (0) if ((EDX >> 15) & 1) setFeature(FEATURE_CMOV); if ((EDX >> 23) & 1) setFeature(FEATURE_MMX); if ((EDX >> 25) & 1) setFeature(FEATURE_SSE); if ((EDX >> 26) & 1) setFeature(FEATURE_SSE2); if ((ECX >> 0) & 1) setFeature(FEATURE_SSE3); if ((ECX >> 1) & 1) setFeature(FEATURE_PCLMUL); if ((ECX >> 9) & 1) setFeature(FEATURE_SSSE3); if ((ECX >> 12) & 1) setFeature(FEATURE_FMA); if ((ECX >> 19) & 1) setFeature(FEATURE_SSE4_1); if ((ECX >> 20) & 1) setFeature(FEATURE_SSE4_2); if ((ECX >> 23) & 1) setFeature(FEATURE_POPCNT); if ((ECX >> 25) & 1) setFeature(FEATURE_AES); // If CPUID indicates support for XSAVE, XRESTORE and AVX, and XGETBV // indicates that the AVX registers will be saved and restored on context // switch, then we have full AVX support. const unsigned AVXBits = (1 << 27) | (1 << 28); bool HasAVX = ((ECX & AVXBits) == AVXBits) && !getX86XCR0(&EAX, &EDX) && ((EAX & 0x6) == 0x6); bool HasAVX512Save = HasAVX && ((EAX & 0xe0) == 0xe0); if (HasAVX) setFeature(FEATURE_AVX); bool HasLeaf7 = MaxLeaf >= 0x7 && !getX86CpuIDAndInfoEx(0x7, 0x0, &EAX, &EBX, &ECX, &EDX); if (HasLeaf7 && ((EBX >> 3) & 1)) setFeature(FEATURE_BMI); if (HasLeaf7 && ((EBX >> 5) & 1) && HasAVX) setFeature(FEATURE_AVX2); - if (HasLeaf7 && ((EBX >> 9) & 1)) + if (HasLeaf7 && ((EBX >> 8) & 1)) setFeature(FEATURE_BMI2); if (HasLeaf7 && ((EBX >> 16) & 1) && HasAVX512Save) setFeature(FEATURE_AVX512F); if (HasLeaf7 && ((EBX >> 17) & 1) && HasAVX512Save) setFeature(FEATURE_AVX512DQ); if (HasLeaf7 && ((EBX >> 21) & 1) && HasAVX512Save) setFeature(FEATURE_AVX512IFMA); if (HasLeaf7 && ((EBX >> 26) & 1) && HasAVX512Save) setFeature(FEATURE_AVX512PF); if (HasLeaf7 && ((EBX >> 27) & 1) && HasAVX512Save) setFeature(FEATURE_AVX512ER); if (HasLeaf7 && ((EBX >> 28) & 1) && HasAVX512Save) setFeature(FEATURE_AVX512CD); if (HasLeaf7 && ((EBX >> 30) & 1) && HasAVX512Save) setFeature(FEATURE_AVX512BW); if (HasLeaf7 && ((EBX >> 31) & 1) && HasAVX512Save) setFeature(FEATURE_AVX512VL); if (HasLeaf7 && ((ECX >> 1) & 1) && HasAVX512Save) setFeature(FEATURE_AVX512VBMI); if (HasLeaf7 && ((ECX >> 6) & 1) && HasAVX512Save) setFeature(FEATURE_AVX512VBMI2); if (HasLeaf7 && ((ECX >> 8) & 1)) setFeature(FEATURE_GFNI); if (HasLeaf7 && ((ECX >> 10) & 1) && HasAVX) setFeature(FEATURE_VPCLMULQDQ); if (HasLeaf7 && ((ECX >> 11) & 1) && HasAVX512Save) setFeature(FEATURE_AVX512VNNI); if (HasLeaf7 && ((ECX >> 12) & 1) && HasAVX512Save) setFeature(FEATURE_AVX512BITALG); if (HasLeaf7 && ((ECX >> 14) & 1) && HasAVX512Save) setFeature(FEATURE_AVX512VPOPCNTDQ); if (HasLeaf7 && ((EDX >> 2) & 1) && HasAVX512Save) setFeature(FEATURE_AVX5124VNNIW); if (HasLeaf7 && ((EDX >> 3) & 1) && HasAVX512Save) setFeature(FEATURE_AVX5124FMAPS); unsigned MaxExtLevel; getX86CpuIDAndInfo(0x80000000, &MaxExtLevel, &EBX, &ECX, &EDX); bool HasExtLeaf1 = MaxExtLevel >= 0x80000001 && !getX86CpuIDAndInfo(0x80000001, &EAX, &EBX, &ECX, &EDX); if (HasExtLeaf1 && ((ECX >> 6) & 1)) setFeature(FEATURE_SSE4_A); if (HasExtLeaf1 && ((ECX >> 11) & 1)) setFeature(FEATURE_XOP); if (HasExtLeaf1 && ((ECX >> 16) & 1)) setFeature(FEATURE_FMA4); *FeaturesOut = Features; *Features2Out = Features2; #undef setFeature } #if defined(HAVE_INIT_PRIORITY) #define CONSTRUCTOR_ATTRIBUTE __attribute__((__constructor__ 101)) #elif __has_attribute(__constructor__) #define CONSTRUCTOR_ATTRIBUTE __attribute__((__constructor__)) #else // FIXME: For MSVC, we should make a function pointer global in .CRT$X?? so that // this runs during initialization. #define CONSTRUCTOR_ATTRIBUTE #endif #ifndef _WIN32 __attribute__((visibility("hidden"))) #endif int __cpu_indicator_init(void) CONSTRUCTOR_ATTRIBUTE; #ifndef _WIN32 __attribute__((visibility("hidden"))) #endif struct __processor_model { unsigned int __cpu_vendor; unsigned int __cpu_type; unsigned int __cpu_subtype; unsigned int __cpu_features[1]; } __cpu_model = {0, 0, 0, {0}}; #ifndef _WIN32 __attribute__((visibility("hidden"))) #endif unsigned int __cpu_features2; // A constructor function that is sets __cpu_model and __cpu_features2 with // the right values. This needs to run only once. This constructor is // given the highest priority and it should run before constructors without // the priority set. However, it still runs after ifunc initializers and // needs to be called explicitly there. int CONSTRUCTOR_ATTRIBUTE __cpu_indicator_init(void) { unsigned EAX, EBX, ECX, EDX; unsigned MaxLeaf = 5; unsigned Vendor; unsigned Model, Family, Brand_id; unsigned Features = 0; unsigned Features2 = 0; // This function needs to run just once. if (__cpu_model.__cpu_vendor) return 0; if (!isCpuIdSupported()) return -1; // Assume cpuid insn present. Run in level 0 to get vendor id. if (getX86CpuIDAndInfo(0, &MaxLeaf, &Vendor, &ECX, &EDX) || MaxLeaf < 1) { __cpu_model.__cpu_vendor = VENDOR_OTHER; return -1; } getX86CpuIDAndInfo(1, &EAX, &EBX, &ECX, &EDX); detectX86FamilyModel(EAX, &Family, &Model); Brand_id = EBX & 0xff; // Find available features. getAvailableFeatures(ECX, EDX, MaxLeaf, &Features, &Features2); __cpu_model.__cpu_features[0] = Features; __cpu_features2 = Features2; if (Vendor == SIG_INTEL) { // Get CPU type. getIntelProcessorTypeAndSubtype(Family, Model, Brand_id, Features, Features2, &(__cpu_model.__cpu_type), &(__cpu_model.__cpu_subtype)); __cpu_model.__cpu_vendor = VENDOR_INTEL; } else if (Vendor == SIG_AMD) { // Get CPU type. getAMDProcessorTypeAndSubtype(Family, Model, Features, Features2, &(__cpu_model.__cpu_type), &(__cpu_model.__cpu_subtype)); __cpu_model.__cpu_vendor = VENDOR_AMD; } else __cpu_model.__cpu_vendor = VENDOR_OTHER; assert(__cpu_model.__cpu_vendor < VENDOR_MAX); assert(__cpu_model.__cpu_type < CPU_TYPE_MAX); assert(__cpu_model.__cpu_subtype < CPU_SUBTYPE_MAX); return 0; } #endif Index: vendor/compiler-rt/dist-release_90/lib/interception/interception_linux.cc =================================================================== --- vendor/compiler-rt/dist-release_90/lib/interception/interception_linux.cc (revision 351306) +++ vendor/compiler-rt/dist-release_90/lib/interception/interception_linux.cc (revision 351307) @@ -1,83 +1,78 @@ //===-- interception_linux.cc -----------------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is a part of AddressSanitizer, an address sanity checker. // // Linux-specific interception methods. //===----------------------------------------------------------------------===// #include "interception.h" #if SANITIZER_LINUX || SANITIZER_FREEBSD || SANITIZER_NETBSD || \ SANITIZER_OPENBSD || SANITIZER_SOLARIS #include // for dlsym() and dlvsym() namespace __interception { #if SANITIZER_NETBSD static int StrCmp(const char *s1, const char *s2) { while (true) { if (*s1 != *s2) return false; if (*s1 == 0) return true; s1++; s2++; } } #endif -static void *GetFuncAddr(const char *name, uptr wrapper_addr) { +static void *GetFuncAddr(const char *name) { #if SANITIZER_NETBSD // FIXME: Find a better way to handle renames if (StrCmp(name, "sigaction")) name = "__sigaction14"; #endif void *addr = dlsym(RTLD_NEXT, name); if (!addr) { // If the lookup using RTLD_NEXT failed, the sanitizer runtime library is // later in the library search order than the DSO that we are trying to // intercept, which means that we cannot intercept this function. We still // want the address of the real definition, though, so look it up using // RTLD_DEFAULT. addr = dlsym(RTLD_DEFAULT, name); - - // In case `name' is not loaded, dlsym ends up finding the actual wrapper. - // We don't want to intercept the wrapper and have it point to itself. - if ((uptr)addr == wrapper_addr) - addr = nullptr; } return addr; } bool InterceptFunction(const char *name, uptr *ptr_to_real, uptr func, uptr wrapper) { - void *addr = GetFuncAddr(name, wrapper); + void *addr = GetFuncAddr(name); *ptr_to_real = (uptr)addr; return addr && (func == wrapper); } // Android and Solaris do not have dlvsym #if !SANITIZER_ANDROID && !SANITIZER_SOLARIS && !SANITIZER_OPENBSD static void *GetFuncAddr(const char *name, const char *ver) { return dlvsym(RTLD_NEXT, name, ver); } bool InterceptFunction(const char *name, const char *ver, uptr *ptr_to_real, uptr func, uptr wrapper) { void *addr = GetFuncAddr(name, ver); *ptr_to_real = (uptr)addr; return addr && (func == wrapper); } #endif // !SANITIZER_ANDROID } // namespace __interception #endif // SANITIZER_LINUX || SANITIZER_FREEBSD || SANITIZER_NETBSD || // SANITIZER_OPENBSD || SANITIZER_SOLARIS Index: vendor/compiler-rt/dist-release_90/lib/msan/msan_linux.cc =================================================================== --- vendor/compiler-rt/dist-release_90/lib/msan/msan_linux.cc (revision 351306) +++ vendor/compiler-rt/dist-release_90/lib/msan/msan_linux.cc (revision 351307) @@ -1,262 +1,262 @@ //===-- msan_linux.cc -----------------------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is a part of MemorySanitizer. // // Linux-, NetBSD- and FreeBSD-specific code. //===----------------------------------------------------------------------===// #include "sanitizer_common/sanitizer_platform.h" #if SANITIZER_FREEBSD || SANITIZER_LINUX || SANITIZER_NETBSD #include "msan.h" #include "msan_report.h" #include "msan_thread.h" #include #include #include #include #include #include #include #include #include #include #include #include "sanitizer_common/sanitizer_common.h" #include "sanitizer_common/sanitizer_procmaps.h" namespace __msan { void ReportMapRange(const char *descr, uptr beg, uptr size) { if (size > 0) { uptr end = beg + size - 1; VPrintf(1, "%s : %p - %p\n", descr, beg, end); } } static bool CheckMemoryRangeAvailability(uptr beg, uptr size) { if (size > 0) { uptr end = beg + size - 1; if (!MemoryRangeIsAvailable(beg, end)) { Printf("FATAL: Memory range %p - %p is not available.\n", beg, end); return false; } } return true; } static bool ProtectMemoryRange(uptr beg, uptr size, const char *name) { if (size > 0) { void *addr = MmapFixedNoAccess(beg, size, name); if (beg == 0 && addr) { // Depending on the kernel configuration, we may not be able to protect // the page at address zero. uptr gap = 16 * GetPageSizeCached(); beg += gap; size -= gap; addr = MmapFixedNoAccess(beg, size, name); } if ((uptr)addr != beg) { uptr end = beg + size - 1; Printf("FATAL: Cannot protect memory range %p - %p (%s).\n", beg, end, name); return false; } } return true; } static void CheckMemoryLayoutSanity() { uptr prev_end = 0; for (unsigned i = 0; i < kMemoryLayoutSize; ++i) { uptr start = kMemoryLayout[i].start; uptr end = kMemoryLayout[i].end; MappingDesc::Type type = kMemoryLayout[i].type; CHECK_LT(start, end); CHECK_EQ(prev_end, start); CHECK(addr_is_type(start, type)); CHECK(addr_is_type((start + end) / 2, type)); CHECK(addr_is_type(end - 1, type)); if (type == MappingDesc::APP) { uptr addr = start; CHECK(MEM_IS_SHADOW(MEM_TO_SHADOW(addr))); CHECK(MEM_IS_ORIGIN(MEM_TO_ORIGIN(addr))); CHECK_EQ(MEM_TO_ORIGIN(addr), SHADOW_TO_ORIGIN(MEM_TO_SHADOW(addr))); addr = (start + end) / 2; CHECK(MEM_IS_SHADOW(MEM_TO_SHADOW(addr))); CHECK(MEM_IS_ORIGIN(MEM_TO_ORIGIN(addr))); CHECK_EQ(MEM_TO_ORIGIN(addr), SHADOW_TO_ORIGIN(MEM_TO_SHADOW(addr))); addr = end - 1; CHECK(MEM_IS_SHADOW(MEM_TO_SHADOW(addr))); CHECK(MEM_IS_ORIGIN(MEM_TO_ORIGIN(addr))); CHECK_EQ(MEM_TO_ORIGIN(addr), SHADOW_TO_ORIGIN(MEM_TO_SHADOW(addr))); } prev_end = end; } } bool InitShadow(bool init_origins) { // Let user know mapping parameters first. VPrintf(1, "__msan_init %p\n", &__msan_init); for (unsigned i = 0; i < kMemoryLayoutSize; ++i) VPrintf(1, "%s: %zx - %zx\n", kMemoryLayout[i].name, kMemoryLayout[i].start, kMemoryLayout[i].end - 1); CheckMemoryLayoutSanity(); if (!MEM_IS_APP(&__msan_init)) { Printf("FATAL: Code %p is out of application range. Non-PIE build?\n", (uptr)&__msan_init); return false; } const uptr maxVirtualAddress = GetMaxUserVirtualAddress(); for (unsigned i = 0; i < kMemoryLayoutSize; ++i) { uptr start = kMemoryLayout[i].start; uptr end = kMemoryLayout[i].end; uptr size= end - start; MappingDesc::Type type = kMemoryLayout[i].type; // Check if the segment should be mapped based on platform constraints. if (start >= maxVirtualAddress) continue; bool map = type == MappingDesc::SHADOW || (init_origins && type == MappingDesc::ORIGIN); bool protect = type == MappingDesc::INVALID || (!init_origins && type == MappingDesc::ORIGIN); CHECK(!(map && protect)); if (!map && !protect) CHECK(type == MappingDesc::APP); if (map) { if (!CheckMemoryRangeAvailability(start, size)) return false; if (!MmapFixedNoReserve(start, size, kMemoryLayout[i].name)) return false; if (common_flags()->use_madv_dontdump) DontDumpShadowMemory(start, size); } if (protect) { if (!CheckMemoryRangeAvailability(start, size)) return false; if (!ProtectMemoryRange(start, size, kMemoryLayout[i].name)) return false; } } return true; } static void MsanAtExit(void) { if (flags()->print_stats && (flags()->atexit || msan_report_count > 0)) ReportStats(); if (msan_report_count > 0) { ReportAtExitStatistics(); if (common_flags()->exitcode) internal__exit(common_flags()->exitcode); } } void InstallAtExitHandler() { atexit(MsanAtExit); } // ---------------------- TSD ---------------- {{{1 -#if SANITIZER_NETBSD || SANITIZER_FREEBSD -// Thread Static Data cannot be used in early init on NetBSD and FreeBSD. +#if SANITIZER_NETBSD +// Thread Static Data cannot be used in early init on NetBSD. // Reuse the MSan TSD API for compatibility with existing code // with an alternative implementation. static void (*tsd_destructor)(void *tsd) = nullptr; struct tsd_key { tsd_key() : key(nullptr) {} ~tsd_key() { CHECK(tsd_destructor); if (key) (*tsd_destructor)(key); } MsanThread *key; }; static thread_local struct tsd_key key; void MsanTSDInit(void (*destructor)(void *tsd)) { CHECK(!tsd_destructor); tsd_destructor = destructor; } MsanThread *GetCurrentThread() { CHECK(tsd_destructor); return key.key; } void SetCurrentThread(MsanThread *tsd) { CHECK(tsd_destructor); CHECK(tsd); CHECK(!key.key); key.key = tsd; } void MsanTSDDtor(void *tsd) { CHECK(tsd_destructor); CHECK_EQ(key.key, tsd); key.key = nullptr; // Make sure that signal handler can not see a stale current thread pointer. atomic_signal_fence(memory_order_seq_cst); MsanThread::TSDDtor(tsd); } #else static pthread_key_t tsd_key; static bool tsd_key_inited = false; void MsanTSDInit(void (*destructor)(void *tsd)) { CHECK(!tsd_key_inited); tsd_key_inited = true; CHECK_EQ(0, pthread_key_create(&tsd_key, destructor)); } static THREADLOCAL MsanThread* msan_current_thread; MsanThread *GetCurrentThread() { return msan_current_thread; } void SetCurrentThread(MsanThread *t) { // Make sure we do not reset the current MsanThread. CHECK_EQ(0, msan_current_thread); msan_current_thread = t; // Make sure that MsanTSDDtor gets called at the end. CHECK(tsd_key_inited); pthread_setspecific(tsd_key, (void *)t); } void MsanTSDDtor(void *tsd) { MsanThread *t = (MsanThread*)tsd; if (t->destructor_iterations_ > 1) { t->destructor_iterations_--; CHECK_EQ(0, pthread_setspecific(tsd_key, tsd)); return; } msan_current_thread = nullptr; // Make sure that signal handler can not see a stale current thread pointer. atomic_signal_fence(memory_order_seq_cst); MsanThread::TSDDtor(tsd); } #endif } // namespace __msan #endif // SANITIZER_FREEBSD || SANITIZER_LINUX || SANITIZER_NETBSD Index: vendor/compiler-rt/dist-release_90/lib/sanitizer_common/sanitizer_interceptors_ioctl_netbsd.inc =================================================================== --- vendor/compiler-rt/dist-release_90/lib/sanitizer_common/sanitizer_interceptors_ioctl_netbsd.inc (revision 351306) +++ vendor/compiler-rt/dist-release_90/lib/sanitizer_common/sanitizer_interceptors_ioctl_netbsd.inc (revision 351307) @@ -1,1508 +1,1533 @@ //===-- sanitizer_interceptors_ioctl_netbsd.inc -----------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // Ioctl handling in common sanitizer interceptors. //===----------------------------------------------------------------------===// #if SANITIZER_NETBSD #include "sanitizer_flags.h" struct ioctl_desc { unsigned req; // FIXME: support read+write arguments. Currently READWRITE and WRITE do the // same thing. // XXX: The declarations below may use WRITE instead of READWRITE, unless // explicitly noted. enum { NONE, READ, WRITE, READWRITE, CUSTOM } type : 3; unsigned size : 29; const char *name; }; -const unsigned ioctl_table_max = 1200; +const unsigned ioctl_table_max = 1236; static ioctl_desc ioctl_table[ioctl_table_max]; static unsigned ioctl_table_size = 0; // This can not be declared as a global, because references to struct_*_sz // require a global initializer. And this table must be available before global // initializers are run. static void ioctl_table_fill() { #define _(rq, tp, sz) \ if (IOCTL_##rq != IOCTL_NOT_PRESENT) { \ CHECK(ioctl_table_size < ioctl_table_max); \ ioctl_table[ioctl_table_size].req = IOCTL_##rq; \ ioctl_table[ioctl_table_size].type = ioctl_desc::tp; \ ioctl_table[ioctl_table_size].size = sz; \ ioctl_table[ioctl_table_size].name = #rq; \ ++ioctl_table_size; \ } /* Entries from file: altq/altq_afmap.h */ _(AFM_ADDFMAP, READWRITE, struct_atm_flowmap_sz); _(AFM_DELFMAP, READWRITE, struct_atm_flowmap_sz); _(AFM_CLEANFMAP, READWRITE, struct_atm_flowmap_sz); _(AFM_GETFMAP, READWRITE, struct_atm_flowmap_sz); /* Entries from file: altq/altq.h */ _(ALTQGTYPE, READWRITE, struct_altqreq_sz); _(ALTQTBRSET, READ, struct_tbrreq_sz); _(ALTQTBRGET, READWRITE, struct_tbrreq_sz); /* Entries from file: altq/altq_blue.h */ _(BLUE_IF_ATTACH, READ, struct_blue_interface_sz); _(BLUE_DISABLE, READ, struct_blue_interface_sz); _(BLUE_CONFIG, READWRITE, struct_blue_conf_sz); _(BLUE_GETSTATS, READWRITE, struct_blue_stats_sz); /* Entries from file: altq/altq_cbq.h */ _(CBQ_ENABLE, READ, struct_cbq_interface_sz); _(CBQ_ADD_CLASS, READWRITE, struct_cbq_add_class_sz); _(CBQ_DEL_CLASS, READ, struct_cbq_delete_class_sz); _(CBQ_MODIFY_CLASS, READWRITE, struct_cbq_modify_class_sz); _(CBQ_DEL_FILTER, READ, struct_cbq_delete_filter_sz); _(CBQ_GETSTATS, READWRITE, struct_cbq_getstats_sz); /* Entries from file: altq/altq_cdnr.h */ _(CDNR_IF_DETACH, READ, struct_cdnr_interface_sz); _(CDNR_ADD_FILTER, READWRITE, struct_cdnr_add_filter_sz); _(CDNR_GETSTATS, READWRITE, struct_cdnr_get_stats_sz); _(CDNR_ADD_ELEM, READWRITE, struct_cdnr_add_element_sz); _(CDNR_DEL_ELEM, READ, struct_cdnr_delete_element_sz); _(CDNR_ADD_TBM, READWRITE, struct_cdnr_add_tbmeter_sz); _(CDNR_MOD_TBM, READ, struct_cdnr_modify_tbmeter_sz); _(CDNR_TBM_STATS, READWRITE, struct_cdnr_tbmeter_stats_sz); _(CDNR_ADD_TCM, READWRITE, struct_cdnr_add_trtcm_sz); _(CDNR_MOD_TCM, READWRITE, struct_cdnr_modify_trtcm_sz); _(CDNR_TCM_STATS, READWRITE, struct_cdnr_tcm_stats_sz); _(CDNR_ADD_TSW, READWRITE, struct_cdnr_add_tswtcm_sz); _(CDNR_MOD_TSW, READWRITE, struct_cdnr_modify_tswtcm_sz); /* Entries from file: altq/altq_fifoq.h */ _(FIFOQ_CONFIG, READWRITE, struct_fifoq_conf_sz); _(FIFOQ_GETSTATS, READWRITE, struct_fifoq_getstats_sz); /* Entries from file: altq/altq_hfsc.h */ _(HFSC_CLEAR_HIERARCHY, READ, struct_hfsc_interface_sz); _(HFSC_ADD_CLASS, READWRITE, struct_hfsc_add_class_sz); _(HFSC_GETSTATS, READWRITE, struct_hfsc_class_stats_sz); /* Entries from file: altq/altq_jobs.h */ _(JOBS_IF_ATTACH, READ, struct_jobs_attach_sz); _(JOBS_IF_DETACH, READ, struct_jobs_interface_sz); _(JOBS_ENABLE, READ, struct_jobs_interface_sz); _(JOBS_DISABLE, READ, struct_jobs_interface_sz); _(JOBS_CLEAR, READ, struct_jobs_interface_sz); _(JOBS_ADD_CLASS, READWRITE, struct_jobs_add_class_sz); _(JOBS_MOD_CLASS, READ, struct_jobs_modify_class_sz); /* Entries from file: altq/altq_priq.h */ _(PRIQ_IF_ATTACH, READ, struct_priq_interface_sz); _(PRIQ_CLEAR, READ, struct_priq_interface_sz); _(PRIQ_ADD_CLASS, READWRITE, struct_priq_add_class_sz); _(PRIQ_DEL_CLASS, READ, struct_priq_delete_class_sz); _(PRIQ_MOD_CLASS, READ, struct_priq_modify_class_sz); _(PRIQ_ADD_FILTER, READWRITE, struct_priq_add_filter_sz); _(PRIQ_DEL_FILTER, READ, struct_priq_delete_filter_sz); _(PRIQ_GETSTATS, READWRITE, struct_priq_class_stats_sz); /* Entries from file: altq/altq_red.h */ _(RED_CONFIG, READWRITE, struct_red_conf_sz); _(RED_GETSTATS, READWRITE, struct_red_stats_sz); _(RED_SETDEFAULTS, READ, struct_redparams_sz); /* Entries from file: altq/altq_rio.h */ _(RIO_CONFIG, READWRITE, struct_rio_conf_sz); _(RIO_GETSTATS, READWRITE, struct_rio_stats_sz); _(RIO_SETDEFAULTS, READ, struct_redparams_sz); /* Entries from file: altq/altq_wfq.h */ _(WFQ_CONFIG, READWRITE, struct_wfq_conf_sz); _(WFQ_GET_QID, READWRITE, struct_wfq_getqid_sz); _(WFQ_SET_WEIGHT, READWRITE, struct_wfq_setweight_sz); /* Entries from file: crypto/cryptodev.h */ _(CRIOGET, READWRITE, sizeof(u32)); _(CIOCFSESSION, READ, sizeof(u32)); _(CIOCKEY, READWRITE, struct_crypt_kop_sz); _(CIOCNFKEYM, READWRITE, struct_crypt_mkop_sz); _(CIOCNFSESSION, READ, struct_crypt_sfop_sz); _(CIOCNCRYPTRETM, READWRITE, struct_cryptret_sz); _(CIOCNCRYPTRET, READWRITE, struct_crypt_result_sz); _(CIOCGSESSION, READWRITE, struct_session_op_sz); _(CIOCNGSESSION, READWRITE, struct_crypt_sgop_sz); _(CIOCCRYPT, READWRITE, struct_crypt_op_sz); _(CIOCNCRYPTM, READWRITE, struct_crypt_mop_sz); _(CIOCASYMFEAT, WRITE, sizeof(u32)); /* Entries from file: dev/apm/apmio.h */ _(APM_IOC_REJECT, READ, struct_apm_event_info_sz); _(OAPM_IOC_GETPOWER, WRITE, struct_apm_power_info_sz); _(APM_IOC_GETPOWER, READWRITE, struct_apm_power_info_sz); _(APM_IOC_NEXTEVENT, WRITE, struct_apm_event_info_sz); _(APM_IOC_DEV_CTL, READ, struct_apm_ctl_sz); /* Entries from file: dev/dm/netbsd-dm.h */ _(NETBSD_DM_IOCTL, READWRITE, struct_plistref_sz); /* Entries from file: dev/dmover/dmover_io.h */ _(DMIO_SETFUNC, READ, struct_dmio_setfunc_sz); /* Entries from file: dev/dtv/dtvio_demux.h */ _(DMX_START, NONE, 0); _(DMX_STOP, NONE, 0); _(DMX_SET_FILTER, READ, struct_dmx_sct_filter_params_sz); _(DMX_SET_PES_FILTER, READ, struct_dmx_pes_filter_params_sz); _(DMX_SET_BUFFER_SIZE, NONE, 0); _(DMX_GET_STC, READWRITE, struct_dmx_stc_sz); _(DMX_ADD_PID, READ, sizeof(u16)); _(DMX_REMOVE_PID, READ, sizeof(u16)); _(DMX_GET_CAPS, WRITE, struct_dmx_caps_sz); _(DMX_SET_SOURCE, READ, enum_dmx_source_sz); /* Entries from file: dev/dtv/dtvio_frontend.h */ _(FE_READ_STATUS, WRITE, enum_fe_status_sz); _(FE_READ_BER, WRITE, sizeof(u32)); _(FE_READ_SNR, WRITE, sizeof(u16)); _(FE_READ_SIGNAL_STRENGTH, WRITE, sizeof(u16)); _(FE_READ_UNCORRECTED_BLOCKS, WRITE, sizeof(u32)); _(FE_SET_FRONTEND, READWRITE, struct_dvb_frontend_parameters_sz); _(FE_GET_FRONTEND, WRITE, struct_dvb_frontend_parameters_sz); _(FE_GET_EVENT, WRITE, struct_dvb_frontend_event_sz); _(FE_GET_INFO, WRITE, struct_dvb_frontend_info_sz); _(FE_DISEQC_RESET_OVERLOAD, NONE, 0); _(FE_DISEQC_SEND_MASTER_CMD, READ, struct_dvb_diseqc_master_cmd_sz); _(FE_DISEQC_RECV_SLAVE_REPLY, WRITE, struct_dvb_diseqc_slave_reply_sz); _(FE_DISEQC_SEND_BURST, READ, enum_fe_sec_mini_cmd_sz); _(FE_SET_TONE, READ, enum_fe_sec_tone_mode_sz); _(FE_SET_VOLTAGE, READ, enum_fe_sec_voltage_sz); _(FE_ENABLE_HIGH_LNB_VOLTAGE, READ, sizeof(int)); _(FE_SET_FRONTEND_TUNE_MODE, READ, sizeof(unsigned int)); _(FE_DISHNETWORK_SEND_LEGACY_CMD, READ, sizeof(unsigned long)); /* Entries from file: dev/filemon/filemon.h */ _(FILEMON_SET_FD, READWRITE, sizeof(int)); _(FILEMON_SET_PID, READWRITE, sizeof(int)); /* Entries from file: dev/hdaudio/hdaudioio.h */ _(HDAUDIO_FGRP_INFO, READWRITE, struct_plistref_sz); _(HDAUDIO_FGRP_GETCONFIG, READWRITE, struct_plistref_sz); _(HDAUDIO_FGRP_SETCONFIG, READWRITE, struct_plistref_sz); _(HDAUDIO_FGRP_WIDGET_INFO, READWRITE, struct_plistref_sz); _(HDAUDIO_FGRP_CODEC_INFO, READWRITE, struct_plistref_sz); _(HDAUDIO_AFG_WIDGET_INFO, READWRITE, struct_plistref_sz); _(HDAUDIO_AFG_CODEC_INFO, READWRITE, struct_plistref_sz); /* Entries from file: dev/hdmicec/hdmicecio.h */ _(CEC_GET_PHYS_ADDR, WRITE, sizeof(u16)); _(CEC_GET_LOG_ADDRS, WRITE, sizeof(u16)); _(CEC_SET_LOG_ADDRS, READ, sizeof(u16)); _(CEC_GET_VENDOR_ID, WRITE, sizeof(u32)); /* Entries from file: dev/hpc/hpcfbio.h */ _(HPCFBIO_GCONF, READWRITE, struct_hpcfb_fbconf_sz); _(HPCFBIO_SCONF, READ, struct_hpcfb_fbconf_sz); _(HPCFBIO_GDSPCONF, READWRITE, struct_hpcfb_dspconf_sz); _(HPCFBIO_SDSPCONF, READ, struct_hpcfb_dspconf_sz); _(HPCFBIO_GOP, WRITE, struct_hpcfb_dsp_op_sz); _(HPCFBIO_SOP, READWRITE, struct_hpcfb_dsp_op_sz); /* Entries from file: dev/i2o/iopio.h */ _(IOPIOCPT, READWRITE, struct_ioppt_sz); _(IOPIOCGLCT, READWRITE, struct_iovec_sz); _(IOPIOCGSTATUS, READWRITE, struct_iovec_sz); _(IOPIOCRECONFIG, NONE, 0); _(IOPIOCGTIDMAP, READWRITE, struct_iovec_sz); /* Entries from file: dev/ic/athioctl.h */ _(SIOCGATHSTATS, READWRITE, struct_ifreq_sz); _(SIOCGATHDIAG, READWRITE, struct_ath_diag_sz); /* Entries from file: dev/ic/bt8xx.h */ _(METEORCAPTUR, READ, sizeof(int)); _(METEORCAPFRM, READ, struct_meteor_capframe_sz); _(METEORSETGEO, READ, struct_meteor_geomet_sz); _(METEORGETGEO, WRITE, struct_meteor_geomet_sz); _(METEORSTATUS, WRITE, sizeof(unsigned short)); _(METEORSHUE, READ, sizeof(signed char)); _(METEORGHUE, WRITE, sizeof(signed char)); _(METEORSFMT, READ, sizeof(unsigned int)); _(METEORGFMT, WRITE, sizeof(unsigned int)); _(METEORSINPUT, READ, sizeof(unsigned int)); _(METEORGINPUT, WRITE, sizeof(unsigned int)); _(METEORSCHCV, READ, sizeof(unsigned char)); _(METEORGCHCV, WRITE, sizeof(unsigned char)); _(METEORSCOUNT, READ, struct_meteor_counts_sz); _(METEORGCOUNT, WRITE, struct_meteor_counts_sz); _(METEORSFPS, READ, sizeof(unsigned short)); _(METEORGFPS, WRITE, sizeof(unsigned short)); _(METEORSSIGNAL, READ, sizeof(unsigned int)); _(METEORGSIGNAL, WRITE, sizeof(unsigned int)); _(METEORSVIDEO, READ, struct_meteor_video_sz); _(METEORGVIDEO, WRITE, struct_meteor_video_sz); _(METEORSBRIG, READ, sizeof(unsigned char)); _(METEORGBRIG, WRITE, sizeof(unsigned char)); _(METEORSCSAT, READ, sizeof(unsigned char)); _(METEORGCSAT, WRITE, sizeof(unsigned char)); _(METEORSCONT, READ, sizeof(unsigned char)); _(METEORGCONT, WRITE, sizeof(unsigned char)); _(METEORSHWS, READ, sizeof(unsigned char)); _(METEORGHWS, WRITE, sizeof(unsigned char)); _(METEORSVWS, READ, sizeof(unsigned char)); _(METEORGVWS, WRITE, sizeof(unsigned char)); _(METEORSTS, READ, sizeof(unsigned char)); _(METEORGTS, WRITE, sizeof(unsigned char)); _(TVTUNER_SETCHNL, READ, sizeof(unsigned int)); _(TVTUNER_GETCHNL, WRITE, sizeof(unsigned int)); _(TVTUNER_SETTYPE, READ, sizeof(unsigned int)); _(TVTUNER_GETTYPE, WRITE, sizeof(unsigned int)); _(TVTUNER_GETSTATUS, WRITE, sizeof(unsigned int)); _(TVTUNER_SETFREQ, READ, sizeof(unsigned int)); _(TVTUNER_GETFREQ, WRITE, sizeof(unsigned int)); _(TVTUNER_SETAFC, READ, sizeof(int)); _(TVTUNER_GETAFC, WRITE, sizeof(int)); _(RADIO_SETMODE, READ, sizeof(unsigned int)); _(RADIO_GETMODE, WRITE, sizeof(unsigned char)); _(RADIO_SETFREQ, READ, sizeof(unsigned int)); _(RADIO_GETFREQ, WRITE, sizeof(unsigned int)); _(METEORSACTPIXFMT, READ, sizeof(int)); _(METEORGACTPIXFMT, WRITE, sizeof(int)); _(METEORGSUPPIXFMT, READWRITE, struct_meteor_pixfmt_sz); _(TVTUNER_GETCHNLSET, READWRITE, struct_bktr_chnlset_sz); _(REMOTE_GETKEY, WRITE, struct_bktr_remote_sz); /* Entries from file: dev/ic/icp_ioctl.h */ _(GDT_IOCTL_GENERAL, READWRITE, struct_gdt_ucmd_sz); _(GDT_IOCTL_DRVERS, WRITE, sizeof(int)); _(GDT_IOCTL_CTRTYPE, READWRITE, struct_gdt_ctrt_sz); _(GDT_IOCTL_OSVERS, WRITE, struct_gdt_osv_sz); _(GDT_IOCTL_CTRCNT, WRITE, sizeof(int)); _(GDT_IOCTL_EVENT, READWRITE, struct_gdt_event_sz); _(GDT_IOCTL_STATIST, WRITE, struct_gdt_statist_sz); _(GDT_IOCTL_RESCAN, READWRITE, struct_gdt_rescan_sz); /* Entries from file: dev/ic/isp_ioctl.h */ _(ISP_SDBLEV, READWRITE, sizeof(int)); _(ISP_RESETHBA, NONE, 0); _(ISP_RESCAN, NONE, 0); _(ISP_SETROLE, READWRITE, sizeof(int)); _(ISP_GETROLE, WRITE, sizeof(int)); _(ISP_GET_STATS, WRITE, struct_isp_stats_sz); _(ISP_CLR_STATS, NONE, 0); _(ISP_FC_LIP, NONE, 0); _(ISP_FC_GETDINFO, READWRITE, struct_isp_fc_device_sz); _(ISP_GET_FW_CRASH_DUMP, NONE, 0); _(ISP_FORCE_CRASH_DUMP, NONE, 0); _(ISP_FC_GETHINFO, READWRITE, struct_isp_hba_device_sz); _(ISP_TSK_MGMT, READWRITE, struct_isp_fc_tsk_mgmt_sz); _(ISP_FC_GETDLIST, NONE, 0); /* Entries from file: dev/ic/mlxio.h */ _(MLXD_STATUS, WRITE, sizeof(int)); _(MLXD_CHECKASYNC, WRITE, sizeof(int)); _(MLXD_DETACH, READ, sizeof(int)); _(MLX_RESCAN_DRIVES, NONE, 0); _(MLX_PAUSE_CHANNEL, READ, struct_mlx_pause_sz); _(MLX_COMMAND, READWRITE, struct_mlx_usercommand_sz); _(MLX_REBUILDASYNC, READWRITE, struct_mlx_rebuild_request_sz); _(MLX_REBUILDSTAT, WRITE, struct_mlx_rebuild_status_sz); _(MLX_GET_SYSDRIVE, READWRITE, sizeof(int)); _(MLX_GET_CINFO, WRITE, struct_mlx_cinfo_sz); /* Entries from file: dev/ic/nvmeio.h */ _(NVME_PASSTHROUGH_CMD, READWRITE, struct_nvme_pt_command_sz); /* Entries from file: dev/ic/qemufwcfgio.h */ _(FWCFGIO_SET_INDEX, READ, sizeof(u16)); /* Entries from file: dev/ir/irdaio.h */ _(IRDA_RESET_PARAMS, NONE, 0); _(IRDA_SET_PARAMS, READ, struct_irda_params_sz); _(IRDA_GET_SPEEDMASK, WRITE, sizeof(unsigned int)); _(IRDA_GET_TURNAROUNDMASK, WRITE, sizeof(unsigned int)); _(IRFRAMETTY_GET_DEVICE, WRITE, sizeof(unsigned int)); _(IRFRAMETTY_GET_DONGLE, WRITE, sizeof(unsigned int)); _(IRFRAMETTY_SET_DONGLE, READ, sizeof(unsigned int)); /* Entries from file: dev/isa/isvio.h */ _(ISV_CMD, READWRITE, struct_isv_cmd_sz); /* Entries from file: dev/isa/wtreg.h */ _(WTQICMD, NONE, 0); /* Entries from file: dev/iscsi/iscsi_ioctl.h */ _(ISCSI_GET_VERSION, READWRITE, struct_iscsi_get_version_parameters_sz); _(ISCSI_LOGIN, READWRITE, struct_iscsi_login_parameters_sz); _(ISCSI_LOGOUT, READWRITE, struct_iscsi_logout_parameters_sz); _(ISCSI_ADD_CONNECTION, READWRITE, struct_iscsi_login_parameters_sz); _(ISCSI_RESTORE_CONNECTION, READWRITE, struct_iscsi_login_parameters_sz); _(ISCSI_REMOVE_CONNECTION, READWRITE, struct_iscsi_remove_parameters_sz); _(ISCSI_CONNECTION_STATUS, READWRITE, struct_iscsi_conn_status_parameters_sz); _(ISCSI_SEND_TARGETS, READWRITE, struct_iscsi_send_targets_parameters_sz); _(ISCSI_SET_NODE_NAME, READWRITE, struct_iscsi_set_node_name_parameters_sz); _(ISCSI_IO_COMMAND, READWRITE, struct_iscsi_iocommand_parameters_sz); _(ISCSI_REGISTER_EVENT, READWRITE, struct_iscsi_register_event_parameters_sz); _(ISCSI_DEREGISTER_EVENT, READWRITE, struct_iscsi_register_event_parameters_sz); _(ISCSI_WAIT_EVENT, READWRITE, struct_iscsi_wait_event_parameters_sz); _(ISCSI_POLL_EVENT, READWRITE, struct_iscsi_wait_event_parameters_sz); /* Entries from file: dev/ofw/openfirmio.h */ _(OFIOCGET, READWRITE, struct_ofiocdesc_sz); _(OFIOCSET, READ, struct_ofiocdesc_sz); _(OFIOCNEXTPROP, READWRITE, struct_ofiocdesc_sz); _(OFIOCGETOPTNODE, WRITE, sizeof(int)); _(OFIOCGETNEXT, READWRITE, sizeof(int)); _(OFIOCGETCHILD, READWRITE, sizeof(int)); _(OFIOCFINDDEVICE, READWRITE, struct_ofiocdesc_sz); /* Entries from file: dev/pci/amrio.h */ _(AMR_IO_VERSION, WRITE, sizeof(int)); _(AMR_IO_COMMAND, READWRITE, struct_amr_user_ioctl_sz); /* Entries from file: dev/pci/mlyio.h */ _(MLYIO_COMMAND, READWRITE, struct_mly_user_command_sz); _(MLYIO_HEALTH, READ, struct_mly_user_health_sz); /* Entries from file: dev/pci/pciio.h */ _(PCI_IOC_CFGREAD, READWRITE, struct_pciio_cfgreg_sz); _(PCI_IOC_CFGWRITE, READ, struct_pciio_cfgreg_sz); _(PCI_IOC_BDF_CFGREAD, READWRITE, struct_pciio_bdf_cfgreg_sz); _(PCI_IOC_BDF_CFGWRITE, READ, struct_pciio_bdf_cfgreg_sz); _(PCI_IOC_BUSINFO, WRITE, struct_pciio_businfo_sz); _(PCI_IOC_DRVNAME, READWRITE, struct_pciio_drvname_sz); _(PCI_IOC_DRVNAMEONBUS, READWRITE, struct_pciio_drvnameonbus_sz); /* Entries from file: dev/pci/tweio.h */ _(TWEIO_COMMAND, READWRITE, struct_twe_usercommand_sz); _(TWEIO_STATS, READWRITE, union_twe_statrequest_sz); _(TWEIO_AEN_POLL, WRITE, sizeof(int)); _(TWEIO_AEN_WAIT, WRITE, sizeof(int)); _(TWEIO_SET_PARAM, READ, struct_twe_paramcommand_sz); _(TWEIO_GET_PARAM, READ, struct_twe_paramcommand_sz); _(TWEIO_RESET, NONE, 0); _(TWEIO_ADD_UNIT, READ, struct_twe_drivecommand_sz); _(TWEIO_DEL_UNIT, READ, struct_twe_drivecommand_sz); /* Entries from file: dev/pcmcia/if_cnwioctl.h */ _(SIOCSCNWDOMAIN, READ, struct_ifreq_sz); _(SIOCGCNWDOMAIN, READWRITE, struct_ifreq_sz); _(SIOCSCNWKEY, READWRITE, struct_ifreq_sz); _(SIOCGCNWSTATUS, READWRITE, struct_cnwstatus_sz); _(SIOCGCNWSTATS, READWRITE, struct_cnwistats_sz); _(SIOCGCNWTRAIL, READWRITE, struct_cnwitrail_sz); /* Entries from file: dev/pcmcia/if_rayreg.h */ _(SIOCGRAYSIGLEV, READWRITE, struct_ifreq_sz); /* Entries from file: dev/raidframe/raidframeio.h */ _(RAIDFRAME_SHUTDOWN, NONE, 0); _(RAIDFRAME_TUR, READ, sizeof(u64)); _(RAIDFRAME_FAIL_DISK, READ, struct_rf_recon_req_sz); _(RAIDFRAME_CHECK_RECON_STATUS, READWRITE, sizeof(int)); _(RAIDFRAME_REWRITEPARITY, NONE, 0); _(RAIDFRAME_COPYBACK, NONE, 0); _(RAIDFRAME_SPARET_WAIT, WRITE, struct_RF_SparetWait_sz); _(RAIDFRAME_SEND_SPARET, READ, sizeof(uptr)); _(RAIDFRAME_ABORT_SPARET_WAIT, NONE, 0); _(RAIDFRAME_START_ATRACE, NONE, 0); _(RAIDFRAME_STOP_ATRACE, NONE, 0); _(RAIDFRAME_GET_SIZE, WRITE, sizeof(int)); _(RAIDFRAME_RESET_ACCTOTALS, NONE, 0); _(RAIDFRAME_KEEP_ACCTOTALS, READ, sizeof(int)); _(RAIDFRAME_GET_COMPONENT_LABEL, READWRITE, struct_RF_ComponentLabel_sz); _(RAIDFRAME_SET_COMPONENT_LABEL, READ, struct_RF_ComponentLabel_sz); _(RAIDFRAME_INIT_LABELS, READ, struct_RF_ComponentLabel_sz); _(RAIDFRAME_ADD_HOT_SPARE, READ, struct_RF_SingleComponent_sz); _(RAIDFRAME_REMOVE_HOT_SPARE, READ, struct_RF_SingleComponent_sz); _(RAIDFRAME_REBUILD_IN_PLACE, READ, struct_RF_SingleComponent_sz); _(RAIDFRAME_CHECK_PARITY, READWRITE, sizeof(int)); _(RAIDFRAME_CHECK_PARITYREWRITE_STATUS, READWRITE, sizeof(int)); _(RAIDFRAME_CHECK_COPYBACK_STATUS, READWRITE, sizeof(int)); _(RAIDFRAME_SET_AUTOCONFIG, READWRITE, sizeof(int)); _(RAIDFRAME_SET_ROOT, READWRITE, sizeof(int)); _(RAIDFRAME_DELETE_COMPONENT, READ, struct_RF_SingleComponent_sz); _(RAIDFRAME_INCORPORATE_HOT_SPARE, READ, struct_RF_SingleComponent_sz); _(RAIDFRAME_CHECK_RECON_STATUS_EXT, READWRITE, struct_RF_ProgressInfo_sz); _(RAIDFRAME_CHECK_PARITYREWRITE_STATUS_EXT, READWRITE, struct_RF_ProgressInfo_sz); _(RAIDFRAME_CHECK_COPYBACK_STATUS_EXT, READWRITE, struct_RF_ProgressInfo_sz); _(RAIDFRAME_PARITYMAP_STATUS, WRITE, struct_rf_pmstat_sz); _(RAIDFRAME_PARITYMAP_GET_DISABLE, WRITE, sizeof(int)); _(RAIDFRAME_PARITYMAP_SET_DISABLE, READ, sizeof(int)); _(RAIDFRAME_PARITYMAP_SET_PARAMS, READ, struct_rf_pmparams_sz); _(RAIDFRAME_SET_LAST_UNIT, READ, sizeof(int)); _(RAIDFRAME_GET_INFO, READWRITE, sizeof(uptr)); _(RAIDFRAME_CONFIGURE, READ, sizeof(uptr)); /* Entries from file: dev/sbus/mbppio.h */ _(MBPPIOCSPARAM, READ, struct_mbpp_param_sz); _(MBPPIOCGPARAM, WRITE, struct_mbpp_param_sz); _(MBPPIOCGSTAT, WRITE, sizeof(int)); /* Entries from file: dev/scsipi/ses.h */ _(SESIOC_GETNOBJ, NONE, 0); _(SESIOC_GETOBJMAP, NONE, 0); _(SESIOC_GETENCSTAT, NONE, 0); _(SESIOC_SETENCSTAT, NONE, 0); _(SESIOC_GETOBJSTAT, NONE, 0); _(SESIOC_SETOBJSTAT, NONE, 0); _(SESIOC_GETTEXT, NONE, 0); _(SESIOC_INIT, NONE, 0); /* Entries from file: dev/sun/disklabel.h */ _(SUN_DKIOCGGEOM, WRITE, struct_sun_dkgeom_sz); _(SUN_DKIOCINFO, WRITE, struct_sun_dkctlr_sz); _(SUN_DKIOCGPART, WRITE, struct_sun_dkpart_sz); /* Entries from file: dev/sun/fbio.h */ _(FBIOGTYPE, WRITE, struct_fbtype_sz); _(FBIOPUTCMAP, READ, struct_fbcmap_sz); _(FBIOGETCMAP, READ, struct_fbcmap_sz); _(FBIOGATTR, WRITE, struct_fbgattr_sz); _(FBIOSVIDEO, READ, sizeof(int)); _(FBIOGVIDEO, WRITE, sizeof(int)); _(FBIOSCURSOR, READ, struct_fbcursor_sz); _(FBIOGCURSOR, READWRITE, struct_fbcursor_sz); _(FBIOSCURPOS, READ, struct_fbcurpos_sz); _(FBIOGCURPOS, READ, struct_fbcurpos_sz); _(FBIOGCURMAX, WRITE, struct_fbcurpos_sz); /* Entries from file: dev/sun/kbio.h */ _(KIOCTRANS, READ, sizeof(int)); _(KIOCSETKEY, READWRITE, struct_okiockey_sz); _(KIOCGETKEY, READWRITE, struct_okiockey_sz); _(KIOCGTRANS, WRITE, sizeof(int)); _(KIOCCMD, READ, sizeof(int)); _(KIOCTYPE, WRITE, sizeof(int)); _(KIOCSDIRECT, READ, sizeof(int)); _(KIOCSKEY, READ, struct_kiockeymap_sz); _(KIOCGKEY, READWRITE, struct_kiockeymap_sz); _(KIOCSLED, READ, sizeof(char)); _(KIOCGLED, WRITE, sizeof(char)); _(KIOCLAYOUT, WRITE, sizeof(int)); /* Entries from file: dev/sun/vuid_event.h */ _(VUIDSFORMAT, READ, sizeof(int)); _(VUIDGFORMAT, WRITE, sizeof(int)); /* Entries from file: dev/tc/sticio.h */ _(STICIO_GXINFO, WRITE, struct_stic_xinfo_sz); _(STICIO_RESET, NONE, 0); _(STICIO_STARTQ, NONE, 0); _(STICIO_STOPQ, NONE, 0); /* Entries from file: dev/usb/ukyopon.h */ _(UKYOPON_IDENTIFY, WRITE, struct_ukyopon_identify_sz); /* Entries from file: dev/usb/urio.h */ _(URIO_SEND_COMMAND, READWRITE, struct_urio_command_sz); _(URIO_RECV_COMMAND, READWRITE, struct_urio_command_sz); /* Entries from file: dev/usb/usb.h */ _(USB_REQUEST, READWRITE, struct_usb_ctl_request_sz); _(USB_SETDEBUG, READ, sizeof(int)); _(USB_DISCOVER, NONE, 0); _(USB_DEVICEINFO, READWRITE, struct_usb_device_info_sz); _(USB_DEVICEINFO_OLD, READWRITE, struct_usb_device_info_old_sz); _(USB_DEVICESTATS, WRITE, struct_usb_device_stats_sz); _(USB_GET_REPORT_DESC, WRITE, struct_usb_ctl_report_desc_sz); _(USB_SET_IMMED, READ, sizeof(int)); _(USB_GET_REPORT, READWRITE, struct_usb_ctl_report_sz); _(USB_SET_REPORT, READ, struct_usb_ctl_report_sz); _(USB_GET_REPORT_ID, WRITE, sizeof(int)); _(USB_GET_CONFIG, WRITE, sizeof(int)); _(USB_SET_CONFIG, READ, sizeof(int)); _(USB_GET_ALTINTERFACE, READWRITE, struct_usb_alt_interface_sz); _(USB_SET_ALTINTERFACE, READWRITE, struct_usb_alt_interface_sz); _(USB_GET_NO_ALT, READWRITE, struct_usb_alt_interface_sz); _(USB_GET_DEVICE_DESC, WRITE, struct_usb_device_descriptor_sz); _(USB_GET_CONFIG_DESC, READWRITE, struct_usb_config_desc_sz); _(USB_GET_INTERFACE_DESC, READWRITE, struct_usb_interface_desc_sz); _(USB_GET_ENDPOINT_DESC, READWRITE, struct_usb_endpoint_desc_sz); _(USB_GET_FULL_DESC, READWRITE, struct_usb_full_desc_sz); _(USB_GET_STRING_DESC, READWRITE, struct_usb_string_desc_sz); _(USB_DO_REQUEST, READWRITE, struct_usb_ctl_request_sz); _(USB_GET_DEVICEINFO, WRITE, struct_usb_device_info_sz); _(USB_GET_DEVICEINFO_OLD, WRITE, struct_usb_device_info_old_sz); _(USB_SET_SHORT_XFER, READ, sizeof(int)); _(USB_SET_TIMEOUT, READ, sizeof(int)); _(USB_SET_BULK_RA, READ, sizeof(int)); _(USB_SET_BULK_WB, READ, sizeof(int)); _(USB_SET_BULK_RA_OPT, READ, struct_usb_bulk_ra_wb_opt_sz); _(USB_SET_BULK_WB_OPT, READ, struct_usb_bulk_ra_wb_opt_sz); _(USB_GET_CM_OVER_DATA, WRITE, sizeof(int)); _(USB_SET_CM_OVER_DATA, READ, sizeof(int)); /* Entries from file: dev/usb/utoppy.h */ _(UTOPPYIOTURBO, READ, sizeof(int)); _(UTOPPYIOREBOOT, NONE, 0); _(UTOPPYIOSTATS, WRITE, struct_utoppy_stats_sz); _(UTOPPYIORENAME, READ, struct_utoppy_rename_sz); _(UTOPPYIOMKDIR, READ, sizeof(uptr)); _(UTOPPYIODELETE, READ, sizeof(uptr)); _(UTOPPYIOREADDIR, READ, sizeof(uptr)); _(UTOPPYIOREADFILE, READ, struct_utoppy_readfile_sz); _(UTOPPYIOWRITEFILE, READ, struct_utoppy_writefile_sz); /* Entries from file: dev/vme/xio.h */ _(DIOSXDCMD, READWRITE, struct_xd_iocmd_sz); /* Entries from file: dev/wscons/wsdisplay_usl_io.h */ _(VT_OPENQRY, WRITE, sizeof(int)); _(VT_SETMODE, READ, struct_vt_mode_sz); _(VT_GETMODE, WRITE, struct_vt_mode_sz); _(VT_RELDISP, NONE, 0); _(VT_ACTIVATE, NONE, 0); _(VT_WAITACTIVE, NONE, 0); _(VT_GETACTIVE, WRITE, sizeof(int)); _(VT_GETSTATE, WRITE, struct_vt_stat_sz); _(KDGETKBENT, READWRITE, struct_kbentry_sz); _(KDGKBMODE, WRITE, sizeof(int)); _(KDSKBMODE, NONE, 0); _(KDMKTONE, NONE, 0); _(KDSETMODE, NONE, 0); _(KDENABIO, NONE, 0); _(KDDISABIO, NONE, 0); _(KDGKBTYPE, WRITE, sizeof(char)); _(KDGETLED, WRITE, sizeof(int)); _(KDSETLED, NONE, 0); _(KDSETRAD, NONE, 0); _(VGAPCVTID, READWRITE, struct_pcvtid_sz); _(CONS_GETVERS, WRITE, sizeof(int)); /* Entries from file: dev/wscons/wsconsio.h */ _(WSKBDIO_GTYPE, WRITE, sizeof(unsigned int)); _(WSKBDIO_BELL, NONE, 0); _(WSKBDIO_COMPLEXBELL, READ, struct_wskbd_bell_data_sz); _(WSKBDIO_SETBELL, READ, struct_wskbd_bell_data_sz); _(WSKBDIO_GETBELL, WRITE, struct_wskbd_bell_data_sz); _(WSKBDIO_SETDEFAULTBELL, READ, struct_wskbd_bell_data_sz); _(WSKBDIO_GETDEFAULTBELL, WRITE, struct_wskbd_bell_data_sz); _(WSKBDIO_SETKEYREPEAT, READ, struct_wskbd_keyrepeat_data_sz); _(WSKBDIO_GETKEYREPEAT, WRITE, struct_wskbd_keyrepeat_data_sz); _(WSKBDIO_SETDEFAULTKEYREPEAT, READ, struct_wskbd_keyrepeat_data_sz); _(WSKBDIO_GETDEFAULTKEYREPEAT, WRITE, struct_wskbd_keyrepeat_data_sz); _(WSKBDIO_SETLEDS, READ, sizeof(int)); _(WSKBDIO_GETLEDS, WRITE, sizeof(int)); _(WSKBDIO_GETMAP, READWRITE, struct_wskbd_map_data_sz); _(WSKBDIO_SETMAP, READ, struct_wskbd_map_data_sz); _(WSKBDIO_GETENCODING, WRITE, sizeof(int)); _(WSKBDIO_SETENCODING, READ, sizeof(int)); _(WSKBDIO_SETMODE, READ, sizeof(int)); _(WSKBDIO_GETMODE, WRITE, sizeof(int)); _(WSKBDIO_SETKEYCLICK, READ, sizeof(int)); _(WSKBDIO_GETKEYCLICK, WRITE, sizeof(int)); _(WSKBDIO_GETSCROLL, WRITE, struct_wskbd_scroll_data_sz); _(WSKBDIO_SETSCROLL, READ, struct_wskbd_scroll_data_sz); _(WSKBDIO_SETVERSION, READ, sizeof(int)); _(WSMOUSEIO_GTYPE, WRITE, sizeof(unsigned int)); _(WSMOUSEIO_SRES, READ, sizeof(unsigned int)); _(WSMOUSEIO_SSCALE, READ, sizeof(unsigned int)); _(WSMOUSEIO_SRATE, READ, sizeof(unsigned int)); _(WSMOUSEIO_SCALIBCOORDS, READ, struct_wsmouse_calibcoords_sz); _(WSMOUSEIO_GCALIBCOORDS, WRITE, struct_wsmouse_calibcoords_sz); _(WSMOUSEIO_GETID, READWRITE, struct_wsmouse_id_sz); _(WSMOUSEIO_GETREPEAT, WRITE, struct_wsmouse_repeat_sz); _(WSMOUSEIO_SETREPEAT, READ, struct_wsmouse_repeat_sz); _(WSMOUSEIO_SETVERSION, READ, sizeof(int)); _(WSDISPLAYIO_GTYPE, WRITE, sizeof(unsigned int)); _(WSDISPLAYIO_GINFO, WRITE, struct_wsdisplay_fbinfo_sz); _(WSDISPLAYIO_GETCMAP, READ, struct_wsdisplay_cmap_sz); _(WSDISPLAYIO_PUTCMAP, READ, struct_wsdisplay_cmap_sz); _(WSDISPLAYIO_GVIDEO, WRITE, sizeof(unsigned int)); _(WSDISPLAYIO_SVIDEO, READ, sizeof(unsigned int)); _(WSDISPLAYIO_GCURPOS, WRITE, struct_wsdisplay_curpos_sz); _(WSDISPLAYIO_SCURPOS, READ, struct_wsdisplay_curpos_sz); _(WSDISPLAYIO_GCURMAX, WRITE, struct_wsdisplay_curpos_sz); _(WSDISPLAYIO_GCURSOR, READWRITE, struct_wsdisplay_cursor_sz); _(WSDISPLAYIO_SCURSOR, READ, struct_wsdisplay_cursor_sz); _(WSDISPLAYIO_GMODE, WRITE, sizeof(unsigned int)); _(WSDISPLAYIO_SMODE, READ, sizeof(unsigned int)); _(WSDISPLAYIO_LDFONT, READ, struct_wsdisplay_font_sz); _(WSDISPLAYIO_ADDSCREEN, READ, struct_wsdisplay_addscreendata_sz); _(WSDISPLAYIO_DELSCREEN, READ, struct_wsdisplay_delscreendata_sz); _(WSDISPLAYIO_SFONT, READ, struct_wsdisplay_usefontdata_sz); _(_O_WSDISPLAYIO_SETKEYBOARD, READWRITE, struct_wsdisplay_kbddata_sz); _(WSDISPLAYIO_GETPARAM, READWRITE, struct_wsdisplay_param_sz); _(WSDISPLAYIO_SETPARAM, READWRITE, struct_wsdisplay_param_sz); _(WSDISPLAYIO_GETACTIVESCREEN, WRITE, sizeof(int)); _(WSDISPLAYIO_GETWSCHAR, READWRITE, struct_wsdisplay_char_sz); _(WSDISPLAYIO_PUTWSCHAR, READWRITE, struct_wsdisplay_char_sz); _(WSDISPLAYIO_DGSCROLL, WRITE, struct_wsdisplay_scroll_data_sz); _(WSDISPLAYIO_DSSCROLL, READ, struct_wsdisplay_scroll_data_sz); _(WSDISPLAYIO_GMSGATTRS, WRITE, struct_wsdisplay_msgattrs_sz); _(WSDISPLAYIO_SMSGATTRS, READ, struct_wsdisplay_msgattrs_sz); _(WSDISPLAYIO_GBORDER, WRITE, sizeof(int)); _(WSDISPLAYIO_SBORDER, READ, sizeof(int)); _(WSDISPLAYIO_SSPLASH, READ, sizeof(int)); _(WSDISPLAYIO_SPROGRESS, READ, sizeof(int)); _(WSDISPLAYIO_LINEBYTES, WRITE, sizeof(unsigned int)); _(WSDISPLAYIO_SETVERSION, READ, sizeof(int)); _(WSMUXIO_ADD_DEVICE, READ, struct_wsmux_device_sz); _(WSMUXIO_REMOVE_DEVICE, READ, struct_wsmux_device_sz); _(WSMUXIO_LIST_DEVICES, READWRITE, struct_wsmux_device_list_sz); _(WSMUXIO_INJECTEVENT, READ, struct_wscons_event_sz); _(WSDISPLAYIO_GET_BUSID, WRITE, struct_wsdisplayio_bus_id_sz); _(WSDISPLAYIO_GET_EDID, READWRITE, struct_wsdisplayio_edid_info_sz); _(WSDISPLAYIO_SET_POLLING, READ, sizeof(int)); _(WSDISPLAYIO_GET_FBINFO, READWRITE, struct_wsdisplayio_fbinfo_sz); _(WSDISPLAYIO_DOBLIT, READWRITE, struct_wsdisplayio_blit_sz); _(WSDISPLAYIO_WAITBLIT, READWRITE, struct_wsdisplayio_blit_sz); /* Entries from file: dev/biovar.h */ _(BIOCLOCATE, READWRITE, struct_bio_locate_sz); _(BIOCINQ, READWRITE, struct_bioc_inq_sz); _(BIOCDISK_NOVOL, READWRITE, struct_bioc_disk_sz); _(BIOCDISK, READWRITE, struct_bioc_disk_sz); _(BIOCVOL, READWRITE, struct_bioc_vol_sz); _(BIOCALARM, READWRITE, struct_bioc_alarm_sz); _(BIOCBLINK, READWRITE, struct_bioc_blink_sz); _(BIOCSETSTATE, READWRITE, struct_bioc_setstate_sz); _(BIOCVOLOPS, READWRITE, struct_bioc_volops_sz); /* Entries from file: dev/md.h */ _(MD_GETCONF, WRITE, struct_md_conf_sz); _(MD_SETCONF, READ, struct_md_conf_sz); /* Entries from file: dev/ccdvar.h */ _(CCDIOCSET, READWRITE, struct_ccd_ioctl_sz); _(CCDIOCCLR, READ, struct_ccd_ioctl_sz); /* Entries from file: dev/cgdvar.h */ _(CGDIOCSET, READWRITE, struct_cgd_ioctl_sz); _(CGDIOCCLR, READ, struct_cgd_ioctl_sz); _(CGDIOCGET, READWRITE, struct_cgd_user_sz); /* Entries from file: dev/fssvar.h */ _(FSSIOCSET, READ, struct_fss_set_sz); _(FSSIOCGET, WRITE, struct_fss_get_sz); _(FSSIOCCLR, NONE, 0); _(FSSIOFSET, READ, sizeof(int)); _(FSSIOFGET, WRITE, sizeof(int)); /* Entries from file: dev/bluetooth/btdev.h */ _(BTDEV_ATTACH, READ, struct_plistref_sz); _(BTDEV_DETACH, READ, struct_plistref_sz); /* Entries from file: dev/bluetooth/btsco.h */ _(BTSCO_GETINFO, WRITE, struct_btsco_info_sz); /* Entries from file: dev/kttcpio.h */ _(KTTCP_IO_SEND, READWRITE, struct_kttcp_io_args_sz); _(KTTCP_IO_RECV, READWRITE, struct_kttcp_io_args_sz); /* Entries from file: dev/lockstat.h */ _(IOC_LOCKSTAT_GVERSION, WRITE, sizeof(int)); _(IOC_LOCKSTAT_ENABLE, READ, struct_lsenable_sz); _(IOC_LOCKSTAT_DISABLE, WRITE, struct_lsdisable_sz); /* Entries from file: dev/vndvar.h */ _(VNDIOCSET, READWRITE, struct_vnd_ioctl_sz); _(VNDIOCCLR, READ, struct_vnd_ioctl_sz); _(VNDIOCGET, READWRITE, struct_vnd_user_sz); /* Entries from file: dev/spkrio.h */ _(SPKRTONE, READ, struct_tone_sz); _(SPKRTUNE, NONE, 0); _(SPKRGETVOL, WRITE, sizeof(unsigned int)); _(SPKRSETVOL, READ, sizeof(unsigned int)); -#if 0 /* WIP */ +#if defined(__x86_64__) /* Entries from file: dev/nvmm/nvmm_ioctl.h */ _(NVMM_IOC_CAPABILITY, WRITE, struct_nvmm_ioc_capability_sz); _(NVMM_IOC_MACHINE_CREATE, READWRITE, struct_nvmm_ioc_machine_create_sz); _(NVMM_IOC_MACHINE_DESTROY, READ, struct_nvmm_ioc_machine_destroy_sz); _(NVMM_IOC_MACHINE_CONFIGURE, READ, struct_nvmm_ioc_machine_configure_sz); _(NVMM_IOC_VCPU_CREATE, READ, struct_nvmm_ioc_vcpu_create_sz); _(NVMM_IOC_VCPU_DESTROY, READ, struct_nvmm_ioc_vcpu_destroy_sz); _(NVMM_IOC_VCPU_SETSTATE, READ, struct_nvmm_ioc_vcpu_setstate_sz); _(NVMM_IOC_VCPU_GETSTATE, READ, struct_nvmm_ioc_vcpu_getstate_sz); _(NVMM_IOC_VCPU_INJECT, READ, struct_nvmm_ioc_vcpu_inject_sz); _(NVMM_IOC_VCPU_RUN, READWRITE, struct_nvmm_ioc_vcpu_run_sz); _(NVMM_IOC_GPA_MAP, READ, struct_nvmm_ioc_gpa_map_sz); _(NVMM_IOC_GPA_UNMAP, READ, struct_nvmm_ioc_gpa_unmap_sz); _(NVMM_IOC_HVA_MAP, READ, struct_nvmm_ioc_hva_map_sz); _(NVMM_IOC_HVA_UNMAP, READ, struct_nvmm_ioc_hva_unmap_sz); + _(NVMM_IOC_CTL, READ, struct_nvmm_ioc_ctl_sz); #endif + /* Entries from file: dev/spi/spi_io.h */ + _(SPI_IOCTL_CONFIGURE, READ, struct_spi_ioctl_configure_sz); + _(SPI_IOCTL_TRANSFER, READ, struct_spi_ioctl_transfer_sz); /* Entries from file: fs/autofs/autofs_ioctl.h */ _(AUTOFSREQUEST, WRITE, struct_autofs_daemon_request_sz); _(AUTOFSDONE, READ, struct_autofs_daemon_done_sz); /* Entries from file: net/bpf.h */ _(BIOCGBLEN, WRITE, sizeof(unsigned int)); _(BIOCSBLEN, READWRITE, sizeof(unsigned int)); _(BIOCSETF, READ, struct_bpf_program_sz); _(BIOCFLUSH, NONE, 0); _(BIOCPROMISC, NONE, 0); _(BIOCGDLT, WRITE, sizeof(unsigned int)); _(BIOCGETIF, WRITE, struct_ifreq_sz); _(BIOCSETIF, READ, struct_ifreq_sz); _(BIOCGSTATS, WRITE, struct_bpf_stat_sz); _(BIOCGSTATSOLD, WRITE, struct_bpf_stat_old_sz); _(BIOCIMMEDIATE, READ, sizeof(unsigned int)); _(BIOCVERSION, WRITE, struct_bpf_version_sz); _(BIOCSTCPF, READ, struct_bpf_program_sz); _(BIOCSUDPF, READ, struct_bpf_program_sz); _(BIOCGHDRCMPLT, WRITE, sizeof(unsigned int)); _(BIOCSHDRCMPLT, READ, sizeof(unsigned int)); _(BIOCSDLT, READ, sizeof(unsigned int)); _(BIOCGDLTLIST, READWRITE, struct_bpf_dltlist_sz); _(BIOCGDIRECTION, WRITE, sizeof(unsigned int)); _(BIOCSDIRECTION, READ, sizeof(unsigned int)); _(BIOCSRTIMEOUT, READ, struct_timeval_sz); _(BIOCGRTIMEOUT, WRITE, struct_timeval_sz); _(BIOCGFEEDBACK, WRITE, sizeof(unsigned int)); _(BIOCSFEEDBACK, READ, sizeof(unsigned int)); /* Entries from file: net/if_gre.h */ _(GRESADDRS, READ, struct_ifreq_sz); _(GRESADDRD, READ, struct_ifreq_sz); _(GREGADDRS, READWRITE, struct_ifreq_sz); _(GREGADDRD, READWRITE, struct_ifreq_sz); _(GRESPROTO, READ, struct_ifreq_sz); _(GREGPROTO, READWRITE, struct_ifreq_sz); _(GRESSOCK, READ, struct_ifreq_sz); _(GREDSOCK, READ, struct_ifreq_sz); /* Entries from file: net/if_ppp.h */ _(PPPIOCGRAWIN, WRITE, struct_ppp_rawin_sz); _(PPPIOCGFLAGS, WRITE, sizeof(int)); _(PPPIOCSFLAGS, READ, sizeof(int)); _(PPPIOCGASYNCMAP, WRITE, sizeof(int)); _(PPPIOCSASYNCMAP, READ, sizeof(int)); _(PPPIOCGUNIT, WRITE, sizeof(int)); _(PPPIOCGRASYNCMAP, WRITE, sizeof(int)); _(PPPIOCSRASYNCMAP, READ, sizeof(int)); _(PPPIOCGMRU, WRITE, sizeof(int)); _(PPPIOCSMRU, READ, sizeof(int)); _(PPPIOCSMAXCID, READ, sizeof(int)); _(PPPIOCGXASYNCMAP, WRITE, (8 * sizeof(u32))); _(PPPIOCSXASYNCMAP, READ, (8 * sizeof(u32))); _(PPPIOCXFERUNIT, NONE, 0); _(PPPIOCSCOMPRESS, READ, struct_ppp_option_data_sz); _(PPPIOCGNPMODE, READWRITE, struct_npioctl_sz); _(PPPIOCSNPMODE, READ, struct_npioctl_sz); _(PPPIOCGIDLE, WRITE, struct_ppp_idle_sz); _(PPPIOCGMTU, WRITE, sizeof(int)); _(PPPIOCSMTU, READ, sizeof(int)); _(SIOCGPPPSTATS, READWRITE, struct_ifpppstatsreq_sz); _(SIOCGPPPCSTATS, READWRITE, struct_ifpppcstatsreq_sz); /* Entries from file: net/npf.h */ _(IOC_NPF_VERSION, WRITE, sizeof(int)); _(IOC_NPF_SWITCH, READ, sizeof(int)); _(IOC_NPF_LOAD, READWRITE, struct_nvlist_ref_sz); _(IOC_NPF_TABLE, READ, struct_npf_ioctl_table_sz); _(IOC_NPF_STATS, READ, sizeof(uptr)); _(IOC_NPF_SAVE, WRITE, struct_nvlist_ref_sz); _(IOC_NPF_RULE, READWRITE, struct_nvlist_ref_sz); _(IOC_NPF_CONN_LOOKUP, READWRITE, struct_nvlist_ref_sz); /* Entries from file: net/if_pppoe.h */ _(PPPOESETPARMS, READ, struct_pppoediscparms_sz); _(PPPOEGETPARMS, READWRITE, struct_pppoediscparms_sz); _(PPPOEGETSESSION, READWRITE, struct_pppoeconnectionstate_sz); /* Entries from file: net/if_sppp.h */ _(SPPPGETAUTHCFG, READWRITE, struct_spppauthcfg_sz); _(SPPPSETAUTHCFG, READ, struct_spppauthcfg_sz); _(SPPPGETLCPCFG, READWRITE, struct_sppplcpcfg_sz); _(SPPPSETLCPCFG, READ, struct_sppplcpcfg_sz); _(SPPPGETSTATUS, READWRITE, struct_spppstatus_sz); _(SPPPGETSTATUSNCP, READWRITE, struct_spppstatusncp_sz); _(SPPPGETIDLETO, READWRITE, struct_spppidletimeout_sz); _(SPPPSETIDLETO, READ, struct_spppidletimeout_sz); _(SPPPGETAUTHFAILURES, READWRITE, struct_spppauthfailurestats_sz); _(SPPPSETAUTHFAILURE, READ, struct_spppauthfailuresettings_sz); _(SPPPSETDNSOPTS, READ, struct_spppdnssettings_sz); _(SPPPGETDNSOPTS, READWRITE, struct_spppdnssettings_sz); _(SPPPGETDNSADDRS, READWRITE, struct_spppdnsaddrs_sz); _(SPPPSETKEEPALIVE, READ, struct_spppkeepalivesettings_sz); _(SPPPGETKEEPALIVE, READWRITE, struct_spppkeepalivesettings_sz); /* Entries from file: net/if_srt.h */ _(SRT_GETNRT, WRITE, sizeof(unsigned int)); _(SRT_GETRT, READWRITE, struct_srt_rt_sz); _(SRT_SETRT, READ, struct_srt_rt_sz); _(SRT_DELRT, READ, sizeof(unsigned int)); _(SRT_SFLAGS, READ, sizeof(unsigned int)); _(SRT_GFLAGS, WRITE, sizeof(unsigned int)); _(SRT_SGFLAGS, READWRITE, sizeof(unsigned int)); _(SRT_DEBUG, READ, sizeof(uptr)); /* Entries from file: net/if_tap.h */ _(TAPGIFNAME, WRITE, struct_ifreq_sz); /* Entries from file: net/if_tun.h */ _(TUNSDEBUG, READ, sizeof(int)); _(TUNGDEBUG, WRITE, sizeof(int)); _(TUNSIFMODE, READ, sizeof(int)); _(TUNSIFHEAD, READ, sizeof(int)); _(TUNGIFHEAD, WRITE, sizeof(int)); /* Entries from file: net/pfvar.h */ _(DIOCSTART, NONE, 0); _(DIOCSTOP, NONE, 0); _(DIOCADDRULE, READWRITE, struct_pfioc_rule_sz); _(DIOCGETRULES, READWRITE, struct_pfioc_rule_sz); _(DIOCGETRULE, READWRITE, struct_pfioc_rule_sz); _(DIOCSETLCK, READWRITE, sizeof(u32)); _(DIOCCLRSTATES, READWRITE, struct_pfioc_state_kill_sz); _(DIOCGETSTATE, READWRITE, struct_pfioc_state_sz); _(DIOCSETSTATUSIF, READWRITE, struct_pfioc_if_sz); _(DIOCGETSTATUS, READWRITE, struct_pf_status_sz); _(DIOCCLRSTATUS, NONE, 0); _(DIOCNATLOOK, READWRITE, struct_pfioc_natlook_sz); _(DIOCSETDEBUG, READWRITE, sizeof(u32)); _(DIOCGETSTATES, READWRITE, struct_pfioc_states_sz); _(DIOCCHANGERULE, READWRITE, struct_pfioc_rule_sz); _(DIOCSETTIMEOUT, READWRITE, struct_pfioc_tm_sz); _(DIOCGETTIMEOUT, READWRITE, struct_pfioc_tm_sz); _(DIOCADDSTATE, READWRITE, struct_pfioc_state_sz); _(DIOCCLRRULECTRS, NONE, 0); _(DIOCGETLIMIT, READWRITE, struct_pfioc_limit_sz); _(DIOCSETLIMIT, READWRITE, struct_pfioc_limit_sz); _(DIOCKILLSTATES, READWRITE, struct_pfioc_state_kill_sz); _(DIOCSTARTALTQ, NONE, 0); _(DIOCSTOPALTQ, NONE, 0); _(DIOCADDALTQ, READWRITE, struct_pfioc_altq_sz); _(DIOCGETALTQS, READWRITE, struct_pfioc_altq_sz); _(DIOCGETALTQ, READWRITE, struct_pfioc_altq_sz); _(DIOCCHANGEALTQ, READWRITE, struct_pfioc_altq_sz); _(DIOCGETQSTATS, READWRITE, struct_pfioc_qstats_sz); _(DIOCBEGINADDRS, READWRITE, struct_pfioc_pooladdr_sz); _(DIOCADDADDR, READWRITE, struct_pfioc_pooladdr_sz); _(DIOCGETADDRS, READWRITE, struct_pfioc_pooladdr_sz); _(DIOCGETADDR, READWRITE, struct_pfioc_pooladdr_sz); _(DIOCCHANGEADDR, READWRITE, struct_pfioc_pooladdr_sz); _(DIOCADDSTATES, READWRITE, struct_pfioc_states_sz); _(DIOCGETRULESETS, READWRITE, struct_pfioc_ruleset_sz); _(DIOCGETRULESET, READWRITE, struct_pfioc_ruleset_sz); _(DIOCRCLRTABLES, READWRITE, struct_pfioc_table_sz); _(DIOCRADDTABLES, READWRITE, struct_pfioc_table_sz); _(DIOCRDELTABLES, READWRITE, struct_pfioc_table_sz); _(DIOCRGETTABLES, READWRITE, struct_pfioc_table_sz); _(DIOCRGETTSTATS, READWRITE, struct_pfioc_table_sz); _(DIOCRCLRTSTATS, READWRITE, struct_pfioc_table_sz); _(DIOCRCLRADDRS, READWRITE, struct_pfioc_table_sz); _(DIOCRADDADDRS, READWRITE, struct_pfioc_table_sz); _(DIOCRDELADDRS, READWRITE, struct_pfioc_table_sz); _(DIOCRSETADDRS, READWRITE, struct_pfioc_table_sz); _(DIOCRGETADDRS, READWRITE, struct_pfioc_table_sz); _(DIOCRGETASTATS, READWRITE, struct_pfioc_table_sz); _(DIOCRCLRASTATS, READWRITE, struct_pfioc_table_sz); _(DIOCRTSTADDRS, READWRITE, struct_pfioc_table_sz); _(DIOCRSETTFLAGS, READWRITE, struct_pfioc_table_sz); _(DIOCRINADEFINE, READWRITE, struct_pfioc_table_sz); _(DIOCOSFPFLUSH, NONE, 0); _(DIOCOSFPADD, READWRITE, struct_pf_osfp_ioctl_sz); _(DIOCOSFPGET, READWRITE, struct_pf_osfp_ioctl_sz); _(DIOCXBEGIN, READWRITE, struct_pfioc_trans_sz); _(DIOCXCOMMIT, READWRITE, struct_pfioc_trans_sz); _(DIOCXROLLBACK, READWRITE, struct_pfioc_trans_sz); _(DIOCGETSRCNODES, READWRITE, struct_pfioc_src_nodes_sz); _(DIOCCLRSRCNODES, NONE, 0); _(DIOCSETHOSTID, READWRITE, sizeof(u32)); _(DIOCIGETIFACES, READWRITE, struct_pfioc_iface_sz); _(DIOCSETIFFLAG, READWRITE, struct_pfioc_iface_sz); _(DIOCCLRIFFLAG, READWRITE, struct_pfioc_iface_sz); _(DIOCKILLSRCNODES, READWRITE, struct_pfioc_src_node_kill_sz); /* Entries from file: netbt/hci.h */ _(SIOCGBTINFO, READWRITE, struct_btreq_sz); _(SIOCGBTINFOA, READWRITE, struct_btreq_sz); _(SIOCNBTINFO, READWRITE, struct_btreq_sz); _(SIOCSBTFLAGS, READWRITE, struct_btreq_sz); _(SIOCSBTPOLICY, READWRITE, struct_btreq_sz); _(SIOCSBTPTYPE, READWRITE, struct_btreq_sz); _(SIOCGBTSTATS, READWRITE, struct_btreq_sz); _(SIOCZBTSTATS, READWRITE, struct_btreq_sz); _(SIOCBTDUMP, READ, struct_btreq_sz); _(SIOCSBTSCOMTU, READWRITE, struct_btreq_sz); _(SIOCGBTFEAT, READWRITE, struct_btreq_sz); /* Entries from file: netinet/ip_nat.h */ _(SIOCADNAT, READ, struct_ipfobj_sz); _(SIOCRMNAT, READ, struct_ipfobj_sz); _(SIOCGNATS, READWRITE, struct_ipfobj_sz); _(SIOCGNATL, READWRITE, struct_ipfobj_sz); _(SIOCPURGENAT, READWRITE, struct_ipfobj_sz); /* Entries from file: netinet/sctp_uio.h */ _(SIOCCONNECTX, READWRITE, struct_sctp_connectx_addrs_sz); _(SIOCCONNECTXDEL, READWRITE, struct_sctp_connectx_addrs_sz); /* Entries from file: netinet6/in6_var.h */ _(SIOCSIFINFO_FLAGS, READWRITE, struct_in6_ndireq_sz); _(SIOCAADDRCTL_POLICY, READ, struct_in6_addrpolicy_sz); _(SIOCDADDRCTL_POLICY, READ, struct_in6_addrpolicy_sz); /* Entries from file: netsmb/smb_dev.h */ _(SMBIOC_OPENSESSION, READ, struct_smbioc_ossn_sz); _(SMBIOC_OPENSHARE, READ, struct_smbioc_oshare_sz); _(SMBIOC_REQUEST, READWRITE, struct_smbioc_rq_sz); _(SMBIOC_SETFLAGS, READ, struct_smbioc_flags_sz); _(SMBIOC_LOOKUP, READ, struct_smbioc_lookup_sz); _(SMBIOC_READ, READWRITE, struct_smbioc_rw_sz); _(SMBIOC_WRITE, READWRITE, struct_smbioc_rw_sz); /* Entries from file: sys/agpio.h */ _(AGPIOC_INFO, WRITE, struct__agp_info_sz); _(AGPIOC_ACQUIRE, NONE, 0); _(AGPIOC_RELEASE, NONE, 0); _(AGPIOC_SETUP, READ, struct__agp_setup_sz); _(AGPIOC_ALLOCATE, READWRITE, struct__agp_allocate_sz); _(AGPIOC_DEALLOCATE, READ, sizeof(int)); _(AGPIOC_BIND, READ, struct__agp_bind_sz); _(AGPIOC_UNBIND, READ, struct__agp_unbind_sz); /* Entries from file: sys/audioio.h */ _(AUDIO_GETINFO, WRITE, struct_audio_info_sz); _(AUDIO_SETINFO, READWRITE, struct_audio_info_sz); _(AUDIO_DRAIN, NONE, 0); _(AUDIO_FLUSH, NONE, 0); _(AUDIO_WSEEK, WRITE, sizeof(unsigned long)); _(AUDIO_RERROR, WRITE, sizeof(int)); _(AUDIO_GETDEV, WRITE, struct_audio_device_sz); _(AUDIO_GETENC, READWRITE, struct_audio_encoding_sz); _(AUDIO_GETFD, WRITE, sizeof(int)); _(AUDIO_SETFD, READWRITE, sizeof(int)); _(AUDIO_PERROR, WRITE, sizeof(int)); _(AUDIO_GETIOFFS, WRITE, struct_audio_offset_sz); _(AUDIO_GETOOFFS, WRITE, struct_audio_offset_sz); _(AUDIO_GETPROPS, WRITE, sizeof(int)); _(AUDIO_GETBUFINFO, WRITE, struct_audio_info_sz); _(AUDIO_SETCHAN, READ, sizeof(int)); _(AUDIO_GETCHAN, WRITE, sizeof(int)); + _(AUDIO_QUERYFORMAT, READWRITE, struct_audio_format_query_sz); + _(AUDIO_GETFORMAT, WRITE, struct_audio_info_sz); + _(AUDIO_SETFORMAT, READ, struct_audio_info_sz); _(AUDIO_MIXER_READ, READWRITE, struct_mixer_ctrl_sz); _(AUDIO_MIXER_WRITE, READWRITE, struct_mixer_ctrl_sz); _(AUDIO_MIXER_DEVINFO, READWRITE, struct_mixer_devinfo_sz); /* Entries from file: sys/ataio.h */ _(ATAIOCCOMMAND, READWRITE, struct_atareq_sz); _(ATABUSIOSCAN, READ, struct_atabusioscan_args_sz); _(ATABUSIORESET, NONE, 0); _(ATABUSIODETACH, READ, struct_atabusiodetach_args_sz); /* Entries from file: sys/cdio.h */ _(CDIOCPLAYTRACKS, READ, struct_ioc_play_track_sz); _(CDIOCPLAYBLOCKS, READ, struct_ioc_play_blocks_sz); _(CDIOCREADSUBCHANNEL, READWRITE, struct_ioc_read_subchannel_sz); _(CDIOREADTOCHEADER, WRITE, struct_ioc_toc_header_sz); _(CDIOREADTOCENTRIES, READWRITE, struct_ioc_read_toc_entry_sz); _(CDIOREADMSADDR, READWRITE, sizeof(int)); _(CDIOCSETPATCH, READ, struct_ioc_patch_sz); _(CDIOCGETVOL, WRITE, struct_ioc_vol_sz); _(CDIOCSETVOL, READ, struct_ioc_vol_sz); _(CDIOCSETMONO, NONE, 0); _(CDIOCSETSTEREO, NONE, 0); _(CDIOCSETMUTE, NONE, 0); _(CDIOCSETLEFT, NONE, 0); _(CDIOCSETRIGHT, NONE, 0); _(CDIOCSETDEBUG, NONE, 0); _(CDIOCCLRDEBUG, NONE, 0); _(CDIOCPAUSE, NONE, 0); _(CDIOCRESUME, NONE, 0); _(CDIOCRESET, NONE, 0); _(CDIOCSTART, NONE, 0); _(CDIOCSTOP, NONE, 0); _(CDIOCEJECT, NONE, 0); _(CDIOCALLOW, NONE, 0); _(CDIOCPREVENT, NONE, 0); _(CDIOCCLOSE, NONE, 0); _(CDIOCPLAYMSF, READ, struct_ioc_play_msf_sz); _(CDIOCLOADUNLOAD, READ, struct_ioc_load_unload_sz); /* Entries from file: sys/chio.h */ _(CHIOMOVE, READ, struct_changer_move_request_sz); _(CHIOEXCHANGE, READ, struct_changer_exchange_request_sz); _(CHIOPOSITION, READ, struct_changer_position_request_sz); _(CHIOSPICKER, READ, sizeof(int)); _(CHIOGPARAMS, WRITE, struct_changer_params_sz); _(CHIOIELEM, NONE, 0); _(OCHIOGSTATUS, READ, struct_ochanger_element_status_request_sz); _(CHIOGSTATUS, READ, struct_changer_element_status_request_sz); _(CHIOSVOLTAG, READ, struct_changer_set_voltag_request_sz); /* Entries from file: sys/clockctl.h */ _(CLOCKCTL_SETTIMEOFDAY, READ, struct_clockctl_settimeofday_sz); _(CLOCKCTL_ADJTIME, READWRITE, struct_clockctl_adjtime_sz); _(CLOCKCTL_CLOCK_SETTIME, READ, struct_clockctl_clock_settime_sz); _(CLOCKCTL_NTP_ADJTIME, READWRITE, struct_clockctl_ntp_adjtime_sz); /* Entries from file: sys/cpuio.h */ _(IOC_CPU_SETSTATE, READ, struct_cpustate_sz); _(IOC_CPU_GETSTATE, READWRITE, struct_cpustate_sz); _(IOC_CPU_GETCOUNT, WRITE, sizeof(int)); _(IOC_CPU_MAPID, READWRITE, sizeof(int)); _(IOC_CPU_UCODE_GET_VERSION, READWRITE, struct_cpu_ucode_version_sz); _(IOC_CPU_UCODE_APPLY, READ, struct_cpu_ucode_sz); /* Entries from file: sys/dkio.h */ _(DIOCGDINFO, WRITE, struct_disklabel_sz); _(DIOCSDINFO, READ, struct_disklabel_sz); _(DIOCWDINFO, READ, 0); _(DIOCRFORMAT, READWRITE, struct_format_op_sz); _(DIOCWFORMAT, READWRITE, struct_format_op_sz); _(DIOCSSTEP, READ, sizeof(int)); _(DIOCSRETRIES, READ, sizeof(int)); _(DIOCKLABEL, READ, sizeof(int)); _(DIOCWLABEL, READ, sizeof(int)); _(DIOCSBAD, READ, struct_dkbad_sz); _(DIOCEJECT, READ, sizeof(int)); _(ODIOCEJECT, NONE, 0); _(DIOCLOCK, READ, sizeof(int)); _(DIOCGDEFLABEL, WRITE, struct_disklabel_sz); _(DIOCCLRLABEL, NONE, 0); _(DIOCGCACHE, WRITE, sizeof(int)); _(DIOCSCACHE, READ, sizeof(int)); _(DIOCCACHESYNC, READ, sizeof(int)); _(DIOCBSLIST, READWRITE, struct_disk_badsecinfo_sz); _(DIOCBSFLUSH, NONE, 0); _(DIOCAWEDGE, READWRITE, struct_dkwedge_info_sz); _(DIOCGWEDGEINFO, WRITE, struct_dkwedge_info_sz); _(DIOCDWEDGE, READ, struct_dkwedge_info_sz); _(DIOCLWEDGES, READWRITE, struct_dkwedge_list_sz); _(DIOCGSTRATEGY, WRITE, struct_disk_strategy_sz); _(DIOCSSTRATEGY, READ, struct_disk_strategy_sz); _(DIOCGDISKINFO, WRITE, struct_plistref_sz); _(DIOCTUR, WRITE, sizeof(int)); _(DIOCMWEDGES, WRITE, sizeof(int)); _(DIOCGSECTORSIZE, WRITE, sizeof(unsigned int)); _(DIOCGMEDIASIZE, WRITE, sizeof(uptr)); + _(DIOCRMWEDGES, WRITE, sizeof(int)); /* Entries from file: sys/drvctlio.h */ _(DRVDETACHDEV, READ, struct_devdetachargs_sz); _(DRVRESCANBUS, READ, struct_devrescanargs_sz); _(DRVCTLCOMMAND, READWRITE, struct_plistref_sz); _(DRVRESUMEDEV, READ, struct_devpmargs_sz); _(DRVLISTDEV, READWRITE, struct_devlistargs_sz); _(DRVGETEVENT, WRITE, struct_plistref_sz); _(DRVSUSPENDDEV, READ, struct_devpmargs_sz); /* Entries from file: sys/dvdio.h */ _(DVD_READ_STRUCT, READWRITE, union_dvd_struct_sz); _(DVD_WRITE_STRUCT, READWRITE, union_dvd_struct_sz); _(DVD_AUTH, READWRITE, union_dvd_authinfo_sz); /* Entries from file: sys/envsys.h */ _(ENVSYS_GETDICTIONARY, READWRITE, struct_plistref_sz); _(ENVSYS_SETDICTIONARY, READWRITE, struct_plistref_sz); _(ENVSYS_REMOVEPROPS, READWRITE, struct_plistref_sz); _(ENVSYS_GTREDATA, READWRITE, struct_envsys_tre_data_sz); _(ENVSYS_GTREINFO, READWRITE, struct_envsys_basic_info_sz); /* Entries from file: sys/event.h */ _(KFILTER_BYFILTER, READWRITE, struct_kfilter_mapping_sz); _(KFILTER_BYNAME, READWRITE, struct_kfilter_mapping_sz); /* Entries from file: sys/fdio.h */ _(FDIOCGETOPTS, WRITE, 0); _(FDIOCSETOPTS, READ, sizeof(int)); _(FDIOCSETFORMAT, READ, struct_fdformat_parms_sz); _(FDIOCGETFORMAT, WRITE, struct_fdformat_parms_sz); _(FDIOCFORMAT_TRACK, READ, struct_fdformat_cmd_sz); /* Entries from file: sys/filio.h */ _(FIOCLEX, NONE, 0); _(FIONCLEX, NONE, 0); _(FIOSEEKDATA, READWRITE, sizeof(uptr)); _(FIOSEEKHOLE, READWRITE, sizeof(uptr)); _(FIONREAD, WRITE, sizeof(int)); _(FIONBIO, READ, sizeof(int)); _(FIOASYNC, READ, sizeof(int)); _(FIOSETOWN, READ, sizeof(int)); _(FIOGETOWN, WRITE, sizeof(int)); _(OFIOGETBMAP, READWRITE, sizeof(u32)); _(FIOGETBMAP, READWRITE, sizeof(u64)); _(FIONWRITE, WRITE, sizeof(int)); _(FIONSPACE, WRITE, sizeof(int)); /* Entries from file: sys/gpio.h */ _(GPIOINFO, WRITE, struct_gpio_info_sz); _(GPIOSET, READWRITE, struct_gpio_set_sz); _(GPIOUNSET, READWRITE, struct_gpio_set_sz); _(GPIOREAD, READWRITE, struct_gpio_req_sz); _(GPIOWRITE, READWRITE, struct_gpio_req_sz); _(GPIOTOGGLE, READWRITE, struct_gpio_req_sz); _(GPIOATTACH, READWRITE, struct_gpio_attach_sz); /* Entries from file: sys/ioctl.h */ _(PTIOCNETBSD, READ, struct_ioctl_pt_sz); _(PTIOCSUNOS, READ, struct_ioctl_pt_sz); _(PTIOCLINUX, READ, struct_ioctl_pt_sz); _(PTIOCFREEBSD, READ, struct_ioctl_pt_sz); _(PTIOCULTRIX, READ, struct_ioctl_pt_sz); /* Entries from file: sys/ioctl_compat.h */ _(TIOCHPCL, NONE, 0); _(TIOCGETP, WRITE, struct_sgttyb_sz); _(TIOCSETP, READ, struct_sgttyb_sz); _(TIOCSETN, READ, 0); _(TIOCSETC, READ, struct_tchars_sz); _(TIOCGETC, WRITE, struct_tchars_sz); _(TIOCLBIS, READ, sizeof(int)); _(TIOCLBIC, READ, sizeof(int)); _(TIOCLSET, READ, sizeof(int)); _(TIOCLGET, WRITE, sizeof(int)); _(TIOCSLTC, READ, struct_ltchars_sz); _(TIOCGLTC, WRITE, struct_ltchars_sz); _(OTIOCCONS, NONE, 0); /* Entries from file: sys/joystick.h */ _(JOY_SETTIMEOUT, READ, sizeof(int)); _(JOY_GETTIMEOUT, WRITE, sizeof(int)); _(JOY_SET_X_OFFSET, READ, sizeof(int)); _(JOY_SET_Y_OFFSET, READ, sizeof(int)); _(JOY_GET_Y_OFFSET, WRITE, sizeof(int)); /* Entries from file: sys/ksyms.h */ _(OKIOCGSYMBOL, READ, struct_ksyms_ogsymbol_sz); _(OKIOCGVALUE, READ, struct_ksyms_ogsymbol_sz); _(KIOCGSIZE, WRITE, sizeof(int)); _(KIOCGVALUE, READWRITE, struct_ksyms_gvalue_sz); _(KIOCGSYMBOL, READWRITE, struct_ksyms_gsymbol_sz); /* Entries from file: sys/lua.h */ _(LUAINFO, READWRITE, struct_lua_info_sz); _(LUACREATE, READWRITE, struct_lua_create_sz); _(LUADESTROY, READWRITE, struct_lua_create_sz); _(LUAREQUIRE, READWRITE, struct_lua_require_sz); _(LUALOAD, READWRITE, struct_lua_load_sz); /* Entries from file: sys/midiio.h */ _(MIDI_PRETIME, READWRITE, sizeof(int)); _(MIDI_MPUMODE, READWRITE, sizeof(int)); _(MIDI_MPUCMD, READWRITE, struct_mpu_command_rec_sz); _(SEQUENCER_RESET, NONE, 0); _(SEQUENCER_SYNC, NONE, 0); _(SEQUENCER_INFO, READWRITE, struct_synth_info_sz); _(SEQUENCER_CTRLRATE, READWRITE, sizeof(int)); _(SEQUENCER_GETOUTCOUNT, WRITE, sizeof(int)); _(SEQUENCER_GETINCOUNT, WRITE, sizeof(int)); _(SEQUENCER_RESETSAMPLES, READ, sizeof(int)); _(SEQUENCER_NRSYNTHS, WRITE, sizeof(int)); _(SEQUENCER_NRMIDIS, WRITE, sizeof(int)); _(SEQUENCER_THRESHOLD, READ, sizeof(int)); _(SEQUENCER_MEMAVL, READWRITE, sizeof(int)); _(SEQUENCER_PANIC, NONE, 0); _(SEQUENCER_OUTOFBAND, READ, struct_seq_event_rec_sz); _(SEQUENCER_GETTIME, WRITE, sizeof(int)); _(SEQUENCER_TMR_TIMEBASE, READWRITE, sizeof(int)); _(SEQUENCER_TMR_START, NONE, 0); _(SEQUENCER_TMR_STOP, NONE, 0); _(SEQUENCER_TMR_CONTINUE, NONE, 0); _(SEQUENCER_TMR_TEMPO, READWRITE, sizeof(int)); _(SEQUENCER_TMR_SOURCE, READWRITE, sizeof(int)); _(SEQUENCER_TMR_METRONOME, READ, sizeof(int)); _(SEQUENCER_TMR_SELECT, READ, sizeof(int)); /* Entries from file: sys/mtio.h */ _(MTIOCTOP, READ, struct_mtop_sz); _(MTIOCGET, WRITE, struct_mtget_sz); _(MTIOCIEOT, NONE, 0); _(MTIOCEEOT, NONE, 0); _(MTIOCRDSPOS, WRITE, sizeof(u32)); _(MTIOCRDHPOS, WRITE, sizeof(u32)); _(MTIOCSLOCATE, READ, sizeof(u32)); _(MTIOCHLOCATE, READ, sizeof(u32)); /* Entries from file: sys/power.h */ _(POWER_EVENT_RECVDICT, READWRITE, struct_plistref_sz); _(POWER_IOC_GET_TYPE, WRITE, struct_power_type_sz); /* Entries from file: sys/radioio.h */ _(RIOCGINFO, WRITE, struct_radio_info_sz); _(RIOCSINFO, READWRITE, struct_radio_info_sz); _(RIOCSSRCH, READ, sizeof(int)); /* Entries from file: sys/rndio.h */ _(RNDGETENTCNT, WRITE, sizeof(u32)); _(RNDGETSRCNUM, READWRITE, struct_rndstat_sz); _(RNDGETSRCNAME, READWRITE, struct_rndstat_name_sz); _(RNDCTL, READ, struct_rndctl_sz); _(RNDADDDATA, READ, struct_rnddata_sz); _(RNDGETPOOLSTAT, WRITE, struct_rndpoolstat_sz); _(RNDGETESTNUM, READWRITE, struct_rndstat_est_sz); _(RNDGETESTNAME, READWRITE, struct_rndstat_est_name_sz); /* Entries from file: sys/scanio.h */ _(SCIOCGET, WRITE, struct_scan_io_sz); _(SCIOCSET, READ, struct_scan_io_sz); _(SCIOCRESTART, NONE, 0); /* Entries from file: sys/scsiio.h */ _(SCIOCCOMMAND, READWRITE, struct_scsireq_sz); _(SCIOCDEBUG, READ, sizeof(int)); _(SCIOCIDENTIFY, WRITE, struct_scsi_addr_sz); _(OSCIOCIDENTIFY, WRITE, struct_oscsi_addr_sz); _(SCIOCDECONFIG, NONE, 0); _(SCIOCRECONFIG, NONE, 0); _(SCIOCRESET, NONE, 0); _(SCBUSIOSCAN, READ, struct_scbusioscan_args_sz); _(SCBUSIORESET, NONE, 0); _(SCBUSIODETACH, READ, struct_scbusiodetach_args_sz); _(SCBUSACCEL, READ, struct_scbusaccel_args_sz); /* Entries from file: sys/sockio.h */ _(SIOCSHIWAT, READ, sizeof(int)); _(SIOCGHIWAT, WRITE, sizeof(int)); _(SIOCSLOWAT, READ, sizeof(int)); _(SIOCGLOWAT, WRITE, sizeof(int)); _(SIOCATMARK, WRITE, sizeof(int)); _(SIOCSPGRP, READ, sizeof(int)); _(SIOCGPGRP, WRITE, sizeof(int)); _(SIOCPEELOFF, READWRITE, sizeof(int)); _(SIOCADDRT, READ, struct_ortentry_sz); _(SIOCDELRT, READ, struct_ortentry_sz); _(SIOCSIFADDR, READ, struct_ifreq_sz); _(SIOCGIFADDR, READWRITE, struct_ifreq_sz); _(SIOCSIFDSTADDR, READ, struct_ifreq_sz); _(SIOCGIFDSTADDR, READWRITE, struct_ifreq_sz); _(SIOCSIFFLAGS, READ, struct_ifreq_sz); _(SIOCGIFFLAGS, READWRITE, struct_ifreq_sz); _(SIOCGIFBRDADDR, READWRITE, struct_ifreq_sz); _(SIOCSIFBRDADDR, READ, struct_ifreq_sz); _(SIOCGIFCONF, READWRITE, struct_ifconf_sz); _(SIOCGIFNETMASK, READWRITE, struct_ifreq_sz); _(SIOCSIFNETMASK, READ, struct_ifreq_sz); _(SIOCGIFMETRIC, READWRITE, struct_ifreq_sz); _(SIOCSIFMETRIC, READ, struct_ifreq_sz); _(SIOCDIFADDR, READ, struct_ifreq_sz); _(SIOCAIFADDR, READ, struct_ifaliasreq_sz); _(SIOCGIFALIAS, READWRITE, struct_ifaliasreq_sz); _(SIOCGIFAFLAG_IN, READWRITE, struct_ifreq_sz); _(SIOCALIFADDR, READ, struct_if_laddrreq_sz); _(SIOCGLIFADDR, READWRITE, struct_if_laddrreq_sz); _(SIOCDLIFADDR, READ, struct_if_laddrreq_sz); _(SIOCSIFADDRPREF, READ, struct_if_addrprefreq_sz); _(SIOCGIFADDRPREF, READWRITE, struct_if_addrprefreq_sz); _(SIOCADDMULTI, READ, struct_ifreq_sz); _(SIOCDELMULTI, READ, struct_ifreq_sz); _(SIOCGETVIFCNT, READWRITE, struct_sioc_vif_req_sz); _(SIOCGETSGCNT, READWRITE, struct_sioc_sg_req_sz); _(SIOCSIFMEDIA, READWRITE, struct_ifreq_sz); _(SIOCGIFMEDIA, READWRITE, struct_ifmediareq_sz); _(SIOCSIFGENERIC, READ, struct_ifreq_sz); _(SIOCGIFGENERIC, READWRITE, struct_ifreq_sz); _(SIOCSIFPHYADDR, READ, struct_ifaliasreq_sz); _(SIOCGIFPSRCADDR, READWRITE, struct_ifreq_sz); _(SIOCGIFPDSTADDR, READWRITE, struct_ifreq_sz); _(SIOCDIFPHYADDR, READ, struct_ifreq_sz); _(SIOCSLIFPHYADDR, READ, struct_if_laddrreq_sz); _(SIOCGLIFPHYADDR, READWRITE, struct_if_laddrreq_sz); _(SIOCSIFMTU, READ, struct_ifreq_sz); _(SIOCGIFMTU, READWRITE, struct_ifreq_sz); _(SIOCSDRVSPEC, READ, struct_ifdrv_sz); _(SIOCGDRVSPEC, READWRITE, struct_ifdrv_sz); _(SIOCIFCREATE, READ, struct_ifreq_sz); _(SIOCIFDESTROY, READ, struct_ifreq_sz); _(SIOCIFGCLONERS, READWRITE, struct_if_clonereq_sz); _(SIOCGIFDLT, READWRITE, struct_ifreq_sz); _(SIOCGIFCAP, READWRITE, struct_ifcapreq_sz); _(SIOCSIFCAP, READ, struct_ifcapreq_sz); _(SIOCSVH, READWRITE, struct_ifreq_sz); _(SIOCGVH, READWRITE, struct_ifreq_sz); _(SIOCINITIFADDR, READWRITE, struct_ifaddr_sz); _(SIOCGIFDATA, READWRITE, struct_ifdatareq_sz); _(SIOCZIFDATA, READWRITE, struct_ifdatareq_sz); _(SIOCGLINKSTR, READWRITE, struct_ifdrv_sz); _(SIOCSLINKSTR, READ, struct_ifdrv_sz); _(SIOCGETHERCAP, READWRITE, struct_eccapreq_sz); _(SIOCGIFINDEX, READWRITE, struct_ifreq_sz); _(SIOCSETHERCAP, READ, struct_eccapreq_sz); + _(SIOCSIFDESCR, READ, struct_ifreq_sz); + _(SIOCGIFDESCR, READWRITE, struct_ifreq_sz); _(SIOCGUMBINFO, READWRITE, struct_ifreq_sz); _(SIOCSUMBPARAM, READ, struct_ifreq_sz); _(SIOCGUMBPARAM, READWRITE, struct_ifreq_sz); _(SIOCSETPFSYNC, READ, struct_ifreq_sz); _(SIOCGETPFSYNC, READWRITE, struct_ifreq_sz); /* Entries from file: sys/timepps.h */ _(PPS_IOC_CREATE, NONE, 0); _(PPS_IOC_DESTROY, NONE, 0); _(PPS_IOC_SETPARAMS, READ, struct_pps_params_sz); _(PPS_IOC_GETPARAMS, WRITE, struct_pps_params_sz); _(PPS_IOC_GETCAP, WRITE, sizeof(int)); _(PPS_IOC_FETCH, READWRITE, struct_pps_info_sz); _(PPS_IOC_KCBIND, READ, sizeof(int)); /* Entries from file: sys/ttycom.h */ _(TIOCEXCL, NONE, 0); _(TIOCNXCL, NONE, 0); _(TIOCFLUSH, READ, sizeof(int)); _(TIOCGETA, WRITE, struct_termios_sz); _(TIOCSETA, READ, struct_termios_sz); _(TIOCSETAW, READ, 0); _(TIOCSETAF, READ, 0); _(TIOCGETD, WRITE, sizeof(int)); _(TIOCSETD, READ, sizeof(int)); _(TIOCGLINED, WRITE, (32 * sizeof(char))); _(TIOCSLINED, READ, (32 * sizeof(char))); _(TIOCSBRK, NONE, 0); _(TIOCCBRK, NONE, 0); _(TIOCSDTR, NONE, 0); _(TIOCCDTR, NONE, 0); _(TIOCGPGRP, WRITE, sizeof(int)); _(TIOCSPGRP, READ, sizeof(int)); _(TIOCOUTQ, WRITE, sizeof(int)); _(TIOCSTI, READ, sizeof(char)); _(TIOCNOTTY, NONE, 0); _(TIOCPKT, READ, sizeof(int)); _(TIOCSTOP, NONE, 0); _(TIOCSTART, NONE, 0); _(TIOCMSET, READ, sizeof(int)); _(TIOCMBIS, READ, sizeof(int)); _(TIOCMBIC, READ, sizeof(int)); _(TIOCMGET, WRITE, sizeof(int)); _(TIOCREMOTE, READ, sizeof(int)); _(TIOCGWINSZ, WRITE, struct_winsize_sz); _(TIOCSWINSZ, READ, struct_winsize_sz); _(TIOCUCNTL, READ, sizeof(int)); _(TIOCSTAT, READ, sizeof(int)); _(TIOCGSID, WRITE, sizeof(int)); _(TIOCCONS, READ, sizeof(int)); _(TIOCSCTTY, NONE, 0); _(TIOCEXT, READ, sizeof(int)); _(TIOCSIG, NONE, 0); _(TIOCDRAIN, NONE, 0); _(TIOCGFLAGS, WRITE, sizeof(int)); _(TIOCSFLAGS, READ, sizeof(int)); _(TIOCDCDTIMESTAMP, WRITE, struct_timeval_sz); _(TIOCRCVFRAME, READ, sizeof(uptr)); _(TIOCXMTFRAME, READ, sizeof(uptr)); _(TIOCPTMGET, WRITE, struct_ptmget_sz); _(TIOCGRANTPT, NONE, 0); _(TIOCPTSNAME, WRITE, struct_ptmget_sz); _(TIOCSQSIZE, READ, sizeof(int)); _(TIOCGQSIZE, WRITE, sizeof(int)); /* Entries from file: sys/verified_exec.h */ _(VERIEXEC_LOAD, READ, struct_plistref_sz); _(VERIEXEC_TABLESIZE, READ, struct_plistref_sz); _(VERIEXEC_DELETE, READ, struct_plistref_sz); _(VERIEXEC_QUERY, READWRITE, struct_plistref_sz); _(VERIEXEC_DUMP, WRITE, struct_plistref_sz); _(VERIEXEC_FLUSH, NONE, 0); /* Entries from file: sys/videoio.h */ _(VIDIOC_QUERYCAP, WRITE, struct_v4l2_capability_sz); _(VIDIOC_RESERVED, NONE, 0); _(VIDIOC_ENUM_FMT, READWRITE, struct_v4l2_fmtdesc_sz); _(VIDIOC_G_FMT, READWRITE, struct_v4l2_format_sz); _(VIDIOC_S_FMT, READWRITE, struct_v4l2_format_sz); _(VIDIOC_REQBUFS, READWRITE, struct_v4l2_requestbuffers_sz); _(VIDIOC_QUERYBUF, READWRITE, struct_v4l2_buffer_sz); _(VIDIOC_G_FBUF, WRITE, struct_v4l2_framebuffer_sz); _(VIDIOC_S_FBUF, READ, struct_v4l2_framebuffer_sz); _(VIDIOC_OVERLAY, READ, sizeof(int)); _(VIDIOC_QBUF, READWRITE, struct_v4l2_buffer_sz); _(VIDIOC_DQBUF, READWRITE, struct_v4l2_buffer_sz); _(VIDIOC_STREAMON, READ, sizeof(int)); _(VIDIOC_STREAMOFF, READ, sizeof(int)); _(VIDIOC_G_PARM, READWRITE, struct_v4l2_streamparm_sz); _(VIDIOC_S_PARM, READWRITE, struct_v4l2_streamparm_sz); _(VIDIOC_G_STD, WRITE, sizeof(u64)); _(VIDIOC_S_STD, READ, sizeof(u64)); _(VIDIOC_ENUMSTD, READWRITE, struct_v4l2_standard_sz); _(VIDIOC_ENUMINPUT, READWRITE, struct_v4l2_input_sz); _(VIDIOC_G_CTRL, READWRITE, struct_v4l2_control_sz); _(VIDIOC_S_CTRL, READWRITE, struct_v4l2_control_sz); _(VIDIOC_G_TUNER, READWRITE, struct_v4l2_tuner_sz); _(VIDIOC_S_TUNER, READ, struct_v4l2_tuner_sz); _(VIDIOC_G_AUDIO, WRITE, struct_v4l2_audio_sz); _(VIDIOC_S_AUDIO, READ, struct_v4l2_audio_sz); _(VIDIOC_QUERYCTRL, READWRITE, struct_v4l2_queryctrl_sz); _(VIDIOC_QUERYMENU, READWRITE, struct_v4l2_querymenu_sz); _(VIDIOC_G_INPUT, WRITE, sizeof(int)); _(VIDIOC_S_INPUT, READWRITE, sizeof(int)); _(VIDIOC_G_OUTPUT, WRITE, sizeof(int)); _(VIDIOC_S_OUTPUT, READWRITE, sizeof(int)); _(VIDIOC_ENUMOUTPUT, READWRITE, struct_v4l2_output_sz); _(VIDIOC_G_AUDOUT, WRITE, struct_v4l2_audioout_sz); _(VIDIOC_S_AUDOUT, READ, struct_v4l2_audioout_sz); _(VIDIOC_G_MODULATOR, READWRITE, struct_v4l2_modulator_sz); _(VIDIOC_S_MODULATOR, READ, struct_v4l2_modulator_sz); _(VIDIOC_G_FREQUENCY, READWRITE, struct_v4l2_frequency_sz); _(VIDIOC_S_FREQUENCY, READ, struct_v4l2_frequency_sz); _(VIDIOC_CROPCAP, READWRITE, struct_v4l2_cropcap_sz); _(VIDIOC_G_CROP, READWRITE, struct_v4l2_crop_sz); _(VIDIOC_S_CROP, READ, struct_v4l2_crop_sz); _(VIDIOC_G_JPEGCOMP, WRITE, struct_v4l2_jpegcompression_sz); _(VIDIOC_S_JPEGCOMP, READ, struct_v4l2_jpegcompression_sz); _(VIDIOC_QUERYSTD, WRITE, sizeof(u64)); _(VIDIOC_TRY_FMT, READWRITE, struct_v4l2_format_sz); _(VIDIOC_ENUMAUDIO, READWRITE, struct_v4l2_audio_sz); _(VIDIOC_ENUMAUDOUT, READWRITE, struct_v4l2_audioout_sz); _(VIDIOC_G_PRIORITY, WRITE, enum_v4l2_priority_sz); _(VIDIOC_S_PRIORITY, READ, enum_v4l2_priority_sz); _(VIDIOC_ENUM_FRAMESIZES, READWRITE, struct_v4l2_frmsizeenum_sz); _(VIDIOC_ENUM_FRAMEINTERVALS, READWRITE, struct_v4l2_frmivalenum_sz); /* Entries from file: sys/wdog.h */ _(WDOGIOC_GMODE, READWRITE, struct_wdog_mode_sz); _(WDOGIOC_SMODE, READ, struct_wdog_mode_sz); _(WDOGIOC_WHICH, WRITE, struct_wdog_mode_sz); _(WDOGIOC_TICKLE, NONE, 0); _(WDOGIOC_GTICKLER, WRITE, sizeof(int)); _(WDOGIOC_GWDOGS, READWRITE, struct_wdog_conf_sz); + /* Entries from file: sys/kcov.h */ + _(KCOV_IOC_SETBUFSIZE, READ, sizeof(u64)); + _(KCOV_IOC_ENABLE, READ, sizeof(int)); + _(KCOV_IOC_DISABLE, NONE, 0); + /* Entries from file: sys/ipmi.h */ + _(IPMICTL_RECEIVE_MSG_TRUNC, READWRITE, struct_ipmi_recv_sz); + _(IPMICTL_RECEIVE_MSG, READWRITE, struct_ipmi_recv_sz); + _(IPMICTL_SEND_COMMAND, READ, struct_ipmi_req_sz); + _(IPMICTL_REGISTER_FOR_CMD, READ, struct_ipmi_cmdspec_sz); + _(IPMICTL_UNREGISTER_FOR_CMD, READ, struct_ipmi_cmdspec_sz); + _(IPMICTL_SET_GETS_EVENTS_CMD, READ, sizeof(int)); + _(IPMICTL_SET_MY_ADDRESS_CMD, READ, sizeof(unsigned int)); + _(IPMICTL_GET_MY_ADDRESS_CMD, WRITE, sizeof(unsigned int)); + _(IPMICTL_SET_MY_LUN_CMD, READ, sizeof(unsigned int)); + _(IPMICTL_GET_MY_LUN_CMD, WRITE, sizeof(unsigned int)); /* Entries from file: soundcard.h */ _(SNDCTL_DSP_RESET, NONE, 0); _(SNDCTL_DSP_SYNC, NONE, 0); _(SNDCTL_DSP_SPEED, READWRITE, sizeof(int)); _(SOUND_PCM_READ_RATE, WRITE, sizeof(int)); _(SNDCTL_DSP_STEREO, READWRITE, sizeof(int)); _(SNDCTL_DSP_GETBLKSIZE, READWRITE, sizeof(int)); _(SNDCTL_DSP_SETFMT, READWRITE, sizeof(int)); _(SOUND_PCM_READ_BITS, WRITE, sizeof(int)); _(SNDCTL_DSP_CHANNELS, READWRITE, sizeof(int)); _(SOUND_PCM_READ_CHANNELS, WRITE, sizeof(int)); _(SOUND_PCM_WRITE_FILTER, READWRITE, sizeof(int)); _(SOUND_PCM_READ_FILTER, WRITE, sizeof(int)); _(SNDCTL_DSP_POST, NONE, 0); _(SNDCTL_DSP_SUBDIVIDE, READWRITE, sizeof(int)); _(SNDCTL_DSP_SETFRAGMENT, READWRITE, sizeof(int)); _(SNDCTL_DSP_GETFMTS, WRITE, sizeof(int)); _(SNDCTL_DSP_GETOSPACE, WRITE, struct_audio_buf_info_sz); _(SNDCTL_DSP_GETISPACE, WRITE, struct_audio_buf_info_sz); _(SNDCTL_DSP_NONBLOCK, NONE, 0); _(SNDCTL_DSP_GETCAPS, WRITE, sizeof(int)); _(SNDCTL_DSP_GETTRIGGER, WRITE, sizeof(int)); _(SNDCTL_DSP_SETTRIGGER, READ, sizeof(int)); _(SNDCTL_DSP_GETIPTR, WRITE, struct_count_info_sz); _(SNDCTL_DSP_GETOPTR, WRITE, struct_count_info_sz); _(SNDCTL_DSP_MAPINBUF, WRITE, struct_buffmem_desc_sz); _(SNDCTL_DSP_MAPOUTBUF, WRITE, struct_buffmem_desc_sz); _(SNDCTL_DSP_SETSYNCRO, NONE, 0); _(SNDCTL_DSP_SETDUPLEX, NONE, 0); _(SNDCTL_DSP_PROFILE, READ, sizeof(int)); _(SNDCTL_DSP_GETODELAY, WRITE, sizeof(int)); _(SOUND_MIXER_INFO, WRITE, struct_mixer_info_sz); _(SOUND_OLD_MIXER_INFO, WRITE, struct__old_mixer_info_sz); _(OSS_GETVERSION, WRITE, sizeof(int)); _(SNDCTL_SYSINFO, WRITE, struct_oss_sysinfo_sz); _(SNDCTL_AUDIOINFO, READWRITE, struct_oss_audioinfo_sz); _(SNDCTL_ENGINEINFO, READWRITE, struct_oss_audioinfo_sz); _(SNDCTL_DSP_GETPLAYVOL, WRITE, sizeof(unsigned int)); _(SNDCTL_DSP_SETPLAYVOL, READ, sizeof(unsigned int)); _(SNDCTL_DSP_GETRECVOL, WRITE, sizeof(unsigned int)); _(SNDCTL_DSP_SETRECVOL, READ, sizeof(unsigned int)); _(SNDCTL_DSP_SKIP, NONE, 0); _(SNDCTL_DSP_SILENCE, NONE, 0); #undef _ } static bool ioctl_initialized = false; struct ioctl_desc_compare { bool operator()(const ioctl_desc &left, const ioctl_desc &right) const { return left.req < right.req; } }; static void ioctl_init() { ioctl_table_fill(); Sort(ioctl_table, ioctl_table_size, ioctl_desc_compare()); bool bad = false; for (unsigned i = 0; i < ioctl_table_size - 1; ++i) { if (ioctl_table[i].req >= ioctl_table[i + 1].req) { Printf("Duplicate or unsorted ioctl request id %x >= %x (%s vs %s)\n", ioctl_table[i].req, ioctl_table[i + 1].req, ioctl_table[i].name, ioctl_table[i + 1].name); bad = true; } } if (bad) Die(); ioctl_initialized = true; } static const ioctl_desc *ioctl_table_lookup(unsigned req) { int left = 0; int right = ioctl_table_size; while (left < right) { int mid = (left + right) / 2; if (ioctl_table[mid].req < req) left = mid + 1; else right = mid; } if (left == right && ioctl_table[left].req == req) return ioctl_table + left; else return nullptr; } static bool ioctl_decode(unsigned req, ioctl_desc *desc) { CHECK(desc); desc->req = req; desc->name = ""; desc->size = IOC_SIZE(req); // Sanity check. if (desc->size > 0xFFFF) return false; unsigned dir = IOC_DIR(req); switch (dir) { case IOC_NONE: desc->type = ioctl_desc::NONE; break; case IOC_READ | IOC_WRITE: desc->type = ioctl_desc::READWRITE; break; case IOC_READ: desc->type = ioctl_desc::WRITE; break; case IOC_WRITE: desc->type = ioctl_desc::READ; break; default: return false; } // Size can be 0 iff type is NONE. if ((desc->type == IOC_NONE) != (desc->size == 0)) return false; // Sanity check. if (IOC_TYPE(req) == 0) return false; return true; } static const ioctl_desc *ioctl_lookup(unsigned req) { const ioctl_desc *desc = ioctl_table_lookup(req); if (desc) return desc; // Try stripping access size from the request id. desc = ioctl_table_lookup(req & ~(IOC_SIZEMASK << IOC_SIZESHIFT)); // Sanity check: requests that encode access size are either read or write and // have size of 0 in the table. if (desc && desc->size == 0 && (desc->type == ioctl_desc::READWRITE || desc->type == ioctl_desc::WRITE || desc->type == ioctl_desc::READ)) return desc; return nullptr; } static void ioctl_common_pre(void *ctx, const ioctl_desc *desc, int d, unsigned request, void *arg) { if (desc->type == ioctl_desc::READ || desc->type == ioctl_desc::READWRITE) { unsigned size = desc->size ? desc->size : IOC_SIZE(request); COMMON_INTERCEPTOR_READ_RANGE(ctx, arg, size); } if (desc->type != ioctl_desc::CUSTOM) return; if (request == IOCTL_SIOCGIFCONF) { struct __sanitizer_ifconf *ifc = (__sanitizer_ifconf *)arg; COMMON_INTERCEPTOR_READ_RANGE(ctx, (char *)&ifc->ifc_len, sizeof(ifc->ifc_len)); } } static void ioctl_common_post(void *ctx, const ioctl_desc *desc, int res, int d, unsigned request, void *arg) { if (desc->type == ioctl_desc::WRITE || desc->type == ioctl_desc::READWRITE) { // FIXME: add verbose output unsigned size = desc->size ? desc->size : IOC_SIZE(request); COMMON_INTERCEPTOR_WRITE_RANGE(ctx, arg, size); } if (desc->type != ioctl_desc::CUSTOM) return; if (request == IOCTL_SIOCGIFCONF) { struct __sanitizer_ifconf *ifc = (__sanitizer_ifconf *)arg; COMMON_INTERCEPTOR_WRITE_RANGE(ctx, ifc->ifc_ifcu.ifcu_req, ifc->ifc_len); } } #endif // SANITIZER_NETBSD Index: vendor/compiler-rt/dist-release_90/lib/sanitizer_common/sanitizer_linux.cc =================================================================== --- vendor/compiler-rt/dist-release_90/lib/sanitizer_common/sanitizer_linux.cc (revision 351306) +++ vendor/compiler-rt/dist-release_90/lib/sanitizer_common/sanitizer_linux.cc (revision 351307) @@ -1,2102 +1,2106 @@ //===-- sanitizer_linux.cc ------------------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is shared between AddressSanitizer and ThreadSanitizer // run-time libraries and implements linux-specific functions from // sanitizer_libc.h. //===----------------------------------------------------------------------===// #include "sanitizer_platform.h" #if SANITIZER_FREEBSD || SANITIZER_LINUX || SANITIZER_NETBSD || \ SANITIZER_OPENBSD || SANITIZER_SOLARIS #include "sanitizer_common.h" #include "sanitizer_flags.h" #include "sanitizer_getauxval.h" #include "sanitizer_internal_defs.h" #include "sanitizer_libc.h" #include "sanitizer_linux.h" #include "sanitizer_mutex.h" #include "sanitizer_placement_new.h" #include "sanitizer_procmaps.h" #if SANITIZER_LINUX #include #endif // For mips64, syscall(__NR_stat) fills the buffer in the 'struct kernel_stat' // format. Struct kernel_stat is defined as 'struct stat' in asm/stat.h. To // access stat from asm/stat.h, without conflicting with definition in // sys/stat.h, we use this trick. #if defined(__mips64) #include #include #define stat kernel_stat #include #undef stat #endif #include #include #include #include #include #include #include #include #include #if !SANITIZER_SOLARIS #include #endif #include #include #include #include #include #if !SANITIZER_OPENBSD #include #endif #if SANITIZER_OPENBSD #include #include #endif #include #if SANITIZER_LINUX #include #endif #if SANITIZER_LINUX && !SANITIZER_ANDROID #include #endif #if SANITIZER_FREEBSD #include #include #include extern "C" { // must be included after and on // FreeBSD 9.2 and 10.0. #include } #include #endif // SANITIZER_FREEBSD #if SANITIZER_NETBSD #include // For NAME_MAX #include #include extern struct ps_strings *__ps_strings; #endif // SANITIZER_NETBSD #if SANITIZER_SOLARIS #include #include #define environ _environ #endif extern char **environ; #if SANITIZER_LINUX // struct kernel_timeval { long tv_sec; long tv_usec; }; // is broken on some linux distributions. const int FUTEX_WAIT = 0; const int FUTEX_WAKE = 1; const int FUTEX_PRIVATE_FLAG = 128; const int FUTEX_WAIT_PRIVATE = FUTEX_WAIT | FUTEX_PRIVATE_FLAG; const int FUTEX_WAKE_PRIVATE = FUTEX_WAKE | FUTEX_PRIVATE_FLAG; #endif // SANITIZER_LINUX // Are we using 32-bit or 64-bit Linux syscalls? // x32 (which defines __x86_64__) has SANITIZER_WORDSIZE == 32 // but it still needs to use 64-bit syscalls. #if SANITIZER_LINUX && (defined(__x86_64__) || defined(__powerpc64__) || \ SANITIZER_WORDSIZE == 64) # define SANITIZER_LINUX_USES_64BIT_SYSCALLS 1 #else # define SANITIZER_LINUX_USES_64BIT_SYSCALLS 0 #endif // Note : FreeBSD had implemented both // Linux and OpenBSD apis, available from // future 12.x version most likely #if SANITIZER_LINUX && defined(__NR_getrandom) # if !defined(GRND_NONBLOCK) # define GRND_NONBLOCK 1 # endif # define SANITIZER_USE_GETRANDOM 1 #else # define SANITIZER_USE_GETRANDOM 0 #endif // SANITIZER_LINUX && defined(__NR_getrandom) #if SANITIZER_OPENBSD # define SANITIZER_USE_GETENTROPY 1 #else # if SANITIZER_FREEBSD && __FreeBSD_version >= 1200000 # define SANITIZER_USE_GETENTROPY 1 # else # define SANITIZER_USE_GETENTROPY 0 # endif #endif // SANITIZER_USE_GETENTROPY namespace __sanitizer { #if SANITIZER_LINUX && defined(__x86_64__) #include "sanitizer_syscall_linux_x86_64.inc" #elif SANITIZER_LINUX && defined(__aarch64__) #include "sanitizer_syscall_linux_aarch64.inc" #elif SANITIZER_LINUX && defined(__arm__) #include "sanitizer_syscall_linux_arm.inc" #else #include "sanitizer_syscall_generic.inc" #endif // --------------- sanitizer_libc.h #if !SANITIZER_SOLARIS && !SANITIZER_NETBSD #if !SANITIZER_S390 && !SANITIZER_OPENBSD uptr internal_mmap(void *addr, uptr length, int prot, int flags, int fd, OFF_T offset) { #if SANITIZER_FREEBSD || SANITIZER_LINUX_USES_64BIT_SYSCALLS return internal_syscall(SYSCALL(mmap), (uptr)addr, length, prot, flags, fd, offset); #else // mmap2 specifies file offset in 4096-byte units. CHECK(IsAligned(offset, 4096)); return internal_syscall(SYSCALL(mmap2), addr, length, prot, flags, fd, offset / 4096); #endif } #endif // !SANITIZER_S390 && !SANITIZER_OPENBSD #if !SANITIZER_OPENBSD uptr internal_munmap(void *addr, uptr length) { return internal_syscall(SYSCALL(munmap), (uptr)addr, length); } int internal_mprotect(void *addr, uptr length, int prot) { return internal_syscall(SYSCALL(mprotect), (uptr)addr, length, prot); } #endif uptr internal_close(fd_t fd) { return internal_syscall(SYSCALL(close), fd); } uptr internal_open(const char *filename, int flags) { #if SANITIZER_USES_CANONICAL_LINUX_SYSCALLS return internal_syscall(SYSCALL(openat), AT_FDCWD, (uptr)filename, flags); #else return internal_syscall(SYSCALL(open), (uptr)filename, flags); #endif } uptr internal_open(const char *filename, int flags, u32 mode) { #if SANITIZER_USES_CANONICAL_LINUX_SYSCALLS return internal_syscall(SYSCALL(openat), AT_FDCWD, (uptr)filename, flags, mode); #else return internal_syscall(SYSCALL(open), (uptr)filename, flags, mode); #endif } uptr internal_read(fd_t fd, void *buf, uptr count) { sptr res; HANDLE_EINTR(res, (sptr)internal_syscall(SYSCALL(read), fd, (uptr)buf, count)); return res; } uptr internal_write(fd_t fd, const void *buf, uptr count) { sptr res; HANDLE_EINTR(res, (sptr)internal_syscall(SYSCALL(write), fd, (uptr)buf, count)); return res; } uptr internal_ftruncate(fd_t fd, uptr size) { sptr res; HANDLE_EINTR(res, (sptr)internal_syscall(SYSCALL(ftruncate), fd, (OFF_T)size)); return res; } #if !SANITIZER_LINUX_USES_64BIT_SYSCALLS && SANITIZER_LINUX static void stat64_to_stat(struct stat64 *in, struct stat *out) { internal_memset(out, 0, sizeof(*out)); out->st_dev = in->st_dev; out->st_ino = in->st_ino; out->st_mode = in->st_mode; out->st_nlink = in->st_nlink; out->st_uid = in->st_uid; out->st_gid = in->st_gid; out->st_rdev = in->st_rdev; out->st_size = in->st_size; out->st_blksize = in->st_blksize; out->st_blocks = in->st_blocks; out->st_atime = in->st_atime; out->st_mtime = in->st_mtime; out->st_ctime = in->st_ctime; } #endif #if defined(__mips64) // Undefine compatibility macros from // so that they would not clash with the kernel_stat // st_[a|m|c]time fields #undef st_atime #undef st_mtime #undef st_ctime #if defined(SANITIZER_ANDROID) // Bionic sys/stat.h defines additional macros // for compatibility with the old NDKs and // they clash with the kernel_stat structure // st_[a|m|c]time_nsec fields. #undef st_atime_nsec #undef st_mtime_nsec #undef st_ctime_nsec #endif static void kernel_stat_to_stat(struct kernel_stat *in, struct stat *out) { internal_memset(out, 0, sizeof(*out)); out->st_dev = in->st_dev; out->st_ino = in->st_ino; out->st_mode = in->st_mode; out->st_nlink = in->st_nlink; out->st_uid = in->st_uid; out->st_gid = in->st_gid; out->st_rdev = in->st_rdev; out->st_size = in->st_size; out->st_blksize = in->st_blksize; out->st_blocks = in->st_blocks; #if defined(__USE_MISC) || \ defined(__USE_XOPEN2K8) || \ defined(SANITIZER_ANDROID) out->st_atim.tv_sec = in->st_atime; out->st_atim.tv_nsec = in->st_atime_nsec; out->st_mtim.tv_sec = in->st_mtime; out->st_mtim.tv_nsec = in->st_mtime_nsec; out->st_ctim.tv_sec = in->st_ctime; out->st_ctim.tv_nsec = in->st_ctime_nsec; #else out->st_atime = in->st_atime; out->st_atimensec = in->st_atime_nsec; out->st_mtime = in->st_mtime; out->st_mtimensec = in->st_mtime_nsec; out->st_ctime = in->st_ctime; out->st_atimensec = in->st_ctime_nsec; #endif } #endif uptr internal_stat(const char *path, void *buf) { #if SANITIZER_FREEBSD || SANITIZER_OPENBSD return internal_syscall(SYSCALL(fstatat), AT_FDCWD, (uptr)path, (uptr)buf, 0); #elif SANITIZER_USES_CANONICAL_LINUX_SYSCALLS return internal_syscall(SYSCALL(newfstatat), AT_FDCWD, (uptr)path, (uptr)buf, 0); #elif SANITIZER_LINUX_USES_64BIT_SYSCALLS # if defined(__mips64) // For mips64, stat syscall fills buffer in the format of kernel_stat struct kernel_stat kbuf; int res = internal_syscall(SYSCALL(stat), path, &kbuf); kernel_stat_to_stat(&kbuf, (struct stat *)buf); return res; # else return internal_syscall(SYSCALL(stat), (uptr)path, (uptr)buf); # endif #else struct stat64 buf64; int res = internal_syscall(SYSCALL(stat64), path, &buf64); stat64_to_stat(&buf64, (struct stat *)buf); return res; #endif } uptr internal_lstat(const char *path, void *buf) { #if SANITIZER_FREEBSD || SANITIZER_OPENBSD return internal_syscall(SYSCALL(fstatat), AT_FDCWD, (uptr)path, (uptr)buf, AT_SYMLINK_NOFOLLOW); #elif SANITIZER_USES_CANONICAL_LINUX_SYSCALLS return internal_syscall(SYSCALL(newfstatat), AT_FDCWD, (uptr)path, (uptr)buf, AT_SYMLINK_NOFOLLOW); #elif SANITIZER_LINUX_USES_64BIT_SYSCALLS # if SANITIZER_MIPS64 // For mips64, lstat syscall fills buffer in the format of kernel_stat struct kernel_stat kbuf; int res = internal_syscall(SYSCALL(lstat), path, &kbuf); kernel_stat_to_stat(&kbuf, (struct stat *)buf); return res; # else return internal_syscall(SYSCALL(lstat), (uptr)path, (uptr)buf); # endif #else struct stat64 buf64; int res = internal_syscall(SYSCALL(lstat64), path, &buf64); stat64_to_stat(&buf64, (struct stat *)buf); return res; #endif } uptr internal_fstat(fd_t fd, void *buf) { #if SANITIZER_FREEBSD || SANITIZER_OPENBSD || \ SANITIZER_LINUX_USES_64BIT_SYSCALLS #if SANITIZER_MIPS64 && !SANITIZER_OPENBSD // For mips64, fstat syscall fills buffer in the format of kernel_stat struct kernel_stat kbuf; int res = internal_syscall(SYSCALL(fstat), fd, &kbuf); kernel_stat_to_stat(&kbuf, (struct stat *)buf); return res; # else return internal_syscall(SYSCALL(fstat), fd, (uptr)buf); # endif #else struct stat64 buf64; int res = internal_syscall(SYSCALL(fstat64), fd, &buf64); stat64_to_stat(&buf64, (struct stat *)buf); return res; #endif } uptr internal_filesize(fd_t fd) { struct stat st; if (internal_fstat(fd, &st)) return -1; return (uptr)st.st_size; } uptr internal_dup(int oldfd) { return internal_syscall(SYSCALL(dup), oldfd); } uptr internal_dup2(int oldfd, int newfd) { #if SANITIZER_USES_CANONICAL_LINUX_SYSCALLS return internal_syscall(SYSCALL(dup3), oldfd, newfd, 0); #else return internal_syscall(SYSCALL(dup2), oldfd, newfd); #endif } uptr internal_readlink(const char *path, char *buf, uptr bufsize) { #if SANITIZER_USES_CANONICAL_LINUX_SYSCALLS return internal_syscall(SYSCALL(readlinkat), AT_FDCWD, (uptr)path, (uptr)buf, bufsize); #elif SANITIZER_OPENBSD return internal_syscall(SYSCALL(readlinkat), AT_FDCWD, (uptr)path, (uptr)buf, bufsize); #else return internal_syscall(SYSCALL(readlink), (uptr)path, (uptr)buf, bufsize); #endif } uptr internal_unlink(const char *path) { #if SANITIZER_USES_CANONICAL_LINUX_SYSCALLS || SANITIZER_OPENBSD return internal_syscall(SYSCALL(unlinkat), AT_FDCWD, (uptr)path, 0); #else return internal_syscall(SYSCALL(unlink), (uptr)path); #endif } uptr internal_rename(const char *oldpath, const char *newpath) { #if SANITIZER_USES_CANONICAL_LINUX_SYSCALLS || SANITIZER_OPENBSD return internal_syscall(SYSCALL(renameat), AT_FDCWD, (uptr)oldpath, AT_FDCWD, (uptr)newpath); #else return internal_syscall(SYSCALL(rename), (uptr)oldpath, (uptr)newpath); #endif } uptr internal_sched_yield() { return internal_syscall(SYSCALL(sched_yield)); } void internal__exit(int exitcode) { #if SANITIZER_FREEBSD || SANITIZER_OPENBSD internal_syscall(SYSCALL(exit), exitcode); #else internal_syscall(SYSCALL(exit_group), exitcode); #endif Die(); // Unreachable. } unsigned int internal_sleep(unsigned int seconds) { struct timespec ts; ts.tv_sec = seconds; ts.tv_nsec = 0; int res = internal_syscall(SYSCALL(nanosleep), &ts, &ts); if (res) return ts.tv_sec; return 0; } uptr internal_execve(const char *filename, char *const argv[], char *const envp[]) { return internal_syscall(SYSCALL(execve), (uptr)filename, (uptr)argv, (uptr)envp); } #endif // !SANITIZER_SOLARIS && !SANITIZER_NETBSD // ----------------- sanitizer_common.h bool FileExists(const char *filename) { if (ShouldMockFailureToOpen(filename)) return false; struct stat st; #if SANITIZER_USES_CANONICAL_LINUX_SYSCALLS if (internal_syscall(SYSCALL(newfstatat), AT_FDCWD, filename, &st, 0)) #else if (internal_stat(filename, &st)) #endif return false; // Sanity check: filename is a regular file. return S_ISREG(st.st_mode); } #if !SANITIZER_NETBSD tid_t GetTid() { #if SANITIZER_FREEBSD long Tid; thr_self(&Tid); return Tid; #elif SANITIZER_OPENBSD return internal_syscall(SYSCALL(getthrid)); #elif SANITIZER_SOLARIS return thr_self(); #else return internal_syscall(SYSCALL(gettid)); #endif } int TgKill(pid_t pid, tid_t tid, int sig) { #if SANITIZER_LINUX return internal_syscall(SYSCALL(tgkill), pid, tid, sig); #elif SANITIZER_FREEBSD return internal_syscall(SYSCALL(thr_kill2), pid, tid, sig); #elif SANITIZER_OPENBSD (void)pid; return internal_syscall(SYSCALL(thrkill), tid, sig, nullptr); #elif SANITIZER_SOLARIS (void)pid; return thr_kill(tid, sig); #endif } #endif #if !SANITIZER_SOLARIS && !SANITIZER_NETBSD u64 NanoTime() { #if SANITIZER_FREEBSD || SANITIZER_OPENBSD timeval tv; #else kernel_timeval tv; #endif internal_memset(&tv, 0, sizeof(tv)); internal_syscall(SYSCALL(gettimeofday), &tv, 0); return (u64)tv.tv_sec * 1000*1000*1000 + tv.tv_usec * 1000; } uptr internal_clock_gettime(__sanitizer_clockid_t clk_id, void *tp) { return internal_syscall(SYSCALL(clock_gettime), clk_id, tp); } #endif // !SANITIZER_SOLARIS && !SANITIZER_NETBSD // Like getenv, but reads env directly from /proc (on Linux) or parses the // 'environ' array (on some others) and does not use libc. This function // should be called first inside __asan_init. const char *GetEnv(const char *name) { #if SANITIZER_FREEBSD || SANITIZER_NETBSD || SANITIZER_OPENBSD || \ SANITIZER_SOLARIS if (::environ != 0) { uptr NameLen = internal_strlen(name); for (char **Env = ::environ; *Env != 0; Env++) { if (internal_strncmp(*Env, name, NameLen) == 0 && (*Env)[NameLen] == '=') return (*Env) + NameLen + 1; } } return 0; // Not found. #elif SANITIZER_LINUX static char *environ; static uptr len; static bool inited; if (!inited) { inited = true; uptr environ_size; if (!ReadFileToBuffer("/proc/self/environ", &environ, &environ_size, &len)) environ = nullptr; } if (!environ || len == 0) return nullptr; uptr namelen = internal_strlen(name); const char *p = environ; while (*p != '\0') { // will happen at the \0\0 that terminates the buffer // proc file has the format NAME=value\0NAME=value\0NAME=value\0... const char* endp = (char*)internal_memchr(p, '\0', len - (p - environ)); if (!endp) // this entry isn't NUL terminated return nullptr; else if (!internal_memcmp(p, name, namelen) && p[namelen] == '=') // Match. return p + namelen + 1; // point after = p = endp + 1; } return nullptr; // Not found. #else #error "Unsupported platform" #endif } #if !SANITIZER_FREEBSD && !SANITIZER_NETBSD && !SANITIZER_OPENBSD extern "C" { SANITIZER_WEAK_ATTRIBUTE extern void *__libc_stack_end; } #endif #if !SANITIZER_GO && !SANITIZER_FREEBSD && !SANITIZER_NETBSD && \ !SANITIZER_OPENBSD static void ReadNullSepFileToArray(const char *path, char ***arr, int arr_size) { char *buff; uptr buff_size; uptr buff_len; *arr = (char **)MmapOrDie(arr_size * sizeof(char *), "NullSepFileArray"); if (!ReadFileToBuffer(path, &buff, &buff_size, &buff_len, 1024 * 1024)) { (*arr)[0] = nullptr; return; } (*arr)[0] = buff; int count, i; for (count = 1, i = 1; ; i++) { if (buff[i] == 0) { if (buff[i+1] == 0) break; (*arr)[count] = &buff[i+1]; CHECK_LE(count, arr_size - 1); // FIXME: make this more flexible. count++; } } (*arr)[count] = nullptr; } #endif #if !SANITIZER_OPENBSD static void GetArgsAndEnv(char ***argv, char ***envp) { #if SANITIZER_FREEBSD // On FreeBSD, retrieving the argument and environment arrays is done via the // kern.ps_strings sysctl, which returns a pointer to a structure containing // this information. See also . ps_strings *pss; uptr sz = sizeof(pss); if (internal_sysctlbyname("kern.ps_strings", &pss, &sz, NULL, 0) == -1) { Printf("sysctl kern.ps_strings failed\n"); Die(); } *argv = pss->ps_argvstr; *envp = pss->ps_envstr; #elif SANITIZER_NETBSD *argv = __ps_strings->ps_argvstr; *envp = __ps_strings->ps_envstr; #else // SANITIZER_FREEBSD #if !SANITIZER_GO if (&__libc_stack_end) { #endif // !SANITIZER_GO uptr* stack_end = (uptr*)__libc_stack_end; int argc = *stack_end; *argv = (char**)(stack_end + 1); *envp = (char**)(stack_end + argc + 2); #if !SANITIZER_GO } else { static const int kMaxArgv = 2000, kMaxEnvp = 2000; ReadNullSepFileToArray("/proc/self/cmdline", argv, kMaxArgv); ReadNullSepFileToArray("/proc/self/environ", envp, kMaxEnvp); } #endif // !SANITIZER_GO #endif // SANITIZER_FREEBSD } char **GetArgv() { char **argv, **envp; GetArgsAndEnv(&argv, &envp); return argv; } char **GetEnviron() { char **argv, **envp; GetArgsAndEnv(&argv, &envp); return envp; } #endif // !SANITIZER_OPENBSD #if !SANITIZER_SOLARIS enum MutexState { MtxUnlocked = 0, MtxLocked = 1, MtxSleeping = 2 }; BlockingMutex::BlockingMutex() { internal_memset(this, 0, sizeof(*this)); } void BlockingMutex::Lock() { CHECK_EQ(owner_, 0); atomic_uint32_t *m = reinterpret_cast(&opaque_storage_); if (atomic_exchange(m, MtxLocked, memory_order_acquire) == MtxUnlocked) return; while (atomic_exchange(m, MtxSleeping, memory_order_acquire) != MtxUnlocked) { #if SANITIZER_FREEBSD _umtx_op(m, UMTX_OP_WAIT_UINT, MtxSleeping, 0, 0); #elif SANITIZER_NETBSD sched_yield(); /* No userspace futex-like synchronization */ #else internal_syscall(SYSCALL(futex), (uptr)m, FUTEX_WAIT_PRIVATE, MtxSleeping, 0, 0, 0); #endif } } void BlockingMutex::Unlock() { atomic_uint32_t *m = reinterpret_cast(&opaque_storage_); u32 v = atomic_exchange(m, MtxUnlocked, memory_order_release); CHECK_NE(v, MtxUnlocked); if (v == MtxSleeping) { #if SANITIZER_FREEBSD _umtx_op(m, UMTX_OP_WAKE, 1, 0, 0); #elif SANITIZER_NETBSD /* No userspace futex-like synchronization */ #else internal_syscall(SYSCALL(futex), (uptr)m, FUTEX_WAKE_PRIVATE, 1, 0, 0, 0); #endif } } void BlockingMutex::CheckLocked() { atomic_uint32_t *m = reinterpret_cast(&opaque_storage_); CHECK_NE(MtxUnlocked, atomic_load(m, memory_order_relaxed)); } #endif // !SANITIZER_SOLARIS // ----------------- sanitizer_linux.h // The actual size of this structure is specified by d_reclen. // Note that getdents64 uses a different structure format. We only provide the // 32-bit syscall here. #if SANITIZER_NETBSD // Not used #elif SANITIZER_OPENBSD // struct dirent is different for Linux and us. At this moment, we use only // d_fileno (Linux call this d_ino), d_reclen, and d_name. struct linux_dirent { u64 d_ino; // d_fileno u16 d_reclen; u16 d_namlen; // not used u8 d_type; // not used char d_name[NAME_MAX + 1]; }; #else struct linux_dirent { #if SANITIZER_X32 || defined(__aarch64__) u64 d_ino; u64 d_off; #else unsigned long d_ino; unsigned long d_off; #endif unsigned short d_reclen; #ifdef __aarch64__ unsigned char d_type; #endif char d_name[256]; }; #endif #if !SANITIZER_SOLARIS && !SANITIZER_NETBSD // Syscall wrappers. uptr internal_ptrace(int request, int pid, void *addr, void *data) { return internal_syscall(SYSCALL(ptrace), request, pid, (uptr)addr, (uptr)data); } uptr internal_waitpid(int pid, int *status, int options) { return internal_syscall(SYSCALL(wait4), pid, (uptr)status, options, 0 /* rusage */); } uptr internal_getpid() { return internal_syscall(SYSCALL(getpid)); } uptr internal_getppid() { return internal_syscall(SYSCALL(getppid)); } uptr internal_getdents(fd_t fd, struct linux_dirent *dirp, unsigned int count) { #if SANITIZER_FREEBSD return internal_syscall(SYSCALL(getdirentries), fd, (uptr)dirp, count, NULL); #elif SANITIZER_USES_CANONICAL_LINUX_SYSCALLS return internal_syscall(SYSCALL(getdents64), fd, (uptr)dirp, count); #else return internal_syscall(SYSCALL(getdents), fd, (uptr)dirp, count); #endif } uptr internal_lseek(fd_t fd, OFF_T offset, int whence) { return internal_syscall(SYSCALL(lseek), fd, offset, whence); } #if SANITIZER_LINUX uptr internal_prctl(int option, uptr arg2, uptr arg3, uptr arg4, uptr arg5) { return internal_syscall(SYSCALL(prctl), option, arg2, arg3, arg4, arg5); } #endif uptr internal_sigaltstack(const void *ss, void *oss) { return internal_syscall(SYSCALL(sigaltstack), (uptr)ss, (uptr)oss); } int internal_fork() { #if SANITIZER_USES_CANONICAL_LINUX_SYSCALLS return internal_syscall(SYSCALL(clone), SIGCHLD, 0); #else return internal_syscall(SYSCALL(fork)); #endif } #if SANITIZER_FREEBSD || SANITIZER_OPENBSD int internal_sysctl(const int *name, unsigned int namelen, void *oldp, uptr *oldlenp, const void *newp, uptr newlen) { #if SANITIZER_OPENBSD return sysctl(name, namelen, oldp, (size_t *)oldlenp, (void *)newp, (size_t)newlen); #else return internal_syscall(SYSCALL(__sysctl), name, namelen, oldp, (size_t *)oldlenp, newp, (size_t)newlen); #endif } #if SANITIZER_FREEBSD int internal_sysctlbyname(const char *sname, void *oldp, uptr *oldlenp, const void *newp, uptr newlen) { - return sysctlbyname(sname, oldp, (size_t *)oldlenp, newp, (size_t)newlen); + static decltype(sysctlbyname) *real = nullptr; + if (!real) + real = (decltype(sysctlbyname) *)dlsym(RTLD_NEXT, "sysctlbyname"); + CHECK(real); + return real(sname, oldp, (size_t *)oldlenp, newp, (size_t)newlen); } #endif #endif #if SANITIZER_LINUX #define SA_RESTORER 0x04000000 // Doesn't set sa_restorer if the caller did not set it, so use with caution //(see below). int internal_sigaction_norestorer(int signum, const void *act, void *oldact) { __sanitizer_kernel_sigaction_t k_act, k_oldact; internal_memset(&k_act, 0, sizeof(__sanitizer_kernel_sigaction_t)); internal_memset(&k_oldact, 0, sizeof(__sanitizer_kernel_sigaction_t)); const __sanitizer_sigaction *u_act = (const __sanitizer_sigaction *)act; __sanitizer_sigaction *u_oldact = (__sanitizer_sigaction *)oldact; if (u_act) { k_act.handler = u_act->handler; k_act.sigaction = u_act->sigaction; internal_memcpy(&k_act.sa_mask, &u_act->sa_mask, sizeof(__sanitizer_kernel_sigset_t)); // Without SA_RESTORER kernel ignores the calls (probably returns EINVAL). k_act.sa_flags = u_act->sa_flags | SA_RESTORER; // FIXME: most often sa_restorer is unset, however the kernel requires it // to point to a valid signal restorer that calls the rt_sigreturn syscall. // If sa_restorer passed to the kernel is NULL, the program may crash upon // signal delivery or fail to unwind the stack in the signal handler. // libc implementation of sigaction() passes its own restorer to // rt_sigaction, so we need to do the same (we'll need to reimplement the // restorers; for x86_64 the restorer address can be obtained from // oldact->sa_restorer upon a call to sigaction(xxx, NULL, oldact). #if !SANITIZER_ANDROID || !SANITIZER_MIPS32 k_act.sa_restorer = u_act->sa_restorer; #endif } uptr result = internal_syscall(SYSCALL(rt_sigaction), (uptr)signum, (uptr)(u_act ? &k_act : nullptr), (uptr)(u_oldact ? &k_oldact : nullptr), (uptr)sizeof(__sanitizer_kernel_sigset_t)); if ((result == 0) && u_oldact) { u_oldact->handler = k_oldact.handler; u_oldact->sigaction = k_oldact.sigaction; internal_memcpy(&u_oldact->sa_mask, &k_oldact.sa_mask, sizeof(__sanitizer_kernel_sigset_t)); u_oldact->sa_flags = k_oldact.sa_flags; #if !SANITIZER_ANDROID || !SANITIZER_MIPS32 u_oldact->sa_restorer = k_oldact.sa_restorer; #endif } return result; } #endif // SANITIZER_LINUX uptr internal_sigprocmask(int how, __sanitizer_sigset_t *set, __sanitizer_sigset_t *oldset) { #if SANITIZER_FREEBSD || SANITIZER_OPENBSD return internal_syscall(SYSCALL(sigprocmask), how, set, oldset); #else __sanitizer_kernel_sigset_t *k_set = (__sanitizer_kernel_sigset_t *)set; __sanitizer_kernel_sigset_t *k_oldset = (__sanitizer_kernel_sigset_t *)oldset; return internal_syscall(SYSCALL(rt_sigprocmask), (uptr)how, (uptr)&k_set->sig[0], (uptr)&k_oldset->sig[0], sizeof(__sanitizer_kernel_sigset_t)); #endif } void internal_sigfillset(__sanitizer_sigset_t *set) { internal_memset(set, 0xff, sizeof(*set)); } void internal_sigemptyset(__sanitizer_sigset_t *set) { internal_memset(set, 0, sizeof(*set)); } #if SANITIZER_LINUX void internal_sigdelset(__sanitizer_sigset_t *set, int signum) { signum -= 1; CHECK_GE(signum, 0); CHECK_LT(signum, sizeof(*set) * 8); __sanitizer_kernel_sigset_t *k_set = (__sanitizer_kernel_sigset_t *)set; const uptr idx = signum / (sizeof(k_set->sig[0]) * 8); const uptr bit = signum % (sizeof(k_set->sig[0]) * 8); k_set->sig[idx] &= ~(1 << bit); } bool internal_sigismember(__sanitizer_sigset_t *set, int signum) { signum -= 1; CHECK_GE(signum, 0); CHECK_LT(signum, sizeof(*set) * 8); __sanitizer_kernel_sigset_t *k_set = (__sanitizer_kernel_sigset_t *)set; const uptr idx = signum / (sizeof(k_set->sig[0]) * 8); const uptr bit = signum % (sizeof(k_set->sig[0]) * 8); return k_set->sig[idx] & (1 << bit); } #elif SANITIZER_FREEBSD void internal_sigdelset(__sanitizer_sigset_t *set, int signum) { sigset_t *rset = reinterpret_cast(set); sigdelset(rset, signum); } bool internal_sigismember(__sanitizer_sigset_t *set, int signum) { sigset_t *rset = reinterpret_cast(set); return sigismember(rset, signum); } #endif #endif // !SANITIZER_SOLARIS #if !SANITIZER_NETBSD // ThreadLister implementation. ThreadLister::ThreadLister(pid_t pid) : pid_(pid), buffer_(4096) { char task_directory_path[80]; internal_snprintf(task_directory_path, sizeof(task_directory_path), "/proc/%d/task/", pid); descriptor_ = internal_open(task_directory_path, O_RDONLY | O_DIRECTORY); if (internal_iserror(descriptor_)) { Report("Can't open /proc/%d/task for reading.\n", pid); } } ThreadLister::Result ThreadLister::ListThreads( InternalMmapVector *threads) { if (internal_iserror(descriptor_)) return Error; internal_lseek(descriptor_, 0, SEEK_SET); threads->clear(); Result result = Ok; for (bool first_read = true;; first_read = false) { // Resize to max capacity if it was downsized by IsAlive. buffer_.resize(buffer_.capacity()); CHECK_GE(buffer_.size(), 4096); uptr read = internal_getdents( descriptor_, (struct linux_dirent *)buffer_.data(), buffer_.size()); if (!read) return result; if (internal_iserror(read)) { Report("Can't read directory entries from /proc/%d/task.\n", pid_); return Error; } for (uptr begin = (uptr)buffer_.data(), end = begin + read; begin < end;) { struct linux_dirent *entry = (struct linux_dirent *)begin; begin += entry->d_reclen; if (entry->d_ino == 1) { // Inode 1 is for bad blocks and also can be a reason for early return. // Should be emitted if kernel tried to output terminating thread. // See proc_task_readdir implementation in Linux. result = Incomplete; } if (entry->d_ino && *entry->d_name >= '0' && *entry->d_name <= '9') threads->push_back(internal_atoll(entry->d_name)); } // Now we are going to detect short-read or early EOF. In such cases Linux // can return inconsistent list with missing alive threads. // Code will just remember that the list can be incomplete but it will // continue reads to return as much as possible. if (!first_read) { // The first one was a short-read by definition. result = Incomplete; } else if (read > buffer_.size() - 1024) { // Read was close to the buffer size. So double the size and assume the // worst. buffer_.resize(buffer_.size() * 2); result = Incomplete; } else if (!threads->empty() && !IsAlive(threads->back())) { // Maybe Linux early returned from read on terminated thread (!pid_alive) // and failed to restore read position. // See next_tid and proc_task_instantiate in Linux. result = Incomplete; } } } bool ThreadLister::IsAlive(int tid) { // /proc/%d/task/%d/status uses same call to detect alive threads as // proc_task_readdir. See task_state implementation in Linux. char path[80]; internal_snprintf(path, sizeof(path), "/proc/%d/task/%d/status", pid_, tid); if (!ReadFileToVector(path, &buffer_) || buffer_.empty()) return false; buffer_.push_back(0); static const char kPrefix[] = "\nPPid:"; const char *field = internal_strstr(buffer_.data(), kPrefix); if (!field) return false; field += internal_strlen(kPrefix); return (int)internal_atoll(field) != 0; } ThreadLister::~ThreadLister() { if (!internal_iserror(descriptor_)) internal_close(descriptor_); } #endif #if SANITIZER_WORDSIZE == 32 // Take care of unusable kernel area in top gigabyte. static uptr GetKernelAreaSize() { #if SANITIZER_LINUX && !SANITIZER_X32 const uptr gbyte = 1UL << 30; // Firstly check if there are writable segments // mapped to top gigabyte (e.g. stack). MemoryMappingLayout proc_maps(/*cache_enabled*/true); if (proc_maps.Error()) return 0; MemoryMappedSegment segment; while (proc_maps.Next(&segment)) { if ((segment.end >= 3 * gbyte) && segment.IsWritable()) return 0; } #if !SANITIZER_ANDROID // Even if nothing is mapped, top Gb may still be accessible // if we are running on 64-bit kernel. // Uname may report misleading results if personality type // is modified (e.g. under schroot) so check this as well. struct utsname uname_info; int pers = personality(0xffffffffUL); if (!(pers & PER_MASK) && uname(&uname_info) == 0 && internal_strstr(uname_info.machine, "64")) return 0; #endif // SANITIZER_ANDROID // Top gigabyte is reserved for kernel. return gbyte; #else return 0; #endif // SANITIZER_LINUX && !SANITIZER_X32 } #endif // SANITIZER_WORDSIZE == 32 uptr GetMaxVirtualAddress() { #if (SANITIZER_NETBSD || SANITIZER_OPENBSD) && defined(__x86_64__) return 0x7f7ffffff000ULL; // (0x00007f8000000000 - PAGE_SIZE) #elif SANITIZER_WORDSIZE == 64 # if defined(__powerpc64__) || defined(__aarch64__) // On PowerPC64 we have two different address space layouts: 44- and 46-bit. // We somehow need to figure out which one we are using now and choose // one of 0x00000fffffffffffUL and 0x00003fffffffffffUL. // Note that with 'ulimit -s unlimited' the stack is moved away from the top // of the address space, so simply checking the stack address is not enough. // This should (does) work for both PowerPC64 Endian modes. // Similarly, aarch64 has multiple address space layouts: 39, 42 and 47-bit. return (1ULL << (MostSignificantSetBitIndex(GET_CURRENT_FRAME()) + 1)) - 1; # elif defined(__mips64) return (1ULL << 40) - 1; // 0x000000ffffffffffUL; # elif defined(__s390x__) return (1ULL << 53) - 1; // 0x001fffffffffffffUL; #elif defined(__sparc__) return ~(uptr)0; # else return (1ULL << 47) - 1; // 0x00007fffffffffffUL; # endif #else // SANITIZER_WORDSIZE == 32 # if defined(__s390__) return (1ULL << 31) - 1; // 0x7fffffff; # else return (1ULL << 32) - 1; // 0xffffffff; # endif #endif // SANITIZER_WORDSIZE } uptr GetMaxUserVirtualAddress() { uptr addr = GetMaxVirtualAddress(); #if SANITIZER_WORDSIZE == 32 && !defined(__s390__) if (!common_flags()->full_address_space) addr -= GetKernelAreaSize(); CHECK_LT(reinterpret_cast(&addr), addr); #endif return addr; } #if !SANITIZER_ANDROID uptr GetPageSize() { #if SANITIZER_LINUX && (defined(__x86_64__) || defined(__i386__)) return EXEC_PAGESIZE; #elif SANITIZER_USE_GETAUXVAL return getauxval(AT_PAGESZ); #elif SANITIZER_FREEBSD || SANITIZER_NETBSD // Use sysctl as sysconf can trigger interceptors internally. int pz = 0; uptr pzl = sizeof(pz); int mib[2] = {CTL_HW, HW_PAGESIZE}; int rv = internal_sysctl(mib, 2, &pz, &pzl, nullptr, 0); CHECK_EQ(rv, 0); return (uptr)pz; #else return sysconf(_SC_PAGESIZE); // EXEC_PAGESIZE may not be trustworthy. #endif } #endif // !SANITIZER_ANDROID #if !SANITIZER_OPENBSD uptr ReadBinaryName(/*out*/char *buf, uptr buf_len) { #if SANITIZER_SOLARIS const char *default_module_name = getexecname(); CHECK_NE(default_module_name, NULL); return internal_snprintf(buf, buf_len, "%s", default_module_name); #else #if SANITIZER_FREEBSD || SANITIZER_NETBSD #if SANITIZER_FREEBSD const int Mib[4] = {CTL_KERN, KERN_PROC, KERN_PROC_PATHNAME, -1}; #else const int Mib[4] = {CTL_KERN, KERN_PROC_ARGS, -1, KERN_PROC_PATHNAME}; #endif const char *default_module_name = "kern.proc.pathname"; uptr Size = buf_len; bool IsErr = (internal_sysctl(Mib, ARRAY_SIZE(Mib), buf, &Size, NULL, 0) != 0); int readlink_error = IsErr ? errno : 0; uptr module_name_len = Size; #else const char *default_module_name = "/proc/self/exe"; uptr module_name_len = internal_readlink( default_module_name, buf, buf_len); int readlink_error; bool IsErr = internal_iserror(module_name_len, &readlink_error); #endif // SANITIZER_SOLARIS if (IsErr) { // We can't read binary name for some reason, assume it's unknown. Report("WARNING: reading executable name failed with errno %d, " "some stack frames may not be symbolized\n", readlink_error); module_name_len = internal_snprintf(buf, buf_len, "%s", default_module_name); CHECK_LT(module_name_len, buf_len); } return module_name_len; #endif } #endif // !SANITIZER_OPENBSD uptr ReadLongProcessName(/*out*/ char *buf, uptr buf_len) { #if SANITIZER_LINUX char *tmpbuf; uptr tmpsize; uptr tmplen; if (ReadFileToBuffer("/proc/self/cmdline", &tmpbuf, &tmpsize, &tmplen, 1024 * 1024)) { internal_strncpy(buf, tmpbuf, buf_len); UnmapOrDie(tmpbuf, tmpsize); return internal_strlen(buf); } #endif return ReadBinaryName(buf, buf_len); } // Match full names of the form /path/to/base_name{-,.}* bool LibraryNameIs(const char *full_name, const char *base_name) { const char *name = full_name; // Strip path. while (*name != '\0') name++; while (name > full_name && *name != '/') name--; if (*name == '/') name++; uptr base_name_length = internal_strlen(base_name); if (internal_strncmp(name, base_name, base_name_length)) return false; return (name[base_name_length] == '-' || name[base_name_length] == '.'); } #if !SANITIZER_ANDROID // Call cb for each region mapped by map. void ForEachMappedRegion(link_map *map, void (*cb)(const void *, uptr)) { CHECK_NE(map, nullptr); #if !SANITIZER_FREEBSD && !SANITIZER_OPENBSD typedef ElfW(Phdr) Elf_Phdr; typedef ElfW(Ehdr) Elf_Ehdr; #endif // !SANITIZER_FREEBSD && !SANITIZER_OPENBSD char *base = (char *)map->l_addr; Elf_Ehdr *ehdr = (Elf_Ehdr *)base; char *phdrs = base + ehdr->e_phoff; char *phdrs_end = phdrs + ehdr->e_phnum * ehdr->e_phentsize; // Find the segment with the minimum base so we can "relocate" the p_vaddr // fields. Typically ET_DYN objects (DSOs) have base of zero and ET_EXEC // objects have a non-zero base. uptr preferred_base = (uptr)-1; for (char *iter = phdrs; iter != phdrs_end; iter += ehdr->e_phentsize) { Elf_Phdr *phdr = (Elf_Phdr *)iter; if (phdr->p_type == PT_LOAD && preferred_base > (uptr)phdr->p_vaddr) preferred_base = (uptr)phdr->p_vaddr; } // Compute the delta from the real base to get a relocation delta. sptr delta = (uptr)base - preferred_base; // Now we can figure out what the loader really mapped. for (char *iter = phdrs; iter != phdrs_end; iter += ehdr->e_phentsize) { Elf_Phdr *phdr = (Elf_Phdr *)iter; if (phdr->p_type == PT_LOAD) { uptr seg_start = phdr->p_vaddr + delta; uptr seg_end = seg_start + phdr->p_memsz; // None of these values are aligned. We consider the ragged edges of the // load command as defined, since they are mapped from the file. seg_start = RoundDownTo(seg_start, GetPageSizeCached()); seg_end = RoundUpTo(seg_end, GetPageSizeCached()); cb((void *)seg_start, seg_end - seg_start); } } } #endif #if defined(__x86_64__) && SANITIZER_LINUX // We cannot use glibc's clone wrapper, because it messes with the child // task's TLS. It writes the PID and TID of the child task to its thread // descriptor, but in our case the child task shares the thread descriptor with // the parent (because we don't know how to allocate a new thread // descriptor to keep glibc happy). So the stock version of clone(), when // used with CLONE_VM, would end up corrupting the parent's thread descriptor. uptr internal_clone(int (*fn)(void *), void *child_stack, int flags, void *arg, int *parent_tidptr, void *newtls, int *child_tidptr) { long long res; if (!fn || !child_stack) return -EINVAL; CHECK_EQ(0, (uptr)child_stack % 16); child_stack = (char *)child_stack - 2 * sizeof(unsigned long long); ((unsigned long long *)child_stack)[0] = (uptr)fn; ((unsigned long long *)child_stack)[1] = (uptr)arg; register void *r8 __asm__("r8") = newtls; register int *r10 __asm__("r10") = child_tidptr; __asm__ __volatile__( /* %rax = syscall(%rax = SYSCALL(clone), * %rdi = flags, * %rsi = child_stack, * %rdx = parent_tidptr, * %r8 = new_tls, * %r10 = child_tidptr) */ "syscall\n" /* if (%rax != 0) * return; */ "testq %%rax,%%rax\n" "jnz 1f\n" /* In the child. Terminate unwind chain. */ // XXX: We should also terminate the CFI unwind chain // here. Unfortunately clang 3.2 doesn't support the // necessary CFI directives, so we skip that part. "xorq %%rbp,%%rbp\n" /* Call "fn(arg)". */ "popq %%rax\n" "popq %%rdi\n" "call *%%rax\n" /* Call _exit(%rax). */ "movq %%rax,%%rdi\n" "movq %2,%%rax\n" "syscall\n" /* Return to parent. */ "1:\n" : "=a" (res) : "a"(SYSCALL(clone)), "i"(SYSCALL(exit)), "S"(child_stack), "D"(flags), "d"(parent_tidptr), "r"(r8), "r"(r10) : "memory", "r11", "rcx"); return res; } #elif defined(__mips__) uptr internal_clone(int (*fn)(void *), void *child_stack, int flags, void *arg, int *parent_tidptr, void *newtls, int *child_tidptr) { long long res; if (!fn || !child_stack) return -EINVAL; CHECK_EQ(0, (uptr)child_stack % 16); child_stack = (char *)child_stack - 2 * sizeof(unsigned long long); ((unsigned long long *)child_stack)[0] = (uptr)fn; ((unsigned long long *)child_stack)[1] = (uptr)arg; register void *a3 __asm__("$7") = newtls; register int *a4 __asm__("$8") = child_tidptr; // We don't have proper CFI directives here because it requires alot of code // for very marginal benefits. __asm__ __volatile__( /* $v0 = syscall($v0 = __NR_clone, * $a0 = flags, * $a1 = child_stack, * $a2 = parent_tidptr, * $a3 = new_tls, * $a4 = child_tidptr) */ ".cprestore 16;\n" "move $4,%1;\n" "move $5,%2;\n" "move $6,%3;\n" "move $7,%4;\n" /* Store the fifth argument on stack * if we are using 32-bit abi. */ #if SANITIZER_WORDSIZE == 32 "lw %5,16($29);\n" #else "move $8,%5;\n" #endif "li $2,%6;\n" "syscall;\n" /* if ($v0 != 0) * return; */ "bnez $2,1f;\n" /* Call "fn(arg)". */ #if SANITIZER_WORDSIZE == 32 #ifdef __BIG_ENDIAN__ "lw $25,4($29);\n" "lw $4,12($29);\n" #else "lw $25,0($29);\n" "lw $4,8($29);\n" #endif #else "ld $25,0($29);\n" "ld $4,8($29);\n" #endif "jal $25;\n" /* Call _exit($v0). */ "move $4,$2;\n" "li $2,%7;\n" "syscall;\n" /* Return to parent. */ "1:\n" : "=r" (res) : "r"(flags), "r"(child_stack), "r"(parent_tidptr), "r"(a3), "r"(a4), "i"(__NR_clone), "i"(__NR_exit) : "memory", "$29" ); return res; } #elif defined(__aarch64__) uptr internal_clone(int (*fn)(void *), void *child_stack, int flags, void *arg, int *parent_tidptr, void *newtls, int *child_tidptr) { long long res; if (!fn || !child_stack) return -EINVAL; CHECK_EQ(0, (uptr)child_stack % 16); child_stack = (char *)child_stack - 2 * sizeof(unsigned long long); ((unsigned long long *)child_stack)[0] = (uptr)fn; ((unsigned long long *)child_stack)[1] = (uptr)arg; register int (*__fn)(void *) __asm__("x0") = fn; register void *__stack __asm__("x1") = child_stack; register int __flags __asm__("x2") = flags; register void *__arg __asm__("x3") = arg; register int *__ptid __asm__("x4") = parent_tidptr; register void *__tls __asm__("x5") = newtls; register int *__ctid __asm__("x6") = child_tidptr; __asm__ __volatile__( "mov x0,x2\n" /* flags */ "mov x2,x4\n" /* ptid */ "mov x3,x5\n" /* tls */ "mov x4,x6\n" /* ctid */ "mov x8,%9\n" /* clone */ "svc 0x0\n" /* if (%r0 != 0) * return %r0; */ "cmp x0, #0\n" "bne 1f\n" /* In the child, now. Call "fn(arg)". */ "ldp x1, x0, [sp], #16\n" "blr x1\n" /* Call _exit(%r0). */ "mov x8, %10\n" "svc 0x0\n" "1:\n" : "=r" (res) : "i"(-EINVAL), "r"(__fn), "r"(__stack), "r"(__flags), "r"(__arg), "r"(__ptid), "r"(__tls), "r"(__ctid), "i"(__NR_clone), "i"(__NR_exit) : "x30", "memory"); return res; } #elif defined(__powerpc64__) uptr internal_clone(int (*fn)(void *), void *child_stack, int flags, void *arg, int *parent_tidptr, void *newtls, int *child_tidptr) { long long res; // Stack frame structure. #if SANITIZER_PPC64V1 // Back chain == 0 (SP + 112) // Frame (112 bytes): // Parameter save area (SP + 48), 8 doublewords // TOC save area (SP + 40) // Link editor doubleword (SP + 32) // Compiler doubleword (SP + 24) // LR save area (SP + 16) // CR save area (SP + 8) // Back chain (SP + 0) # define FRAME_SIZE 112 # define FRAME_TOC_SAVE_OFFSET 40 #elif SANITIZER_PPC64V2 // Back chain == 0 (SP + 32) // Frame (32 bytes): // TOC save area (SP + 24) // LR save area (SP + 16) // CR save area (SP + 8) // Back chain (SP + 0) # define FRAME_SIZE 32 # define FRAME_TOC_SAVE_OFFSET 24 #else # error "Unsupported PPC64 ABI" #endif if (!fn || !child_stack) return -EINVAL; CHECK_EQ(0, (uptr)child_stack % 16); register int (*__fn)(void *) __asm__("r3") = fn; register void *__cstack __asm__("r4") = child_stack; register int __flags __asm__("r5") = flags; register void *__arg __asm__("r6") = arg; register int *__ptidptr __asm__("r7") = parent_tidptr; register void *__newtls __asm__("r8") = newtls; register int *__ctidptr __asm__("r9") = child_tidptr; __asm__ __volatile__( /* fn and arg are saved across the syscall */ "mr 28, %5\n\t" "mr 27, %8\n\t" /* syscall r0 == __NR_clone r3 == flags r4 == child_stack r5 == parent_tidptr r6 == newtls r7 == child_tidptr */ "mr 3, %7\n\t" "mr 5, %9\n\t" "mr 6, %10\n\t" "mr 7, %11\n\t" "li 0, %3\n\t" "sc\n\t" /* Test if syscall was successful */ "cmpdi cr1, 3, 0\n\t" "crandc cr1*4+eq, cr1*4+eq, cr0*4+so\n\t" "bne- cr1, 1f\n\t" /* Set up stack frame */ "li 29, 0\n\t" "stdu 29, -8(1)\n\t" "stdu 1, -%12(1)\n\t" /* Do the function call */ "std 2, %13(1)\n\t" #if SANITIZER_PPC64V1 "ld 0, 0(28)\n\t" "ld 2, 8(28)\n\t" "mtctr 0\n\t" #elif SANITIZER_PPC64V2 "mr 12, 28\n\t" "mtctr 12\n\t" #else # error "Unsupported PPC64 ABI" #endif "mr 3, 27\n\t" "bctrl\n\t" "ld 2, %13(1)\n\t" /* Call _exit(r3) */ "li 0, %4\n\t" "sc\n\t" /* Return to parent */ "1:\n\t" "mr %0, 3\n\t" : "=r" (res) : "0" (-1), "i" (EINVAL), "i" (__NR_clone), "i" (__NR_exit), "r" (__fn), "r" (__cstack), "r" (__flags), "r" (__arg), "r" (__ptidptr), "r" (__newtls), "r" (__ctidptr), "i" (FRAME_SIZE), "i" (FRAME_TOC_SAVE_OFFSET) : "cr0", "cr1", "memory", "ctr", "r0", "r27", "r28", "r29"); return res; } #elif defined(__i386__) && SANITIZER_LINUX uptr internal_clone(int (*fn)(void *), void *child_stack, int flags, void *arg, int *parent_tidptr, void *newtls, int *child_tidptr) { int res; if (!fn || !child_stack) return -EINVAL; CHECK_EQ(0, (uptr)child_stack % 16); child_stack = (char *)child_stack - 7 * sizeof(unsigned int); ((unsigned int *)child_stack)[0] = (uptr)flags; ((unsigned int *)child_stack)[1] = (uptr)0; ((unsigned int *)child_stack)[2] = (uptr)fn; ((unsigned int *)child_stack)[3] = (uptr)arg; __asm__ __volatile__( /* %eax = syscall(%eax = SYSCALL(clone), * %ebx = flags, * %ecx = child_stack, * %edx = parent_tidptr, * %esi = new_tls, * %edi = child_tidptr) */ /* Obtain flags */ "movl (%%ecx), %%ebx\n" /* Do the system call */ "pushl %%ebx\n" "pushl %%esi\n" "pushl %%edi\n" /* Remember the flag value. */ "movl %%ebx, (%%ecx)\n" "int $0x80\n" "popl %%edi\n" "popl %%esi\n" "popl %%ebx\n" /* if (%eax != 0) * return; */ "test %%eax,%%eax\n" "jnz 1f\n" /* terminate the stack frame */ "xorl %%ebp,%%ebp\n" /* Call FN. */ "call *%%ebx\n" #ifdef PIC "call here\n" "here:\n" "popl %%ebx\n" "addl $_GLOBAL_OFFSET_TABLE_+[.-here], %%ebx\n" #endif /* Call exit */ "movl %%eax, %%ebx\n" "movl %2, %%eax\n" "int $0x80\n" "1:\n" : "=a" (res) : "a"(SYSCALL(clone)), "i"(SYSCALL(exit)), "c"(child_stack), "d"(parent_tidptr), "S"(newtls), "D"(child_tidptr) : "memory"); return res; } #elif defined(__arm__) && SANITIZER_LINUX uptr internal_clone(int (*fn)(void *), void *child_stack, int flags, void *arg, int *parent_tidptr, void *newtls, int *child_tidptr) { unsigned int res; if (!fn || !child_stack) return -EINVAL; child_stack = (char *)child_stack - 2 * sizeof(unsigned int); ((unsigned int *)child_stack)[0] = (uptr)fn; ((unsigned int *)child_stack)[1] = (uptr)arg; register int r0 __asm__("r0") = flags; register void *r1 __asm__("r1") = child_stack; register int *r2 __asm__("r2") = parent_tidptr; register void *r3 __asm__("r3") = newtls; register int *r4 __asm__("r4") = child_tidptr; register int r7 __asm__("r7") = __NR_clone; #if __ARM_ARCH > 4 || defined (__ARM_ARCH_4T__) # define ARCH_HAS_BX #endif #if __ARM_ARCH > 4 # define ARCH_HAS_BLX #endif #ifdef ARCH_HAS_BX # ifdef ARCH_HAS_BLX # define BLX(R) "blx " #R "\n" # else # define BLX(R) "mov lr, pc; bx " #R "\n" # endif #else # define BLX(R) "mov lr, pc; mov pc," #R "\n" #endif __asm__ __volatile__( /* %r0 = syscall(%r7 = SYSCALL(clone), * %r0 = flags, * %r1 = child_stack, * %r2 = parent_tidptr, * %r3 = new_tls, * %r4 = child_tidptr) */ /* Do the system call */ "swi 0x0\n" /* if (%r0 != 0) * return %r0; */ "cmp r0, #0\n" "bne 1f\n" /* In the child, now. Call "fn(arg)". */ "ldr r0, [sp, #4]\n" "ldr ip, [sp], #8\n" BLX(ip) /* Call _exit(%r0). */ "mov r7, %7\n" "swi 0x0\n" "1:\n" "mov %0, r0\n" : "=r"(res) : "r"(r0), "r"(r1), "r"(r2), "r"(r3), "r"(r4), "r"(r7), "i"(__NR_exit) : "memory"); return res; } #endif // defined(__x86_64__) && SANITIZER_LINUX #if SANITIZER_ANDROID #if __ANDROID_API__ < 21 extern "C" __attribute__((weak)) int dl_iterate_phdr( int (*)(struct dl_phdr_info *, size_t, void *), void *); #endif static int dl_iterate_phdr_test_cb(struct dl_phdr_info *info, size_t size, void *data) { // Any name starting with "lib" indicates a bug in L where library base names // are returned instead of paths. if (info->dlpi_name && info->dlpi_name[0] == 'l' && info->dlpi_name[1] == 'i' && info->dlpi_name[2] == 'b') { *(bool *)data = true; return 1; } return 0; } static atomic_uint32_t android_api_level; static AndroidApiLevel AndroidDetectApiLevelStatic() { #if __ANDROID_API__ <= 19 return ANDROID_KITKAT; #elif __ANDROID_API__ <= 22 return ANDROID_LOLLIPOP_MR1; #else return ANDROID_POST_LOLLIPOP; #endif } static AndroidApiLevel AndroidDetectApiLevel() { if (!&dl_iterate_phdr) return ANDROID_KITKAT; // K or lower bool base_name_seen = false; dl_iterate_phdr(dl_iterate_phdr_test_cb, &base_name_seen); if (base_name_seen) return ANDROID_LOLLIPOP_MR1; // L MR1 return ANDROID_POST_LOLLIPOP; // post-L // Plain L (API level 21) is completely broken wrt ASan and not very // interesting to detect. } extern "C" __attribute__((weak)) void* _DYNAMIC; AndroidApiLevel AndroidGetApiLevel() { AndroidApiLevel level = (AndroidApiLevel)atomic_load(&android_api_level, memory_order_relaxed); if (level) return level; level = &_DYNAMIC == nullptr ? AndroidDetectApiLevelStatic() : AndroidDetectApiLevel(); atomic_store(&android_api_level, level, memory_order_relaxed); return level; } #endif static HandleSignalMode GetHandleSignalModeImpl(int signum) { switch (signum) { case SIGABRT: return common_flags()->handle_abort; case SIGILL: return common_flags()->handle_sigill; case SIGTRAP: return common_flags()->handle_sigtrap; case SIGFPE: return common_flags()->handle_sigfpe; case SIGSEGV: return common_flags()->handle_segv; case SIGBUS: return common_flags()->handle_sigbus; } return kHandleSignalNo; } HandleSignalMode GetHandleSignalMode(int signum) { HandleSignalMode result = GetHandleSignalModeImpl(signum); if (result == kHandleSignalYes && !common_flags()->allow_user_segv_handler) return kHandleSignalExclusive; return result; } #if !SANITIZER_GO void *internal_start_thread(void(*func)(void *arg), void *arg) { // Start the thread with signals blocked, otherwise it can steal user signals. __sanitizer_sigset_t set, old; internal_sigfillset(&set); #if SANITIZER_LINUX && !SANITIZER_ANDROID // Glibc uses SIGSETXID signal during setuid call. If this signal is blocked // on any thread, setuid call hangs (see test/tsan/setuid.c). internal_sigdelset(&set, 33); #endif internal_sigprocmask(SIG_SETMASK, &set, &old); void *th; real_pthread_create(&th, nullptr, (void*(*)(void *arg))func, arg); internal_sigprocmask(SIG_SETMASK, &old, nullptr); return th; } void internal_join_thread(void *th) { real_pthread_join(th, nullptr); } #else void *internal_start_thread(void (*func)(void *), void *arg) { return 0; } void internal_join_thread(void *th) {} #endif #if defined(__aarch64__) // Android headers in the older NDK releases miss this definition. struct __sanitizer_esr_context { struct _aarch64_ctx head; uint64_t esr; }; static bool Aarch64GetESR(ucontext_t *ucontext, u64 *esr) { static const u32 kEsrMagic = 0x45535201; u8 *aux = ucontext->uc_mcontext.__reserved; while (true) { _aarch64_ctx *ctx = (_aarch64_ctx *)aux; if (ctx->size == 0) break; if (ctx->magic == kEsrMagic) { *esr = ((__sanitizer_esr_context *)ctx)->esr; return true; } aux += ctx->size; } return false; } #endif #if SANITIZER_OPENBSD using Context = sigcontext; #else using Context = ucontext_t; #endif SignalContext::WriteFlag SignalContext::GetWriteFlag() const { Context *ucontext = (Context *)context; #if defined(__x86_64__) || defined(__i386__) static const uptr PF_WRITE = 1U << 1; #if SANITIZER_FREEBSD uptr err = ucontext->uc_mcontext.mc_err; #elif SANITIZER_NETBSD uptr err = ucontext->uc_mcontext.__gregs[_REG_ERR]; #elif SANITIZER_OPENBSD uptr err = ucontext->sc_err; #elif SANITIZER_SOLARIS && defined(__i386__) const int Err = 13; uptr err = ucontext->uc_mcontext.gregs[Err]; #else uptr err = ucontext->uc_mcontext.gregs[REG_ERR]; #endif // SANITIZER_FREEBSD return err & PF_WRITE ? WRITE : READ; #elif defined(__mips__) uint32_t *exception_source; uint32_t faulty_instruction; uint32_t op_code; exception_source = (uint32_t *)ucontext->uc_mcontext.pc; faulty_instruction = (uint32_t)(*exception_source); op_code = (faulty_instruction >> 26) & 0x3f; // FIXME: Add support for FPU, microMIPS, DSP, MSA memory instructions. switch (op_code) { case 0x28: // sb case 0x29: // sh case 0x2b: // sw case 0x3f: // sd #if __mips_isa_rev < 6 case 0x2c: // sdl case 0x2d: // sdr case 0x2a: // swl case 0x2e: // swr #endif return SignalContext::WRITE; case 0x20: // lb case 0x24: // lbu case 0x21: // lh case 0x25: // lhu case 0x23: // lw case 0x27: // lwu case 0x37: // ld #if __mips_isa_rev < 6 case 0x1a: // ldl case 0x1b: // ldr case 0x22: // lwl case 0x26: // lwr #endif return SignalContext::READ; #if __mips_isa_rev == 6 case 0x3b: // pcrel op_code = (faulty_instruction >> 19) & 0x3; switch (op_code) { case 0x1: // lwpc case 0x2: // lwupc return SignalContext::READ; } #endif } return SignalContext::UNKNOWN; #elif defined(__arm__) static const uptr FSR_WRITE = 1U << 11; uptr fsr = ucontext->uc_mcontext.error_code; return fsr & FSR_WRITE ? WRITE : READ; #elif defined(__aarch64__) static const u64 ESR_ELx_WNR = 1U << 6; u64 esr; if (!Aarch64GetESR(ucontext, &esr)) return UNKNOWN; return esr & ESR_ELx_WNR ? WRITE : READ; #elif defined(__sparc__) // Decode the instruction to determine the access type. // From OpenSolaris $SRC/uts/sun4/os/trap.c (get_accesstype). #if SANITIZER_SOLARIS uptr pc = ucontext->uc_mcontext.gregs[REG_PC]; #else // Historical BSDism here. struct sigcontext *scontext = (struct sigcontext *)context; #if defined(__arch64__) uptr pc = scontext->sigc_regs.tpc; #else uptr pc = scontext->si_regs.pc; #endif #endif u32 instr = *(u32 *)pc; return (instr >> 21) & 1 ? WRITE: READ; #else (void)ucontext; return UNKNOWN; // FIXME: Implement. #endif } void SignalContext::DumpAllRegisters(void *context) { // FIXME: Implement this. } static void GetPcSpBp(void *context, uptr *pc, uptr *sp, uptr *bp) { #if SANITIZER_NETBSD // This covers all NetBSD architectures ucontext_t *ucontext = (ucontext_t *)context; *pc = _UC_MACHINE_PC(ucontext); *bp = _UC_MACHINE_FP(ucontext); *sp = _UC_MACHINE_SP(ucontext); #elif defined(__arm__) ucontext_t *ucontext = (ucontext_t*)context; *pc = ucontext->uc_mcontext.arm_pc; *bp = ucontext->uc_mcontext.arm_fp; *sp = ucontext->uc_mcontext.arm_sp; #elif defined(__aarch64__) ucontext_t *ucontext = (ucontext_t*)context; *pc = ucontext->uc_mcontext.pc; *bp = ucontext->uc_mcontext.regs[29]; *sp = ucontext->uc_mcontext.sp; #elif defined(__hppa__) ucontext_t *ucontext = (ucontext_t*)context; *pc = ucontext->uc_mcontext.sc_iaoq[0]; /* GCC uses %r3 whenever a frame pointer is needed. */ *bp = ucontext->uc_mcontext.sc_gr[3]; *sp = ucontext->uc_mcontext.sc_gr[30]; #elif defined(__x86_64__) # if SANITIZER_FREEBSD ucontext_t *ucontext = (ucontext_t*)context; *pc = ucontext->uc_mcontext.mc_rip; *bp = ucontext->uc_mcontext.mc_rbp; *sp = ucontext->uc_mcontext.mc_rsp; #elif SANITIZER_OPENBSD sigcontext *ucontext = (sigcontext *)context; *pc = ucontext->sc_rip; *bp = ucontext->sc_rbp; *sp = ucontext->sc_rsp; # else ucontext_t *ucontext = (ucontext_t*)context; *pc = ucontext->uc_mcontext.gregs[REG_RIP]; *bp = ucontext->uc_mcontext.gregs[REG_RBP]; *sp = ucontext->uc_mcontext.gregs[REG_RSP]; # endif #elif defined(__i386__) # if SANITIZER_FREEBSD ucontext_t *ucontext = (ucontext_t*)context; *pc = ucontext->uc_mcontext.mc_eip; *bp = ucontext->uc_mcontext.mc_ebp; *sp = ucontext->uc_mcontext.mc_esp; #elif SANITIZER_OPENBSD sigcontext *ucontext = (sigcontext *)context; *pc = ucontext->sc_eip; *bp = ucontext->sc_ebp; *sp = ucontext->sc_esp; # else ucontext_t *ucontext = (ucontext_t*)context; # if SANITIZER_SOLARIS /* Use the numeric values: the symbolic ones are undefined by llvm include/llvm/Support/Solaris.h. */ # ifndef REG_EIP # define REG_EIP 14 // REG_PC # endif # ifndef REG_EBP # define REG_EBP 6 // REG_FP # endif # ifndef REG_ESP # define REG_ESP 17 // REG_SP # endif # endif *pc = ucontext->uc_mcontext.gregs[REG_EIP]; *bp = ucontext->uc_mcontext.gregs[REG_EBP]; *sp = ucontext->uc_mcontext.gregs[REG_ESP]; # endif #elif defined(__powerpc__) || defined(__powerpc64__) ucontext_t *ucontext = (ucontext_t*)context; *pc = ucontext->uc_mcontext.regs->nip; *sp = ucontext->uc_mcontext.regs->gpr[PT_R1]; // The powerpc{,64}-linux ABIs do not specify r31 as the frame // pointer, but GCC always uses r31 when we need a frame pointer. *bp = ucontext->uc_mcontext.regs->gpr[PT_R31]; #elif defined(__sparc__) #if defined(__arch64__) || defined(__sparcv9) #define STACK_BIAS 2047 #else #define STACK_BIAS 0 # endif # if SANITIZER_SOLARIS ucontext_t *ucontext = (ucontext_t *)context; *pc = ucontext->uc_mcontext.gregs[REG_PC]; *sp = ucontext->uc_mcontext.gregs[REG_O6] + STACK_BIAS; #else // Historical BSDism here. struct sigcontext *scontext = (struct sigcontext *)context; #if defined(__arch64__) *pc = scontext->sigc_regs.tpc; *sp = scontext->sigc_regs.u_regs[14] + STACK_BIAS; #else *pc = scontext->si_regs.pc; *sp = scontext->si_regs.u_regs[14]; #endif # endif *bp = (uptr)((uhwptr *)*sp)[14] + STACK_BIAS; #elif defined(__mips__) ucontext_t *ucontext = (ucontext_t*)context; *pc = ucontext->uc_mcontext.pc; *bp = ucontext->uc_mcontext.gregs[30]; *sp = ucontext->uc_mcontext.gregs[29]; #elif defined(__s390__) ucontext_t *ucontext = (ucontext_t*)context; # if defined(__s390x__) *pc = ucontext->uc_mcontext.psw.addr; # else *pc = ucontext->uc_mcontext.psw.addr & 0x7fffffff; # endif *bp = ucontext->uc_mcontext.gregs[11]; *sp = ucontext->uc_mcontext.gregs[15]; #else # error "Unsupported arch" #endif } void SignalContext::InitPcSpBp() { GetPcSpBp(context, &pc, &sp, &bp); } void InitializePlatformEarly() { // Do nothing. } void MaybeReexec() { // No need to re-exec on Linux. } void CheckASLR() { #if SANITIZER_NETBSD int mib[3]; int paxflags; uptr len = sizeof(paxflags); mib[0] = CTL_PROC; mib[1] = internal_getpid(); mib[2] = PROC_PID_PAXFLAGS; if (UNLIKELY(internal_sysctl(mib, 3, &paxflags, &len, NULL, 0) == -1)) { Printf("sysctl failed\n"); Die(); } if (UNLIKELY(paxflags & CTL_PROC_PAXFLAGS_ASLR)) { Printf("This sanitizer is not compatible with enabled ASLR\n"); Die(); } #elif SANITIZER_PPC64V2 // Disable ASLR for Linux PPC64LE. int old_personality = personality(0xffffffff); if (old_personality != -1 && (old_personality & ADDR_NO_RANDOMIZE) == 0) { VReport(1, "WARNING: Program is being run with address space layout " "randomization (ASLR) enabled which prevents the thread and " "memory sanitizers from working on powerpc64le.\n" "ASLR will be disabled and the program re-executed.\n"); CHECK_NE(personality(old_personality | ADDR_NO_RANDOMIZE), -1); ReExec(); } #else // Do nothing #endif } void CheckMPROTECT() { #if SANITIZER_NETBSD int mib[3]; int paxflags; uptr len = sizeof(paxflags); mib[0] = CTL_PROC; mib[1] = internal_getpid(); mib[2] = PROC_PID_PAXFLAGS; if (UNLIKELY(internal_sysctl(mib, 3, &paxflags, &len, NULL, 0) == -1)) { Printf("sysctl failed\n"); Die(); } if (UNLIKELY(paxflags & CTL_PROC_PAXFLAGS_MPROTECT)) { Printf("This sanitizer is not compatible with enabled MPROTECT\n"); Die(); } #else // Do nothing #endif } void PrintModuleMap() { } void CheckNoDeepBind(const char *filename, int flag) { #ifdef RTLD_DEEPBIND if (flag & RTLD_DEEPBIND) { Report( "You are trying to dlopen a %s shared library with RTLD_DEEPBIND flag" " which is incompatibe with sanitizer runtime " "(see https://github.com/google/sanitizers/issues/611 for details" "). If you want to run %s library under sanitizers please remove " "RTLD_DEEPBIND from dlopen flags.\n", filename, filename); Die(); } #endif } uptr FindAvailableMemoryRange(uptr size, uptr alignment, uptr left_padding, uptr *largest_gap_found, uptr *max_occupied_addr) { UNREACHABLE("FindAvailableMemoryRange is not available"); return 0; } bool GetRandom(void *buffer, uptr length, bool blocking) { if (!buffer || !length || length > 256) return false; #if SANITIZER_USE_GETENTROPY uptr rnd = getentropy(buffer, length); int rverrno = 0; if (internal_iserror(rnd, &rverrno) && rverrno == EFAULT) return false; else if (rnd == 0) return true; #endif // SANITIZER_USE_GETENTROPY #if SANITIZER_USE_GETRANDOM static atomic_uint8_t skip_getrandom_syscall; if (!atomic_load_relaxed(&skip_getrandom_syscall)) { // Up to 256 bytes, getrandom will not be interrupted. uptr res = internal_syscall(SYSCALL(getrandom), buffer, length, blocking ? 0 : GRND_NONBLOCK); int rverrno = 0; if (internal_iserror(res, &rverrno) && rverrno == ENOSYS) atomic_store_relaxed(&skip_getrandom_syscall, 1); else if (res == length) return true; } #endif // SANITIZER_USE_GETRANDOM // Up to 256 bytes, a read off /dev/urandom will not be interrupted. // blocking is moot here, O_NONBLOCK has no effect when opening /dev/urandom. uptr fd = internal_open("/dev/urandom", O_RDONLY); if (internal_iserror(fd)) return false; uptr res = internal_read(fd, buffer, length); if (internal_iserror(res)) return false; internal_close(fd); return true; } } // namespace __sanitizer #endif Index: vendor/compiler-rt/dist-release_90/lib/sanitizer_common/sanitizer_platform_limits_netbsd.cc =================================================================== --- vendor/compiler-rt/dist-release_90/lib/sanitizer_common/sanitizer_platform_limits_netbsd.cc (revision 351306) +++ vendor/compiler-rt/dist-release_90/lib/sanitizer_common/sanitizer_platform_limits_netbsd.cc (revision 351307) @@ -1,2345 +1,2395 @@ //===-- sanitizer_platform_limits_netbsd.cc -------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is a part of Sanitizer common code. // // Sizes and layouts of platform-specific NetBSD data structures. //===----------------------------------------------------------------------===// #include "sanitizer_platform.h" #if SANITIZER_NETBSD #define _KMEMUSER #define RAY_DO_SIGLEV // clang-format off #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include +#include +#include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include -#if 0 -#include -#endif #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include +#include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include + +#if defined(__x86_64__) +#include +#endif // clang-format on // Include these after system headers to avoid name clashes and ambiguities. #include "sanitizer_internal_defs.h" #include "sanitizer_platform_limits_netbsd.h" namespace __sanitizer { unsigned struct_utsname_sz = sizeof(struct utsname); unsigned struct_stat_sz = sizeof(struct stat); unsigned struct_rusage_sz = sizeof(struct rusage); unsigned struct_tm_sz = sizeof(struct tm); unsigned struct_passwd_sz = sizeof(struct passwd); unsigned struct_group_sz = sizeof(struct group); unsigned siginfo_t_sz = sizeof(siginfo_t); unsigned struct_sigaction_sz = sizeof(struct sigaction); unsigned struct_itimerval_sz = sizeof(struct itimerval); unsigned pthread_t_sz = sizeof(pthread_t); unsigned pthread_mutex_t_sz = sizeof(pthread_mutex_t); unsigned pthread_cond_t_sz = sizeof(pthread_cond_t); unsigned pid_t_sz = sizeof(pid_t); unsigned timeval_sz = sizeof(timeval); unsigned uid_t_sz = sizeof(uid_t); unsigned gid_t_sz = sizeof(gid_t); unsigned mbstate_t_sz = sizeof(mbstate_t); unsigned sigset_t_sz = sizeof(sigset_t); unsigned struct_timezone_sz = sizeof(struct timezone); unsigned struct_tms_sz = sizeof(struct tms); unsigned struct_sigevent_sz = sizeof(struct sigevent); unsigned struct_sched_param_sz = sizeof(struct sched_param); unsigned struct_sockaddr_sz = sizeof(struct sockaddr); unsigned ucontext_t_sz = sizeof(ucontext_t); unsigned struct_rlimit_sz = sizeof(struct rlimit); unsigned struct_timespec_sz = sizeof(struct timespec); unsigned struct_sembuf_sz = sizeof(struct sembuf); unsigned struct_kevent_sz = sizeof(struct kevent); unsigned struct_FTS_sz = sizeof(FTS); unsigned struct_FTSENT_sz = sizeof(FTSENT); unsigned struct_regex_sz = sizeof(regex_t); unsigned struct_regmatch_sz = sizeof(regmatch_t); unsigned struct_fstab_sz = sizeof(struct fstab); unsigned struct_utimbuf_sz = sizeof(struct utimbuf); unsigned struct_itimerspec_sz = sizeof(struct itimerspec); unsigned struct_timex_sz = sizeof(struct timex); unsigned struct_msqid_ds_sz = sizeof(struct msqid_ds); unsigned struct_mq_attr_sz = sizeof(struct mq_attr); unsigned struct_statvfs_sz = sizeof(struct statvfs); unsigned struct_sigaltstack_sz = sizeof(stack_t); const uptr sig_ign = (uptr)SIG_IGN; const uptr sig_dfl = (uptr)SIG_DFL; const uptr sig_err = (uptr)SIG_ERR; const uptr sa_siginfo = (uptr)SA_SIGINFO; const unsigned long __sanitizer_bufsiz = BUFSIZ; int ptrace_pt_io = PT_IO; int ptrace_pt_lwpinfo = PT_LWPINFO; int ptrace_pt_set_event_mask = PT_SET_EVENT_MASK; int ptrace_pt_get_event_mask = PT_GET_EVENT_MASK; int ptrace_pt_get_process_state = PT_GET_PROCESS_STATE; int ptrace_pt_set_siginfo = PT_SET_SIGINFO; int ptrace_pt_get_siginfo = PT_GET_SIGINFO; int ptrace_piod_read_d = PIOD_READ_D; int ptrace_piod_write_d = PIOD_WRITE_D; int ptrace_piod_read_i = PIOD_READ_I; int ptrace_piod_write_i = PIOD_WRITE_I; int ptrace_piod_read_auxv = PIOD_READ_AUXV; #if defined(PT_SETREGS) && defined(PT_GETREGS) int ptrace_pt_setregs = PT_SETREGS; int ptrace_pt_getregs = PT_GETREGS; #else int ptrace_pt_setregs = -1; int ptrace_pt_getregs = -1; #endif #if defined(PT_SETFPREGS) && defined(PT_GETFPREGS) int ptrace_pt_setfpregs = PT_SETFPREGS; int ptrace_pt_getfpregs = PT_GETFPREGS; #else int ptrace_pt_setfpregs = -1; int ptrace_pt_getfpregs = -1; #endif #if defined(PT_SETDBREGS) && defined(PT_GETDBREGS) int ptrace_pt_setdbregs = PT_SETDBREGS; int ptrace_pt_getdbregs = PT_GETDBREGS; #else int ptrace_pt_setdbregs = -1; int ptrace_pt_getdbregs = -1; #endif unsigned struct_ptrace_ptrace_io_desc_struct_sz = sizeof(struct ptrace_io_desc); unsigned struct_ptrace_ptrace_lwpinfo_struct_sz = sizeof(struct ptrace_lwpinfo); unsigned struct_ptrace_ptrace_event_struct_sz = sizeof(ptrace_event_t); unsigned struct_ptrace_ptrace_siginfo_struct_sz = sizeof(ptrace_siginfo_t); #if defined(PT_SETREGS) unsigned struct_ptrace_reg_struct_sz = sizeof(struct reg); #else unsigned struct_ptrace_reg_struct_sz = -1; #endif #if defined(PT_SETFPREGS) unsigned struct_ptrace_fpreg_struct_sz = sizeof(struct fpreg); #else unsigned struct_ptrace_fpreg_struct_sz = -1; #endif #if defined(PT_SETDBREGS) unsigned struct_ptrace_dbreg_struct_sz = sizeof(struct dbreg); #else unsigned struct_ptrace_dbreg_struct_sz = -1; #endif int shmctl_ipc_stat = (int)IPC_STAT; unsigned struct_utmp_sz = sizeof(struct utmp); unsigned struct_utmpx_sz = sizeof(struct utmpx); int map_fixed = MAP_FIXED; int af_inet = (int)AF_INET; int af_inet6 = (int)AF_INET6; uptr __sanitizer_in_addr_sz(int af) { if (af == AF_INET) return sizeof(struct in_addr); else if (af == AF_INET6) return sizeof(struct in6_addr); else return 0; } unsigned struct_ElfW_Phdr_sz = sizeof(Elf_Phdr); int glob_nomatch = GLOB_NOMATCH; int glob_altdirfunc = GLOB_ALTDIRFUNC; unsigned path_max = PATH_MAX; int struct_ttyent_sz = sizeof(struct ttyent); struct __sanitizer_nvlist_ref_t { void *buf; uptr len; int flags; }; typedef __sanitizer_nvlist_ref_t nvlist_ref_t; // ioctl arguments unsigned struct_altqreq_sz = sizeof(altqreq); unsigned struct_amr_user_ioctl_sz = sizeof(amr_user_ioctl); unsigned struct_ap_control_sz = sizeof(ap_control); unsigned struct_apm_ctl_sz = sizeof(apm_ctl); unsigned struct_apm_event_info_sz = sizeof(apm_event_info); unsigned struct_apm_power_info_sz = sizeof(apm_power_info); unsigned struct_atabusiodetach_args_sz = sizeof(atabusiodetach_args); unsigned struct_atabusioscan_args_sz = sizeof(atabusioscan_args); unsigned struct_ath_diag_sz = sizeof(ath_diag); unsigned struct_atm_flowmap_sz = sizeof(atm_flowmap); unsigned struct_audio_buf_info_sz = sizeof(audio_buf_info); unsigned struct_audio_device_sz = sizeof(audio_device); unsigned struct_audio_encoding_sz = sizeof(audio_encoding); unsigned struct_audio_info_sz = sizeof(audio_info); unsigned struct_audio_offset_sz = sizeof(audio_offset); unsigned struct_bio_locate_sz = sizeof(bio_locate); unsigned struct_bioc_alarm_sz = sizeof(bioc_alarm); unsigned struct_bioc_blink_sz = sizeof(bioc_blink); unsigned struct_bioc_disk_sz = sizeof(bioc_disk); unsigned struct_bioc_inq_sz = sizeof(bioc_inq); unsigned struct_bioc_setstate_sz = sizeof(bioc_setstate); unsigned struct_bioc_vol_sz = sizeof(bioc_vol); unsigned struct_bioc_volops_sz = sizeof(bioc_volops); unsigned struct_bktr_chnlset_sz = sizeof(bktr_chnlset); unsigned struct_bktr_remote_sz = sizeof(bktr_remote); unsigned struct_blue_conf_sz = sizeof(blue_conf); unsigned struct_blue_interface_sz = sizeof(blue_interface); unsigned struct_blue_stats_sz = sizeof(blue_stats); unsigned struct_bpf_dltlist_sz = sizeof(bpf_dltlist); unsigned struct_bpf_program_sz = sizeof(bpf_program); unsigned struct_bpf_stat_old_sz = sizeof(bpf_stat_old); unsigned struct_bpf_stat_sz = sizeof(bpf_stat); unsigned struct_bpf_version_sz = sizeof(bpf_version); unsigned struct_btreq_sz = sizeof(btreq); unsigned struct_btsco_info_sz = sizeof(btsco_info); unsigned struct_buffmem_desc_sz = sizeof(buffmem_desc); unsigned struct_cbq_add_class_sz = sizeof(cbq_add_class); unsigned struct_cbq_add_filter_sz = sizeof(cbq_add_filter); unsigned struct_cbq_delete_class_sz = sizeof(cbq_delete_class); unsigned struct_cbq_delete_filter_sz = sizeof(cbq_delete_filter); unsigned struct_cbq_getstats_sz = sizeof(cbq_getstats); unsigned struct_cbq_interface_sz = sizeof(cbq_interface); unsigned struct_cbq_modify_class_sz = sizeof(cbq_modify_class); unsigned struct_ccd_ioctl_sz = sizeof(ccd_ioctl); unsigned struct_cdnr_add_element_sz = sizeof(cdnr_add_element); unsigned struct_cdnr_add_filter_sz = sizeof(cdnr_add_filter); unsigned struct_cdnr_add_tbmeter_sz = sizeof(cdnr_add_tbmeter); unsigned struct_cdnr_add_trtcm_sz = sizeof(cdnr_add_trtcm); unsigned struct_cdnr_add_tswtcm_sz = sizeof(cdnr_add_tswtcm); unsigned struct_cdnr_delete_element_sz = sizeof(cdnr_delete_element); unsigned struct_cdnr_delete_filter_sz = sizeof(cdnr_delete_filter); unsigned struct_cdnr_get_stats_sz = sizeof(cdnr_get_stats); unsigned struct_cdnr_interface_sz = sizeof(cdnr_interface); unsigned struct_cdnr_modify_tbmeter_sz = sizeof(cdnr_modify_tbmeter); unsigned struct_cdnr_modify_trtcm_sz = sizeof(cdnr_modify_trtcm); unsigned struct_cdnr_modify_tswtcm_sz = sizeof(cdnr_modify_tswtcm); unsigned struct_cdnr_tbmeter_stats_sz = sizeof(cdnr_tbmeter_stats); unsigned struct_cdnr_tcm_stats_sz = sizeof(cdnr_tcm_stats); unsigned struct_cgd_ioctl_sz = sizeof(cgd_ioctl); unsigned struct_cgd_user_sz = sizeof(cgd_user); unsigned struct_changer_element_status_request_sz = sizeof(changer_element_status_request); unsigned struct_changer_exchange_request_sz = sizeof(changer_exchange_request); unsigned struct_changer_move_request_sz = sizeof(changer_move_request); unsigned struct_changer_params_sz = sizeof(changer_params); unsigned struct_changer_position_request_sz = sizeof(changer_position_request); unsigned struct_changer_set_voltag_request_sz = sizeof(changer_set_voltag_request); unsigned struct_clockctl_adjtime_sz = sizeof(clockctl_adjtime); unsigned struct_clockctl_clock_settime_sz = sizeof(clockctl_clock_settime); unsigned struct_clockctl_ntp_adjtime_sz = sizeof(clockctl_ntp_adjtime); unsigned struct_clockctl_settimeofday_sz = sizeof(clockctl_settimeofday); unsigned struct_cnwistats_sz = sizeof(cnwistats); unsigned struct_cnwitrail_sz = sizeof(cnwitrail); unsigned struct_cnwstatus_sz = sizeof(cnwstatus); unsigned struct_count_info_sz = sizeof(count_info); unsigned struct_cpu_ucode_sz = sizeof(cpu_ucode); unsigned struct_cpu_ucode_version_sz = sizeof(cpu_ucode_version); unsigned struct_crypt_kop_sz = sizeof(crypt_kop); unsigned struct_crypt_mkop_sz = sizeof(crypt_mkop); unsigned struct_crypt_mop_sz = sizeof(crypt_mop); unsigned struct_crypt_op_sz = sizeof(crypt_op); unsigned struct_crypt_result_sz = sizeof(crypt_result); unsigned struct_crypt_sfop_sz = sizeof(crypt_sfop); unsigned struct_crypt_sgop_sz = sizeof(crypt_sgop); unsigned struct_cryptret_sz = sizeof(cryptret); unsigned struct_devdetachargs_sz = sizeof(devdetachargs); unsigned struct_devlistargs_sz = sizeof(devlistargs); unsigned struct_devpmargs_sz = sizeof(devpmargs); unsigned struct_devrescanargs_sz = sizeof(devrescanargs); unsigned struct_disk_badsecinfo_sz = sizeof(disk_badsecinfo); unsigned struct_disk_strategy_sz = sizeof(disk_strategy); unsigned struct_disklabel_sz = sizeof(disklabel); unsigned struct_dkbad_sz = sizeof(dkbad); unsigned struct_dkwedge_info_sz = sizeof(dkwedge_info); unsigned struct_dkwedge_list_sz = sizeof(dkwedge_list); unsigned struct_dmio_setfunc_sz = sizeof(dmio_setfunc); unsigned struct_dmx_pes_filter_params_sz = sizeof(dmx_pes_filter_params); unsigned struct_dmx_sct_filter_params_sz = sizeof(dmx_sct_filter_params); unsigned struct_dmx_stc_sz = sizeof(dmx_stc); unsigned struct_dvb_diseqc_master_cmd_sz = sizeof(dvb_diseqc_master_cmd); unsigned struct_dvb_diseqc_slave_reply_sz = sizeof(dvb_diseqc_slave_reply); unsigned struct_dvb_frontend_event_sz = sizeof(dvb_frontend_event); unsigned struct_dvb_frontend_info_sz = sizeof(dvb_frontend_info); unsigned struct_dvb_frontend_parameters_sz = sizeof(dvb_frontend_parameters); unsigned struct_eccapreq_sz = sizeof(eccapreq); unsigned struct_fbcmap_sz = sizeof(fbcmap); unsigned struct_fbcurpos_sz = sizeof(fbcurpos); unsigned struct_fbcursor_sz = sizeof(fbcursor); unsigned struct_fbgattr_sz = sizeof(fbgattr); unsigned struct_fbsattr_sz = sizeof(fbsattr); unsigned struct_fbtype_sz = sizeof(fbtype); unsigned struct_fdformat_cmd_sz = sizeof(fdformat_cmd); unsigned struct_fdformat_parms_sz = sizeof(fdformat_parms); unsigned struct_fifoq_conf_sz = sizeof(fifoq_conf); unsigned struct_fifoq_getstats_sz = sizeof(fifoq_getstats); unsigned struct_fifoq_interface_sz = sizeof(fifoq_interface); unsigned struct_format_op_sz = sizeof(format_op); unsigned struct_fss_get_sz = sizeof(fss_get); unsigned struct_fss_set_sz = sizeof(fss_set); unsigned struct_gpio_attach_sz = sizeof(gpio_attach); unsigned struct_gpio_info_sz = sizeof(gpio_info); unsigned struct_gpio_req_sz = sizeof(gpio_req); unsigned struct_gpio_set_sz = sizeof(gpio_set); unsigned struct_hfsc_add_class_sz = sizeof(hfsc_add_class); unsigned struct_hfsc_add_filter_sz = sizeof(hfsc_add_filter); unsigned struct_hfsc_attach_sz = sizeof(hfsc_attach); unsigned struct_hfsc_class_stats_sz = sizeof(hfsc_class_stats); unsigned struct_hfsc_delete_class_sz = sizeof(hfsc_delete_class); unsigned struct_hfsc_delete_filter_sz = sizeof(hfsc_delete_filter); unsigned struct_hfsc_interface_sz = sizeof(hfsc_interface); unsigned struct_hfsc_modify_class_sz = sizeof(hfsc_modify_class); unsigned struct_hpcfb_dsp_op_sz = sizeof(hpcfb_dsp_op); unsigned struct_hpcfb_dspconf_sz = sizeof(hpcfb_dspconf); unsigned struct_hpcfb_fbconf_sz = sizeof(hpcfb_fbconf); unsigned struct_if_addrprefreq_sz = sizeof(if_addrprefreq); unsigned struct_if_clonereq_sz = sizeof(if_clonereq); unsigned struct_if_laddrreq_sz = sizeof(if_laddrreq); unsigned struct_ifaddr_sz = sizeof(ifaddr); unsigned struct_ifaliasreq_sz = sizeof(ifaliasreq); unsigned struct_ifcapreq_sz = sizeof(ifcapreq); unsigned struct_ifconf_sz = sizeof(ifconf); unsigned struct_ifdatareq_sz = sizeof(ifdatareq); unsigned struct_ifdrv_sz = sizeof(ifdrv); unsigned struct_ifmediareq_sz = sizeof(ifmediareq); unsigned struct_ifpppcstatsreq_sz = sizeof(ifpppcstatsreq); unsigned struct_ifpppstatsreq_sz = sizeof(ifpppstatsreq); unsigned struct_ifreq_sz = sizeof(ifreq); unsigned struct_in6_addrpolicy_sz = sizeof(in6_addrpolicy); unsigned struct_in6_ndireq_sz = sizeof(in6_ndireq); unsigned struct_ioc_load_unload_sz = sizeof(ioc_load_unload); unsigned struct_ioc_patch_sz = sizeof(ioc_patch); unsigned struct_ioc_play_blocks_sz = sizeof(ioc_play_blocks); unsigned struct_ioc_play_msf_sz = sizeof(ioc_play_msf); unsigned struct_ioc_play_track_sz = sizeof(ioc_play_track); unsigned struct_ioc_read_subchannel_sz = sizeof(ioc_read_subchannel); unsigned struct_ioc_read_toc_entry_sz = sizeof(ioc_read_toc_entry); unsigned struct_ioc_toc_header_sz = sizeof(ioc_toc_header); unsigned struct_ioc_vol_sz = sizeof(ioc_vol); unsigned struct_ioctl_pt_sz = sizeof(ioctl_pt); unsigned struct_ioppt_sz = sizeof(ioppt); unsigned struct_iovec_sz = sizeof(iovec); unsigned struct_ipfobj_sz = sizeof(ipfobj); unsigned struct_irda_params_sz = sizeof(irda_params); unsigned struct_isp_fc_device_sz = sizeof(isp_fc_device); unsigned struct_isp_fc_tsk_mgmt_sz = sizeof(isp_fc_tsk_mgmt); unsigned struct_isp_hba_device_sz = sizeof(isp_hba_device); unsigned struct_isv_cmd_sz = sizeof(isv_cmd); unsigned struct_jobs_add_class_sz = sizeof(jobs_add_class); unsigned struct_jobs_add_filter_sz = sizeof(jobs_add_filter); unsigned struct_jobs_attach_sz = sizeof(jobs_attach); unsigned struct_jobs_class_stats_sz = sizeof(jobs_class_stats); unsigned struct_jobs_delete_class_sz = sizeof(jobs_delete_class); unsigned struct_jobs_delete_filter_sz = sizeof(jobs_delete_filter); unsigned struct_jobs_interface_sz = sizeof(jobs_interface); unsigned struct_jobs_modify_class_sz = sizeof(jobs_modify_class); unsigned struct_kbentry_sz = sizeof(kbentry); unsigned struct_kfilter_mapping_sz = sizeof(kfilter_mapping); unsigned struct_kiockeymap_sz = sizeof(kiockeymap); unsigned struct_ksyms_gsymbol_sz = sizeof(ksyms_gsymbol); unsigned struct_ksyms_gvalue_sz = sizeof(ksyms_gvalue); unsigned struct_ksyms_ogsymbol_sz = sizeof(ksyms_ogsymbol); unsigned struct_kttcp_io_args_sz = sizeof(kttcp_io_args); unsigned struct_ltchars_sz = sizeof(ltchars); unsigned struct_lua_create_sz = sizeof(struct lua_create); unsigned struct_lua_info_sz = sizeof(struct lua_info); unsigned struct_lua_load_sz = sizeof(struct lua_load); unsigned struct_lua_require_sz = sizeof(lua_require); unsigned struct_mbpp_param_sz = sizeof(mbpp_param); unsigned struct_md_conf_sz = sizeof(md_conf); unsigned struct_meteor_capframe_sz = sizeof(meteor_capframe); unsigned struct_meteor_counts_sz = sizeof(meteor_counts); unsigned struct_meteor_geomet_sz = sizeof(meteor_geomet); unsigned struct_meteor_pixfmt_sz = sizeof(meteor_pixfmt); unsigned struct_meteor_video_sz = sizeof(meteor_video); unsigned struct_mlx_cinfo_sz = sizeof(mlx_cinfo); unsigned struct_mlx_pause_sz = sizeof(mlx_pause); unsigned struct_mlx_rebuild_request_sz = sizeof(mlx_rebuild_request); unsigned struct_mlx_rebuild_status_sz = sizeof(mlx_rebuild_status); unsigned struct_mlx_usercommand_sz = sizeof(mlx_usercommand); unsigned struct_mly_user_command_sz = sizeof(mly_user_command); unsigned struct_mly_user_health_sz = sizeof(mly_user_health); unsigned struct_mtget_sz = sizeof(mtget); unsigned struct_mtop_sz = sizeof(mtop); unsigned struct_npf_ioctl_table_sz = sizeof(npf_ioctl_table); unsigned struct_npioctl_sz = sizeof(npioctl); unsigned struct_nvme_pt_command_sz = sizeof(nvme_pt_command); unsigned struct_ochanger_element_status_request_sz = sizeof(ochanger_element_status_request); unsigned struct_ofiocdesc_sz = sizeof(ofiocdesc); unsigned struct_okiockey_sz = sizeof(okiockey); unsigned struct_ortentry_sz = sizeof(ortentry); unsigned struct_oscsi_addr_sz = sizeof(oscsi_addr); unsigned struct_oss_audioinfo_sz = sizeof(oss_audioinfo); unsigned struct_oss_sysinfo_sz = sizeof(oss_sysinfo); unsigned struct_pciio_bdf_cfgreg_sz = sizeof(pciio_bdf_cfgreg); unsigned struct_pciio_businfo_sz = sizeof(pciio_businfo); unsigned struct_pciio_cfgreg_sz = sizeof(pciio_cfgreg); unsigned struct_pciio_drvname_sz = sizeof(pciio_drvname); unsigned struct_pciio_drvnameonbus_sz = sizeof(pciio_drvnameonbus); unsigned struct_pcvtid_sz = sizeof(pcvtid); unsigned struct_pf_osfp_ioctl_sz = sizeof(pf_osfp_ioctl); unsigned struct_pf_status_sz = sizeof(pf_status); unsigned struct_pfioc_altq_sz = sizeof(pfioc_altq); unsigned struct_pfioc_if_sz = sizeof(pfioc_if); unsigned struct_pfioc_iface_sz = sizeof(pfioc_iface); unsigned struct_pfioc_limit_sz = sizeof(pfioc_limit); unsigned struct_pfioc_natlook_sz = sizeof(pfioc_natlook); unsigned struct_pfioc_pooladdr_sz = sizeof(pfioc_pooladdr); unsigned struct_pfioc_qstats_sz = sizeof(pfioc_qstats); unsigned struct_pfioc_rule_sz = sizeof(pfioc_rule); unsigned struct_pfioc_ruleset_sz = sizeof(pfioc_ruleset); unsigned struct_pfioc_src_node_kill_sz = sizeof(pfioc_src_node_kill); unsigned struct_pfioc_src_nodes_sz = sizeof(pfioc_src_nodes); unsigned struct_pfioc_state_kill_sz = sizeof(pfioc_state_kill); unsigned struct_pfioc_state_sz = sizeof(pfioc_state); unsigned struct_pfioc_states_sz = sizeof(pfioc_states); unsigned struct_pfioc_table_sz = sizeof(pfioc_table); unsigned struct_pfioc_tm_sz = sizeof(pfioc_tm); unsigned struct_pfioc_trans_sz = sizeof(pfioc_trans); unsigned struct_plistref_sz = sizeof(plistref); unsigned struct_power_type_sz = sizeof(power_type); unsigned struct_ppp_idle_sz = sizeof(ppp_idle); unsigned struct_ppp_option_data_sz = sizeof(ppp_option_data); unsigned struct_ppp_rawin_sz = sizeof(ppp_rawin); unsigned struct_pppoeconnectionstate_sz = sizeof(pppoeconnectionstate); unsigned struct_pppoediscparms_sz = sizeof(pppoediscparms); unsigned struct_priq_add_class_sz = sizeof(priq_add_class); unsigned struct_priq_add_filter_sz = sizeof(priq_add_filter); unsigned struct_priq_class_stats_sz = sizeof(priq_class_stats); unsigned struct_priq_delete_class_sz = sizeof(priq_delete_class); unsigned struct_priq_delete_filter_sz = sizeof(priq_delete_filter); unsigned struct_priq_interface_sz = sizeof(priq_interface); unsigned struct_priq_modify_class_sz = sizeof(priq_modify_class); unsigned struct_ptmget_sz = sizeof(ptmget); unsigned struct_radio_info_sz = sizeof(radio_info); unsigned struct_red_conf_sz = sizeof(red_conf); unsigned struct_red_interface_sz = sizeof(red_interface); unsigned struct_red_stats_sz = sizeof(red_stats); unsigned struct_redparams_sz = sizeof(redparams); unsigned struct_rf_pmparams_sz = sizeof(rf_pmparams); unsigned struct_rf_pmstat_sz = sizeof(rf_pmstat); unsigned struct_rf_recon_req_sz = sizeof(rf_recon_req); unsigned struct_rio_conf_sz = sizeof(rio_conf); unsigned struct_rio_interface_sz = sizeof(rio_interface); unsigned struct_rio_stats_sz = sizeof(rio_stats); unsigned struct_scan_io_sz = sizeof(scan_io); unsigned struct_scbusaccel_args_sz = sizeof(scbusaccel_args); unsigned struct_scbusiodetach_args_sz = sizeof(scbusiodetach_args); unsigned struct_scbusioscan_args_sz = sizeof(scbusioscan_args); unsigned struct_scsi_addr_sz = sizeof(scsi_addr); unsigned struct_seq_event_rec_sz = sizeof(seq_event_rec); unsigned struct_session_op_sz = sizeof(session_op); unsigned struct_sgttyb_sz = sizeof(sgttyb); unsigned struct_sioc_sg_req_sz = sizeof(sioc_sg_req); unsigned struct_sioc_vif_req_sz = sizeof(sioc_vif_req); unsigned struct_smbioc_flags_sz = sizeof(smbioc_flags); unsigned struct_smbioc_lookup_sz = sizeof(smbioc_lookup); unsigned struct_smbioc_oshare_sz = sizeof(smbioc_oshare); unsigned struct_smbioc_ossn_sz = sizeof(smbioc_ossn); unsigned struct_smbioc_rq_sz = sizeof(smbioc_rq); unsigned struct_smbioc_rw_sz = sizeof(smbioc_rw); unsigned struct_spppauthcfg_sz = sizeof(spppauthcfg); unsigned struct_spppauthfailuresettings_sz = sizeof(spppauthfailuresettings); unsigned struct_spppauthfailurestats_sz = sizeof(spppauthfailurestats); unsigned struct_spppdnsaddrs_sz = sizeof(spppdnsaddrs); unsigned struct_spppdnssettings_sz = sizeof(spppdnssettings); unsigned struct_spppidletimeout_sz = sizeof(spppidletimeout); unsigned struct_spppkeepalivesettings_sz = sizeof(spppkeepalivesettings); unsigned struct_sppplcpcfg_sz = sizeof(sppplcpcfg); unsigned struct_spppstatus_sz = sizeof(spppstatus); unsigned struct_spppstatusncp_sz = sizeof(spppstatusncp); unsigned struct_srt_rt_sz = sizeof(srt_rt); unsigned struct_stic_xinfo_sz = sizeof(stic_xinfo); unsigned struct_sun_dkctlr_sz = sizeof(sun_dkctlr); unsigned struct_sun_dkgeom_sz = sizeof(sun_dkgeom); unsigned struct_sun_dkpart_sz = sizeof(sun_dkpart); unsigned struct_synth_info_sz = sizeof(synth_info); unsigned struct_tbrreq_sz = sizeof(tbrreq); unsigned struct_tchars_sz = sizeof(tchars); unsigned struct_termios_sz = sizeof(termios); unsigned struct_timeval_sz = sizeof(timeval); unsigned struct_twe_drivecommand_sz = sizeof(twe_drivecommand); unsigned struct_twe_paramcommand_sz = sizeof(twe_paramcommand); unsigned struct_twe_usercommand_sz = sizeof(twe_usercommand); unsigned struct_ukyopon_identify_sz = sizeof(ukyopon_identify); unsigned struct_urio_command_sz = sizeof(urio_command); unsigned struct_usb_alt_interface_sz = sizeof(usb_alt_interface); unsigned struct_usb_bulk_ra_wb_opt_sz = sizeof(usb_bulk_ra_wb_opt); unsigned struct_usb_config_desc_sz = sizeof(usb_config_desc); unsigned struct_usb_ctl_report_desc_sz = sizeof(usb_ctl_report_desc); unsigned struct_usb_ctl_report_sz = sizeof(usb_ctl_report); unsigned struct_usb_ctl_request_sz = sizeof(usb_ctl_request); +#if defined(__x86_64__) +unsigned struct_nvmm_ioc_capability_sz = sizeof(nvmm_ioc_capability); +unsigned struct_nvmm_ioc_machine_create_sz = sizeof(nvmm_ioc_machine_create); +unsigned struct_nvmm_ioc_machine_destroy_sz = sizeof(nvmm_ioc_machine_destroy); +unsigned struct_nvmm_ioc_machine_configure_sz = + sizeof(nvmm_ioc_machine_configure); +unsigned struct_nvmm_ioc_vcpu_create_sz = sizeof(nvmm_ioc_vcpu_create); +unsigned struct_nvmm_ioc_vcpu_destroy_sz = sizeof(nvmm_ioc_vcpu_destroy); +unsigned struct_nvmm_ioc_vcpu_setstate_sz = sizeof(nvmm_ioc_vcpu_destroy); +unsigned struct_nvmm_ioc_vcpu_getstate_sz = sizeof(nvmm_ioc_vcpu_getstate); +unsigned struct_nvmm_ioc_vcpu_inject_sz = sizeof(nvmm_ioc_vcpu_inject); +unsigned struct_nvmm_ioc_vcpu_run_sz = sizeof(nvmm_ioc_vcpu_run); +unsigned struct_nvmm_ioc_gpa_map_sz = sizeof(nvmm_ioc_gpa_map); +unsigned struct_nvmm_ioc_gpa_unmap_sz = sizeof(nvmm_ioc_gpa_unmap); +unsigned struct_nvmm_ioc_hva_map_sz = sizeof(nvmm_ioc_hva_map); +unsigned struct_nvmm_ioc_hva_unmap_sz = sizeof(nvmm_ioc_hva_unmap); +unsigned struct_nvmm_ioc_ctl_sz = sizeof(nvmm_ioc_ctl); +#endif +unsigned struct_spi_ioctl_configure_sz = sizeof(spi_ioctl_configure); +unsigned struct_spi_ioctl_transfer_sz = sizeof(spi_ioctl_transfer); unsigned struct_autofs_daemon_request_sz = sizeof(autofs_daemon_request); unsigned struct_autofs_daemon_done_sz = sizeof(autofs_daemon_done); unsigned struct_sctp_connectx_addrs_sz = sizeof(sctp_connectx_addrs); unsigned struct_usb_device_info_old_sz = sizeof(usb_device_info_old); unsigned struct_usb_device_info_sz = sizeof(usb_device_info); unsigned struct_usb_device_stats_sz = sizeof(usb_device_stats); unsigned struct_usb_endpoint_desc_sz = sizeof(usb_endpoint_desc); unsigned struct_usb_full_desc_sz = sizeof(usb_full_desc); unsigned struct_usb_interface_desc_sz = sizeof(usb_interface_desc); unsigned struct_usb_string_desc_sz = sizeof(usb_string_desc); unsigned struct_utoppy_readfile_sz = sizeof(utoppy_readfile); unsigned struct_utoppy_rename_sz = sizeof(utoppy_rename); unsigned struct_utoppy_stats_sz = sizeof(utoppy_stats); unsigned struct_utoppy_writefile_sz = sizeof(utoppy_writefile); unsigned struct_v4l2_audio_sz = sizeof(v4l2_audio); unsigned struct_v4l2_audioout_sz = sizeof(v4l2_audioout); unsigned struct_v4l2_buffer_sz = sizeof(v4l2_buffer); unsigned struct_v4l2_capability_sz = sizeof(v4l2_capability); unsigned struct_v4l2_control_sz = sizeof(v4l2_control); unsigned struct_v4l2_crop_sz = sizeof(v4l2_crop); unsigned struct_v4l2_cropcap_sz = sizeof(v4l2_cropcap); unsigned struct_v4l2_fmtdesc_sz = sizeof(v4l2_fmtdesc); unsigned struct_v4l2_format_sz = sizeof(v4l2_format); unsigned struct_v4l2_framebuffer_sz = sizeof(v4l2_framebuffer); unsigned struct_v4l2_frequency_sz = sizeof(v4l2_frequency); unsigned struct_v4l2_frmivalenum_sz = sizeof(v4l2_frmivalenum); unsigned struct_v4l2_frmsizeenum_sz = sizeof(v4l2_frmsizeenum); unsigned struct_v4l2_input_sz = sizeof(v4l2_input); unsigned struct_v4l2_jpegcompression_sz = sizeof(v4l2_jpegcompression); unsigned struct_v4l2_modulator_sz = sizeof(v4l2_modulator); unsigned struct_v4l2_output_sz = sizeof(v4l2_output); unsigned struct_v4l2_queryctrl_sz = sizeof(v4l2_queryctrl); unsigned struct_v4l2_querymenu_sz = sizeof(v4l2_querymenu); unsigned struct_v4l2_requestbuffers_sz = sizeof(v4l2_requestbuffers); unsigned struct_v4l2_standard_sz = sizeof(v4l2_standard); unsigned struct_v4l2_streamparm_sz = sizeof(v4l2_streamparm); unsigned struct_v4l2_tuner_sz = sizeof(v4l2_tuner); unsigned struct_vnd_ioctl_sz = sizeof(vnd_ioctl); unsigned struct_vnd_user_sz = sizeof(vnd_user); unsigned struct_vt_stat_sz = sizeof(vt_stat); unsigned struct_wdog_conf_sz = sizeof(wdog_conf); unsigned struct_wdog_mode_sz = sizeof(wdog_mode); +unsigned struct_ipmi_recv_sz = sizeof(ipmi_recv); +unsigned struct_ipmi_req_sz = sizeof(ipmi_req); +unsigned struct_ipmi_cmdspec_sz = sizeof(ipmi_cmdspec); unsigned struct_wfq_conf_sz = sizeof(wfq_conf); unsigned struct_wfq_getqid_sz = sizeof(wfq_getqid); unsigned struct_wfq_getstats_sz = sizeof(wfq_getstats); unsigned struct_wfq_interface_sz = sizeof(wfq_interface); unsigned struct_wfq_setweight_sz = sizeof(wfq_setweight); unsigned struct_winsize_sz = sizeof(winsize); unsigned struct_wscons_event_sz = sizeof(wscons_event); unsigned struct_wsdisplay_addscreendata_sz = sizeof(wsdisplay_addscreendata); unsigned struct_wsdisplay_char_sz = sizeof(wsdisplay_char); unsigned struct_wsdisplay_cmap_sz = sizeof(wsdisplay_cmap); unsigned struct_wsdisplay_curpos_sz = sizeof(wsdisplay_curpos); unsigned struct_wsdisplay_cursor_sz = sizeof(wsdisplay_cursor); unsigned struct_wsdisplay_delscreendata_sz = sizeof(wsdisplay_delscreendata); unsigned struct_wsdisplay_fbinfo_sz = sizeof(wsdisplay_fbinfo); unsigned struct_wsdisplay_font_sz = sizeof(wsdisplay_font); unsigned struct_wsdisplay_kbddata_sz = sizeof(wsdisplay_kbddata); unsigned struct_wsdisplay_msgattrs_sz = sizeof(wsdisplay_msgattrs); unsigned struct_wsdisplay_param_sz = sizeof(wsdisplay_param); unsigned struct_wsdisplay_scroll_data_sz = sizeof(wsdisplay_scroll_data); unsigned struct_wsdisplay_usefontdata_sz = sizeof(wsdisplay_usefontdata); unsigned struct_wsdisplayio_blit_sz = sizeof(wsdisplayio_blit); unsigned struct_wsdisplayio_bus_id_sz = sizeof(wsdisplayio_bus_id); unsigned struct_wsdisplayio_edid_info_sz = sizeof(wsdisplayio_edid_info); unsigned struct_wsdisplayio_fbinfo_sz = sizeof(wsdisplayio_fbinfo); unsigned struct_wskbd_bell_data_sz = sizeof(wskbd_bell_data); unsigned struct_wskbd_keyrepeat_data_sz = sizeof(wskbd_keyrepeat_data); unsigned struct_wskbd_map_data_sz = sizeof(wskbd_map_data); unsigned struct_wskbd_scroll_data_sz = sizeof(wskbd_scroll_data); unsigned struct_wsmouse_calibcoords_sz = sizeof(wsmouse_calibcoords); unsigned struct_wsmouse_id_sz = sizeof(wsmouse_id); unsigned struct_wsmouse_repeat_sz = sizeof(wsmouse_repeat); unsigned struct_wsmux_device_list_sz = sizeof(wsmux_device_list); unsigned struct_wsmux_device_sz = sizeof(wsmux_device); unsigned struct_xd_iocmd_sz = sizeof(xd_iocmd); unsigned struct_scsireq_sz = sizeof(struct scsireq); unsigned struct_tone_sz = sizeof(tone_t); unsigned union_twe_statrequest_sz = sizeof(union twe_statrequest); unsigned struct_usb_device_descriptor_sz = sizeof(usb_device_descriptor_t); unsigned struct_vt_mode_sz = sizeof(struct vt_mode); unsigned struct__old_mixer_info_sz = sizeof(struct _old_mixer_info); unsigned struct__agp_allocate_sz = sizeof(struct _agp_allocate); unsigned struct__agp_bind_sz = sizeof(struct _agp_bind); unsigned struct__agp_info_sz = sizeof(struct _agp_info); unsigned struct__agp_setup_sz = sizeof(struct _agp_setup); unsigned struct__agp_unbind_sz = sizeof(struct _agp_unbind); unsigned struct_atareq_sz = sizeof(struct atareq); unsigned struct_cpustate_sz = sizeof(struct cpustate); unsigned struct_dmx_caps_sz = sizeof(struct dmx_caps); unsigned enum_dmx_source_sz = sizeof(dmx_source_t); unsigned union_dvd_authinfo_sz = sizeof(dvd_authinfo); unsigned union_dvd_struct_sz = sizeof(dvd_struct); unsigned enum_v4l2_priority_sz = sizeof(enum v4l2_priority); unsigned struct_envsys_basic_info_sz = sizeof(struct envsys_basic_info); unsigned struct_envsys_tre_data_sz = sizeof(struct envsys_tre_data); unsigned enum_fe_sec_mini_cmd_sz = sizeof(enum fe_sec_mini_cmd); unsigned enum_fe_sec_tone_mode_sz = sizeof(enum fe_sec_tone_mode); unsigned enum_fe_sec_voltage_sz = sizeof(enum fe_sec_voltage); unsigned enum_fe_status_sz = sizeof(enum fe_status); unsigned struct_gdt_ctrt_sz = sizeof(struct gdt_ctrt); unsigned struct_gdt_event_sz = sizeof(struct gdt_event); unsigned struct_gdt_osv_sz = sizeof(struct gdt_osv); unsigned struct_gdt_rescan_sz = sizeof(struct gdt_rescan); unsigned struct_gdt_statist_sz = sizeof(struct gdt_statist); unsigned struct_gdt_ucmd_sz = sizeof(struct gdt_ucmd); unsigned struct_iscsi_conn_status_parameters_sz = sizeof(iscsi_conn_status_parameters_t); unsigned struct_iscsi_get_version_parameters_sz = sizeof(iscsi_get_version_parameters_t); unsigned struct_iscsi_iocommand_parameters_sz = sizeof(iscsi_iocommand_parameters_t); unsigned struct_iscsi_login_parameters_sz = sizeof(iscsi_login_parameters_t); unsigned struct_iscsi_logout_parameters_sz = sizeof(iscsi_logout_parameters_t); unsigned struct_iscsi_register_event_parameters_sz = sizeof(iscsi_register_event_parameters_t); unsigned struct_iscsi_remove_parameters_sz = sizeof(iscsi_remove_parameters_t); unsigned struct_iscsi_send_targets_parameters_sz = sizeof(iscsi_send_targets_parameters_t); unsigned struct_iscsi_set_node_name_parameters_sz = sizeof(iscsi_set_node_name_parameters_t); unsigned struct_iscsi_wait_event_parameters_sz = sizeof(iscsi_wait_event_parameters_t); unsigned struct_isp_stats_sz = sizeof(isp_stats_t); unsigned struct_lsenable_sz = sizeof(struct lsenable); unsigned struct_lsdisable_sz = sizeof(struct lsdisable); +unsigned struct_audio_format_query_sz = sizeof(audio_format_query); unsigned struct_mixer_ctrl_sz = sizeof(struct mixer_ctrl); unsigned struct_mixer_devinfo_sz = sizeof(struct mixer_devinfo); unsigned struct_mpu_command_rec_sz = sizeof(mpu_command_rec); unsigned struct_rndstat_sz = sizeof(rndstat_t); unsigned struct_rndstat_name_sz = sizeof(rndstat_name_t); unsigned struct_rndctl_sz = sizeof(rndctl_t); unsigned struct_rnddata_sz = sizeof(rnddata_t); unsigned struct_rndpoolstat_sz = sizeof(rndpoolstat_t); unsigned struct_rndstat_est_sz = sizeof(rndstat_est_t); unsigned struct_rndstat_est_name_sz = sizeof(rndstat_est_name_t); unsigned struct_pps_params_sz = sizeof(pps_params_t); unsigned struct_pps_info_sz = sizeof(pps_info_t); unsigned struct_mixer_info_sz = sizeof(struct mixer_info); unsigned struct_RF_SparetWait_sz = sizeof(RF_SparetWait_t); unsigned struct_RF_ComponentLabel_sz = sizeof(RF_ComponentLabel_t); unsigned struct_RF_SingleComponent_sz = sizeof(RF_SingleComponent_t); unsigned struct_RF_ProgressInfo_sz = sizeof(RF_ProgressInfo_t); unsigned struct_nvlist_ref_sz = sizeof(struct __sanitizer_nvlist_ref_t); unsigned struct_StringList_sz = sizeof(StringList); const unsigned IOCTL_NOT_PRESENT = 0; unsigned IOCTL_AFM_ADDFMAP = AFM_ADDFMAP; unsigned IOCTL_AFM_DELFMAP = AFM_DELFMAP; unsigned IOCTL_AFM_CLEANFMAP = AFM_CLEANFMAP; unsigned IOCTL_AFM_GETFMAP = AFM_GETFMAP; unsigned IOCTL_ALTQGTYPE = ALTQGTYPE; unsigned IOCTL_ALTQTBRSET = ALTQTBRSET; unsigned IOCTL_ALTQTBRGET = ALTQTBRGET; unsigned IOCTL_BLUE_IF_ATTACH = BLUE_IF_ATTACH; unsigned IOCTL_BLUE_IF_DETACH = BLUE_IF_DETACH; unsigned IOCTL_BLUE_ENABLE = BLUE_ENABLE; unsigned IOCTL_BLUE_DISABLE = BLUE_DISABLE; unsigned IOCTL_BLUE_CONFIG = BLUE_CONFIG; unsigned IOCTL_BLUE_GETSTATS = BLUE_GETSTATS; unsigned IOCTL_CBQ_IF_ATTACH = CBQ_IF_ATTACH; unsigned IOCTL_CBQ_IF_DETACH = CBQ_IF_DETACH; unsigned IOCTL_CBQ_ENABLE = CBQ_ENABLE; unsigned IOCTL_CBQ_DISABLE = CBQ_DISABLE; unsigned IOCTL_CBQ_CLEAR_HIERARCHY = CBQ_CLEAR_HIERARCHY; unsigned IOCTL_CBQ_ADD_CLASS = CBQ_ADD_CLASS; unsigned IOCTL_CBQ_DEL_CLASS = CBQ_DEL_CLASS; unsigned IOCTL_CBQ_MODIFY_CLASS = CBQ_MODIFY_CLASS; unsigned IOCTL_CBQ_ADD_FILTER = CBQ_ADD_FILTER; unsigned IOCTL_CBQ_DEL_FILTER = CBQ_DEL_FILTER; unsigned IOCTL_CBQ_GETSTATS = CBQ_GETSTATS; unsigned IOCTL_CDNR_IF_ATTACH = CDNR_IF_ATTACH; unsigned IOCTL_CDNR_IF_DETACH = CDNR_IF_DETACH; unsigned IOCTL_CDNR_ENABLE = CDNR_ENABLE; unsigned IOCTL_CDNR_DISABLE = CDNR_DISABLE; unsigned IOCTL_CDNR_ADD_FILTER = CDNR_ADD_FILTER; unsigned IOCTL_CDNR_DEL_FILTER = CDNR_DEL_FILTER; unsigned IOCTL_CDNR_GETSTATS = CDNR_GETSTATS; unsigned IOCTL_CDNR_ADD_ELEM = CDNR_ADD_ELEM; unsigned IOCTL_CDNR_DEL_ELEM = CDNR_DEL_ELEM; unsigned IOCTL_CDNR_ADD_TBM = CDNR_ADD_TBM; unsigned IOCTL_CDNR_MOD_TBM = CDNR_MOD_TBM; unsigned IOCTL_CDNR_TBM_STATS = CDNR_TBM_STATS; unsigned IOCTL_CDNR_ADD_TCM = CDNR_ADD_TCM; unsigned IOCTL_CDNR_MOD_TCM = CDNR_MOD_TCM; unsigned IOCTL_CDNR_TCM_STATS = CDNR_TCM_STATS; unsigned IOCTL_CDNR_ADD_TSW = CDNR_ADD_TSW; unsigned IOCTL_CDNR_MOD_TSW = CDNR_MOD_TSW; unsigned IOCTL_FIFOQ_IF_ATTACH = FIFOQ_IF_ATTACH; unsigned IOCTL_FIFOQ_IF_DETACH = FIFOQ_IF_DETACH; unsigned IOCTL_FIFOQ_ENABLE = FIFOQ_ENABLE; unsigned IOCTL_FIFOQ_DISABLE = FIFOQ_DISABLE; unsigned IOCTL_FIFOQ_CONFIG = FIFOQ_CONFIG; unsigned IOCTL_FIFOQ_GETSTATS = FIFOQ_GETSTATS; unsigned IOCTL_HFSC_IF_ATTACH = HFSC_IF_ATTACH; unsigned IOCTL_HFSC_IF_DETACH = HFSC_IF_DETACH; unsigned IOCTL_HFSC_ENABLE = HFSC_ENABLE; unsigned IOCTL_HFSC_DISABLE = HFSC_DISABLE; unsigned IOCTL_HFSC_CLEAR_HIERARCHY = HFSC_CLEAR_HIERARCHY; unsigned IOCTL_HFSC_ADD_CLASS = HFSC_ADD_CLASS; unsigned IOCTL_HFSC_DEL_CLASS = HFSC_DEL_CLASS; unsigned IOCTL_HFSC_MOD_CLASS = HFSC_MOD_CLASS; unsigned IOCTL_HFSC_ADD_FILTER = HFSC_ADD_FILTER; unsigned IOCTL_HFSC_DEL_FILTER = HFSC_DEL_FILTER; unsigned IOCTL_HFSC_GETSTATS = HFSC_GETSTATS; unsigned IOCTL_JOBS_IF_ATTACH = JOBS_IF_ATTACH; unsigned IOCTL_JOBS_IF_DETACH = JOBS_IF_DETACH; unsigned IOCTL_JOBS_ENABLE = JOBS_ENABLE; unsigned IOCTL_JOBS_DISABLE = JOBS_DISABLE; unsigned IOCTL_JOBS_CLEAR = JOBS_CLEAR; unsigned IOCTL_JOBS_ADD_CLASS = JOBS_ADD_CLASS; unsigned IOCTL_JOBS_DEL_CLASS = JOBS_DEL_CLASS; unsigned IOCTL_JOBS_MOD_CLASS = JOBS_MOD_CLASS; unsigned IOCTL_JOBS_ADD_FILTER = JOBS_ADD_FILTER; unsigned IOCTL_JOBS_DEL_FILTER = JOBS_DEL_FILTER; unsigned IOCTL_JOBS_GETSTATS = JOBS_GETSTATS; unsigned IOCTL_PRIQ_IF_ATTACH = PRIQ_IF_ATTACH; unsigned IOCTL_PRIQ_IF_DETACH = PRIQ_IF_DETACH; unsigned IOCTL_PRIQ_ENABLE = PRIQ_ENABLE; unsigned IOCTL_PRIQ_DISABLE = PRIQ_DISABLE; unsigned IOCTL_PRIQ_CLEAR = PRIQ_CLEAR; unsigned IOCTL_PRIQ_ADD_CLASS = PRIQ_ADD_CLASS; unsigned IOCTL_PRIQ_DEL_CLASS = PRIQ_DEL_CLASS; unsigned IOCTL_PRIQ_MOD_CLASS = PRIQ_MOD_CLASS; unsigned IOCTL_PRIQ_ADD_FILTER = PRIQ_ADD_FILTER; unsigned IOCTL_PRIQ_DEL_FILTER = PRIQ_DEL_FILTER; unsigned IOCTL_PRIQ_GETSTATS = PRIQ_GETSTATS; unsigned IOCTL_RED_IF_ATTACH = RED_IF_ATTACH; unsigned IOCTL_RED_IF_DETACH = RED_IF_DETACH; unsigned IOCTL_RED_ENABLE = RED_ENABLE; unsigned IOCTL_RED_DISABLE = RED_DISABLE; unsigned IOCTL_RED_CONFIG = RED_CONFIG; unsigned IOCTL_RED_GETSTATS = RED_GETSTATS; unsigned IOCTL_RED_SETDEFAULTS = RED_SETDEFAULTS; unsigned IOCTL_RIO_IF_ATTACH = RIO_IF_ATTACH; unsigned IOCTL_RIO_IF_DETACH = RIO_IF_DETACH; unsigned IOCTL_RIO_ENABLE = RIO_ENABLE; unsigned IOCTL_RIO_DISABLE = RIO_DISABLE; unsigned IOCTL_RIO_CONFIG = RIO_CONFIG; unsigned IOCTL_RIO_GETSTATS = RIO_GETSTATS; unsigned IOCTL_RIO_SETDEFAULTS = RIO_SETDEFAULTS; unsigned IOCTL_WFQ_IF_ATTACH = WFQ_IF_ATTACH; unsigned IOCTL_WFQ_IF_DETACH = WFQ_IF_DETACH; unsigned IOCTL_WFQ_ENABLE = WFQ_ENABLE; unsigned IOCTL_WFQ_DISABLE = WFQ_DISABLE; unsigned IOCTL_WFQ_CONFIG = WFQ_CONFIG; unsigned IOCTL_WFQ_GET_STATS = WFQ_GET_STATS; unsigned IOCTL_WFQ_GET_QID = WFQ_GET_QID; unsigned IOCTL_WFQ_SET_WEIGHT = WFQ_SET_WEIGHT; unsigned IOCTL_CRIOGET = CRIOGET; unsigned IOCTL_CIOCFSESSION = CIOCFSESSION; unsigned IOCTL_CIOCKEY = CIOCKEY; unsigned IOCTL_CIOCNFKEYM = CIOCNFKEYM; unsigned IOCTL_CIOCNFSESSION = CIOCNFSESSION; unsigned IOCTL_CIOCNCRYPTRETM = CIOCNCRYPTRETM; unsigned IOCTL_CIOCNCRYPTRET = CIOCNCRYPTRET; unsigned IOCTL_CIOCGSESSION = CIOCGSESSION; unsigned IOCTL_CIOCNGSESSION = CIOCNGSESSION; unsigned IOCTL_CIOCCRYPT = CIOCCRYPT; unsigned IOCTL_CIOCNCRYPTM = CIOCNCRYPTM; unsigned IOCTL_CIOCASYMFEAT = CIOCASYMFEAT; unsigned IOCTL_APM_IOC_REJECT = APM_IOC_REJECT; unsigned IOCTL_APM_IOC_STANDBY = APM_IOC_STANDBY; unsigned IOCTL_APM_IOC_SUSPEND = APM_IOC_SUSPEND; unsigned IOCTL_OAPM_IOC_GETPOWER = OAPM_IOC_GETPOWER; unsigned IOCTL_APM_IOC_GETPOWER = APM_IOC_GETPOWER; unsigned IOCTL_APM_IOC_NEXTEVENT = APM_IOC_NEXTEVENT; unsigned IOCTL_APM_IOC_DEV_CTL = APM_IOC_DEV_CTL; unsigned IOCTL_NETBSD_DM_IOCTL = NETBSD_DM_IOCTL; unsigned IOCTL_DMIO_SETFUNC = DMIO_SETFUNC; unsigned IOCTL_DMX_START = DMX_START; unsigned IOCTL_DMX_STOP = DMX_STOP; unsigned IOCTL_DMX_SET_FILTER = DMX_SET_FILTER; unsigned IOCTL_DMX_SET_PES_FILTER = DMX_SET_PES_FILTER; unsigned IOCTL_DMX_SET_BUFFER_SIZE = DMX_SET_BUFFER_SIZE; unsigned IOCTL_DMX_GET_STC = DMX_GET_STC; unsigned IOCTL_DMX_ADD_PID = DMX_ADD_PID; unsigned IOCTL_DMX_REMOVE_PID = DMX_REMOVE_PID; unsigned IOCTL_DMX_GET_CAPS = DMX_GET_CAPS; unsigned IOCTL_DMX_SET_SOURCE = DMX_SET_SOURCE; unsigned IOCTL_FE_READ_STATUS = FE_READ_STATUS; unsigned IOCTL_FE_READ_BER = FE_READ_BER; unsigned IOCTL_FE_READ_SNR = FE_READ_SNR; unsigned IOCTL_FE_READ_SIGNAL_STRENGTH = FE_READ_SIGNAL_STRENGTH; unsigned IOCTL_FE_READ_UNCORRECTED_BLOCKS = FE_READ_UNCORRECTED_BLOCKS; unsigned IOCTL_FE_SET_FRONTEND = FE_SET_FRONTEND; unsigned IOCTL_FE_GET_FRONTEND = FE_GET_FRONTEND; unsigned IOCTL_FE_GET_EVENT = FE_GET_EVENT; unsigned IOCTL_FE_GET_INFO = FE_GET_INFO; unsigned IOCTL_FE_DISEQC_RESET_OVERLOAD = FE_DISEQC_RESET_OVERLOAD; unsigned IOCTL_FE_DISEQC_SEND_MASTER_CMD = FE_DISEQC_SEND_MASTER_CMD; unsigned IOCTL_FE_DISEQC_RECV_SLAVE_REPLY = FE_DISEQC_RECV_SLAVE_REPLY; unsigned IOCTL_FE_DISEQC_SEND_BURST = FE_DISEQC_SEND_BURST; unsigned IOCTL_FE_SET_TONE = FE_SET_TONE; unsigned IOCTL_FE_SET_VOLTAGE = FE_SET_VOLTAGE; unsigned IOCTL_FE_ENABLE_HIGH_LNB_VOLTAGE = FE_ENABLE_HIGH_LNB_VOLTAGE; unsigned IOCTL_FE_SET_FRONTEND_TUNE_MODE = FE_SET_FRONTEND_TUNE_MODE; unsigned IOCTL_FE_DISHNETWORK_SEND_LEGACY_CMD = FE_DISHNETWORK_SEND_LEGACY_CMD; unsigned IOCTL_FILEMON_SET_FD = FILEMON_SET_FD; unsigned IOCTL_FILEMON_SET_PID = FILEMON_SET_PID; unsigned IOCTL_HDAUDIO_FGRP_INFO = HDAUDIO_FGRP_INFO; unsigned IOCTL_HDAUDIO_FGRP_GETCONFIG = HDAUDIO_FGRP_GETCONFIG; unsigned IOCTL_HDAUDIO_FGRP_SETCONFIG = HDAUDIO_FGRP_SETCONFIG; unsigned IOCTL_HDAUDIO_FGRP_WIDGET_INFO = HDAUDIO_FGRP_WIDGET_INFO; unsigned IOCTL_HDAUDIO_FGRP_CODEC_INFO = HDAUDIO_FGRP_CODEC_INFO; unsigned IOCTL_HDAUDIO_AFG_WIDGET_INFO = HDAUDIO_AFG_WIDGET_INFO; unsigned IOCTL_HDAUDIO_AFG_CODEC_INFO = HDAUDIO_AFG_CODEC_INFO; unsigned IOCTL_CEC_GET_PHYS_ADDR = CEC_GET_PHYS_ADDR; unsigned IOCTL_CEC_GET_LOG_ADDRS = CEC_GET_LOG_ADDRS; unsigned IOCTL_CEC_SET_LOG_ADDRS = CEC_SET_LOG_ADDRS; unsigned IOCTL_CEC_GET_VENDOR_ID = CEC_GET_VENDOR_ID; unsigned IOCTL_HPCFBIO_GCONF = HPCFBIO_GCONF; unsigned IOCTL_HPCFBIO_SCONF = HPCFBIO_SCONF; unsigned IOCTL_HPCFBIO_GDSPCONF = HPCFBIO_GDSPCONF; unsigned IOCTL_HPCFBIO_SDSPCONF = HPCFBIO_SDSPCONF; unsigned IOCTL_HPCFBIO_GOP = HPCFBIO_GOP; unsigned IOCTL_HPCFBIO_SOP = HPCFBIO_SOP; unsigned IOCTL_IOPIOCPT = IOPIOCPT; unsigned IOCTL_IOPIOCGLCT = IOPIOCGLCT; unsigned IOCTL_IOPIOCGSTATUS = IOPIOCGSTATUS; unsigned IOCTL_IOPIOCRECONFIG = IOPIOCRECONFIG; unsigned IOCTL_IOPIOCGTIDMAP = IOPIOCGTIDMAP; unsigned IOCTL_SIOCGATHSTATS = SIOCGATHSTATS; unsigned IOCTL_SIOCGATHDIAG = SIOCGATHDIAG; unsigned IOCTL_METEORCAPTUR = METEORCAPTUR; unsigned IOCTL_METEORCAPFRM = METEORCAPFRM; unsigned IOCTL_METEORSETGEO = METEORSETGEO; unsigned IOCTL_METEORGETGEO = METEORGETGEO; unsigned IOCTL_METEORSTATUS = METEORSTATUS; unsigned IOCTL_METEORSHUE = METEORSHUE; unsigned IOCTL_METEORGHUE = METEORGHUE; unsigned IOCTL_METEORSFMT = METEORSFMT; unsigned IOCTL_METEORGFMT = METEORGFMT; unsigned IOCTL_METEORSINPUT = METEORSINPUT; unsigned IOCTL_METEORGINPUT = METEORGINPUT; unsigned IOCTL_METEORSCHCV = METEORSCHCV; unsigned IOCTL_METEORGCHCV = METEORGCHCV; unsigned IOCTL_METEORSCOUNT = METEORSCOUNT; unsigned IOCTL_METEORGCOUNT = METEORGCOUNT; unsigned IOCTL_METEORSFPS = METEORSFPS; unsigned IOCTL_METEORGFPS = METEORGFPS; unsigned IOCTL_METEORSSIGNAL = METEORSSIGNAL; unsigned IOCTL_METEORGSIGNAL = METEORGSIGNAL; unsigned IOCTL_METEORSVIDEO = METEORSVIDEO; unsigned IOCTL_METEORGVIDEO = METEORGVIDEO; unsigned IOCTL_METEORSBRIG = METEORSBRIG; unsigned IOCTL_METEORGBRIG = METEORGBRIG; unsigned IOCTL_METEORSCSAT = METEORSCSAT; unsigned IOCTL_METEORGCSAT = METEORGCSAT; unsigned IOCTL_METEORSCONT = METEORSCONT; unsigned IOCTL_METEORGCONT = METEORGCONT; unsigned IOCTL_METEORSHWS = METEORSHWS; unsigned IOCTL_METEORGHWS = METEORGHWS; unsigned IOCTL_METEORSVWS = METEORSVWS; unsigned IOCTL_METEORGVWS = METEORGVWS; unsigned IOCTL_METEORSTS = METEORSTS; unsigned IOCTL_METEORGTS = METEORGTS; unsigned IOCTL_TVTUNER_SETCHNL = TVTUNER_SETCHNL; unsigned IOCTL_TVTUNER_GETCHNL = TVTUNER_GETCHNL; unsigned IOCTL_TVTUNER_SETTYPE = TVTUNER_SETTYPE; unsigned IOCTL_TVTUNER_GETTYPE = TVTUNER_GETTYPE; unsigned IOCTL_TVTUNER_GETSTATUS = TVTUNER_GETSTATUS; unsigned IOCTL_TVTUNER_SETFREQ = TVTUNER_SETFREQ; unsigned IOCTL_TVTUNER_GETFREQ = TVTUNER_GETFREQ; unsigned IOCTL_TVTUNER_SETAFC = TVTUNER_SETAFC; unsigned IOCTL_TVTUNER_GETAFC = TVTUNER_GETAFC; unsigned IOCTL_RADIO_SETMODE = RADIO_SETMODE; unsigned IOCTL_RADIO_GETMODE = RADIO_GETMODE; unsigned IOCTL_RADIO_SETFREQ = RADIO_SETFREQ; unsigned IOCTL_RADIO_GETFREQ = RADIO_GETFREQ; unsigned IOCTL_METEORSACTPIXFMT = METEORSACTPIXFMT; unsigned IOCTL_METEORGACTPIXFMT = METEORGACTPIXFMT; unsigned IOCTL_METEORGSUPPIXFMT = METEORGSUPPIXFMT; unsigned IOCTL_TVTUNER_GETCHNLSET = TVTUNER_GETCHNLSET; unsigned IOCTL_REMOTE_GETKEY = REMOTE_GETKEY; unsigned IOCTL_GDT_IOCTL_GENERAL = GDT_IOCTL_GENERAL; unsigned IOCTL_GDT_IOCTL_DRVERS = GDT_IOCTL_DRVERS; unsigned IOCTL_GDT_IOCTL_CTRTYPE = GDT_IOCTL_CTRTYPE; unsigned IOCTL_GDT_IOCTL_OSVERS = GDT_IOCTL_OSVERS; unsigned IOCTL_GDT_IOCTL_CTRCNT = GDT_IOCTL_CTRCNT; unsigned IOCTL_GDT_IOCTL_EVENT = GDT_IOCTL_EVENT; unsigned IOCTL_GDT_IOCTL_STATIST = GDT_IOCTL_STATIST; unsigned IOCTL_GDT_IOCTL_RESCAN = GDT_IOCTL_RESCAN; unsigned IOCTL_ISP_SDBLEV = ISP_SDBLEV; unsigned IOCTL_ISP_RESETHBA = ISP_RESETHBA; unsigned IOCTL_ISP_RESCAN = ISP_RESCAN; unsigned IOCTL_ISP_SETROLE = ISP_SETROLE; unsigned IOCTL_ISP_GETROLE = ISP_GETROLE; unsigned IOCTL_ISP_GET_STATS = ISP_GET_STATS; unsigned IOCTL_ISP_CLR_STATS = ISP_CLR_STATS; unsigned IOCTL_ISP_FC_LIP = ISP_FC_LIP; unsigned IOCTL_ISP_FC_GETDINFO = ISP_FC_GETDINFO; unsigned IOCTL_ISP_GET_FW_CRASH_DUMP = ISP_GET_FW_CRASH_DUMP; unsigned IOCTL_ISP_FORCE_CRASH_DUMP = ISP_FORCE_CRASH_DUMP; unsigned IOCTL_ISP_FC_GETHINFO = ISP_FC_GETHINFO; unsigned IOCTL_ISP_TSK_MGMT = ISP_TSK_MGMT; unsigned IOCTL_ISP_FC_GETDLIST = ISP_FC_GETDLIST; unsigned IOCTL_MLXD_STATUS = MLXD_STATUS; unsigned IOCTL_MLXD_CHECKASYNC = MLXD_CHECKASYNC; unsigned IOCTL_MLXD_DETACH = MLXD_DETACH; unsigned IOCTL_MLX_RESCAN_DRIVES = MLX_RESCAN_DRIVES; unsigned IOCTL_MLX_PAUSE_CHANNEL = MLX_PAUSE_CHANNEL; unsigned IOCTL_MLX_COMMAND = MLX_COMMAND; unsigned IOCTL_MLX_REBUILDASYNC = MLX_REBUILDASYNC; unsigned IOCTL_MLX_REBUILDSTAT = MLX_REBUILDSTAT; unsigned IOCTL_MLX_GET_SYSDRIVE = MLX_GET_SYSDRIVE; unsigned IOCTL_MLX_GET_CINFO = MLX_GET_CINFO; unsigned IOCTL_NVME_PASSTHROUGH_CMD = NVME_PASSTHROUGH_CMD; unsigned IOCTL_FWCFGIO_SET_INDEX = FWCFGIO_SET_INDEX; unsigned IOCTL_IRDA_RESET_PARAMS = IRDA_RESET_PARAMS; unsigned IOCTL_IRDA_SET_PARAMS = IRDA_SET_PARAMS; unsigned IOCTL_IRDA_GET_SPEEDMASK = IRDA_GET_SPEEDMASK; unsigned IOCTL_IRDA_GET_TURNAROUNDMASK = IRDA_GET_TURNAROUNDMASK; unsigned IOCTL_IRFRAMETTY_GET_DEVICE = IRFRAMETTY_GET_DEVICE; unsigned IOCTL_IRFRAMETTY_GET_DONGLE = IRFRAMETTY_GET_DONGLE; unsigned IOCTL_IRFRAMETTY_SET_DONGLE = IRFRAMETTY_SET_DONGLE; unsigned IOCTL_ISV_CMD = ISV_CMD; unsigned IOCTL_WTQICMD = WTQICMD; unsigned IOCTL_ISCSI_GET_VERSION = ISCSI_GET_VERSION; unsigned IOCTL_ISCSI_LOGIN = ISCSI_LOGIN; unsigned IOCTL_ISCSI_LOGOUT = ISCSI_LOGOUT; unsigned IOCTL_ISCSI_ADD_CONNECTION = ISCSI_ADD_CONNECTION; unsigned IOCTL_ISCSI_RESTORE_CONNECTION = ISCSI_RESTORE_CONNECTION; unsigned IOCTL_ISCSI_REMOVE_CONNECTION = ISCSI_REMOVE_CONNECTION; unsigned IOCTL_ISCSI_CONNECTION_STATUS = ISCSI_CONNECTION_STATUS; unsigned IOCTL_ISCSI_SEND_TARGETS = ISCSI_SEND_TARGETS; unsigned IOCTL_ISCSI_SET_NODE_NAME = ISCSI_SET_NODE_NAME; unsigned IOCTL_ISCSI_IO_COMMAND = ISCSI_IO_COMMAND; unsigned IOCTL_ISCSI_REGISTER_EVENT = ISCSI_REGISTER_EVENT; unsigned IOCTL_ISCSI_DEREGISTER_EVENT = ISCSI_DEREGISTER_EVENT; unsigned IOCTL_ISCSI_WAIT_EVENT = ISCSI_WAIT_EVENT; unsigned IOCTL_ISCSI_POLL_EVENT = ISCSI_POLL_EVENT; unsigned IOCTL_OFIOCGET = OFIOCGET; unsigned IOCTL_OFIOCSET = OFIOCSET; unsigned IOCTL_OFIOCNEXTPROP = OFIOCNEXTPROP; unsigned IOCTL_OFIOCGETOPTNODE = OFIOCGETOPTNODE; unsigned IOCTL_OFIOCGETNEXT = OFIOCGETNEXT; unsigned IOCTL_OFIOCGETCHILD = OFIOCGETCHILD; unsigned IOCTL_OFIOCFINDDEVICE = OFIOCFINDDEVICE; unsigned IOCTL_AMR_IO_VERSION = AMR_IO_VERSION; unsigned IOCTL_AMR_IO_COMMAND = AMR_IO_COMMAND; unsigned IOCTL_MLYIO_COMMAND = MLYIO_COMMAND; unsigned IOCTL_MLYIO_HEALTH = MLYIO_HEALTH; unsigned IOCTL_PCI_IOC_CFGREAD = PCI_IOC_CFGREAD; unsigned IOCTL_PCI_IOC_CFGWRITE = PCI_IOC_CFGWRITE; unsigned IOCTL_PCI_IOC_BDF_CFGREAD = PCI_IOC_BDF_CFGREAD; unsigned IOCTL_PCI_IOC_BDF_CFGWRITE = PCI_IOC_BDF_CFGWRITE; unsigned IOCTL_PCI_IOC_BUSINFO = PCI_IOC_BUSINFO; unsigned IOCTL_PCI_IOC_DRVNAME = PCI_IOC_DRVNAME; unsigned IOCTL_PCI_IOC_DRVNAMEONBUS = PCI_IOC_DRVNAMEONBUS; unsigned IOCTL_TWEIO_COMMAND = TWEIO_COMMAND; unsigned IOCTL_TWEIO_STATS = TWEIO_STATS; unsigned IOCTL_TWEIO_AEN_POLL = TWEIO_AEN_POLL; unsigned IOCTL_TWEIO_AEN_WAIT = TWEIO_AEN_WAIT; unsigned IOCTL_TWEIO_SET_PARAM = TWEIO_SET_PARAM; unsigned IOCTL_TWEIO_GET_PARAM = TWEIO_GET_PARAM; unsigned IOCTL_TWEIO_RESET = TWEIO_RESET; unsigned IOCTL_TWEIO_ADD_UNIT = TWEIO_ADD_UNIT; unsigned IOCTL_TWEIO_DEL_UNIT = TWEIO_DEL_UNIT; unsigned IOCTL_SIOCSCNWDOMAIN = SIOCSCNWDOMAIN; unsigned IOCTL_SIOCGCNWDOMAIN = SIOCGCNWDOMAIN; unsigned IOCTL_SIOCSCNWKEY = SIOCSCNWKEY; unsigned IOCTL_SIOCGCNWSTATUS = SIOCGCNWSTATUS; unsigned IOCTL_SIOCGCNWSTATS = SIOCGCNWSTATS; unsigned IOCTL_SIOCGCNWTRAIL = SIOCGCNWTRAIL; unsigned IOCTL_SIOCGRAYSIGLEV = SIOCGRAYSIGLEV; unsigned IOCTL_RAIDFRAME_SHUTDOWN = RAIDFRAME_SHUTDOWN; unsigned IOCTL_RAIDFRAME_TUR = RAIDFRAME_TUR; unsigned IOCTL_RAIDFRAME_FAIL_DISK = RAIDFRAME_FAIL_DISK; unsigned IOCTL_RAIDFRAME_CHECK_RECON_STATUS = RAIDFRAME_CHECK_RECON_STATUS; unsigned IOCTL_RAIDFRAME_REWRITEPARITY = RAIDFRAME_REWRITEPARITY; unsigned IOCTL_RAIDFRAME_COPYBACK = RAIDFRAME_COPYBACK; unsigned IOCTL_RAIDFRAME_SPARET_WAIT = RAIDFRAME_SPARET_WAIT; unsigned IOCTL_RAIDFRAME_SEND_SPARET = RAIDFRAME_SEND_SPARET; unsigned IOCTL_RAIDFRAME_ABORT_SPARET_WAIT = RAIDFRAME_ABORT_SPARET_WAIT; unsigned IOCTL_RAIDFRAME_START_ATRACE = RAIDFRAME_START_ATRACE; unsigned IOCTL_RAIDFRAME_STOP_ATRACE = RAIDFRAME_STOP_ATRACE; unsigned IOCTL_RAIDFRAME_GET_SIZE = RAIDFRAME_GET_SIZE; unsigned IOCTL_RAIDFRAME_RESET_ACCTOTALS = RAIDFRAME_RESET_ACCTOTALS; unsigned IOCTL_RAIDFRAME_KEEP_ACCTOTALS = RAIDFRAME_KEEP_ACCTOTALS; unsigned IOCTL_RAIDFRAME_GET_COMPONENT_LABEL = RAIDFRAME_GET_COMPONENT_LABEL; unsigned IOCTL_RAIDFRAME_SET_COMPONENT_LABEL = RAIDFRAME_SET_COMPONENT_LABEL; unsigned IOCTL_RAIDFRAME_INIT_LABELS = RAIDFRAME_INIT_LABELS; unsigned IOCTL_RAIDFRAME_ADD_HOT_SPARE = RAIDFRAME_ADD_HOT_SPARE; unsigned IOCTL_RAIDFRAME_REMOVE_HOT_SPARE = RAIDFRAME_REMOVE_HOT_SPARE; unsigned IOCTL_RAIDFRAME_REBUILD_IN_PLACE = RAIDFRAME_REBUILD_IN_PLACE; unsigned IOCTL_RAIDFRAME_CHECK_PARITY = RAIDFRAME_CHECK_PARITY; unsigned IOCTL_RAIDFRAME_CHECK_PARITYREWRITE_STATUS = RAIDFRAME_CHECK_PARITYREWRITE_STATUS; unsigned IOCTL_RAIDFRAME_CHECK_COPYBACK_STATUS = RAIDFRAME_CHECK_COPYBACK_STATUS; unsigned IOCTL_RAIDFRAME_SET_AUTOCONFIG = RAIDFRAME_SET_AUTOCONFIG; unsigned IOCTL_RAIDFRAME_SET_ROOT = RAIDFRAME_SET_ROOT; unsigned IOCTL_RAIDFRAME_DELETE_COMPONENT = RAIDFRAME_DELETE_COMPONENT; unsigned IOCTL_RAIDFRAME_INCORPORATE_HOT_SPARE = RAIDFRAME_INCORPORATE_HOT_SPARE; unsigned IOCTL_RAIDFRAME_CHECK_RECON_STATUS_EXT = RAIDFRAME_CHECK_RECON_STATUS_EXT; unsigned IOCTL_RAIDFRAME_CHECK_PARITYREWRITE_STATUS_EXT = RAIDFRAME_CHECK_PARITYREWRITE_STATUS_EXT; unsigned IOCTL_RAIDFRAME_CHECK_COPYBACK_STATUS_EXT = RAIDFRAME_CHECK_COPYBACK_STATUS_EXT; unsigned IOCTL_RAIDFRAME_CONFIGURE = RAIDFRAME_CONFIGURE; unsigned IOCTL_RAIDFRAME_GET_INFO = RAIDFRAME_GET_INFO; unsigned IOCTL_RAIDFRAME_PARITYMAP_STATUS = RAIDFRAME_PARITYMAP_STATUS; unsigned IOCTL_RAIDFRAME_PARITYMAP_GET_DISABLE = RAIDFRAME_PARITYMAP_GET_DISABLE; unsigned IOCTL_RAIDFRAME_PARITYMAP_SET_DISABLE = RAIDFRAME_PARITYMAP_SET_DISABLE; unsigned IOCTL_RAIDFRAME_PARITYMAP_SET_PARAMS = RAIDFRAME_PARITYMAP_SET_PARAMS; unsigned IOCTL_RAIDFRAME_SET_LAST_UNIT = RAIDFRAME_SET_LAST_UNIT; unsigned IOCTL_MBPPIOCSPARAM = MBPPIOCSPARAM; unsigned IOCTL_MBPPIOCGPARAM = MBPPIOCGPARAM; unsigned IOCTL_MBPPIOCGSTAT = MBPPIOCGSTAT; unsigned IOCTL_SESIOC_GETNOBJ = SESIOC_GETNOBJ; unsigned IOCTL_SESIOC_GETOBJMAP = SESIOC_GETOBJMAP; unsigned IOCTL_SESIOC_GETENCSTAT = SESIOC_GETENCSTAT; unsigned IOCTL_SESIOC_SETENCSTAT = SESIOC_SETENCSTAT; unsigned IOCTL_SESIOC_GETOBJSTAT = SESIOC_GETOBJSTAT; unsigned IOCTL_SESIOC_SETOBJSTAT = SESIOC_SETOBJSTAT; unsigned IOCTL_SESIOC_GETTEXT = SESIOC_GETTEXT; unsigned IOCTL_SESIOC_INIT = SESIOC_INIT; unsigned IOCTL_SUN_DKIOCGGEOM = SUN_DKIOCGGEOM; unsigned IOCTL_SUN_DKIOCINFO = SUN_DKIOCINFO; unsigned IOCTL_SUN_DKIOCGPART = SUN_DKIOCGPART; unsigned IOCTL_FBIOGTYPE = FBIOGTYPE; unsigned IOCTL_FBIOPUTCMAP = FBIOPUTCMAP; unsigned IOCTL_FBIOGETCMAP = FBIOGETCMAP; unsigned IOCTL_FBIOGATTR = FBIOGATTR; unsigned IOCTL_FBIOSVIDEO = FBIOSVIDEO; unsigned IOCTL_FBIOGVIDEO = FBIOGVIDEO; unsigned IOCTL_FBIOSCURSOR = FBIOSCURSOR; unsigned IOCTL_FBIOGCURSOR = FBIOGCURSOR; unsigned IOCTL_FBIOSCURPOS = FBIOSCURPOS; unsigned IOCTL_FBIOGCURPOS = FBIOGCURPOS; unsigned IOCTL_FBIOGCURMAX = FBIOGCURMAX; unsigned IOCTL_KIOCTRANS = KIOCTRANS; unsigned IOCTL_KIOCSETKEY = KIOCSETKEY; unsigned IOCTL_KIOCGETKEY = KIOCGETKEY; unsigned IOCTL_KIOCGTRANS = KIOCGTRANS; unsigned IOCTL_KIOCCMD = KIOCCMD; unsigned IOCTL_KIOCTYPE = KIOCTYPE; unsigned IOCTL_KIOCSDIRECT = KIOCSDIRECT; unsigned IOCTL_KIOCSKEY = KIOCSKEY; unsigned IOCTL_KIOCGKEY = KIOCGKEY; unsigned IOCTL_KIOCSLED = KIOCSLED; unsigned IOCTL_KIOCGLED = KIOCGLED; unsigned IOCTL_KIOCLAYOUT = KIOCLAYOUT; unsigned IOCTL_VUIDSFORMAT = VUIDSFORMAT; unsigned IOCTL_VUIDGFORMAT = VUIDGFORMAT; unsigned IOCTL_STICIO_GXINFO = STICIO_GXINFO; unsigned IOCTL_STICIO_RESET = STICIO_RESET; unsigned IOCTL_STICIO_STARTQ = STICIO_STARTQ; unsigned IOCTL_STICIO_STOPQ = STICIO_STOPQ; unsigned IOCTL_UKYOPON_IDENTIFY = UKYOPON_IDENTIFY; unsigned IOCTL_URIO_SEND_COMMAND = URIO_SEND_COMMAND; unsigned IOCTL_URIO_RECV_COMMAND = URIO_RECV_COMMAND; unsigned IOCTL_USB_REQUEST = USB_REQUEST; unsigned IOCTL_USB_SETDEBUG = USB_SETDEBUG; unsigned IOCTL_USB_DISCOVER = USB_DISCOVER; unsigned IOCTL_USB_DEVICEINFO = USB_DEVICEINFO; unsigned IOCTL_USB_DEVICEINFO_OLD = USB_DEVICEINFO_OLD; unsigned IOCTL_USB_DEVICESTATS = USB_DEVICESTATS; unsigned IOCTL_USB_GET_REPORT_DESC = USB_GET_REPORT_DESC; unsigned IOCTL_USB_SET_IMMED = USB_SET_IMMED; unsigned IOCTL_USB_GET_REPORT = USB_GET_REPORT; unsigned IOCTL_USB_SET_REPORT = USB_SET_REPORT; unsigned IOCTL_USB_GET_REPORT_ID = USB_GET_REPORT_ID; unsigned IOCTL_USB_GET_CONFIG = USB_GET_CONFIG; unsigned IOCTL_USB_SET_CONFIG = USB_SET_CONFIG; unsigned IOCTL_USB_GET_ALTINTERFACE = USB_GET_ALTINTERFACE; unsigned IOCTL_USB_SET_ALTINTERFACE = USB_SET_ALTINTERFACE; unsigned IOCTL_USB_GET_NO_ALT = USB_GET_NO_ALT; unsigned IOCTL_USB_GET_DEVICE_DESC = USB_GET_DEVICE_DESC; unsigned IOCTL_USB_GET_CONFIG_DESC = USB_GET_CONFIG_DESC; unsigned IOCTL_USB_GET_INTERFACE_DESC = USB_GET_INTERFACE_DESC; unsigned IOCTL_USB_GET_ENDPOINT_DESC = USB_GET_ENDPOINT_DESC; unsigned IOCTL_USB_GET_FULL_DESC = USB_GET_FULL_DESC; unsigned IOCTL_USB_GET_STRING_DESC = USB_GET_STRING_DESC; unsigned IOCTL_USB_DO_REQUEST = USB_DO_REQUEST; unsigned IOCTL_USB_GET_DEVICEINFO = USB_GET_DEVICEINFO; unsigned IOCTL_USB_GET_DEVICEINFO_OLD = USB_GET_DEVICEINFO_OLD; unsigned IOCTL_USB_SET_SHORT_XFER = USB_SET_SHORT_XFER; unsigned IOCTL_USB_SET_TIMEOUT = USB_SET_TIMEOUT; unsigned IOCTL_USB_SET_BULK_RA = USB_SET_BULK_RA; unsigned IOCTL_USB_SET_BULK_WB = USB_SET_BULK_WB; unsigned IOCTL_USB_SET_BULK_RA_OPT = USB_SET_BULK_RA_OPT; unsigned IOCTL_USB_SET_BULK_WB_OPT = USB_SET_BULK_WB_OPT; unsigned IOCTL_USB_GET_CM_OVER_DATA = USB_GET_CM_OVER_DATA; unsigned IOCTL_USB_SET_CM_OVER_DATA = USB_SET_CM_OVER_DATA; unsigned IOCTL_UTOPPYIOTURBO = UTOPPYIOTURBO; unsigned IOCTL_UTOPPYIOCANCEL = UTOPPYIOCANCEL; unsigned IOCTL_UTOPPYIOREBOOT = UTOPPYIOREBOOT; unsigned IOCTL_UTOPPYIOSTATS = UTOPPYIOSTATS; unsigned IOCTL_UTOPPYIORENAME = UTOPPYIORENAME; unsigned IOCTL_UTOPPYIOMKDIR = UTOPPYIOMKDIR; unsigned IOCTL_UTOPPYIODELETE = UTOPPYIODELETE; unsigned IOCTL_UTOPPYIOREADDIR = UTOPPYIOREADDIR; unsigned IOCTL_UTOPPYIOREADFILE = UTOPPYIOREADFILE; unsigned IOCTL_UTOPPYIOWRITEFILE = UTOPPYIOWRITEFILE; unsigned IOCTL_DIOSXDCMD = DIOSXDCMD; unsigned IOCTL_VT_OPENQRY = VT_OPENQRY; unsigned IOCTL_VT_SETMODE = VT_SETMODE; unsigned IOCTL_VT_GETMODE = VT_GETMODE; unsigned IOCTL_VT_RELDISP = VT_RELDISP; unsigned IOCTL_VT_ACTIVATE = VT_ACTIVATE; unsigned IOCTL_VT_WAITACTIVE = VT_WAITACTIVE; unsigned IOCTL_VT_GETACTIVE = VT_GETACTIVE; unsigned IOCTL_VT_GETSTATE = VT_GETSTATE; unsigned IOCTL_KDGETKBENT = KDGETKBENT; unsigned IOCTL_KDGKBMODE = KDGKBMODE; unsigned IOCTL_KDSKBMODE = KDSKBMODE; unsigned IOCTL_KDMKTONE = KDMKTONE; unsigned IOCTL_KDSETMODE = KDSETMODE; unsigned IOCTL_KDENABIO = KDENABIO; unsigned IOCTL_KDDISABIO = KDDISABIO; unsigned IOCTL_KDGKBTYPE = KDGKBTYPE; unsigned IOCTL_KDGETLED = KDGETLED; unsigned IOCTL_KDSETLED = KDSETLED; unsigned IOCTL_KDSETRAD = KDSETRAD; unsigned IOCTL_VGAPCVTID = VGAPCVTID; unsigned IOCTL_CONS_GETVERS = CONS_GETVERS; unsigned IOCTL_WSKBDIO_GTYPE = WSKBDIO_GTYPE; unsigned IOCTL_WSKBDIO_BELL = WSKBDIO_BELL; unsigned IOCTL_WSKBDIO_COMPLEXBELL = WSKBDIO_COMPLEXBELL; unsigned IOCTL_WSKBDIO_SETBELL = WSKBDIO_SETBELL; unsigned IOCTL_WSKBDIO_GETBELL = WSKBDIO_GETBELL; unsigned IOCTL_WSKBDIO_SETDEFAULTBELL = WSKBDIO_SETDEFAULTBELL; unsigned IOCTL_WSKBDIO_GETDEFAULTBELL = WSKBDIO_GETDEFAULTBELL; unsigned IOCTL_WSKBDIO_SETKEYREPEAT = WSKBDIO_SETKEYREPEAT; unsigned IOCTL_WSKBDIO_GETKEYREPEAT = WSKBDIO_GETKEYREPEAT; unsigned IOCTL_WSKBDIO_SETDEFAULTKEYREPEAT = WSKBDIO_SETDEFAULTKEYREPEAT; unsigned IOCTL_WSKBDIO_GETDEFAULTKEYREPEAT = WSKBDIO_GETDEFAULTKEYREPEAT; unsigned IOCTL_WSKBDIO_SETLEDS = WSKBDIO_SETLEDS; unsigned IOCTL_WSKBDIO_GETLEDS = WSKBDIO_GETLEDS; unsigned IOCTL_WSKBDIO_GETMAP = WSKBDIO_GETMAP; unsigned IOCTL_WSKBDIO_SETMAP = WSKBDIO_SETMAP; unsigned IOCTL_WSKBDIO_GETENCODING = WSKBDIO_GETENCODING; unsigned IOCTL_WSKBDIO_SETENCODING = WSKBDIO_SETENCODING; unsigned IOCTL_WSKBDIO_SETMODE = WSKBDIO_SETMODE; unsigned IOCTL_WSKBDIO_GETMODE = WSKBDIO_GETMODE; unsigned IOCTL_WSKBDIO_SETKEYCLICK = WSKBDIO_SETKEYCLICK; unsigned IOCTL_WSKBDIO_GETKEYCLICK = WSKBDIO_GETKEYCLICK; unsigned IOCTL_WSKBDIO_GETSCROLL = WSKBDIO_GETSCROLL; unsigned IOCTL_WSKBDIO_SETSCROLL = WSKBDIO_SETSCROLL; unsigned IOCTL_WSKBDIO_SETVERSION = WSKBDIO_SETVERSION; unsigned IOCTL_WSMOUSEIO_GTYPE = WSMOUSEIO_GTYPE; unsigned IOCTL_WSMOUSEIO_SRES = WSMOUSEIO_SRES; unsigned IOCTL_WSMOUSEIO_SSCALE = WSMOUSEIO_SSCALE; unsigned IOCTL_WSMOUSEIO_SRATE = WSMOUSEIO_SRATE; unsigned IOCTL_WSMOUSEIO_SCALIBCOORDS = WSMOUSEIO_SCALIBCOORDS; unsigned IOCTL_WSMOUSEIO_GCALIBCOORDS = WSMOUSEIO_GCALIBCOORDS; unsigned IOCTL_WSMOUSEIO_GETID = WSMOUSEIO_GETID; unsigned IOCTL_WSMOUSEIO_GETREPEAT = WSMOUSEIO_GETREPEAT; unsigned IOCTL_WSMOUSEIO_SETREPEAT = WSMOUSEIO_SETREPEAT; unsigned IOCTL_WSMOUSEIO_SETVERSION = WSMOUSEIO_SETVERSION; unsigned IOCTL_WSDISPLAYIO_GTYPE = WSDISPLAYIO_GTYPE; unsigned IOCTL_WSDISPLAYIO_GINFO = WSDISPLAYIO_GINFO; unsigned IOCTL_WSDISPLAYIO_GETCMAP = WSDISPLAYIO_GETCMAP; unsigned IOCTL_WSDISPLAYIO_PUTCMAP = WSDISPLAYIO_PUTCMAP; unsigned IOCTL_WSDISPLAYIO_GVIDEO = WSDISPLAYIO_GVIDEO; unsigned IOCTL_WSDISPLAYIO_SVIDEO = WSDISPLAYIO_SVIDEO; unsigned IOCTL_WSDISPLAYIO_GCURPOS = WSDISPLAYIO_GCURPOS; unsigned IOCTL_WSDISPLAYIO_SCURPOS = WSDISPLAYIO_SCURPOS; unsigned IOCTL_WSDISPLAYIO_GCURMAX = WSDISPLAYIO_GCURMAX; unsigned IOCTL_WSDISPLAYIO_GCURSOR = WSDISPLAYIO_GCURSOR; unsigned IOCTL_WSDISPLAYIO_SCURSOR = WSDISPLAYIO_SCURSOR; unsigned IOCTL_WSDISPLAYIO_GMODE = WSDISPLAYIO_GMODE; unsigned IOCTL_WSDISPLAYIO_SMODE = WSDISPLAYIO_SMODE; unsigned IOCTL_WSDISPLAYIO_LDFONT = WSDISPLAYIO_LDFONT; unsigned IOCTL_WSDISPLAYIO_ADDSCREEN = WSDISPLAYIO_ADDSCREEN; unsigned IOCTL_WSDISPLAYIO_DELSCREEN = WSDISPLAYIO_DELSCREEN; unsigned IOCTL_WSDISPLAYIO_SFONT = WSDISPLAYIO_SFONT; unsigned IOCTL__O_WSDISPLAYIO_SETKEYBOARD = _O_WSDISPLAYIO_SETKEYBOARD; unsigned IOCTL_WSDISPLAYIO_GETPARAM = WSDISPLAYIO_GETPARAM; unsigned IOCTL_WSDISPLAYIO_SETPARAM = WSDISPLAYIO_SETPARAM; unsigned IOCTL_WSDISPLAYIO_GETACTIVESCREEN = WSDISPLAYIO_GETACTIVESCREEN; unsigned IOCTL_WSDISPLAYIO_GETWSCHAR = WSDISPLAYIO_GETWSCHAR; unsigned IOCTL_WSDISPLAYIO_PUTWSCHAR = WSDISPLAYIO_PUTWSCHAR; unsigned IOCTL_WSDISPLAYIO_DGSCROLL = WSDISPLAYIO_DGSCROLL; unsigned IOCTL_WSDISPLAYIO_DSSCROLL = WSDISPLAYIO_DSSCROLL; unsigned IOCTL_WSDISPLAYIO_GMSGATTRS = WSDISPLAYIO_GMSGATTRS; unsigned IOCTL_WSDISPLAYIO_SMSGATTRS = WSDISPLAYIO_SMSGATTRS; unsigned IOCTL_WSDISPLAYIO_GBORDER = WSDISPLAYIO_GBORDER; unsigned IOCTL_WSDISPLAYIO_SBORDER = WSDISPLAYIO_SBORDER; unsigned IOCTL_WSDISPLAYIO_SSPLASH = WSDISPLAYIO_SSPLASH; unsigned IOCTL_WSDISPLAYIO_SPROGRESS = WSDISPLAYIO_SPROGRESS; unsigned IOCTL_WSDISPLAYIO_LINEBYTES = WSDISPLAYIO_LINEBYTES; unsigned IOCTL_WSDISPLAYIO_SETVERSION = WSDISPLAYIO_SETVERSION; unsigned IOCTL_WSMUXIO_ADD_DEVICE = WSMUXIO_ADD_DEVICE; unsigned IOCTL_WSMUXIO_REMOVE_DEVICE = WSMUXIO_REMOVE_DEVICE; unsigned IOCTL_WSMUXIO_LIST_DEVICES = WSMUXIO_LIST_DEVICES; unsigned IOCTL_WSMUXIO_INJECTEVENT = WSMUXIO_INJECTEVENT; unsigned IOCTL_WSDISPLAYIO_GET_BUSID = WSDISPLAYIO_GET_BUSID; unsigned IOCTL_WSDISPLAYIO_GET_EDID = WSDISPLAYIO_GET_EDID; unsigned IOCTL_WSDISPLAYIO_SET_POLLING = WSDISPLAYIO_SET_POLLING; unsigned IOCTL_WSDISPLAYIO_GET_FBINFO = WSDISPLAYIO_GET_FBINFO; unsigned IOCTL_WSDISPLAYIO_DOBLIT = WSDISPLAYIO_DOBLIT; unsigned IOCTL_WSDISPLAYIO_WAITBLIT = WSDISPLAYIO_WAITBLIT; unsigned IOCTL_BIOCLOCATE = BIOCLOCATE; unsigned IOCTL_BIOCINQ = BIOCINQ; unsigned IOCTL_BIOCDISK_NOVOL = BIOCDISK_NOVOL; unsigned IOCTL_BIOCDISK = BIOCDISK; unsigned IOCTL_BIOCVOL = BIOCVOL; unsigned IOCTL_BIOCALARM = BIOCALARM; unsigned IOCTL_BIOCBLINK = BIOCBLINK; unsigned IOCTL_BIOCSETSTATE = BIOCSETSTATE; unsigned IOCTL_BIOCVOLOPS = BIOCVOLOPS; unsigned IOCTL_MD_GETCONF = MD_GETCONF; unsigned IOCTL_MD_SETCONF = MD_SETCONF; unsigned IOCTL_CCDIOCSET = CCDIOCSET; unsigned IOCTL_CCDIOCCLR = CCDIOCCLR; unsigned IOCTL_CGDIOCSET = CGDIOCSET; unsigned IOCTL_CGDIOCCLR = CGDIOCCLR; unsigned IOCTL_CGDIOCGET = CGDIOCGET; unsigned IOCTL_FSSIOCSET = FSSIOCSET; unsigned IOCTL_FSSIOCGET = FSSIOCGET; unsigned IOCTL_FSSIOCCLR = FSSIOCCLR; unsigned IOCTL_FSSIOFSET = FSSIOFSET; unsigned IOCTL_FSSIOFGET = FSSIOFGET; unsigned IOCTL_BTDEV_ATTACH = BTDEV_ATTACH; unsigned IOCTL_BTDEV_DETACH = BTDEV_DETACH; unsigned IOCTL_BTSCO_GETINFO = BTSCO_GETINFO; unsigned IOCTL_KTTCP_IO_SEND = KTTCP_IO_SEND; unsigned IOCTL_KTTCP_IO_RECV = KTTCP_IO_RECV; unsigned IOCTL_IOC_LOCKSTAT_GVERSION = IOC_LOCKSTAT_GVERSION; unsigned IOCTL_IOC_LOCKSTAT_ENABLE = IOC_LOCKSTAT_ENABLE; unsigned IOCTL_IOC_LOCKSTAT_DISABLE = IOC_LOCKSTAT_DISABLE; unsigned IOCTL_VNDIOCSET = VNDIOCSET; unsigned IOCTL_VNDIOCCLR = VNDIOCCLR; unsigned IOCTL_VNDIOCGET = VNDIOCGET; unsigned IOCTL_SPKRTONE = SPKRTONE; unsigned IOCTL_SPKRTUNE = SPKRTUNE; unsigned IOCTL_SPKRGETVOL = SPKRGETVOL; unsigned IOCTL_SPKRSETVOL = SPKRSETVOL; -#if 0 /* interfaces are WIP */ +#if defined(__x86_64__) unsigned IOCTL_NVMM_IOC_CAPABILITY = NVMM_IOC_CAPABILITY; unsigned IOCTL_NVMM_IOC_MACHINE_CREATE = NVMM_IOC_MACHINE_CREATE; unsigned IOCTL_NVMM_IOC_MACHINE_DESTROY = NVMM_IOC_MACHINE_DESTROY; unsigned IOCTL_NVMM_IOC_MACHINE_CONFIGURE = NVMM_IOC_MACHINE_CONFIGURE; unsigned IOCTL_NVMM_IOC_VCPU_CREATE = NVMM_IOC_VCPU_CREATE; unsigned IOCTL_NVMM_IOC_VCPU_DESTROY = NVMM_IOC_VCPU_DESTROY; unsigned IOCTL_NVMM_IOC_VCPU_SETSTATE = NVMM_IOC_VCPU_SETSTATE; unsigned IOCTL_NVMM_IOC_VCPU_GETSTATE = NVMM_IOC_VCPU_GETSTATE; unsigned IOCTL_NVMM_IOC_VCPU_INJECT = NVMM_IOC_VCPU_INJECT; unsigned IOCTL_NVMM_IOC_VCPU_RUN = NVMM_IOC_VCPU_RUN; unsigned IOCTL_NVMM_IOC_GPA_MAP = NVMM_IOC_GPA_MAP; unsigned IOCTL_NVMM_IOC_GPA_UNMAP = NVMM_IOC_GPA_UNMAP; unsigned IOCTL_NVMM_IOC_HVA_MAP = NVMM_IOC_HVA_MAP; unsigned IOCTL_NVMM_IOC_HVA_UNMAP = NVMM_IOC_HVA_UNMAP; +unsigned IOCTL_NVMM_IOC_CTL = NVMM_IOC_CTL; #endif +unsigned IOCTL_SPI_IOCTL_CONFIGURE = SPI_IOCTL_CONFIGURE; +unsigned IOCTL_SPI_IOCTL_TRANSFER = SPI_IOCTL_TRANSFER; unsigned IOCTL_AUTOFSREQUEST = AUTOFSREQUEST; unsigned IOCTL_AUTOFSDONE = AUTOFSDONE; unsigned IOCTL_BIOCGBLEN = BIOCGBLEN; unsigned IOCTL_BIOCSBLEN = BIOCSBLEN; unsigned IOCTL_BIOCSETF = BIOCSETF; unsigned IOCTL_BIOCFLUSH = BIOCFLUSH; unsigned IOCTL_BIOCPROMISC = BIOCPROMISC; unsigned IOCTL_BIOCGDLT = BIOCGDLT; unsigned IOCTL_BIOCGETIF = BIOCGETIF; unsigned IOCTL_BIOCSETIF = BIOCSETIF; unsigned IOCTL_BIOCGSTATS = BIOCGSTATS; unsigned IOCTL_BIOCGSTATSOLD = BIOCGSTATSOLD; unsigned IOCTL_BIOCIMMEDIATE = BIOCIMMEDIATE; unsigned IOCTL_BIOCVERSION = BIOCVERSION; unsigned IOCTL_BIOCSTCPF = BIOCSTCPF; unsigned IOCTL_BIOCSUDPF = BIOCSUDPF; unsigned IOCTL_BIOCGHDRCMPLT = BIOCGHDRCMPLT; unsigned IOCTL_BIOCSHDRCMPLT = BIOCSHDRCMPLT; unsigned IOCTL_BIOCSDLT = BIOCSDLT; unsigned IOCTL_BIOCGDLTLIST = BIOCGDLTLIST; unsigned IOCTL_BIOCGDIRECTION = BIOCGDIRECTION; unsigned IOCTL_BIOCSDIRECTION = BIOCSDIRECTION; unsigned IOCTL_BIOCSRTIMEOUT = BIOCSRTIMEOUT; unsigned IOCTL_BIOCGRTIMEOUT = BIOCGRTIMEOUT; unsigned IOCTL_BIOCGFEEDBACK = BIOCGFEEDBACK; unsigned IOCTL_BIOCSFEEDBACK = BIOCSFEEDBACK; unsigned IOCTL_GRESADDRS = GRESADDRS; unsigned IOCTL_GRESADDRD = GRESADDRD; unsigned IOCTL_GREGADDRS = GREGADDRS; unsigned IOCTL_GREGADDRD = GREGADDRD; unsigned IOCTL_GRESPROTO = GRESPROTO; unsigned IOCTL_GREGPROTO = GREGPROTO; unsigned IOCTL_GRESSOCK = GRESSOCK; unsigned IOCTL_GREDSOCK = GREDSOCK; unsigned IOCTL_PPPIOCGRAWIN = PPPIOCGRAWIN; unsigned IOCTL_PPPIOCGFLAGS = PPPIOCGFLAGS; unsigned IOCTL_PPPIOCSFLAGS = PPPIOCSFLAGS; unsigned IOCTL_PPPIOCGASYNCMAP = PPPIOCGASYNCMAP; unsigned IOCTL_PPPIOCSASYNCMAP = PPPIOCSASYNCMAP; unsigned IOCTL_PPPIOCGUNIT = PPPIOCGUNIT; unsigned IOCTL_PPPIOCGRASYNCMAP = PPPIOCGRASYNCMAP; unsigned IOCTL_PPPIOCSRASYNCMAP = PPPIOCSRASYNCMAP; unsigned IOCTL_PPPIOCGMRU = PPPIOCGMRU; unsigned IOCTL_PPPIOCSMRU = PPPIOCSMRU; unsigned IOCTL_PPPIOCSMAXCID = PPPIOCSMAXCID; unsigned IOCTL_PPPIOCGXASYNCMAP = PPPIOCGXASYNCMAP; unsigned IOCTL_PPPIOCSXASYNCMAP = PPPIOCSXASYNCMAP; unsigned IOCTL_PPPIOCXFERUNIT = PPPIOCXFERUNIT; unsigned IOCTL_PPPIOCSCOMPRESS = PPPIOCSCOMPRESS; unsigned IOCTL_PPPIOCGNPMODE = PPPIOCGNPMODE; unsigned IOCTL_PPPIOCSNPMODE = PPPIOCSNPMODE; unsigned IOCTL_PPPIOCGIDLE = PPPIOCGIDLE; unsigned IOCTL_PPPIOCGMTU = PPPIOCGMTU; unsigned IOCTL_PPPIOCSMTU = PPPIOCSMTU; unsigned IOCTL_SIOCGPPPSTATS = SIOCGPPPSTATS; unsigned IOCTL_SIOCGPPPCSTATS = SIOCGPPPCSTATS; unsigned IOCTL_IOC_NPF_VERSION = IOC_NPF_VERSION; unsigned IOCTL_IOC_NPF_SWITCH = IOC_NPF_SWITCH; unsigned IOCTL_IOC_NPF_LOAD = IOC_NPF_LOAD; unsigned IOCTL_IOC_NPF_TABLE = IOC_NPF_TABLE; unsigned IOCTL_IOC_NPF_STATS = IOC_NPF_STATS; unsigned IOCTL_IOC_NPF_SAVE = IOC_NPF_SAVE; unsigned IOCTL_IOC_NPF_RULE = IOC_NPF_RULE; unsigned IOCTL_IOC_NPF_CONN_LOOKUP = IOC_NPF_CONN_LOOKUP; unsigned IOCTL_PPPOESETPARMS = PPPOESETPARMS; unsigned IOCTL_PPPOEGETPARMS = PPPOEGETPARMS; unsigned IOCTL_PPPOEGETSESSION = PPPOEGETSESSION; unsigned IOCTL_SPPPGETAUTHCFG = SPPPGETAUTHCFG; unsigned IOCTL_SPPPSETAUTHCFG = SPPPSETAUTHCFG; unsigned IOCTL_SPPPGETLCPCFG = SPPPGETLCPCFG; unsigned IOCTL_SPPPSETLCPCFG = SPPPSETLCPCFG; unsigned IOCTL_SPPPGETSTATUS = SPPPGETSTATUS; unsigned IOCTL_SPPPGETSTATUSNCP = SPPPGETSTATUSNCP; unsigned IOCTL_SPPPGETIDLETO = SPPPGETIDLETO; unsigned IOCTL_SPPPSETIDLETO = SPPPSETIDLETO; unsigned IOCTL_SPPPGETAUTHFAILURES = SPPPGETAUTHFAILURES; unsigned IOCTL_SPPPSETAUTHFAILURE = SPPPSETAUTHFAILURE; unsigned IOCTL_SPPPSETDNSOPTS = SPPPSETDNSOPTS; unsigned IOCTL_SPPPGETDNSOPTS = SPPPGETDNSOPTS; unsigned IOCTL_SPPPGETDNSADDRS = SPPPGETDNSADDRS; unsigned IOCTL_SPPPSETKEEPALIVE = SPPPSETKEEPALIVE; unsigned IOCTL_SPPPGETKEEPALIVE = SPPPGETKEEPALIVE; unsigned IOCTL_SRT_GETNRT = SRT_GETNRT; unsigned IOCTL_SRT_GETRT = SRT_GETRT; unsigned IOCTL_SRT_SETRT = SRT_SETRT; unsigned IOCTL_SRT_DELRT = SRT_DELRT; unsigned IOCTL_SRT_SFLAGS = SRT_SFLAGS; unsigned IOCTL_SRT_GFLAGS = SRT_GFLAGS; unsigned IOCTL_SRT_SGFLAGS = SRT_SGFLAGS; unsigned IOCTL_SRT_DEBUG = SRT_DEBUG; unsigned IOCTL_TAPGIFNAME = TAPGIFNAME; unsigned IOCTL_TUNSDEBUG = TUNSDEBUG; unsigned IOCTL_TUNGDEBUG = TUNGDEBUG; unsigned IOCTL_TUNSIFMODE = TUNSIFMODE; unsigned IOCTL_TUNSLMODE = TUNSLMODE; unsigned IOCTL_TUNSIFHEAD = TUNSIFHEAD; unsigned IOCTL_TUNGIFHEAD = TUNGIFHEAD; unsigned IOCTL_DIOCSTART = DIOCSTART; unsigned IOCTL_DIOCSTOP = DIOCSTOP; unsigned IOCTL_DIOCADDRULE = DIOCADDRULE; unsigned IOCTL_DIOCGETRULES = DIOCGETRULES; unsigned IOCTL_DIOCGETRULE = DIOCGETRULE; unsigned IOCTL_DIOCSETLCK = DIOCSETLCK; unsigned IOCTL_DIOCCLRSTATES = DIOCCLRSTATES; unsigned IOCTL_DIOCGETSTATE = DIOCGETSTATE; unsigned IOCTL_DIOCSETSTATUSIF = DIOCSETSTATUSIF; unsigned IOCTL_DIOCGETSTATUS = DIOCGETSTATUS; unsigned IOCTL_DIOCCLRSTATUS = DIOCCLRSTATUS; unsigned IOCTL_DIOCNATLOOK = DIOCNATLOOK; unsigned IOCTL_DIOCSETDEBUG = DIOCSETDEBUG; unsigned IOCTL_DIOCGETSTATES = DIOCGETSTATES; unsigned IOCTL_DIOCCHANGERULE = DIOCCHANGERULE; unsigned IOCTL_DIOCSETTIMEOUT = DIOCSETTIMEOUT; unsigned IOCTL_DIOCGETTIMEOUT = DIOCGETTIMEOUT; unsigned IOCTL_DIOCADDSTATE = DIOCADDSTATE; unsigned IOCTL_DIOCCLRRULECTRS = DIOCCLRRULECTRS; unsigned IOCTL_DIOCGETLIMIT = DIOCGETLIMIT; unsigned IOCTL_DIOCSETLIMIT = DIOCSETLIMIT; unsigned IOCTL_DIOCKILLSTATES = DIOCKILLSTATES; unsigned IOCTL_DIOCSTARTALTQ = DIOCSTARTALTQ; unsigned IOCTL_DIOCSTOPALTQ = DIOCSTOPALTQ; unsigned IOCTL_DIOCADDALTQ = DIOCADDALTQ; unsigned IOCTL_DIOCGETALTQS = DIOCGETALTQS; unsigned IOCTL_DIOCGETALTQ = DIOCGETALTQ; unsigned IOCTL_DIOCCHANGEALTQ = DIOCCHANGEALTQ; unsigned IOCTL_DIOCGETQSTATS = DIOCGETQSTATS; unsigned IOCTL_DIOCBEGINADDRS = DIOCBEGINADDRS; unsigned IOCTL_DIOCADDADDR = DIOCADDADDR; unsigned IOCTL_DIOCGETADDRS = DIOCGETADDRS; unsigned IOCTL_DIOCGETADDR = DIOCGETADDR; unsigned IOCTL_DIOCCHANGEADDR = DIOCCHANGEADDR; unsigned IOCTL_DIOCADDSTATES = DIOCADDSTATES; unsigned IOCTL_DIOCGETRULESETS = DIOCGETRULESETS; unsigned IOCTL_DIOCGETRULESET = DIOCGETRULESET; unsigned IOCTL_DIOCRCLRTABLES = DIOCRCLRTABLES; unsigned IOCTL_DIOCRADDTABLES = DIOCRADDTABLES; unsigned IOCTL_DIOCRDELTABLES = DIOCRDELTABLES; unsigned IOCTL_DIOCRGETTABLES = DIOCRGETTABLES; unsigned IOCTL_DIOCRGETTSTATS = DIOCRGETTSTATS; unsigned IOCTL_DIOCRCLRTSTATS = DIOCRCLRTSTATS; unsigned IOCTL_DIOCRCLRADDRS = DIOCRCLRADDRS; unsigned IOCTL_DIOCRADDADDRS = DIOCRADDADDRS; unsigned IOCTL_DIOCRDELADDRS = DIOCRDELADDRS; unsigned IOCTL_DIOCRSETADDRS = DIOCRSETADDRS; unsigned IOCTL_DIOCRGETADDRS = DIOCRGETADDRS; unsigned IOCTL_DIOCRGETASTATS = DIOCRGETASTATS; unsigned IOCTL_DIOCRCLRASTATS = DIOCRCLRASTATS; unsigned IOCTL_DIOCRTSTADDRS = DIOCRTSTADDRS; unsigned IOCTL_DIOCRSETTFLAGS = DIOCRSETTFLAGS; unsigned IOCTL_DIOCRINADEFINE = DIOCRINADEFINE; unsigned IOCTL_DIOCOSFPFLUSH = DIOCOSFPFLUSH; unsigned IOCTL_DIOCOSFPADD = DIOCOSFPADD; unsigned IOCTL_DIOCOSFPGET = DIOCOSFPGET; unsigned IOCTL_DIOCXBEGIN = DIOCXBEGIN; unsigned IOCTL_DIOCXCOMMIT = DIOCXCOMMIT; unsigned IOCTL_DIOCXROLLBACK = DIOCXROLLBACK; unsigned IOCTL_DIOCGETSRCNODES = DIOCGETSRCNODES; unsigned IOCTL_DIOCCLRSRCNODES = DIOCCLRSRCNODES; unsigned IOCTL_DIOCSETHOSTID = DIOCSETHOSTID; unsigned IOCTL_DIOCIGETIFACES = DIOCIGETIFACES; unsigned IOCTL_DIOCSETIFFLAG = DIOCSETIFFLAG; unsigned IOCTL_DIOCCLRIFFLAG = DIOCCLRIFFLAG; unsigned IOCTL_DIOCKILLSRCNODES = DIOCKILLSRCNODES; unsigned IOCTL_SLIOCGUNIT = SLIOCGUNIT; unsigned IOCTL_SIOCGBTINFO = SIOCGBTINFO; unsigned IOCTL_SIOCGBTINFOA = SIOCGBTINFOA; unsigned IOCTL_SIOCNBTINFO = SIOCNBTINFO; unsigned IOCTL_SIOCSBTFLAGS = SIOCSBTFLAGS; unsigned IOCTL_SIOCSBTPOLICY = SIOCSBTPOLICY; unsigned IOCTL_SIOCSBTPTYPE = SIOCSBTPTYPE; unsigned IOCTL_SIOCGBTSTATS = SIOCGBTSTATS; unsigned IOCTL_SIOCZBTSTATS = SIOCZBTSTATS; unsigned IOCTL_SIOCBTDUMP = SIOCBTDUMP; unsigned IOCTL_SIOCSBTSCOMTU = SIOCSBTSCOMTU; unsigned IOCTL_SIOCGBTFEAT = SIOCGBTFEAT; unsigned IOCTL_SIOCADNAT = SIOCADNAT; unsigned IOCTL_SIOCRMNAT = SIOCRMNAT; unsigned IOCTL_SIOCGNATS = SIOCGNATS; unsigned IOCTL_SIOCGNATL = SIOCGNATL; unsigned IOCTL_SIOCPURGENAT = SIOCPURGENAT; unsigned IOCTL_SIOCCONNECTX = SIOCCONNECTX; unsigned IOCTL_SIOCCONNECTXDEL = SIOCCONNECTXDEL; unsigned IOCTL_SIOCSIFINFO_FLAGS = SIOCSIFINFO_FLAGS; unsigned IOCTL_SIOCAADDRCTL_POLICY = SIOCAADDRCTL_POLICY; unsigned IOCTL_SIOCDADDRCTL_POLICY = SIOCDADDRCTL_POLICY; unsigned IOCTL_SMBIOC_OPENSESSION = SMBIOC_OPENSESSION; unsigned IOCTL_SMBIOC_OPENSHARE = SMBIOC_OPENSHARE; unsigned IOCTL_SMBIOC_REQUEST = SMBIOC_REQUEST; unsigned IOCTL_SMBIOC_SETFLAGS = SMBIOC_SETFLAGS; unsigned IOCTL_SMBIOC_LOOKUP = SMBIOC_LOOKUP; unsigned IOCTL_SMBIOC_READ = SMBIOC_READ; unsigned IOCTL_SMBIOC_WRITE = SMBIOC_WRITE; unsigned IOCTL_AGPIOC_INFO = AGPIOC_INFO; unsigned IOCTL_AGPIOC_ACQUIRE = AGPIOC_ACQUIRE; unsigned IOCTL_AGPIOC_RELEASE = AGPIOC_RELEASE; unsigned IOCTL_AGPIOC_SETUP = AGPIOC_SETUP; unsigned IOCTL_AGPIOC_ALLOCATE = AGPIOC_ALLOCATE; unsigned IOCTL_AGPIOC_DEALLOCATE = AGPIOC_DEALLOCATE; unsigned IOCTL_AGPIOC_BIND = AGPIOC_BIND; unsigned IOCTL_AGPIOC_UNBIND = AGPIOC_UNBIND; unsigned IOCTL_AUDIO_GETINFO = AUDIO_GETINFO; unsigned IOCTL_AUDIO_SETINFO = AUDIO_SETINFO; unsigned IOCTL_AUDIO_DRAIN = AUDIO_DRAIN; unsigned IOCTL_AUDIO_FLUSH = AUDIO_FLUSH; unsigned IOCTL_AUDIO_WSEEK = AUDIO_WSEEK; unsigned IOCTL_AUDIO_RERROR = AUDIO_RERROR; unsigned IOCTL_AUDIO_GETDEV = AUDIO_GETDEV; unsigned IOCTL_AUDIO_GETENC = AUDIO_GETENC; unsigned IOCTL_AUDIO_GETFD = AUDIO_GETFD; unsigned IOCTL_AUDIO_SETFD = AUDIO_SETFD; unsigned IOCTL_AUDIO_PERROR = AUDIO_PERROR; unsigned IOCTL_AUDIO_GETIOFFS = AUDIO_GETIOFFS; unsigned IOCTL_AUDIO_GETOOFFS = AUDIO_GETOOFFS; unsigned IOCTL_AUDIO_GETPROPS = AUDIO_GETPROPS; unsigned IOCTL_AUDIO_GETBUFINFO = AUDIO_GETBUFINFO; unsigned IOCTL_AUDIO_SETCHAN = AUDIO_SETCHAN; unsigned IOCTL_AUDIO_GETCHAN = AUDIO_GETCHAN; +unsigned IOCTL_AUDIO_QUERYFORMAT = AUDIO_QUERYFORMAT; +unsigned IOCTL_AUDIO_GETFORMAT = AUDIO_GETFORMAT; +unsigned IOCTL_AUDIO_SETFORMAT = AUDIO_SETFORMAT; unsigned IOCTL_AUDIO_MIXER_READ = AUDIO_MIXER_READ; unsigned IOCTL_AUDIO_MIXER_WRITE = AUDIO_MIXER_WRITE; unsigned IOCTL_AUDIO_MIXER_DEVINFO = AUDIO_MIXER_DEVINFO; unsigned IOCTL_ATAIOCCOMMAND = ATAIOCCOMMAND; unsigned IOCTL_ATABUSIOSCAN = ATABUSIOSCAN; unsigned IOCTL_ATABUSIORESET = ATABUSIORESET; unsigned IOCTL_ATABUSIODETACH = ATABUSIODETACH; unsigned IOCTL_CDIOCPLAYTRACKS = CDIOCPLAYTRACKS; unsigned IOCTL_CDIOCPLAYBLOCKS = CDIOCPLAYBLOCKS; unsigned IOCTL_CDIOCREADSUBCHANNEL = CDIOCREADSUBCHANNEL; unsigned IOCTL_CDIOREADTOCHEADER = CDIOREADTOCHEADER; unsigned IOCTL_CDIOREADTOCENTRIES = CDIOREADTOCENTRIES; unsigned IOCTL_CDIOREADMSADDR = CDIOREADMSADDR; unsigned IOCTL_CDIOCSETPATCH = CDIOCSETPATCH; unsigned IOCTL_CDIOCGETVOL = CDIOCGETVOL; unsigned IOCTL_CDIOCSETVOL = CDIOCSETVOL; unsigned IOCTL_CDIOCSETMONO = CDIOCSETMONO; unsigned IOCTL_CDIOCSETSTEREO = CDIOCSETSTEREO; unsigned IOCTL_CDIOCSETMUTE = CDIOCSETMUTE; unsigned IOCTL_CDIOCSETLEFT = CDIOCSETLEFT; unsigned IOCTL_CDIOCSETRIGHT = CDIOCSETRIGHT; unsigned IOCTL_CDIOCSETDEBUG = CDIOCSETDEBUG; unsigned IOCTL_CDIOCCLRDEBUG = CDIOCCLRDEBUG; unsigned IOCTL_CDIOCPAUSE = CDIOCPAUSE; unsigned IOCTL_CDIOCRESUME = CDIOCRESUME; unsigned IOCTL_CDIOCRESET = CDIOCRESET; unsigned IOCTL_CDIOCSTART = CDIOCSTART; unsigned IOCTL_CDIOCSTOP = CDIOCSTOP; unsigned IOCTL_CDIOCEJECT = CDIOCEJECT; unsigned IOCTL_CDIOCALLOW = CDIOCALLOW; unsigned IOCTL_CDIOCPREVENT = CDIOCPREVENT; unsigned IOCTL_CDIOCCLOSE = CDIOCCLOSE; unsigned IOCTL_CDIOCPLAYMSF = CDIOCPLAYMSF; unsigned IOCTL_CDIOCLOADUNLOAD = CDIOCLOADUNLOAD; unsigned IOCTL_CHIOMOVE = CHIOMOVE; unsigned IOCTL_CHIOEXCHANGE = CHIOEXCHANGE; unsigned IOCTL_CHIOPOSITION = CHIOPOSITION; unsigned IOCTL_CHIOGPICKER = CHIOGPICKER; unsigned IOCTL_CHIOSPICKER = CHIOSPICKER; unsigned IOCTL_CHIOGPARAMS = CHIOGPARAMS; unsigned IOCTL_CHIOIELEM = CHIOIELEM; unsigned IOCTL_OCHIOGSTATUS = OCHIOGSTATUS; unsigned IOCTL_CHIOGSTATUS = CHIOGSTATUS; unsigned IOCTL_CHIOSVOLTAG = CHIOSVOLTAG; unsigned IOCTL_CLOCKCTL_SETTIMEOFDAY = CLOCKCTL_SETTIMEOFDAY; unsigned IOCTL_CLOCKCTL_ADJTIME = CLOCKCTL_ADJTIME; unsigned IOCTL_CLOCKCTL_CLOCK_SETTIME = CLOCKCTL_CLOCK_SETTIME; unsigned IOCTL_CLOCKCTL_NTP_ADJTIME = CLOCKCTL_NTP_ADJTIME; unsigned IOCTL_IOC_CPU_SETSTATE = IOC_CPU_SETSTATE; unsigned IOCTL_IOC_CPU_GETSTATE = IOC_CPU_GETSTATE; unsigned IOCTL_IOC_CPU_GETCOUNT = IOC_CPU_GETCOUNT; unsigned IOCTL_IOC_CPU_MAPID = IOC_CPU_MAPID; unsigned IOCTL_IOC_CPU_UCODE_GET_VERSION = IOC_CPU_UCODE_GET_VERSION; unsigned IOCTL_IOC_CPU_UCODE_APPLY = IOC_CPU_UCODE_APPLY; unsigned IOCTL_DIOCGDINFO = DIOCGDINFO; unsigned IOCTL_DIOCSDINFO = DIOCSDINFO; unsigned IOCTL_DIOCWDINFO = DIOCWDINFO; unsigned IOCTL_DIOCRFORMAT = DIOCRFORMAT; unsigned IOCTL_DIOCWFORMAT = DIOCWFORMAT; unsigned IOCTL_DIOCSSTEP = DIOCSSTEP; unsigned IOCTL_DIOCSRETRIES = DIOCSRETRIES; unsigned IOCTL_DIOCKLABEL = DIOCKLABEL; unsigned IOCTL_DIOCWLABEL = DIOCWLABEL; unsigned IOCTL_DIOCSBAD = DIOCSBAD; unsigned IOCTL_DIOCEJECT = DIOCEJECT; unsigned IOCTL_ODIOCEJECT = ODIOCEJECT; unsigned IOCTL_DIOCLOCK = DIOCLOCK; unsigned IOCTL_DIOCGDEFLABEL = DIOCGDEFLABEL; unsigned IOCTL_DIOCCLRLABEL = DIOCCLRLABEL; unsigned IOCTL_DIOCGCACHE = DIOCGCACHE; unsigned IOCTL_DIOCSCACHE = DIOCSCACHE; unsigned IOCTL_DIOCCACHESYNC = DIOCCACHESYNC; unsigned IOCTL_DIOCBSLIST = DIOCBSLIST; unsigned IOCTL_DIOCBSFLUSH = DIOCBSFLUSH; unsigned IOCTL_DIOCAWEDGE = DIOCAWEDGE; unsigned IOCTL_DIOCGWEDGEINFO = DIOCGWEDGEINFO; unsigned IOCTL_DIOCDWEDGE = DIOCDWEDGE; unsigned IOCTL_DIOCLWEDGES = DIOCLWEDGES; unsigned IOCTL_DIOCGSTRATEGY = DIOCGSTRATEGY; unsigned IOCTL_DIOCSSTRATEGY = DIOCSSTRATEGY; unsigned IOCTL_DIOCGDISKINFO = DIOCGDISKINFO; unsigned IOCTL_DIOCTUR = DIOCTUR; unsigned IOCTL_DIOCMWEDGES = DIOCMWEDGES; unsigned IOCTL_DIOCGSECTORSIZE = DIOCGSECTORSIZE; unsigned IOCTL_DIOCGMEDIASIZE = DIOCGMEDIASIZE; +unsigned IOCTL_DIOCRMWEDGES = DIOCRMWEDGES; unsigned IOCTL_DRVDETACHDEV = DRVDETACHDEV; unsigned IOCTL_DRVRESCANBUS = DRVRESCANBUS; unsigned IOCTL_DRVCTLCOMMAND = DRVCTLCOMMAND; unsigned IOCTL_DRVRESUMEDEV = DRVRESUMEDEV; unsigned IOCTL_DRVLISTDEV = DRVLISTDEV; unsigned IOCTL_DRVGETEVENT = DRVGETEVENT; unsigned IOCTL_DRVSUSPENDDEV = DRVSUSPENDDEV; unsigned IOCTL_DVD_READ_STRUCT = DVD_READ_STRUCT; unsigned IOCTL_DVD_WRITE_STRUCT = DVD_WRITE_STRUCT; unsigned IOCTL_DVD_AUTH = DVD_AUTH; unsigned IOCTL_ENVSYS_GETDICTIONARY = ENVSYS_GETDICTIONARY; unsigned IOCTL_ENVSYS_SETDICTIONARY = ENVSYS_SETDICTIONARY; unsigned IOCTL_ENVSYS_REMOVEPROPS = ENVSYS_REMOVEPROPS; unsigned IOCTL_ENVSYS_GTREDATA = ENVSYS_GTREDATA; unsigned IOCTL_ENVSYS_GTREINFO = ENVSYS_GTREINFO; unsigned IOCTL_KFILTER_BYFILTER = KFILTER_BYFILTER; unsigned IOCTL_KFILTER_BYNAME = KFILTER_BYNAME; unsigned IOCTL_FDIOCGETOPTS = FDIOCGETOPTS; unsigned IOCTL_FDIOCSETOPTS = FDIOCSETOPTS; unsigned IOCTL_FDIOCSETFORMAT = FDIOCSETFORMAT; unsigned IOCTL_FDIOCGETFORMAT = FDIOCGETFORMAT; unsigned IOCTL_FDIOCFORMAT_TRACK = FDIOCFORMAT_TRACK; unsigned IOCTL_FIOCLEX = FIOCLEX; unsigned IOCTL_FIONCLEX = FIONCLEX; unsigned IOCTL_FIOSEEKDATA = FIOSEEKDATA; unsigned IOCTL_FIOSEEKHOLE = FIOSEEKHOLE; unsigned IOCTL_FIONREAD = FIONREAD; unsigned IOCTL_FIONBIO = FIONBIO; unsigned IOCTL_FIOASYNC = FIOASYNC; unsigned IOCTL_FIOSETOWN = FIOSETOWN; unsigned IOCTL_FIOGETOWN = FIOGETOWN; unsigned IOCTL_OFIOGETBMAP = OFIOGETBMAP; unsigned IOCTL_FIOGETBMAP = FIOGETBMAP; unsigned IOCTL_FIONWRITE = FIONWRITE; unsigned IOCTL_FIONSPACE = FIONSPACE; unsigned IOCTL_GPIOINFO = GPIOINFO; unsigned IOCTL_GPIOSET = GPIOSET; unsigned IOCTL_GPIOUNSET = GPIOUNSET; unsigned IOCTL_GPIOREAD = GPIOREAD; unsigned IOCTL_GPIOWRITE = GPIOWRITE; unsigned IOCTL_GPIOTOGGLE = GPIOTOGGLE; unsigned IOCTL_GPIOATTACH = GPIOATTACH; unsigned IOCTL_PTIOCNETBSD = PTIOCNETBSD; unsigned IOCTL_PTIOCSUNOS = PTIOCSUNOS; unsigned IOCTL_PTIOCLINUX = PTIOCLINUX; unsigned IOCTL_PTIOCFREEBSD = PTIOCFREEBSD; unsigned IOCTL_PTIOCULTRIX = PTIOCULTRIX; unsigned IOCTL_TIOCHPCL = TIOCHPCL; unsigned IOCTL_TIOCGETP = TIOCGETP; unsigned IOCTL_TIOCSETP = TIOCSETP; unsigned IOCTL_TIOCSETN = TIOCSETN; unsigned IOCTL_TIOCSETC = TIOCSETC; unsigned IOCTL_TIOCGETC = TIOCGETC; unsigned IOCTL_TIOCLBIS = TIOCLBIS; unsigned IOCTL_TIOCLBIC = TIOCLBIC; unsigned IOCTL_TIOCLSET = TIOCLSET; unsigned IOCTL_TIOCLGET = TIOCLGET; unsigned IOCTL_TIOCSLTC = TIOCSLTC; unsigned IOCTL_TIOCGLTC = TIOCGLTC; unsigned IOCTL_OTIOCCONS = OTIOCCONS; unsigned IOCTL_JOY_SETTIMEOUT = JOY_SETTIMEOUT; unsigned IOCTL_JOY_GETTIMEOUT = JOY_GETTIMEOUT; unsigned IOCTL_JOY_SET_X_OFFSET = JOY_SET_X_OFFSET; unsigned IOCTL_JOY_SET_Y_OFFSET = JOY_SET_Y_OFFSET; unsigned IOCTL_JOY_GET_X_OFFSET = JOY_GET_X_OFFSET; unsigned IOCTL_JOY_GET_Y_OFFSET = JOY_GET_Y_OFFSET; unsigned IOCTL_OKIOCGSYMBOL = OKIOCGSYMBOL; unsigned IOCTL_OKIOCGVALUE = OKIOCGVALUE; unsigned IOCTL_KIOCGSIZE = KIOCGSIZE; unsigned IOCTL_KIOCGVALUE = KIOCGVALUE; unsigned IOCTL_KIOCGSYMBOL = KIOCGSYMBOL; unsigned IOCTL_LUAINFO = LUAINFO; unsigned IOCTL_LUACREATE = LUACREATE; unsigned IOCTL_LUADESTROY = LUADESTROY; unsigned IOCTL_LUAREQUIRE = LUAREQUIRE; unsigned IOCTL_LUALOAD = LUALOAD; unsigned IOCTL_MIDI_PRETIME = MIDI_PRETIME; unsigned IOCTL_MIDI_MPUMODE = MIDI_MPUMODE; unsigned IOCTL_MIDI_MPUCMD = MIDI_MPUCMD; unsigned IOCTL_SEQUENCER_RESET = SEQUENCER_RESET; unsigned IOCTL_SEQUENCER_SYNC = SEQUENCER_SYNC; unsigned IOCTL_SEQUENCER_INFO = SEQUENCER_INFO; unsigned IOCTL_SEQUENCER_CTRLRATE = SEQUENCER_CTRLRATE; unsigned IOCTL_SEQUENCER_GETOUTCOUNT = SEQUENCER_GETOUTCOUNT; unsigned IOCTL_SEQUENCER_GETINCOUNT = SEQUENCER_GETINCOUNT; unsigned IOCTL_SEQUENCER_RESETSAMPLES = SEQUENCER_RESETSAMPLES; unsigned IOCTL_SEQUENCER_NRSYNTHS = SEQUENCER_NRSYNTHS; unsigned IOCTL_SEQUENCER_NRMIDIS = SEQUENCER_NRMIDIS; unsigned IOCTL_SEQUENCER_THRESHOLD = SEQUENCER_THRESHOLD; unsigned IOCTL_SEQUENCER_MEMAVL = SEQUENCER_MEMAVL; unsigned IOCTL_SEQUENCER_PANIC = SEQUENCER_PANIC; unsigned IOCTL_SEQUENCER_OUTOFBAND = SEQUENCER_OUTOFBAND; unsigned IOCTL_SEQUENCER_GETTIME = SEQUENCER_GETTIME; unsigned IOCTL_SEQUENCER_TMR_TIMEBASE = SEQUENCER_TMR_TIMEBASE; unsigned IOCTL_SEQUENCER_TMR_START = SEQUENCER_TMR_START; unsigned IOCTL_SEQUENCER_TMR_STOP = SEQUENCER_TMR_STOP; unsigned IOCTL_SEQUENCER_TMR_CONTINUE = SEQUENCER_TMR_CONTINUE; unsigned IOCTL_SEQUENCER_TMR_TEMPO = SEQUENCER_TMR_TEMPO; unsigned IOCTL_SEQUENCER_TMR_SOURCE = SEQUENCER_TMR_SOURCE; unsigned IOCTL_SEQUENCER_TMR_METRONOME = SEQUENCER_TMR_METRONOME; unsigned IOCTL_SEQUENCER_TMR_SELECT = SEQUENCER_TMR_SELECT; unsigned IOCTL_MTIOCTOP = MTIOCTOP; unsigned IOCTL_MTIOCGET = MTIOCGET; unsigned IOCTL_MTIOCIEOT = MTIOCIEOT; unsigned IOCTL_MTIOCEEOT = MTIOCEEOT; unsigned IOCTL_MTIOCRDSPOS = MTIOCRDSPOS; unsigned IOCTL_MTIOCRDHPOS = MTIOCRDHPOS; unsigned IOCTL_MTIOCSLOCATE = MTIOCSLOCATE; unsigned IOCTL_MTIOCHLOCATE = MTIOCHLOCATE; unsigned IOCTL_POWER_EVENT_RECVDICT = POWER_EVENT_RECVDICT; unsigned IOCTL_POWER_IOC_GET_TYPE = POWER_IOC_GET_TYPE; unsigned IOCTL_RIOCGINFO = RIOCGINFO; unsigned IOCTL_RIOCSINFO = RIOCSINFO; unsigned IOCTL_RIOCSSRCH = RIOCSSRCH; unsigned IOCTL_RNDGETENTCNT = RNDGETENTCNT; unsigned IOCTL_RNDGETSRCNUM = RNDGETSRCNUM; unsigned IOCTL_RNDGETSRCNAME = RNDGETSRCNAME; unsigned IOCTL_RNDCTL = RNDCTL; unsigned IOCTL_RNDADDDATA = RNDADDDATA; unsigned IOCTL_RNDGETPOOLSTAT = RNDGETPOOLSTAT; unsigned IOCTL_RNDGETESTNUM = RNDGETESTNUM; unsigned IOCTL_RNDGETESTNAME = RNDGETESTNAME; unsigned IOCTL_SCIOCGET = SCIOCGET; unsigned IOCTL_SCIOCSET = SCIOCSET; unsigned IOCTL_SCIOCRESTART = SCIOCRESTART; unsigned IOCTL_SCIOC_USE_ADF = SCIOC_USE_ADF; unsigned IOCTL_SCIOCCOMMAND = SCIOCCOMMAND; unsigned IOCTL_SCIOCDEBUG = SCIOCDEBUG; unsigned IOCTL_SCIOCIDENTIFY = SCIOCIDENTIFY; unsigned IOCTL_OSCIOCIDENTIFY = OSCIOCIDENTIFY; unsigned IOCTL_SCIOCDECONFIG = SCIOCDECONFIG; unsigned IOCTL_SCIOCRECONFIG = SCIOCRECONFIG; unsigned IOCTL_SCIOCRESET = SCIOCRESET; unsigned IOCTL_SCBUSIOSCAN = SCBUSIOSCAN; unsigned IOCTL_SCBUSIORESET = SCBUSIORESET; unsigned IOCTL_SCBUSIODETACH = SCBUSIODETACH; unsigned IOCTL_SCBUSACCEL = SCBUSACCEL; unsigned IOCTL_SCBUSIOLLSCAN = SCBUSIOLLSCAN; unsigned IOCTL_SIOCSHIWAT = SIOCSHIWAT; unsigned IOCTL_SIOCGHIWAT = SIOCGHIWAT; unsigned IOCTL_SIOCSLOWAT = SIOCSLOWAT; unsigned IOCTL_SIOCGLOWAT = SIOCGLOWAT; unsigned IOCTL_SIOCATMARK = SIOCATMARK; unsigned IOCTL_SIOCSPGRP = SIOCSPGRP; unsigned IOCTL_SIOCGPGRP = SIOCGPGRP; unsigned IOCTL_SIOCPEELOFF = SIOCPEELOFF; unsigned IOCTL_SIOCADDRT = SIOCADDRT; unsigned IOCTL_SIOCDELRT = SIOCDELRT; unsigned IOCTL_SIOCSIFADDR = SIOCSIFADDR; unsigned IOCTL_SIOCGIFADDR = SIOCGIFADDR; unsigned IOCTL_SIOCSIFDSTADDR = SIOCSIFDSTADDR; unsigned IOCTL_SIOCGIFDSTADDR = SIOCGIFDSTADDR; unsigned IOCTL_SIOCSIFFLAGS = SIOCSIFFLAGS; unsigned IOCTL_SIOCGIFFLAGS = SIOCGIFFLAGS; unsigned IOCTL_SIOCGIFBRDADDR = SIOCGIFBRDADDR; unsigned IOCTL_SIOCSIFBRDADDR = SIOCSIFBRDADDR; unsigned IOCTL_SIOCGIFCONF = SIOCGIFCONF; unsigned IOCTL_SIOCGIFNETMASK = SIOCGIFNETMASK; unsigned IOCTL_SIOCSIFNETMASK = SIOCSIFNETMASK; unsigned IOCTL_SIOCGIFMETRIC = SIOCGIFMETRIC; unsigned IOCTL_SIOCSIFMETRIC = SIOCSIFMETRIC; unsigned IOCTL_SIOCDIFADDR = SIOCDIFADDR; unsigned IOCTL_SIOCAIFADDR = SIOCAIFADDR; unsigned IOCTL_SIOCGIFALIAS = SIOCGIFALIAS; unsigned IOCTL_SIOCGIFAFLAG_IN = SIOCGIFAFLAG_IN; unsigned IOCTL_SIOCALIFADDR = SIOCALIFADDR; unsigned IOCTL_SIOCGLIFADDR = SIOCGLIFADDR; unsigned IOCTL_SIOCDLIFADDR = SIOCDLIFADDR; unsigned IOCTL_SIOCSIFADDRPREF = SIOCSIFADDRPREF; unsigned IOCTL_SIOCGIFADDRPREF = SIOCGIFADDRPREF; unsigned IOCTL_SIOCADDMULTI = SIOCADDMULTI; unsigned IOCTL_SIOCDELMULTI = SIOCDELMULTI; unsigned IOCTL_SIOCGETVIFCNT = SIOCGETVIFCNT; unsigned IOCTL_SIOCGETSGCNT = SIOCGETSGCNT; unsigned IOCTL_SIOCSIFMEDIA = SIOCSIFMEDIA; unsigned IOCTL_SIOCGIFMEDIA = SIOCGIFMEDIA; unsigned IOCTL_SIOCSIFGENERIC = SIOCSIFGENERIC; unsigned IOCTL_SIOCGIFGENERIC = SIOCGIFGENERIC; unsigned IOCTL_SIOCSIFPHYADDR = SIOCSIFPHYADDR; unsigned IOCTL_SIOCGIFPSRCADDR = SIOCGIFPSRCADDR; unsigned IOCTL_SIOCGIFPDSTADDR = SIOCGIFPDSTADDR; unsigned IOCTL_SIOCDIFPHYADDR = SIOCDIFPHYADDR; unsigned IOCTL_SIOCSLIFPHYADDR = SIOCSLIFPHYADDR; unsigned IOCTL_SIOCGLIFPHYADDR = SIOCGLIFPHYADDR; unsigned IOCTL_SIOCSIFMTU = SIOCSIFMTU; unsigned IOCTL_SIOCGIFMTU = SIOCGIFMTU; unsigned IOCTL_SIOCSDRVSPEC = SIOCSDRVSPEC; unsigned IOCTL_SIOCGDRVSPEC = SIOCGDRVSPEC; unsigned IOCTL_SIOCIFCREATE = SIOCIFCREATE; unsigned IOCTL_SIOCIFDESTROY = SIOCIFDESTROY; unsigned IOCTL_SIOCIFGCLONERS = SIOCIFGCLONERS; unsigned IOCTL_SIOCGIFDLT = SIOCGIFDLT; unsigned IOCTL_SIOCGIFCAP = SIOCGIFCAP; unsigned IOCTL_SIOCSIFCAP = SIOCSIFCAP; unsigned IOCTL_SIOCSVH = SIOCSVH; unsigned IOCTL_SIOCGVH = SIOCGVH; unsigned IOCTL_SIOCINITIFADDR = SIOCINITIFADDR; unsigned IOCTL_SIOCGIFDATA = SIOCGIFDATA; unsigned IOCTL_SIOCZIFDATA = SIOCZIFDATA; unsigned IOCTL_SIOCGLINKSTR = SIOCGLINKSTR; unsigned IOCTL_SIOCSLINKSTR = SIOCSLINKSTR; unsigned IOCTL_SIOCGETHERCAP = SIOCGETHERCAP; unsigned IOCTL_SIOCGIFINDEX = SIOCGIFINDEX; unsigned IOCTL_SIOCSETHERCAP = SIOCSETHERCAP; +unsigned IOCTL_SIOCSIFDESCR = SIOCSIFDESCR; +unsigned IOCTL_SIOCGIFDESCR = SIOCGIFDESCR; unsigned IOCTL_SIOCGUMBINFO = SIOCGUMBINFO; unsigned IOCTL_SIOCSUMBPARAM = SIOCSUMBPARAM; unsigned IOCTL_SIOCGUMBPARAM = SIOCGUMBPARAM; unsigned IOCTL_SIOCSETPFSYNC = SIOCSETPFSYNC; unsigned IOCTL_SIOCGETPFSYNC = SIOCGETPFSYNC; unsigned IOCTL_PPS_IOC_CREATE = PPS_IOC_CREATE; unsigned IOCTL_PPS_IOC_DESTROY = PPS_IOC_DESTROY; unsigned IOCTL_PPS_IOC_SETPARAMS = PPS_IOC_SETPARAMS; unsigned IOCTL_PPS_IOC_GETPARAMS = PPS_IOC_GETPARAMS; unsigned IOCTL_PPS_IOC_GETCAP = PPS_IOC_GETCAP; unsigned IOCTL_PPS_IOC_FETCH = PPS_IOC_FETCH; unsigned IOCTL_PPS_IOC_KCBIND = PPS_IOC_KCBIND; unsigned IOCTL_TIOCEXCL = TIOCEXCL; unsigned IOCTL_TIOCNXCL = TIOCNXCL; unsigned IOCTL_TIOCFLUSH = TIOCFLUSH; unsigned IOCTL_TIOCGETA = TIOCGETA; unsigned IOCTL_TIOCSETA = TIOCSETA; unsigned IOCTL_TIOCSETAW = TIOCSETAW; unsigned IOCTL_TIOCSETAF = TIOCSETAF; unsigned IOCTL_TIOCGETD = TIOCGETD; unsigned IOCTL_TIOCSETD = TIOCSETD; unsigned IOCTL_TIOCGLINED = TIOCGLINED; unsigned IOCTL_TIOCSLINED = TIOCSLINED; unsigned IOCTL_TIOCSBRK = TIOCSBRK; unsigned IOCTL_TIOCCBRK = TIOCCBRK; unsigned IOCTL_TIOCSDTR = TIOCSDTR; unsigned IOCTL_TIOCCDTR = TIOCCDTR; unsigned IOCTL_TIOCGPGRP = TIOCGPGRP; unsigned IOCTL_TIOCSPGRP = TIOCSPGRP; unsigned IOCTL_TIOCOUTQ = TIOCOUTQ; unsigned IOCTL_TIOCSTI = TIOCSTI; unsigned IOCTL_TIOCNOTTY = TIOCNOTTY; unsigned IOCTL_TIOCPKT = TIOCPKT; unsigned IOCTL_TIOCSTOP = TIOCSTOP; unsigned IOCTL_TIOCSTART = TIOCSTART; unsigned IOCTL_TIOCMSET = TIOCMSET; unsigned IOCTL_TIOCMBIS = TIOCMBIS; unsigned IOCTL_TIOCMBIC = TIOCMBIC; unsigned IOCTL_TIOCMGET = TIOCMGET; unsigned IOCTL_TIOCREMOTE = TIOCREMOTE; unsigned IOCTL_TIOCGWINSZ = TIOCGWINSZ; unsigned IOCTL_TIOCSWINSZ = TIOCSWINSZ; unsigned IOCTL_TIOCUCNTL = TIOCUCNTL; unsigned IOCTL_TIOCSTAT = TIOCSTAT; unsigned IOCTL_TIOCGSID = TIOCGSID; unsigned IOCTL_TIOCCONS = TIOCCONS; unsigned IOCTL_TIOCSCTTY = TIOCSCTTY; unsigned IOCTL_TIOCEXT = TIOCEXT; unsigned IOCTL_TIOCSIG = TIOCSIG; unsigned IOCTL_TIOCDRAIN = TIOCDRAIN; unsigned IOCTL_TIOCGFLAGS = TIOCGFLAGS; unsigned IOCTL_TIOCSFLAGS = TIOCSFLAGS; unsigned IOCTL_TIOCDCDTIMESTAMP = TIOCDCDTIMESTAMP; unsigned IOCTL_TIOCRCVFRAME = TIOCRCVFRAME; unsigned IOCTL_TIOCXMTFRAME = TIOCXMTFRAME; unsigned IOCTL_TIOCPTMGET = TIOCPTMGET; unsigned IOCTL_TIOCGRANTPT = TIOCGRANTPT; unsigned IOCTL_TIOCPTSNAME = TIOCPTSNAME; unsigned IOCTL_TIOCSQSIZE = TIOCSQSIZE; unsigned IOCTL_TIOCGQSIZE = TIOCGQSIZE; unsigned IOCTL_VERIEXEC_LOAD = VERIEXEC_LOAD; unsigned IOCTL_VERIEXEC_TABLESIZE = VERIEXEC_TABLESIZE; unsigned IOCTL_VERIEXEC_DELETE = VERIEXEC_DELETE; unsigned IOCTL_VERIEXEC_QUERY = VERIEXEC_QUERY; unsigned IOCTL_VERIEXEC_DUMP = VERIEXEC_DUMP; unsigned IOCTL_VERIEXEC_FLUSH = VERIEXEC_FLUSH; unsigned IOCTL_VIDIOC_QUERYCAP = VIDIOC_QUERYCAP; unsigned IOCTL_VIDIOC_RESERVED = VIDIOC_RESERVED; unsigned IOCTL_VIDIOC_ENUM_FMT = VIDIOC_ENUM_FMT; unsigned IOCTL_VIDIOC_G_FMT = VIDIOC_G_FMT; unsigned IOCTL_VIDIOC_S_FMT = VIDIOC_S_FMT; unsigned IOCTL_VIDIOC_REQBUFS = VIDIOC_REQBUFS; unsigned IOCTL_VIDIOC_QUERYBUF = VIDIOC_QUERYBUF; unsigned IOCTL_VIDIOC_G_FBUF = VIDIOC_G_FBUF; unsigned IOCTL_VIDIOC_S_FBUF = VIDIOC_S_FBUF; unsigned IOCTL_VIDIOC_OVERLAY = VIDIOC_OVERLAY; unsigned IOCTL_VIDIOC_QBUF = VIDIOC_QBUF; unsigned IOCTL_VIDIOC_DQBUF = VIDIOC_DQBUF; unsigned IOCTL_VIDIOC_STREAMON = VIDIOC_STREAMON; unsigned IOCTL_VIDIOC_STREAMOFF = VIDIOC_STREAMOFF; unsigned IOCTL_VIDIOC_G_PARM = VIDIOC_G_PARM; unsigned IOCTL_VIDIOC_S_PARM = VIDIOC_S_PARM; unsigned IOCTL_VIDIOC_G_STD = VIDIOC_G_STD; unsigned IOCTL_VIDIOC_S_STD = VIDIOC_S_STD; unsigned IOCTL_VIDIOC_ENUMSTD = VIDIOC_ENUMSTD; unsigned IOCTL_VIDIOC_ENUMINPUT = VIDIOC_ENUMINPUT; unsigned IOCTL_VIDIOC_G_CTRL = VIDIOC_G_CTRL; unsigned IOCTL_VIDIOC_S_CTRL = VIDIOC_S_CTRL; unsigned IOCTL_VIDIOC_G_TUNER = VIDIOC_G_TUNER; unsigned IOCTL_VIDIOC_S_TUNER = VIDIOC_S_TUNER; unsigned IOCTL_VIDIOC_G_AUDIO = VIDIOC_G_AUDIO; unsigned IOCTL_VIDIOC_S_AUDIO = VIDIOC_S_AUDIO; unsigned IOCTL_VIDIOC_QUERYCTRL = VIDIOC_QUERYCTRL; unsigned IOCTL_VIDIOC_QUERYMENU = VIDIOC_QUERYMENU; unsigned IOCTL_VIDIOC_G_INPUT = VIDIOC_G_INPUT; unsigned IOCTL_VIDIOC_S_INPUT = VIDIOC_S_INPUT; unsigned IOCTL_VIDIOC_G_OUTPUT = VIDIOC_G_OUTPUT; unsigned IOCTL_VIDIOC_S_OUTPUT = VIDIOC_S_OUTPUT; unsigned IOCTL_VIDIOC_ENUMOUTPUT = VIDIOC_ENUMOUTPUT; unsigned IOCTL_VIDIOC_G_AUDOUT = VIDIOC_G_AUDOUT; unsigned IOCTL_VIDIOC_S_AUDOUT = VIDIOC_S_AUDOUT; unsigned IOCTL_VIDIOC_G_MODULATOR = VIDIOC_G_MODULATOR; unsigned IOCTL_VIDIOC_S_MODULATOR = VIDIOC_S_MODULATOR; unsigned IOCTL_VIDIOC_G_FREQUENCY = VIDIOC_G_FREQUENCY; unsigned IOCTL_VIDIOC_S_FREQUENCY = VIDIOC_S_FREQUENCY; unsigned IOCTL_VIDIOC_CROPCAP = VIDIOC_CROPCAP; unsigned IOCTL_VIDIOC_G_CROP = VIDIOC_G_CROP; unsigned IOCTL_VIDIOC_S_CROP = VIDIOC_S_CROP; unsigned IOCTL_VIDIOC_G_JPEGCOMP = VIDIOC_G_JPEGCOMP; unsigned IOCTL_VIDIOC_S_JPEGCOMP = VIDIOC_S_JPEGCOMP; unsigned IOCTL_VIDIOC_QUERYSTD = VIDIOC_QUERYSTD; unsigned IOCTL_VIDIOC_TRY_FMT = VIDIOC_TRY_FMT; unsigned IOCTL_VIDIOC_ENUMAUDIO = VIDIOC_ENUMAUDIO; unsigned IOCTL_VIDIOC_ENUMAUDOUT = VIDIOC_ENUMAUDOUT; unsigned IOCTL_VIDIOC_G_PRIORITY = VIDIOC_G_PRIORITY; unsigned IOCTL_VIDIOC_S_PRIORITY = VIDIOC_S_PRIORITY; unsigned IOCTL_VIDIOC_ENUM_FRAMESIZES = VIDIOC_ENUM_FRAMESIZES; unsigned IOCTL_VIDIOC_ENUM_FRAMEINTERVALS = VIDIOC_ENUM_FRAMEINTERVALS; unsigned IOCTL_WDOGIOC_GMODE = WDOGIOC_GMODE; unsigned IOCTL_WDOGIOC_SMODE = WDOGIOC_SMODE; unsigned IOCTL_WDOGIOC_WHICH = WDOGIOC_WHICH; unsigned IOCTL_WDOGIOC_TICKLE = WDOGIOC_TICKLE; unsigned IOCTL_WDOGIOC_GTICKLER = WDOGIOC_GTICKLER; unsigned IOCTL_WDOGIOC_GWDOGS = WDOGIOC_GWDOGS; +unsigned IOCTL_KCOV_IOC_SETBUFSIZE = KCOV_IOC_SETBUFSIZE; +unsigned IOCTL_KCOV_IOC_ENABLE = KCOV_IOC_ENABLE; +unsigned IOCTL_KCOV_IOC_DISABLE = KCOV_IOC_DISABLE; +unsigned IOCTL_IPMICTL_RECEIVE_MSG_TRUNC = IPMICTL_RECEIVE_MSG_TRUNC; +unsigned IOCTL_IPMICTL_RECEIVE_MSG = IPMICTL_RECEIVE_MSG; +unsigned IOCTL_IPMICTL_SEND_COMMAND = IPMICTL_SEND_COMMAND; +unsigned IOCTL_IPMICTL_REGISTER_FOR_CMD = IPMICTL_REGISTER_FOR_CMD; +unsigned IOCTL_IPMICTL_UNREGISTER_FOR_CMD = IPMICTL_UNREGISTER_FOR_CMD; +unsigned IOCTL_IPMICTL_SET_GETS_EVENTS_CMD = IPMICTL_SET_GETS_EVENTS_CMD; +unsigned IOCTL_IPMICTL_SET_MY_ADDRESS_CMD = IPMICTL_SET_MY_ADDRESS_CMD; +unsigned IOCTL_IPMICTL_GET_MY_ADDRESS_CMD = IPMICTL_GET_MY_ADDRESS_CMD; +unsigned IOCTL_IPMICTL_SET_MY_LUN_CMD = IPMICTL_SET_MY_LUN_CMD; +unsigned IOCTL_IPMICTL_GET_MY_LUN_CMD = IPMICTL_GET_MY_LUN_CMD; unsigned IOCTL_SNDCTL_DSP_RESET = SNDCTL_DSP_RESET; unsigned IOCTL_SNDCTL_DSP_SYNC = SNDCTL_DSP_SYNC; unsigned IOCTL_SNDCTL_DSP_SPEED = SNDCTL_DSP_SPEED; unsigned IOCTL_SOUND_PCM_READ_RATE = SOUND_PCM_READ_RATE; unsigned IOCTL_SNDCTL_DSP_STEREO = SNDCTL_DSP_STEREO; unsigned IOCTL_SNDCTL_DSP_GETBLKSIZE = SNDCTL_DSP_GETBLKSIZE; unsigned IOCTL_SNDCTL_DSP_SETFMT = SNDCTL_DSP_SETFMT; unsigned IOCTL_SOUND_PCM_READ_BITS = SOUND_PCM_READ_BITS; unsigned IOCTL_SNDCTL_DSP_CHANNELS = SNDCTL_DSP_CHANNELS; unsigned IOCTL_SOUND_PCM_READ_CHANNELS = SOUND_PCM_READ_CHANNELS; unsigned IOCTL_SOUND_PCM_WRITE_FILTER = SOUND_PCM_WRITE_FILTER; unsigned IOCTL_SOUND_PCM_READ_FILTER = SOUND_PCM_READ_FILTER; unsigned IOCTL_SNDCTL_DSP_POST = SNDCTL_DSP_POST; unsigned IOCTL_SNDCTL_DSP_SUBDIVIDE = SNDCTL_DSP_SUBDIVIDE; unsigned IOCTL_SNDCTL_DSP_SETFRAGMENT = SNDCTL_DSP_SETFRAGMENT; unsigned IOCTL_SNDCTL_DSP_GETFMTS = SNDCTL_DSP_GETFMTS; unsigned IOCTL_SNDCTL_DSP_GETOSPACE = SNDCTL_DSP_GETOSPACE; unsigned IOCTL_SNDCTL_DSP_GETISPACE = SNDCTL_DSP_GETISPACE; unsigned IOCTL_SNDCTL_DSP_NONBLOCK = SNDCTL_DSP_NONBLOCK; unsigned IOCTL_SNDCTL_DSP_GETCAPS = SNDCTL_DSP_GETCAPS; unsigned IOCTL_SNDCTL_DSP_GETTRIGGER = SNDCTL_DSP_GETTRIGGER; unsigned IOCTL_SNDCTL_DSP_SETTRIGGER = SNDCTL_DSP_SETTRIGGER; unsigned IOCTL_SNDCTL_DSP_GETIPTR = SNDCTL_DSP_GETIPTR; unsigned IOCTL_SNDCTL_DSP_GETOPTR = SNDCTL_DSP_GETOPTR; unsigned IOCTL_SNDCTL_DSP_MAPINBUF = SNDCTL_DSP_MAPINBUF; unsigned IOCTL_SNDCTL_DSP_MAPOUTBUF = SNDCTL_DSP_MAPOUTBUF; unsigned IOCTL_SNDCTL_DSP_SETSYNCRO = SNDCTL_DSP_SETSYNCRO; unsigned IOCTL_SNDCTL_DSP_SETDUPLEX = SNDCTL_DSP_SETDUPLEX; unsigned IOCTL_SNDCTL_DSP_PROFILE = SNDCTL_DSP_PROFILE; unsigned IOCTL_SNDCTL_DSP_GETODELAY = SNDCTL_DSP_GETODELAY; unsigned IOCTL_SOUND_MIXER_INFO = SOUND_MIXER_INFO; unsigned IOCTL_SOUND_OLD_MIXER_INFO = SOUND_OLD_MIXER_INFO; unsigned IOCTL_OSS_GETVERSION = OSS_GETVERSION; unsigned IOCTL_SNDCTL_SYSINFO = SNDCTL_SYSINFO; unsigned IOCTL_SNDCTL_AUDIOINFO = SNDCTL_AUDIOINFO; unsigned IOCTL_SNDCTL_ENGINEINFO = SNDCTL_ENGINEINFO; unsigned IOCTL_SNDCTL_DSP_GETPLAYVOL = SNDCTL_DSP_GETPLAYVOL; unsigned IOCTL_SNDCTL_DSP_SETPLAYVOL = SNDCTL_DSP_SETPLAYVOL; unsigned IOCTL_SNDCTL_DSP_GETRECVOL = SNDCTL_DSP_GETRECVOL; unsigned IOCTL_SNDCTL_DSP_SETRECVOL = SNDCTL_DSP_SETRECVOL; unsigned IOCTL_SNDCTL_DSP_SKIP = SNDCTL_DSP_SKIP; unsigned IOCTL_SNDCTL_DSP_SILENCE = SNDCTL_DSP_SILENCE; const int si_SEGV_MAPERR = SEGV_MAPERR; const int si_SEGV_ACCERR = SEGV_ACCERR; const int modctl_load = MODCTL_LOAD; const int modctl_unload = MODCTL_UNLOAD; const int modctl_stat = MODCTL_STAT; const int modctl_exists = MODCTL_EXISTS; const unsigned SHA1_CTX_sz = sizeof(SHA1_CTX); const unsigned SHA1_return_length = SHA1_DIGEST_STRING_LENGTH; const unsigned MD4_CTX_sz = sizeof(MD4_CTX); const unsigned MD4_return_length = MD4_DIGEST_STRING_LENGTH; const unsigned RMD160_CTX_sz = sizeof(RMD160_CTX); const unsigned RMD160_return_length = RMD160_DIGEST_STRING_LENGTH; const unsigned MD5_CTX_sz = sizeof(MD5_CTX); const unsigned MD5_return_length = MD5_DIGEST_STRING_LENGTH; const unsigned fpos_t_sz = sizeof(fpos_t); const unsigned MD2_CTX_sz = sizeof(MD2_CTX); const unsigned MD2_return_length = MD2_DIGEST_STRING_LENGTH; #define SHA2_CONST(LEN) \ const unsigned SHA##LEN##_CTX_sz = sizeof(SHA##LEN##_CTX); \ const unsigned SHA##LEN##_return_length = SHA##LEN##_DIGEST_STRING_LENGTH; \ const unsigned SHA##LEN##_block_length = SHA##LEN##_BLOCK_LENGTH; \ const unsigned SHA##LEN##_digest_length = SHA##LEN##_DIGEST_LENGTH SHA2_CONST(224); SHA2_CONST(256); SHA2_CONST(384); SHA2_CONST(512); #undef SHA2_CONST const int unvis_valid = UNVIS_VALID; const int unvis_validpush = UNVIS_VALIDPUSH; } // namespace __sanitizer using namespace __sanitizer; COMPILER_CHECK(sizeof(__sanitizer_pthread_attr_t) >= sizeof(pthread_attr_t)); COMPILER_CHECK(sizeof(socklen_t) == sizeof(unsigned)); CHECK_TYPE_SIZE(pthread_key_t); // There are more undocumented fields in dl_phdr_info that we are not interested // in. COMPILER_CHECK(sizeof(__sanitizer_dl_phdr_info) <= sizeof(dl_phdr_info)); CHECK_SIZE_AND_OFFSET(dl_phdr_info, dlpi_addr); CHECK_SIZE_AND_OFFSET(dl_phdr_info, dlpi_name); CHECK_SIZE_AND_OFFSET(dl_phdr_info, dlpi_phdr); CHECK_SIZE_AND_OFFSET(dl_phdr_info, dlpi_phnum); CHECK_TYPE_SIZE(glob_t); CHECK_SIZE_AND_OFFSET(glob_t, gl_pathc); CHECK_SIZE_AND_OFFSET(glob_t, gl_pathv); CHECK_SIZE_AND_OFFSET(glob_t, gl_offs); CHECK_SIZE_AND_OFFSET(glob_t, gl_flags); CHECK_SIZE_AND_OFFSET(glob_t, gl_closedir); CHECK_SIZE_AND_OFFSET(glob_t, gl_readdir); CHECK_SIZE_AND_OFFSET(glob_t, gl_opendir); CHECK_SIZE_AND_OFFSET(glob_t, gl_lstat); CHECK_SIZE_AND_OFFSET(glob_t, gl_stat); CHECK_TYPE_SIZE(addrinfo); CHECK_SIZE_AND_OFFSET(addrinfo, ai_flags); CHECK_SIZE_AND_OFFSET(addrinfo, ai_family); CHECK_SIZE_AND_OFFSET(addrinfo, ai_socktype); CHECK_SIZE_AND_OFFSET(addrinfo, ai_protocol); CHECK_SIZE_AND_OFFSET(addrinfo, ai_protocol); CHECK_SIZE_AND_OFFSET(addrinfo, ai_addrlen); CHECK_SIZE_AND_OFFSET(addrinfo, ai_canonname); CHECK_SIZE_AND_OFFSET(addrinfo, ai_addr); CHECK_TYPE_SIZE(hostent); CHECK_SIZE_AND_OFFSET(hostent, h_name); CHECK_SIZE_AND_OFFSET(hostent, h_aliases); CHECK_SIZE_AND_OFFSET(hostent, h_addrtype); CHECK_SIZE_AND_OFFSET(hostent, h_length); CHECK_SIZE_AND_OFFSET(hostent, h_addr_list); CHECK_TYPE_SIZE(iovec); CHECK_SIZE_AND_OFFSET(iovec, iov_base); CHECK_SIZE_AND_OFFSET(iovec, iov_len); CHECK_TYPE_SIZE(msghdr); CHECK_SIZE_AND_OFFSET(msghdr, msg_name); CHECK_SIZE_AND_OFFSET(msghdr, msg_namelen); CHECK_SIZE_AND_OFFSET(msghdr, msg_iov); CHECK_SIZE_AND_OFFSET(msghdr, msg_iovlen); CHECK_SIZE_AND_OFFSET(msghdr, msg_control); CHECK_SIZE_AND_OFFSET(msghdr, msg_controllen); CHECK_SIZE_AND_OFFSET(msghdr, msg_flags); CHECK_TYPE_SIZE(cmsghdr); CHECK_SIZE_AND_OFFSET(cmsghdr, cmsg_len); CHECK_SIZE_AND_OFFSET(cmsghdr, cmsg_level); CHECK_SIZE_AND_OFFSET(cmsghdr, cmsg_type); COMPILER_CHECK(sizeof(__sanitizer_dirent) <= sizeof(dirent)); CHECK_SIZE_AND_OFFSET(dirent, d_fileno); CHECK_SIZE_AND_OFFSET(dirent, d_reclen); CHECK_TYPE_SIZE(ifconf); CHECK_SIZE_AND_OFFSET(ifconf, ifc_len); CHECK_SIZE_AND_OFFSET(ifconf, ifc_ifcu); CHECK_TYPE_SIZE(pollfd); CHECK_SIZE_AND_OFFSET(pollfd, fd); CHECK_SIZE_AND_OFFSET(pollfd, events); CHECK_SIZE_AND_OFFSET(pollfd, revents); CHECK_TYPE_SIZE(nfds_t); CHECK_TYPE_SIZE(sigset_t); COMPILER_CHECK(sizeof(__sanitizer_sigaction) == sizeof(struct sigaction)); // Can't write checks for sa_handler and sa_sigaction due to them being // preprocessor macros. CHECK_STRUCT_SIZE_AND_OFFSET(sigaction, sa_mask); CHECK_TYPE_SIZE(wordexp_t); CHECK_SIZE_AND_OFFSET(wordexp_t, we_wordc); CHECK_SIZE_AND_OFFSET(wordexp_t, we_wordv); CHECK_SIZE_AND_OFFSET(wordexp_t, we_offs); COMPILER_CHECK(sizeof(__sanitizer_FILE) <= sizeof(FILE)); CHECK_SIZE_AND_OFFSET(FILE, _p); CHECK_SIZE_AND_OFFSET(FILE, _r); CHECK_SIZE_AND_OFFSET(FILE, _w); CHECK_SIZE_AND_OFFSET(FILE, _flags); CHECK_SIZE_AND_OFFSET(FILE, _file); CHECK_SIZE_AND_OFFSET(FILE, _bf); CHECK_SIZE_AND_OFFSET(FILE, _lbfsize); CHECK_SIZE_AND_OFFSET(FILE, _cookie); CHECK_SIZE_AND_OFFSET(FILE, _close); CHECK_SIZE_AND_OFFSET(FILE, _read); CHECK_SIZE_AND_OFFSET(FILE, _seek); CHECK_SIZE_AND_OFFSET(FILE, _write); CHECK_SIZE_AND_OFFSET(FILE, _ext); CHECK_SIZE_AND_OFFSET(FILE, _up); CHECK_SIZE_AND_OFFSET(FILE, _ur); CHECK_SIZE_AND_OFFSET(FILE, _ubuf); CHECK_SIZE_AND_OFFSET(FILE, _nbuf); CHECK_SIZE_AND_OFFSET(FILE, _flush); CHECK_SIZE_AND_OFFSET(FILE, _lb_unused); CHECK_SIZE_AND_OFFSET(FILE, _blksize); CHECK_SIZE_AND_OFFSET(FILE, _offset); CHECK_TYPE_SIZE(tm); CHECK_SIZE_AND_OFFSET(tm, tm_sec); CHECK_SIZE_AND_OFFSET(tm, tm_min); CHECK_SIZE_AND_OFFSET(tm, tm_hour); CHECK_SIZE_AND_OFFSET(tm, tm_mday); CHECK_SIZE_AND_OFFSET(tm, tm_mon); CHECK_SIZE_AND_OFFSET(tm, tm_year); CHECK_SIZE_AND_OFFSET(tm, tm_wday); CHECK_SIZE_AND_OFFSET(tm, tm_yday); CHECK_SIZE_AND_OFFSET(tm, tm_isdst); CHECK_SIZE_AND_OFFSET(tm, tm_gmtoff); CHECK_SIZE_AND_OFFSET(tm, tm_zone); CHECK_TYPE_SIZE(ether_addr); CHECK_TYPE_SIZE(ipc_perm); CHECK_SIZE_AND_OFFSET(ipc_perm, _key); CHECK_SIZE_AND_OFFSET(ipc_perm, _seq); CHECK_SIZE_AND_OFFSET(ipc_perm, uid); CHECK_SIZE_AND_OFFSET(ipc_perm, gid); CHECK_SIZE_AND_OFFSET(ipc_perm, cuid); CHECK_SIZE_AND_OFFSET(ipc_perm, cgid); CHECK_SIZE_AND_OFFSET(ipc_perm, mode); CHECK_TYPE_SIZE(shmid_ds); CHECK_SIZE_AND_OFFSET(shmid_ds, shm_perm); CHECK_SIZE_AND_OFFSET(shmid_ds, shm_segsz); CHECK_SIZE_AND_OFFSET(shmid_ds, shm_atime); CHECK_SIZE_AND_OFFSET(shmid_ds, shm_dtime); CHECK_SIZE_AND_OFFSET(shmid_ds, shm_ctime); CHECK_SIZE_AND_OFFSET(shmid_ds, shm_cpid); CHECK_SIZE_AND_OFFSET(shmid_ds, shm_lpid); CHECK_SIZE_AND_OFFSET(shmid_ds, shm_nattch); CHECK_TYPE_SIZE(clock_t); CHECK_TYPE_SIZE(ifaddrs); CHECK_SIZE_AND_OFFSET(ifaddrs, ifa_next); CHECK_SIZE_AND_OFFSET(ifaddrs, ifa_name); CHECK_SIZE_AND_OFFSET(ifaddrs, ifa_addr); CHECK_SIZE_AND_OFFSET(ifaddrs, ifa_netmask); // Compare against the union, because we can't reach into the union in a // compliant way. #ifdef ifa_dstaddr #undef ifa_dstaddr #endif CHECK_SIZE_AND_OFFSET(ifaddrs, ifa_dstaddr); CHECK_SIZE_AND_OFFSET(ifaddrs, ifa_data); CHECK_TYPE_SIZE(timeb); CHECK_SIZE_AND_OFFSET(timeb, time); CHECK_SIZE_AND_OFFSET(timeb, millitm); CHECK_SIZE_AND_OFFSET(timeb, timezone); CHECK_SIZE_AND_OFFSET(timeb, dstflag); CHECK_TYPE_SIZE(passwd); CHECK_SIZE_AND_OFFSET(passwd, pw_name); CHECK_SIZE_AND_OFFSET(passwd, pw_passwd); CHECK_SIZE_AND_OFFSET(passwd, pw_uid); CHECK_SIZE_AND_OFFSET(passwd, pw_gid); CHECK_SIZE_AND_OFFSET(passwd, pw_dir); CHECK_SIZE_AND_OFFSET(passwd, pw_shell); CHECK_SIZE_AND_OFFSET(passwd, pw_gecos); CHECK_TYPE_SIZE(group); CHECK_SIZE_AND_OFFSET(group, gr_name); CHECK_SIZE_AND_OFFSET(group, gr_passwd); CHECK_SIZE_AND_OFFSET(group, gr_gid); CHECK_SIZE_AND_OFFSET(group, gr_mem); CHECK_TYPE_SIZE(modctl_load_t); CHECK_SIZE_AND_OFFSET(modctl_load_t, ml_filename); CHECK_SIZE_AND_OFFSET(modctl_load_t, ml_flags); CHECK_SIZE_AND_OFFSET(modctl_load_t, ml_props); CHECK_SIZE_AND_OFFSET(modctl_load_t, ml_propslen); #endif // SANITIZER_NETBSD Index: vendor/compiler-rt/dist-release_90/lib/sanitizer_common/sanitizer_platform_limits_netbsd.h =================================================================== --- vendor/compiler-rt/dist-release_90/lib/sanitizer_common/sanitizer_platform_limits_netbsd.h (revision 351306) +++ vendor/compiler-rt/dist-release_90/lib/sanitizer_common/sanitizer_platform_limits_netbsd.h (revision 351307) @@ -1,2360 +1,2405 @@ //===-- sanitizer_platform_limits_netbsd.h --------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is a part of Sanitizer common code. // // Sizes and layouts of platform-specific NetBSD data structures. //===----------------------------------------------------------------------===// #ifndef SANITIZER_PLATFORM_LIMITS_NETBSD_H #define SANITIZER_PLATFORM_LIMITS_NETBSD_H #if SANITIZER_NETBSD #include "sanitizer_internal_defs.h" #include "sanitizer_platform.h" #define _GET_LINK_MAP_BY_DLOPEN_HANDLE(handle, shift) \ ((link_map *)((handle) == nullptr ? nullptr : ((char *)(handle) + (shift)))) #if defined(__x86_64__) #define GET_LINK_MAP_BY_DLOPEN_HANDLE(handle) \ _GET_LINK_MAP_BY_DLOPEN_HANDLE(handle, 264) #elif defined(__i386__) #define GET_LINK_MAP_BY_DLOPEN_HANDLE(handle) \ _GET_LINK_MAP_BY_DLOPEN_HANDLE(handle, 136) #endif namespace __sanitizer { extern unsigned struct_utsname_sz; extern unsigned struct_stat_sz; extern unsigned struct_rusage_sz; extern unsigned siginfo_t_sz; extern unsigned struct_itimerval_sz; extern unsigned pthread_t_sz; extern unsigned pthread_mutex_t_sz; extern unsigned pthread_cond_t_sz; extern unsigned pid_t_sz; extern unsigned timeval_sz; extern unsigned uid_t_sz; extern unsigned gid_t_sz; extern unsigned mbstate_t_sz; extern unsigned struct_timezone_sz; extern unsigned struct_tms_sz; extern unsigned struct_itimerspec_sz; extern unsigned struct_sigevent_sz; extern unsigned struct_sched_param_sz; extern unsigned struct_statfs_sz; extern unsigned struct_sockaddr_sz; extern unsigned ucontext_t_sz; extern unsigned struct_rlimit_sz; extern unsigned struct_utimbuf_sz; extern unsigned struct_timespec_sz; extern unsigned struct_sembuf_sz; extern unsigned struct_kevent_sz; extern unsigned struct_FTS_sz; extern unsigned struct_FTSENT_sz; extern unsigned struct_regex_sz; extern unsigned struct_regmatch_sz; extern unsigned struct_fstab_sz; struct __sanitizer_regmatch { OFF_T rm_so; OFF_T rm_eo; }; typedef struct __sanitizer_modctl_load { const char *ml_filename; int ml_flags; const char *ml_props; uptr ml_propslen; } __sanitizer_modctl_load_t; extern const int modctl_load; extern const int modctl_unload; extern const int modctl_stat; extern const int modctl_exists; union __sanitizer_sigval { int sival_int; uptr sival_ptr; }; struct __sanitizer_sigevent { int sigev_notify; int sigev_signo; union __sanitizer_sigval sigev_value; uptr sigev_notify_function; uptr sigev_notify_attributes; }; struct __sanitizer_aiocb { u64 aio_offset; uptr aio_buf; uptr aio_nbytes; int aio_fildes; int aio_lio_opcode; int aio_reqprio; struct __sanitizer_sigevent aio_sigevent; int _state; int _errno; long _retval; }; struct __sanitizer_sem_t { uptr data[5]; }; struct __sanitizer_ipc_perm { u32 uid; u32 gid; u32 cuid; u32 cgid; u32 mode; unsigned short _seq; long _key; }; struct __sanitizer_shmid_ds { __sanitizer_ipc_perm shm_perm; unsigned long shm_segsz; u32 shm_lpid; u32 shm_cpid; unsigned int shm_nattch; u64 shm_atime; u64 shm_dtime; u64 shm_ctime; void *_shm_internal; }; struct __sanitizer_protoent { char *p_name; char **p_aliases; int p_proto; }; struct __sanitizer_netent { char *n_name; char **n_aliases; int n_addrtype; u32 n_net; }; extern unsigned struct_msqid_ds_sz; extern unsigned struct_mq_attr_sz; extern unsigned struct_timex_sz; extern unsigned struct_statvfs_sz; struct __sanitizer_iovec { void *iov_base; uptr iov_len; }; struct __sanitizer_ifaddrs { struct __sanitizer_ifaddrs *ifa_next; char *ifa_name; unsigned int ifa_flags; void *ifa_addr; // (struct sockaddr *) void *ifa_netmask; // (struct sockaddr *) void *ifa_dstaddr; // (struct sockaddr *) void *ifa_data; unsigned int ifa_addrflags; }; typedef unsigned int __sanitizer_socklen_t; typedef unsigned __sanitizer_pthread_key_t; typedef long long __sanitizer_time_t; typedef int __sanitizer_suseconds_t; struct __sanitizer_timeval { __sanitizer_time_t tv_sec; __sanitizer_suseconds_t tv_usec; }; struct __sanitizer_itimerval { struct __sanitizer_timeval it_interval; struct __sanitizer_timeval it_value; }; struct __sanitizer_timespec { __sanitizer_time_t tv_sec; long tv_nsec; }; struct __sanitizer_passwd { char *pw_name; char *pw_passwd; int pw_uid; int pw_gid; __sanitizer_time_t pw_change; char *pw_class; char *pw_gecos; char *pw_dir; char *pw_shell; __sanitizer_time_t pw_expire; }; struct __sanitizer_group { char *gr_name; char *gr_passwd; int gr_gid; char **gr_mem; }; struct __sanitizer_timeb { __sanitizer_time_t time; unsigned short millitm; short timezone; short dstflag; }; struct __sanitizer_ether_addr { u8 octet[6]; }; struct __sanitizer_tm { int tm_sec; int tm_min; int tm_hour; int tm_mday; int tm_mon; int tm_year; int tm_wday; int tm_yday; int tm_isdst; long int tm_gmtoff; const char *tm_zone; }; struct __sanitizer_msghdr { void *msg_name; unsigned msg_namelen; struct __sanitizer_iovec *msg_iov; unsigned msg_iovlen; void *msg_control; unsigned msg_controllen; int msg_flags; }; struct __sanitizer_mmsghdr { struct __sanitizer_msghdr msg_hdr; unsigned int msg_len; }; struct __sanitizer_cmsghdr { unsigned cmsg_len; int cmsg_level; int cmsg_type; }; struct __sanitizer_dirent { u64 d_fileno; u16 d_reclen; // more fields that we don't care about }; typedef int __sanitizer_clock_t; typedef int __sanitizer_clockid_t; typedef u32 __sanitizer___kernel_uid_t; typedef u32 __sanitizer___kernel_gid_t; typedef u64 __sanitizer___kernel_off_t; typedef struct { u32 fds_bits[8]; } __sanitizer___kernel_fd_set; typedef struct { unsigned int pta_magic; int pta_flags; void *pta_private; } __sanitizer_pthread_attr_t; struct __sanitizer_sigset_t { // uint32_t * 4 unsigned int __bits[4]; }; struct __sanitizer_siginfo { // The size is determined by looking at sizeof of real siginfo_t on linux. u64 opaque[128 / sizeof(u64)]; }; using __sanitizer_sighandler_ptr = void (*)(int sig); using __sanitizer_sigactionhandler_ptr = void (*)(int sig, __sanitizer_siginfo *siginfo, void *uctx); struct __sanitizer_sigaction { union { __sanitizer_sighandler_ptr handler; __sanitizer_sigactionhandler_ptr sigaction; }; __sanitizer_sigset_t sa_mask; int sa_flags; }; extern unsigned struct_sigaltstack_sz; typedef unsigned int __sanitizer_sigset13_t; struct __sanitizer_sigaction13 { __sanitizer_sighandler_ptr osa_handler; __sanitizer_sigset13_t osa_mask; int osa_flags; }; struct __sanitizer_sigaltstack { void *ss_sp; uptr ss_size; int ss_flags; }; typedef __sanitizer_sigset_t __sanitizer_kernel_sigset_t; struct __sanitizer_kernel_sigaction_t { union { void (*handler)(int signo); void (*sigaction)(int signo, void *info, void *ctx); }; unsigned long sa_flags; void (*sa_restorer)(void); __sanitizer_kernel_sigset_t sa_mask; }; extern const uptr sig_ign; extern const uptr sig_dfl; extern const uptr sig_err; extern const uptr sa_siginfo; extern int af_inet; extern int af_inet6; uptr __sanitizer_in_addr_sz(int af); struct __sanitizer_dl_phdr_info { uptr dlpi_addr; const char *dlpi_name; const void *dlpi_phdr; short dlpi_phnum; }; extern unsigned struct_ElfW_Phdr_sz; struct __sanitizer_addrinfo { int ai_flags; int ai_family; int ai_socktype; int ai_protocol; unsigned ai_addrlen; char *ai_canonname; void *ai_addr; struct __sanitizer_addrinfo *ai_next; }; struct __sanitizer_hostent { char *h_name; char **h_aliases; int h_addrtype; int h_length; char **h_addr_list; }; struct __sanitizer_pollfd { int fd; short events; short revents; }; typedef unsigned __sanitizer_nfds_t; typedef int __sanitizer_lwpid_t; struct __sanitizer_glob_t { uptr gl_pathc; uptr gl_matchc; uptr gl_offs; int gl_flags; char **gl_pathv; int (*gl_errfunc)(const char *, int); void (*gl_closedir)(void *dirp); struct dirent *(*gl_readdir)(void *dirp); void *(*gl_opendir)(const char *); int (*gl_lstat)(const char *, void * /* struct stat* */); int (*gl_stat)(const char *, void * /* struct stat* */); }; extern int glob_nomatch; extern int glob_altdirfunc; extern unsigned path_max; extern int struct_ttyent_sz; extern int ptrace_pt_io; extern int ptrace_pt_lwpinfo; extern int ptrace_pt_set_event_mask; extern int ptrace_pt_get_event_mask; extern int ptrace_pt_get_process_state; extern int ptrace_pt_set_siginfo; extern int ptrace_pt_get_siginfo; extern int ptrace_piod_read_d; extern int ptrace_piod_write_d; extern int ptrace_piod_read_i; extern int ptrace_piod_write_i; extern int ptrace_piod_read_auxv; extern int ptrace_pt_setregs; extern int ptrace_pt_getregs; extern int ptrace_pt_setfpregs; extern int ptrace_pt_getfpregs; extern int ptrace_pt_setdbregs; extern int ptrace_pt_getdbregs; struct __sanitizer_ptrace_io_desc { int piod_op; void *piod_offs; void *piod_addr; uptr piod_len; }; struct __sanitizer_ptrace_lwpinfo { __sanitizer_lwpid_t pl_lwpid; int pl_event; }; extern unsigned struct_ptrace_ptrace_io_desc_struct_sz; extern unsigned struct_ptrace_ptrace_lwpinfo_struct_sz; extern unsigned struct_ptrace_ptrace_event_struct_sz; extern unsigned struct_ptrace_ptrace_siginfo_struct_sz; extern unsigned struct_ptrace_reg_struct_sz; extern unsigned struct_ptrace_fpreg_struct_sz; extern unsigned struct_ptrace_dbreg_struct_sz; struct __sanitizer_wordexp_t { uptr we_wordc; char **we_wordv; uptr we_offs; char *we_strings; uptr we_nbytes; }; struct __sanitizer_FILE { unsigned char *_p; int _r; int _w; unsigned short _flags; short _file; struct { unsigned char *_base; int _size; } _bf; int _lbfsize; void *_cookie; int (*_close)(void *ptr); u64 (*_read)(void *, void *, uptr); u64 (*_seek)(void *, u64, int); uptr (*_write)(void *, const void *, uptr); struct { unsigned char *_base; int _size; } _ext; unsigned char *_up; int _ur; unsigned char _ubuf[3]; unsigned char _nbuf[1]; int (*_flush)(void *ptr); char _lb_unused[sizeof(uptr)]; int _blksize; u64 _offset; }; #define SANITIZER_HAS_STRUCT_FILE 1 extern int shmctl_ipc_stat; // This simplifies generic code #define struct_shminfo_sz -1 #define struct_shm_info_sz -1 #define shmctl_shm_stat -1 #define shmctl_ipc_info -1 #define shmctl_shm_info -1 extern unsigned struct_utmp_sz; extern unsigned struct_utmpx_sz; extern int map_fixed; // ioctl arguments struct __sanitizer_ifconf { int ifc_len; union { void *ifcu_req; } ifc_ifcu; }; struct __sanitizer_ttyent { char *ty_name; char *ty_getty; char *ty_type; int ty_status; char *ty_window; char *ty_comment; char *ty_class; }; extern const unsigned long __sanitizer_bufsiz; #define IOC_NRBITS 8 #define IOC_TYPEBITS 8 #define IOC_SIZEBITS 14 #define IOC_DIRBITS 2 #define IOC_NONE 0U #define IOC_WRITE 1U #define IOC_READ 2U #define IOC_NRMASK ((1 << IOC_NRBITS) - 1) #define IOC_TYPEMASK ((1 << IOC_TYPEBITS) - 1) #define IOC_SIZEMASK ((1 << IOC_SIZEBITS) - 1) #undef IOC_DIRMASK #define IOC_DIRMASK ((1 << IOC_DIRBITS) - 1) #define IOC_NRSHIFT 0 #define IOC_TYPESHIFT (IOC_NRSHIFT + IOC_NRBITS) #define IOC_SIZESHIFT (IOC_TYPESHIFT + IOC_TYPEBITS) #define IOC_DIRSHIFT (IOC_SIZESHIFT + IOC_SIZEBITS) #define EVIOC_EV_MAX 0x1f #define EVIOC_ABS_MAX 0x3f #define IOC_DIR(nr) (((nr) >> IOC_DIRSHIFT) & IOC_DIRMASK) #define IOC_TYPE(nr) (((nr) >> IOC_TYPESHIFT) & IOC_TYPEMASK) #define IOC_NR(nr) (((nr) >> IOC_NRSHIFT) & IOC_NRMASK) #define IOC_SIZE(nr) (((nr) >> IOC_SIZESHIFT) & IOC_SIZEMASK) // ioctl request identifiers extern unsigned struct_altqreq_sz; extern unsigned struct_amr_user_ioctl_sz; extern unsigned struct_ap_control_sz; extern unsigned struct_apm_ctl_sz; extern unsigned struct_apm_event_info_sz; extern unsigned struct_apm_power_info_sz; extern unsigned struct_atabusiodetach_args_sz; extern unsigned struct_atabusioscan_args_sz; extern unsigned struct_ath_diag_sz; extern unsigned struct_atm_flowmap_sz; extern unsigned struct_audio_buf_info_sz; extern unsigned struct_audio_device_sz; extern unsigned struct_audio_encoding_sz; extern unsigned struct_audio_info_sz; extern unsigned struct_audio_offset_sz; extern unsigned struct_bio_locate_sz; extern unsigned struct_bioc_alarm_sz; extern unsigned struct_bioc_blink_sz; extern unsigned struct_bioc_disk_sz; extern unsigned struct_bioc_inq_sz; extern unsigned struct_bioc_setstate_sz; extern unsigned struct_bioc_vol_sz; extern unsigned struct_bioc_volops_sz; extern unsigned struct_bktr_chnlset_sz; extern unsigned struct_bktr_remote_sz; extern unsigned struct_blue_conf_sz; extern unsigned struct_blue_interface_sz; extern unsigned struct_blue_stats_sz; extern unsigned struct_bpf_dltlist_sz; extern unsigned struct_bpf_program_sz; extern unsigned struct_bpf_stat_old_sz; extern unsigned struct_bpf_stat_sz; extern unsigned struct_bpf_version_sz; extern unsigned struct_btreq_sz; extern unsigned struct_btsco_info_sz; extern unsigned struct_buffmem_desc_sz; extern unsigned struct_cbq_add_class_sz; extern unsigned struct_cbq_add_filter_sz; extern unsigned struct_cbq_delete_class_sz; extern unsigned struct_cbq_delete_filter_sz; extern unsigned struct_cbq_getstats_sz; extern unsigned struct_cbq_interface_sz; extern unsigned struct_cbq_modify_class_sz; extern unsigned struct_ccd_ioctl_sz; extern unsigned struct_cdnr_add_element_sz; extern unsigned struct_cdnr_add_filter_sz; extern unsigned struct_cdnr_add_tbmeter_sz; extern unsigned struct_cdnr_add_trtcm_sz; extern unsigned struct_cdnr_add_tswtcm_sz; extern unsigned struct_cdnr_delete_element_sz; extern unsigned struct_cdnr_delete_filter_sz; extern unsigned struct_cdnr_get_stats_sz; extern unsigned struct_cdnr_interface_sz; extern unsigned struct_cdnr_modify_tbmeter_sz; extern unsigned struct_cdnr_modify_trtcm_sz; extern unsigned struct_cdnr_modify_tswtcm_sz; extern unsigned struct_cdnr_tbmeter_stats_sz; extern unsigned struct_cdnr_tcm_stats_sz; extern unsigned struct_cgd_ioctl_sz; extern unsigned struct_cgd_user_sz; extern unsigned struct_changer_element_status_request_sz; extern unsigned struct_changer_exchange_request_sz; extern unsigned struct_changer_move_request_sz; extern unsigned struct_changer_params_sz; extern unsigned struct_changer_position_request_sz; extern unsigned struct_changer_set_voltag_request_sz; extern unsigned struct_clockctl_adjtime_sz; extern unsigned struct_clockctl_clock_settime_sz; extern unsigned struct_clockctl_ntp_adjtime_sz; extern unsigned struct_clockctl_settimeofday_sz; extern unsigned struct_cnwistats_sz; extern unsigned struct_cnwitrail_sz; extern unsigned struct_cnwstatus_sz; extern unsigned struct_count_info_sz; extern unsigned struct_cpu_ucode_sz; extern unsigned struct_cpu_ucode_version_sz; extern unsigned struct_crypt_kop_sz; extern unsigned struct_crypt_mkop_sz; extern unsigned struct_crypt_mop_sz; extern unsigned struct_crypt_op_sz; extern unsigned struct_crypt_result_sz; extern unsigned struct_crypt_sfop_sz; extern unsigned struct_crypt_sgop_sz; extern unsigned struct_cryptret_sz; extern unsigned struct_devdetachargs_sz; extern unsigned struct_devlistargs_sz; extern unsigned struct_devpmargs_sz; extern unsigned struct_devrescanargs_sz; extern unsigned struct_disk_badsecinfo_sz; extern unsigned struct_disk_strategy_sz; extern unsigned struct_disklabel_sz; extern unsigned struct_dkbad_sz; extern unsigned struct_dkwedge_info_sz; extern unsigned struct_dkwedge_list_sz; extern unsigned struct_dmio_setfunc_sz; extern unsigned struct_dmx_pes_filter_params_sz; extern unsigned struct_dmx_sct_filter_params_sz; extern unsigned struct_dmx_stc_sz; extern unsigned struct_dvb_diseqc_master_cmd_sz; extern unsigned struct_dvb_diseqc_slave_reply_sz; extern unsigned struct_dvb_frontend_event_sz; extern unsigned struct_dvb_frontend_info_sz; extern unsigned struct_dvb_frontend_parameters_sz; extern unsigned struct_eccapreq_sz; extern unsigned struct_fbcmap_sz; extern unsigned struct_fbcurpos_sz; extern unsigned struct_fbcursor_sz; extern unsigned struct_fbgattr_sz; extern unsigned struct_fbsattr_sz; extern unsigned struct_fbtype_sz; extern unsigned struct_fdformat_cmd_sz; extern unsigned struct_fdformat_parms_sz; extern unsigned struct_fifoq_conf_sz; extern unsigned struct_fifoq_getstats_sz; extern unsigned struct_fifoq_interface_sz; extern unsigned struct_format_op_sz; extern unsigned struct_fss_get_sz; extern unsigned struct_fss_set_sz; extern unsigned struct_gpio_attach_sz; extern unsigned struct_gpio_info_sz; extern unsigned struct_gpio_req_sz; extern unsigned struct_gpio_set_sz; extern unsigned struct_hfsc_add_class_sz; extern unsigned struct_hfsc_add_filter_sz; extern unsigned struct_hfsc_attach_sz; extern unsigned struct_hfsc_class_stats_sz; extern unsigned struct_hfsc_delete_class_sz; extern unsigned struct_hfsc_delete_filter_sz; extern unsigned struct_hfsc_interface_sz; extern unsigned struct_hfsc_modify_class_sz; extern unsigned struct_hpcfb_dsp_op_sz; extern unsigned struct_hpcfb_dspconf_sz; extern unsigned struct_hpcfb_fbconf_sz; extern unsigned struct_if_addrprefreq_sz; extern unsigned struct_if_clonereq_sz; extern unsigned struct_if_laddrreq_sz; extern unsigned struct_ifaddr_sz; extern unsigned struct_ifaliasreq_sz; extern unsigned struct_ifcapreq_sz; extern unsigned struct_ifconf_sz; extern unsigned struct_ifdatareq_sz; extern unsigned struct_ifdrv_sz; extern unsigned struct_ifmediareq_sz; extern unsigned struct_ifpppcstatsreq_sz; extern unsigned struct_ifpppstatsreq_sz; extern unsigned struct_ifreq_sz; extern unsigned struct_in6_addrpolicy_sz; extern unsigned struct_in6_ndireq_sz; extern unsigned struct_ioc_load_unload_sz; extern unsigned struct_ioc_patch_sz; extern unsigned struct_ioc_play_blocks_sz; extern unsigned struct_ioc_play_msf_sz; extern unsigned struct_ioc_play_track_sz; extern unsigned struct_ioc_read_subchannel_sz; extern unsigned struct_ioc_read_toc_entry_sz; extern unsigned struct_ioc_toc_header_sz; extern unsigned struct_ioc_vol_sz; extern unsigned struct_ioctl_pt_sz; extern unsigned struct_ioppt_sz; extern unsigned struct_iovec_sz; extern unsigned struct_ipfobj_sz; extern unsigned struct_irda_params_sz; extern unsigned struct_isp_fc_device_sz; extern unsigned struct_isp_fc_tsk_mgmt_sz; extern unsigned struct_isp_hba_device_sz; extern unsigned struct_isv_cmd_sz; extern unsigned struct_jobs_add_class_sz; extern unsigned struct_jobs_add_filter_sz; extern unsigned struct_jobs_attach_sz; extern unsigned struct_jobs_class_stats_sz; extern unsigned struct_jobs_delete_class_sz; extern unsigned struct_jobs_delete_filter_sz; extern unsigned struct_jobs_interface_sz; extern unsigned struct_jobs_modify_class_sz; extern unsigned struct_kbentry_sz; extern unsigned struct_kfilter_mapping_sz; extern unsigned struct_kiockeymap_sz; extern unsigned struct_ksyms_gsymbol_sz; extern unsigned struct_ksyms_gvalue_sz; extern unsigned struct_ksyms_ogsymbol_sz; extern unsigned struct_kttcp_io_args_sz; extern unsigned struct_ltchars_sz; extern unsigned struct_lua_create_sz; extern unsigned struct_lua_info_sz; extern unsigned struct_lua_load_sz; extern unsigned struct_lua_require_sz; extern unsigned struct_mbpp_param_sz; extern unsigned struct_md_conf_sz; extern unsigned struct_meteor_capframe_sz; extern unsigned struct_meteor_counts_sz; extern unsigned struct_meteor_geomet_sz; extern unsigned struct_meteor_pixfmt_sz; extern unsigned struct_meteor_video_sz; extern unsigned struct_mlx_cinfo_sz; extern unsigned struct_mlx_pause_sz; extern unsigned struct_mlx_rebuild_request_sz; extern unsigned struct_mlx_rebuild_status_sz; extern unsigned struct_mlx_usercommand_sz; extern unsigned struct_mly_user_command_sz; extern unsigned struct_mly_user_health_sz; extern unsigned struct_mtget_sz; extern unsigned struct_mtop_sz; extern unsigned struct_npf_ioctl_table_sz; extern unsigned struct_npioctl_sz; extern unsigned struct_nvme_pt_command_sz; extern unsigned struct_ochanger_element_status_request_sz; extern unsigned struct_ofiocdesc_sz; extern unsigned struct_okiockey_sz; extern unsigned struct_ortentry_sz; extern unsigned struct_oscsi_addr_sz; extern unsigned struct_oss_audioinfo_sz; extern unsigned struct_oss_sysinfo_sz; extern unsigned struct_pciio_bdf_cfgreg_sz; extern unsigned struct_pciio_businfo_sz; extern unsigned struct_pciio_cfgreg_sz; extern unsigned struct_pciio_drvname_sz; extern unsigned struct_pciio_drvnameonbus_sz; extern unsigned struct_pcvtid_sz; extern unsigned struct_pf_osfp_ioctl_sz; extern unsigned struct_pf_status_sz; extern unsigned struct_pfioc_altq_sz; extern unsigned struct_pfioc_if_sz; extern unsigned struct_pfioc_iface_sz; extern unsigned struct_pfioc_limit_sz; extern unsigned struct_pfioc_natlook_sz; extern unsigned struct_pfioc_pooladdr_sz; extern unsigned struct_pfioc_qstats_sz; extern unsigned struct_pfioc_rule_sz; extern unsigned struct_pfioc_ruleset_sz; extern unsigned struct_pfioc_src_node_kill_sz; extern unsigned struct_pfioc_src_nodes_sz; extern unsigned struct_pfioc_state_kill_sz; extern unsigned struct_pfioc_state_sz; extern unsigned struct_pfioc_states_sz; extern unsigned struct_pfioc_table_sz; extern unsigned struct_pfioc_tm_sz; extern unsigned struct_pfioc_trans_sz; extern unsigned struct_plistref_sz; extern unsigned struct_power_type_sz; extern unsigned struct_ppp_idle_sz; extern unsigned struct_ppp_option_data_sz; extern unsigned struct_ppp_rawin_sz; extern unsigned struct_pppoeconnectionstate_sz; extern unsigned struct_pppoediscparms_sz; extern unsigned struct_priq_add_class_sz; extern unsigned struct_priq_add_filter_sz; extern unsigned struct_priq_class_stats_sz; extern unsigned struct_priq_delete_class_sz; extern unsigned struct_priq_delete_filter_sz; extern unsigned struct_priq_interface_sz; extern unsigned struct_priq_modify_class_sz; extern unsigned struct_ptmget_sz; extern unsigned struct_pvctxreq_sz; extern unsigned struct_radio_info_sz; extern unsigned struct_red_conf_sz; extern unsigned struct_red_interface_sz; extern unsigned struct_red_stats_sz; extern unsigned struct_redparams_sz; extern unsigned struct_rf_pmparams_sz; extern unsigned struct_rf_pmstat_sz; extern unsigned struct_rf_recon_req_sz; extern unsigned struct_rio_conf_sz; extern unsigned struct_rio_interface_sz; extern unsigned struct_rio_stats_sz; extern unsigned struct_scan_io_sz; extern unsigned struct_scbusaccel_args_sz; extern unsigned struct_scbusiodetach_args_sz; extern unsigned struct_scbusioscan_args_sz; extern unsigned struct_scsi_addr_sz; extern unsigned struct_seq_event_rec_sz; extern unsigned struct_session_op_sz; extern unsigned struct_sgttyb_sz; extern unsigned struct_sioc_sg_req_sz; extern unsigned struct_sioc_vif_req_sz; extern unsigned struct_smbioc_flags_sz; extern unsigned struct_smbioc_lookup_sz; extern unsigned struct_smbioc_oshare_sz; extern unsigned struct_smbioc_ossn_sz; extern unsigned struct_smbioc_rq_sz; extern unsigned struct_smbioc_rw_sz; extern unsigned struct_spppauthcfg_sz; extern unsigned struct_spppauthfailuresettings_sz; extern unsigned struct_spppauthfailurestats_sz; extern unsigned struct_spppdnsaddrs_sz; extern unsigned struct_spppdnssettings_sz; extern unsigned struct_spppidletimeout_sz; extern unsigned struct_spppkeepalivesettings_sz; extern unsigned struct_sppplcpcfg_sz; extern unsigned struct_spppstatus_sz; extern unsigned struct_spppstatusncp_sz; extern unsigned struct_srt_rt_sz; extern unsigned struct_stic_xinfo_sz; extern unsigned struct_sun_dkctlr_sz; extern unsigned struct_sun_dkgeom_sz; extern unsigned struct_sun_dkpart_sz; extern unsigned struct_synth_info_sz; extern unsigned struct_tbrreq_sz; extern unsigned struct_tchars_sz; extern unsigned struct_termios_sz; extern unsigned struct_timeval_sz; extern unsigned struct_twe_drivecommand_sz; extern unsigned struct_twe_paramcommand_sz; extern unsigned struct_twe_usercommand_sz; extern unsigned struct_ukyopon_identify_sz; extern unsigned struct_urio_command_sz; extern unsigned struct_usb_alt_interface_sz; extern unsigned struct_usb_bulk_ra_wb_opt_sz; extern unsigned struct_usb_config_desc_sz; extern unsigned struct_usb_ctl_report_desc_sz; extern unsigned struct_usb_ctl_report_sz; extern unsigned struct_usb_ctl_request_sz; +#if defined(__x86_64__) +extern unsigned struct_nvmm_ioc_capability_sz; +extern unsigned struct_nvmm_ioc_machine_create_sz; +extern unsigned struct_nvmm_ioc_machine_destroy_sz; +extern unsigned struct_nvmm_ioc_machine_configure_sz; +extern unsigned struct_nvmm_ioc_vcpu_create_sz; +extern unsigned struct_nvmm_ioc_vcpu_destroy_sz; +extern unsigned struct_nvmm_ioc_vcpu_setstate_sz; +extern unsigned struct_nvmm_ioc_vcpu_getstate_sz; +extern unsigned struct_nvmm_ioc_vcpu_inject_sz; +extern unsigned struct_nvmm_ioc_vcpu_run_sz; +extern unsigned struct_nvmm_ioc_gpa_map_sz; +extern unsigned struct_nvmm_ioc_gpa_unmap_sz; +extern unsigned struct_nvmm_ioc_hva_map_sz; +extern unsigned struct_nvmm_ioc_hva_unmap_sz; +extern unsigned struct_nvmm_ioc_ctl_sz; +#endif +extern unsigned struct_spi_ioctl_configure_sz; +extern unsigned struct_spi_ioctl_transfer_sz; extern unsigned struct_autofs_daemon_request_sz; extern unsigned struct_autofs_daemon_done_sz; extern unsigned struct_sctp_connectx_addrs_sz; extern unsigned struct_usb_device_info_old_sz; extern unsigned struct_usb_device_info_sz; extern unsigned struct_usb_device_stats_sz; extern unsigned struct_usb_endpoint_desc_sz; extern unsigned struct_usb_full_desc_sz; extern unsigned struct_usb_interface_desc_sz; extern unsigned struct_usb_string_desc_sz; extern unsigned struct_utoppy_readfile_sz; extern unsigned struct_utoppy_rename_sz; extern unsigned struct_utoppy_stats_sz; extern unsigned struct_utoppy_writefile_sz; extern unsigned struct_v4l2_audio_sz; extern unsigned struct_v4l2_audioout_sz; extern unsigned struct_v4l2_buffer_sz; extern unsigned struct_v4l2_capability_sz; extern unsigned struct_v4l2_control_sz; extern unsigned struct_v4l2_crop_sz; extern unsigned struct_v4l2_cropcap_sz; extern unsigned struct_v4l2_fmtdesc_sz; extern unsigned struct_v4l2_format_sz; extern unsigned struct_v4l2_framebuffer_sz; extern unsigned struct_v4l2_frequency_sz; extern unsigned struct_v4l2_frmivalenum_sz; extern unsigned struct_v4l2_frmsizeenum_sz; extern unsigned struct_v4l2_input_sz; extern unsigned struct_v4l2_jpegcompression_sz; extern unsigned struct_v4l2_modulator_sz; extern unsigned struct_v4l2_output_sz; extern unsigned struct_v4l2_queryctrl_sz; extern unsigned struct_v4l2_querymenu_sz; extern unsigned struct_v4l2_requestbuffers_sz; extern unsigned struct_v4l2_standard_sz; extern unsigned struct_v4l2_streamparm_sz; extern unsigned struct_v4l2_tuner_sz; extern unsigned struct_vnd_ioctl_sz; extern unsigned struct_vnd_user_sz; extern unsigned struct_vt_stat_sz; extern unsigned struct_wdog_conf_sz; extern unsigned struct_wdog_mode_sz; +extern unsigned struct_ipmi_recv_sz; +extern unsigned struct_ipmi_req_sz; +extern unsigned struct_ipmi_cmdspec_sz; extern unsigned struct_wfq_conf_sz; extern unsigned struct_wfq_getqid_sz; extern unsigned struct_wfq_getstats_sz; extern unsigned struct_wfq_interface_sz; extern unsigned struct_wfq_setweight_sz; extern unsigned struct_winsize_sz; extern unsigned struct_wscons_event_sz; extern unsigned struct_wsdisplay_addscreendata_sz; extern unsigned struct_wsdisplay_char_sz; extern unsigned struct_wsdisplay_cmap_sz; extern unsigned struct_wsdisplay_curpos_sz; extern unsigned struct_wsdisplay_cursor_sz; extern unsigned struct_wsdisplay_delscreendata_sz; extern unsigned struct_wsdisplay_fbinfo_sz; extern unsigned struct_wsdisplay_font_sz; extern unsigned struct_wsdisplay_kbddata_sz; extern unsigned struct_wsdisplay_msgattrs_sz; extern unsigned struct_wsdisplay_param_sz; extern unsigned struct_wsdisplay_scroll_data_sz; extern unsigned struct_wsdisplay_usefontdata_sz; extern unsigned struct_wsdisplayio_blit_sz; extern unsigned struct_wsdisplayio_bus_id_sz; extern unsigned struct_wsdisplayio_edid_info_sz; extern unsigned struct_wsdisplayio_fbinfo_sz; extern unsigned struct_wskbd_bell_data_sz; extern unsigned struct_wskbd_keyrepeat_data_sz; extern unsigned struct_wskbd_map_data_sz; extern unsigned struct_wskbd_scroll_data_sz; extern unsigned struct_wsmouse_calibcoords_sz; extern unsigned struct_wsmouse_id_sz; extern unsigned struct_wsmouse_repeat_sz; extern unsigned struct_wsmux_device_list_sz; extern unsigned struct_wsmux_device_sz; extern unsigned struct_xd_iocmd_sz; extern unsigned struct_scsireq_sz; extern unsigned struct_tone_sz; extern unsigned union_twe_statrequest_sz; extern unsigned struct_usb_device_descriptor_sz; extern unsigned struct_vt_mode_sz; extern unsigned struct__old_mixer_info_sz; extern unsigned struct__agp_allocate_sz; extern unsigned struct__agp_bind_sz; extern unsigned struct__agp_info_sz; extern unsigned struct__agp_setup_sz; extern unsigned struct__agp_unbind_sz; extern unsigned struct_atareq_sz; extern unsigned struct_cpustate_sz; extern unsigned struct_dmx_caps_sz; extern unsigned enum_dmx_source_sz; extern unsigned union_dvd_authinfo_sz; extern unsigned union_dvd_struct_sz; extern unsigned enum_v4l2_priority_sz; extern unsigned struct_envsys_basic_info_sz; extern unsigned struct_envsys_tre_data_sz; extern unsigned enum_fe_sec_mini_cmd_sz; extern unsigned enum_fe_sec_tone_mode_sz; extern unsigned enum_fe_sec_voltage_sz; extern unsigned enum_fe_status_sz; extern unsigned struct_gdt_ctrt_sz; extern unsigned struct_gdt_event_sz; extern unsigned struct_gdt_osv_sz; extern unsigned struct_gdt_rescan_sz; extern unsigned struct_gdt_statist_sz; extern unsigned struct_gdt_ucmd_sz; extern unsigned struct_iscsi_conn_status_parameters_sz; extern unsigned struct_iscsi_get_version_parameters_sz; extern unsigned struct_iscsi_iocommand_parameters_sz; extern unsigned struct_iscsi_login_parameters_sz; extern unsigned struct_iscsi_logout_parameters_sz; extern unsigned struct_iscsi_register_event_parameters_sz; extern unsigned struct_iscsi_remove_parameters_sz; extern unsigned struct_iscsi_send_targets_parameters_sz; extern unsigned struct_iscsi_set_node_name_parameters_sz; extern unsigned struct_iscsi_wait_event_parameters_sz; extern unsigned struct_isp_stats_sz; extern unsigned struct_lsenable_sz; extern unsigned struct_lsdisable_sz; +extern unsigned struct_audio_format_query_sz; extern unsigned struct_mixer_ctrl_sz; extern unsigned struct_mixer_devinfo_sz; extern unsigned struct_mpu_command_rec_sz; extern unsigned struct_rndstat_sz; extern unsigned struct_rndstat_name_sz; extern unsigned struct_rndctl_sz; extern unsigned struct_rnddata_sz; extern unsigned struct_rndpoolstat_sz; extern unsigned struct_rndstat_est_sz; extern unsigned struct_rndstat_est_name_sz; extern unsigned struct_pps_params_sz; extern unsigned struct_pps_info_sz; extern unsigned struct_mixer_info_sz; extern unsigned struct_RF_SparetWait_sz; extern unsigned struct_RF_ComponentLabel_sz; extern unsigned struct_RF_SingleComponent_sz; extern unsigned struct_RF_ProgressInfo_sz; extern unsigned struct_nvlist_ref_sz; extern unsigned struct_StringList_sz; // A special value to mark ioctls that are not present on the target platform, // when it can not be determined without including any system headers. extern const unsigned IOCTL_NOT_PRESENT; extern unsigned IOCTL_AFM_ADDFMAP; extern unsigned IOCTL_AFM_DELFMAP; extern unsigned IOCTL_AFM_CLEANFMAP; extern unsigned IOCTL_AFM_GETFMAP; extern unsigned IOCTL_ALTQGTYPE; extern unsigned IOCTL_ALTQTBRSET; extern unsigned IOCTL_ALTQTBRGET; extern unsigned IOCTL_BLUE_IF_ATTACH; extern unsigned IOCTL_BLUE_IF_DETACH; extern unsigned IOCTL_BLUE_ENABLE; extern unsigned IOCTL_BLUE_DISABLE; extern unsigned IOCTL_BLUE_CONFIG; extern unsigned IOCTL_BLUE_GETSTATS; extern unsigned IOCTL_CBQ_IF_ATTACH; extern unsigned IOCTL_CBQ_IF_DETACH; extern unsigned IOCTL_CBQ_ENABLE; extern unsigned IOCTL_CBQ_DISABLE; extern unsigned IOCTL_CBQ_CLEAR_HIERARCHY; extern unsigned IOCTL_CBQ_ADD_CLASS; extern unsigned IOCTL_CBQ_DEL_CLASS; extern unsigned IOCTL_CBQ_MODIFY_CLASS; extern unsigned IOCTL_CBQ_ADD_FILTER; extern unsigned IOCTL_CBQ_DEL_FILTER; extern unsigned IOCTL_CBQ_GETSTATS; extern unsigned IOCTL_CDNR_IF_ATTACH; extern unsigned IOCTL_CDNR_IF_DETACH; extern unsigned IOCTL_CDNR_ENABLE; extern unsigned IOCTL_CDNR_DISABLE; extern unsigned IOCTL_CDNR_ADD_FILTER; extern unsigned IOCTL_CDNR_DEL_FILTER; extern unsigned IOCTL_CDNR_GETSTATS; extern unsigned IOCTL_CDNR_ADD_ELEM; extern unsigned IOCTL_CDNR_DEL_ELEM; extern unsigned IOCTL_CDNR_ADD_TBM; extern unsigned IOCTL_CDNR_MOD_TBM; extern unsigned IOCTL_CDNR_TBM_STATS; extern unsigned IOCTL_CDNR_ADD_TCM; extern unsigned IOCTL_CDNR_MOD_TCM; extern unsigned IOCTL_CDNR_TCM_STATS; extern unsigned IOCTL_CDNR_ADD_TSW; extern unsigned IOCTL_CDNR_MOD_TSW; extern unsigned IOCTL_FIFOQ_IF_ATTACH; extern unsigned IOCTL_FIFOQ_IF_DETACH; extern unsigned IOCTL_FIFOQ_ENABLE; extern unsigned IOCTL_FIFOQ_DISABLE; extern unsigned IOCTL_FIFOQ_CONFIG; extern unsigned IOCTL_FIFOQ_GETSTATS; extern unsigned IOCTL_HFSC_IF_ATTACH; extern unsigned IOCTL_HFSC_IF_DETACH; extern unsigned IOCTL_HFSC_ENABLE; extern unsigned IOCTL_HFSC_DISABLE; extern unsigned IOCTL_HFSC_CLEAR_HIERARCHY; extern unsigned IOCTL_HFSC_ADD_CLASS; extern unsigned IOCTL_HFSC_DEL_CLASS; extern unsigned IOCTL_HFSC_MOD_CLASS; extern unsigned IOCTL_HFSC_ADD_FILTER; extern unsigned IOCTL_HFSC_DEL_FILTER; extern unsigned IOCTL_HFSC_GETSTATS; extern unsigned IOCTL_JOBS_IF_ATTACH; extern unsigned IOCTL_JOBS_IF_DETACH; extern unsigned IOCTL_JOBS_ENABLE; extern unsigned IOCTL_JOBS_DISABLE; extern unsigned IOCTL_JOBS_CLEAR; extern unsigned IOCTL_JOBS_ADD_CLASS; extern unsigned IOCTL_JOBS_DEL_CLASS; extern unsigned IOCTL_JOBS_MOD_CLASS; extern unsigned IOCTL_JOBS_ADD_FILTER; extern unsigned IOCTL_JOBS_DEL_FILTER; extern unsigned IOCTL_JOBS_GETSTATS; extern unsigned IOCTL_PRIQ_IF_ATTACH; extern unsigned IOCTL_PRIQ_IF_DETACH; extern unsigned IOCTL_PRIQ_ENABLE; extern unsigned IOCTL_PRIQ_DISABLE; extern unsigned IOCTL_PRIQ_CLEAR; extern unsigned IOCTL_PRIQ_ADD_CLASS; extern unsigned IOCTL_PRIQ_DEL_CLASS; extern unsigned IOCTL_PRIQ_MOD_CLASS; extern unsigned IOCTL_PRIQ_ADD_FILTER; extern unsigned IOCTL_PRIQ_DEL_FILTER; extern unsigned IOCTL_PRIQ_GETSTATS; extern unsigned IOCTL_RED_IF_ATTACH; extern unsigned IOCTL_RED_IF_DETACH; extern unsigned IOCTL_RED_ENABLE; extern unsigned IOCTL_RED_DISABLE; extern unsigned IOCTL_RED_CONFIG; extern unsigned IOCTL_RED_GETSTATS; extern unsigned IOCTL_RED_SETDEFAULTS; extern unsigned IOCTL_RIO_IF_ATTACH; extern unsigned IOCTL_RIO_IF_DETACH; extern unsigned IOCTL_RIO_ENABLE; extern unsigned IOCTL_RIO_DISABLE; extern unsigned IOCTL_RIO_CONFIG; extern unsigned IOCTL_RIO_GETSTATS; extern unsigned IOCTL_RIO_SETDEFAULTS; extern unsigned IOCTL_WFQ_IF_ATTACH; extern unsigned IOCTL_WFQ_IF_DETACH; extern unsigned IOCTL_WFQ_ENABLE; extern unsigned IOCTL_WFQ_DISABLE; extern unsigned IOCTL_WFQ_CONFIG; extern unsigned IOCTL_WFQ_GET_STATS; extern unsigned IOCTL_WFQ_GET_QID; extern unsigned IOCTL_WFQ_SET_WEIGHT; extern unsigned IOCTL_CRIOGET; extern unsigned IOCTL_CIOCFSESSION; extern unsigned IOCTL_CIOCKEY; extern unsigned IOCTL_CIOCNFKEYM; extern unsigned IOCTL_CIOCNFSESSION; extern unsigned IOCTL_CIOCNCRYPTRETM; extern unsigned IOCTL_CIOCNCRYPTRET; extern unsigned IOCTL_CIOCGSESSION; extern unsigned IOCTL_CIOCNGSESSION; extern unsigned IOCTL_CIOCCRYPT; extern unsigned IOCTL_CIOCNCRYPTM; extern unsigned IOCTL_CIOCASYMFEAT; extern unsigned IOCTL_APM_IOC_REJECT; extern unsigned IOCTL_APM_IOC_STANDBY; extern unsigned IOCTL_APM_IOC_SUSPEND; extern unsigned IOCTL_OAPM_IOC_GETPOWER; extern unsigned IOCTL_APM_IOC_GETPOWER; extern unsigned IOCTL_APM_IOC_NEXTEVENT; extern unsigned IOCTL_APM_IOC_DEV_CTL; extern unsigned IOCTL_NETBSD_DM_IOCTL; extern unsigned IOCTL_DMIO_SETFUNC; extern unsigned IOCTL_DMX_START; extern unsigned IOCTL_DMX_STOP; extern unsigned IOCTL_DMX_SET_FILTER; extern unsigned IOCTL_DMX_SET_PES_FILTER; extern unsigned IOCTL_DMX_SET_BUFFER_SIZE; extern unsigned IOCTL_DMX_GET_STC; extern unsigned IOCTL_DMX_ADD_PID; extern unsigned IOCTL_DMX_REMOVE_PID; extern unsigned IOCTL_DMX_GET_CAPS; extern unsigned IOCTL_DMX_SET_SOURCE; extern unsigned IOCTL_FE_READ_STATUS; extern unsigned IOCTL_FE_READ_BER; extern unsigned IOCTL_FE_READ_SNR; extern unsigned IOCTL_FE_READ_SIGNAL_STRENGTH; extern unsigned IOCTL_FE_READ_UNCORRECTED_BLOCKS; extern unsigned IOCTL_FE_SET_FRONTEND; extern unsigned IOCTL_FE_GET_FRONTEND; extern unsigned IOCTL_FE_GET_EVENT; extern unsigned IOCTL_FE_GET_INFO; extern unsigned IOCTL_FE_DISEQC_RESET_OVERLOAD; extern unsigned IOCTL_FE_DISEQC_SEND_MASTER_CMD; extern unsigned IOCTL_FE_DISEQC_RECV_SLAVE_REPLY; extern unsigned IOCTL_FE_DISEQC_SEND_BURST; extern unsigned IOCTL_FE_SET_TONE; extern unsigned IOCTL_FE_SET_VOLTAGE; extern unsigned IOCTL_FE_ENABLE_HIGH_LNB_VOLTAGE; extern unsigned IOCTL_FE_SET_FRONTEND_TUNE_MODE; extern unsigned IOCTL_FE_DISHNETWORK_SEND_LEGACY_CMD; extern unsigned IOCTL_FILEMON_SET_FD; extern unsigned IOCTL_FILEMON_SET_PID; extern unsigned IOCTL_HDAUDIO_FGRP_INFO; extern unsigned IOCTL_HDAUDIO_FGRP_GETCONFIG; extern unsigned IOCTL_HDAUDIO_FGRP_SETCONFIG; extern unsigned IOCTL_HDAUDIO_FGRP_WIDGET_INFO; extern unsigned IOCTL_HDAUDIO_FGRP_CODEC_INFO; extern unsigned IOCTL_HDAUDIO_AFG_WIDGET_INFO; extern unsigned IOCTL_HDAUDIO_AFG_CODEC_INFO; extern unsigned IOCTL_CEC_GET_PHYS_ADDR; extern unsigned IOCTL_CEC_GET_LOG_ADDRS; extern unsigned IOCTL_CEC_SET_LOG_ADDRS; extern unsigned IOCTL_CEC_GET_VENDOR_ID; extern unsigned IOCTL_HPCFBIO_GCONF; extern unsigned IOCTL_HPCFBIO_SCONF; extern unsigned IOCTL_HPCFBIO_GDSPCONF; extern unsigned IOCTL_HPCFBIO_SDSPCONF; extern unsigned IOCTL_HPCFBIO_GOP; extern unsigned IOCTL_HPCFBIO_SOP; extern unsigned IOCTL_IOPIOCPT; extern unsigned IOCTL_IOPIOCGLCT; extern unsigned IOCTL_IOPIOCGSTATUS; extern unsigned IOCTL_IOPIOCRECONFIG; extern unsigned IOCTL_IOPIOCGTIDMAP; extern unsigned IOCTL_SIOCGATHSTATS; extern unsigned IOCTL_SIOCGATHDIAG; extern unsigned IOCTL_METEORCAPTUR; extern unsigned IOCTL_METEORCAPFRM; extern unsigned IOCTL_METEORSETGEO; extern unsigned IOCTL_METEORGETGEO; extern unsigned IOCTL_METEORSTATUS; extern unsigned IOCTL_METEORSHUE; extern unsigned IOCTL_METEORGHUE; extern unsigned IOCTL_METEORSFMT; extern unsigned IOCTL_METEORGFMT; extern unsigned IOCTL_METEORSINPUT; extern unsigned IOCTL_METEORGINPUT; extern unsigned IOCTL_METEORSCHCV; extern unsigned IOCTL_METEORGCHCV; extern unsigned IOCTL_METEORSCOUNT; extern unsigned IOCTL_METEORGCOUNT; extern unsigned IOCTL_METEORSFPS; extern unsigned IOCTL_METEORGFPS; extern unsigned IOCTL_METEORSSIGNAL; extern unsigned IOCTL_METEORGSIGNAL; extern unsigned IOCTL_METEORSVIDEO; extern unsigned IOCTL_METEORGVIDEO; extern unsigned IOCTL_METEORSBRIG; extern unsigned IOCTL_METEORGBRIG; extern unsigned IOCTL_METEORSCSAT; extern unsigned IOCTL_METEORGCSAT; extern unsigned IOCTL_METEORSCONT; extern unsigned IOCTL_METEORGCONT; extern unsigned IOCTL_METEORSHWS; extern unsigned IOCTL_METEORGHWS; extern unsigned IOCTL_METEORSVWS; extern unsigned IOCTL_METEORGVWS; extern unsigned IOCTL_METEORSTS; extern unsigned IOCTL_METEORGTS; extern unsigned IOCTL_TVTUNER_SETCHNL; extern unsigned IOCTL_TVTUNER_GETCHNL; extern unsigned IOCTL_TVTUNER_SETTYPE; extern unsigned IOCTL_TVTUNER_GETTYPE; extern unsigned IOCTL_TVTUNER_GETSTATUS; extern unsigned IOCTL_TVTUNER_SETFREQ; extern unsigned IOCTL_TVTUNER_GETFREQ; extern unsigned IOCTL_TVTUNER_SETAFC; extern unsigned IOCTL_TVTUNER_GETAFC; extern unsigned IOCTL_RADIO_SETMODE; extern unsigned IOCTL_RADIO_GETMODE; extern unsigned IOCTL_RADIO_SETFREQ; extern unsigned IOCTL_RADIO_GETFREQ; extern unsigned IOCTL_METEORSACTPIXFMT; extern unsigned IOCTL_METEORGACTPIXFMT; extern unsigned IOCTL_METEORGSUPPIXFMT; extern unsigned IOCTL_TVTUNER_GETCHNLSET; extern unsigned IOCTL_REMOTE_GETKEY; extern unsigned IOCTL_GDT_IOCTL_GENERAL; extern unsigned IOCTL_GDT_IOCTL_DRVERS; extern unsigned IOCTL_GDT_IOCTL_CTRTYPE; extern unsigned IOCTL_GDT_IOCTL_OSVERS; extern unsigned IOCTL_GDT_IOCTL_CTRCNT; extern unsigned IOCTL_GDT_IOCTL_EVENT; extern unsigned IOCTL_GDT_IOCTL_STATIST; extern unsigned IOCTL_GDT_IOCTL_RESCAN; extern unsigned IOCTL_ISP_SDBLEV; extern unsigned IOCTL_ISP_RESETHBA; extern unsigned IOCTL_ISP_RESCAN; extern unsigned IOCTL_ISP_SETROLE; extern unsigned IOCTL_ISP_GETROLE; extern unsigned IOCTL_ISP_GET_STATS; extern unsigned IOCTL_ISP_CLR_STATS; extern unsigned IOCTL_ISP_FC_LIP; extern unsigned IOCTL_ISP_FC_GETDINFO; extern unsigned IOCTL_ISP_GET_FW_CRASH_DUMP; extern unsigned IOCTL_ISP_FORCE_CRASH_DUMP; extern unsigned IOCTL_ISP_FC_GETHINFO; extern unsigned IOCTL_ISP_TSK_MGMT; extern unsigned IOCTL_ISP_FC_GETDLIST; extern unsigned IOCTL_MLXD_STATUS; extern unsigned IOCTL_MLXD_CHECKASYNC; extern unsigned IOCTL_MLXD_DETACH; extern unsigned IOCTL_MLX_RESCAN_DRIVES; extern unsigned IOCTL_MLX_PAUSE_CHANNEL; extern unsigned IOCTL_MLX_COMMAND; extern unsigned IOCTL_MLX_REBUILDASYNC; extern unsigned IOCTL_MLX_REBUILDSTAT; extern unsigned IOCTL_MLX_GET_SYSDRIVE; extern unsigned IOCTL_MLX_GET_CINFO; extern unsigned IOCTL_NVME_PASSTHROUGH_CMD; extern unsigned IOCTL_FWCFGIO_SET_INDEX; extern unsigned IOCTL_IRDA_RESET_PARAMS; extern unsigned IOCTL_IRDA_SET_PARAMS; extern unsigned IOCTL_IRDA_GET_SPEEDMASK; extern unsigned IOCTL_IRDA_GET_TURNAROUNDMASK; extern unsigned IOCTL_IRFRAMETTY_GET_DEVICE; extern unsigned IOCTL_IRFRAMETTY_GET_DONGLE; extern unsigned IOCTL_IRFRAMETTY_SET_DONGLE; extern unsigned IOCTL_ISV_CMD; extern unsigned IOCTL_WTQICMD; extern unsigned IOCTL_ISCSI_GET_VERSION; extern unsigned IOCTL_ISCSI_LOGIN; extern unsigned IOCTL_ISCSI_LOGOUT; extern unsigned IOCTL_ISCSI_ADD_CONNECTION; extern unsigned IOCTL_ISCSI_RESTORE_CONNECTION; extern unsigned IOCTL_ISCSI_REMOVE_CONNECTION; extern unsigned IOCTL_ISCSI_CONNECTION_STATUS; extern unsigned IOCTL_ISCSI_SEND_TARGETS; extern unsigned IOCTL_ISCSI_SET_NODE_NAME; extern unsigned IOCTL_ISCSI_IO_COMMAND; extern unsigned IOCTL_ISCSI_REGISTER_EVENT; extern unsigned IOCTL_ISCSI_DEREGISTER_EVENT; extern unsigned IOCTL_ISCSI_WAIT_EVENT; extern unsigned IOCTL_ISCSI_POLL_EVENT; extern unsigned IOCTL_OFIOCGET; extern unsigned IOCTL_OFIOCSET; extern unsigned IOCTL_OFIOCNEXTPROP; extern unsigned IOCTL_OFIOCGETOPTNODE; extern unsigned IOCTL_OFIOCGETNEXT; extern unsigned IOCTL_OFIOCGETCHILD; extern unsigned IOCTL_OFIOCFINDDEVICE; extern unsigned IOCTL_AMR_IO_VERSION; extern unsigned IOCTL_AMR_IO_COMMAND; extern unsigned IOCTL_MLYIO_COMMAND; extern unsigned IOCTL_MLYIO_HEALTH; extern unsigned IOCTL_PCI_IOC_CFGREAD; extern unsigned IOCTL_PCI_IOC_CFGWRITE; extern unsigned IOCTL_PCI_IOC_BDF_CFGREAD; extern unsigned IOCTL_PCI_IOC_BDF_CFGWRITE; extern unsigned IOCTL_PCI_IOC_BUSINFO; extern unsigned IOCTL_PCI_IOC_DRVNAME; extern unsigned IOCTL_PCI_IOC_DRVNAMEONBUS; extern unsigned IOCTL_TWEIO_COMMAND; extern unsigned IOCTL_TWEIO_STATS; extern unsigned IOCTL_TWEIO_AEN_POLL; extern unsigned IOCTL_TWEIO_AEN_WAIT; extern unsigned IOCTL_TWEIO_SET_PARAM; extern unsigned IOCTL_TWEIO_GET_PARAM; extern unsigned IOCTL_TWEIO_RESET; extern unsigned IOCTL_TWEIO_ADD_UNIT; extern unsigned IOCTL_TWEIO_DEL_UNIT; extern unsigned IOCTL_SIOCSCNWDOMAIN; extern unsigned IOCTL_SIOCGCNWDOMAIN; extern unsigned IOCTL_SIOCSCNWKEY; extern unsigned IOCTL_SIOCGCNWSTATUS; extern unsigned IOCTL_SIOCGCNWSTATS; extern unsigned IOCTL_SIOCGCNWTRAIL; extern unsigned IOCTL_SIOCGRAYSIGLEV; extern unsigned IOCTL_RAIDFRAME_SHUTDOWN; extern unsigned IOCTL_RAIDFRAME_TUR; extern unsigned IOCTL_RAIDFRAME_FAIL_DISK; extern unsigned IOCTL_RAIDFRAME_CHECK_RECON_STATUS; extern unsigned IOCTL_RAIDFRAME_REWRITEPARITY; extern unsigned IOCTL_RAIDFRAME_COPYBACK; extern unsigned IOCTL_RAIDFRAME_SPARET_WAIT; extern unsigned IOCTL_RAIDFRAME_SEND_SPARET; extern unsigned IOCTL_RAIDFRAME_ABORT_SPARET_WAIT; extern unsigned IOCTL_RAIDFRAME_START_ATRACE; extern unsigned IOCTL_RAIDFRAME_STOP_ATRACE; extern unsigned IOCTL_RAIDFRAME_GET_SIZE; extern unsigned IOCTL_RAIDFRAME_RESET_ACCTOTALS; extern unsigned IOCTL_RAIDFRAME_KEEP_ACCTOTALS; extern unsigned IOCTL_RAIDFRAME_GET_COMPONENT_LABEL; extern unsigned IOCTL_RAIDFRAME_SET_COMPONENT_LABEL; extern unsigned IOCTL_RAIDFRAME_INIT_LABELS; extern unsigned IOCTL_RAIDFRAME_ADD_HOT_SPARE; extern unsigned IOCTL_RAIDFRAME_REMOVE_HOT_SPARE; extern unsigned IOCTL_RAIDFRAME_REBUILD_IN_PLACE; extern unsigned IOCTL_RAIDFRAME_CHECK_PARITY; extern unsigned IOCTL_RAIDFRAME_CHECK_PARITYREWRITE_STATUS; extern unsigned IOCTL_RAIDFRAME_CHECK_COPYBACK_STATUS; extern unsigned IOCTL_RAIDFRAME_SET_AUTOCONFIG; extern unsigned IOCTL_RAIDFRAME_SET_ROOT; extern unsigned IOCTL_RAIDFRAME_DELETE_COMPONENT; extern unsigned IOCTL_RAIDFRAME_INCORPORATE_HOT_SPARE; extern unsigned IOCTL_RAIDFRAME_CHECK_RECON_STATUS_EXT; extern unsigned IOCTL_RAIDFRAME_CHECK_PARITYREWRITE_STATUS_EXT; extern unsigned IOCTL_RAIDFRAME_CHECK_COPYBACK_STATUS_EXT; extern unsigned IOCTL_RAIDFRAME_CONFIGURE; extern unsigned IOCTL_RAIDFRAME_GET_INFO; extern unsigned IOCTL_RAIDFRAME_PARITYMAP_STATUS; extern unsigned IOCTL_RAIDFRAME_PARITYMAP_GET_DISABLE; extern unsigned IOCTL_RAIDFRAME_PARITYMAP_SET_DISABLE; extern unsigned IOCTL_RAIDFRAME_PARITYMAP_SET_PARAMS; extern unsigned IOCTL_RAIDFRAME_SET_LAST_UNIT; extern unsigned IOCTL_MBPPIOCSPARAM; extern unsigned IOCTL_MBPPIOCGPARAM; extern unsigned IOCTL_MBPPIOCGSTAT; extern unsigned IOCTL_SESIOC_GETNOBJ; extern unsigned IOCTL_SESIOC_GETOBJMAP; extern unsigned IOCTL_SESIOC_GETENCSTAT; extern unsigned IOCTL_SESIOC_SETENCSTAT; extern unsigned IOCTL_SESIOC_GETOBJSTAT; extern unsigned IOCTL_SESIOC_SETOBJSTAT; extern unsigned IOCTL_SESIOC_GETTEXT; extern unsigned IOCTL_SESIOC_INIT; extern unsigned IOCTL_SUN_DKIOCGGEOM; extern unsigned IOCTL_SUN_DKIOCINFO; extern unsigned IOCTL_SUN_DKIOCGPART; extern unsigned IOCTL_FBIOGTYPE; extern unsigned IOCTL_FBIOPUTCMAP; extern unsigned IOCTL_FBIOGETCMAP; extern unsigned IOCTL_FBIOGATTR; extern unsigned IOCTL_FBIOSVIDEO; extern unsigned IOCTL_FBIOGVIDEO; extern unsigned IOCTL_FBIOSCURSOR; extern unsigned IOCTL_FBIOGCURSOR; extern unsigned IOCTL_FBIOSCURPOS; extern unsigned IOCTL_FBIOGCURPOS; extern unsigned IOCTL_FBIOGCURMAX; extern unsigned IOCTL_KIOCTRANS; extern unsigned IOCTL_KIOCSETKEY; extern unsigned IOCTL_KIOCGETKEY; extern unsigned IOCTL_KIOCGTRANS; extern unsigned IOCTL_KIOCCMD; extern unsigned IOCTL_KIOCTYPE; extern unsigned IOCTL_KIOCSDIRECT; extern unsigned IOCTL_KIOCSKEY; extern unsigned IOCTL_KIOCGKEY; extern unsigned IOCTL_KIOCSLED; extern unsigned IOCTL_KIOCGLED; extern unsigned IOCTL_KIOCLAYOUT; extern unsigned IOCTL_VUIDSFORMAT; extern unsigned IOCTL_VUIDGFORMAT; extern unsigned IOCTL_STICIO_GXINFO; extern unsigned IOCTL_STICIO_RESET; extern unsigned IOCTL_STICIO_STARTQ; extern unsigned IOCTL_STICIO_STOPQ; extern unsigned IOCTL_UKYOPON_IDENTIFY; extern unsigned IOCTL_URIO_SEND_COMMAND; extern unsigned IOCTL_URIO_RECV_COMMAND; extern unsigned IOCTL_USB_REQUEST; extern unsigned IOCTL_USB_SETDEBUG; extern unsigned IOCTL_USB_DISCOVER; extern unsigned IOCTL_USB_DEVICEINFO; extern unsigned IOCTL_USB_DEVICEINFO_OLD; extern unsigned IOCTL_USB_DEVICESTATS; extern unsigned IOCTL_USB_GET_REPORT_DESC; extern unsigned IOCTL_USB_SET_IMMED; extern unsigned IOCTL_USB_GET_REPORT; extern unsigned IOCTL_USB_SET_REPORT; extern unsigned IOCTL_USB_GET_REPORT_ID; extern unsigned IOCTL_USB_GET_CONFIG; extern unsigned IOCTL_USB_SET_CONFIG; extern unsigned IOCTL_USB_GET_ALTINTERFACE; extern unsigned IOCTL_USB_SET_ALTINTERFACE; extern unsigned IOCTL_USB_GET_NO_ALT; extern unsigned IOCTL_USB_GET_DEVICE_DESC; extern unsigned IOCTL_USB_GET_CONFIG_DESC; extern unsigned IOCTL_USB_GET_INTERFACE_DESC; extern unsigned IOCTL_USB_GET_ENDPOINT_DESC; extern unsigned IOCTL_USB_GET_FULL_DESC; extern unsigned IOCTL_USB_GET_STRING_DESC; extern unsigned IOCTL_USB_DO_REQUEST; extern unsigned IOCTL_USB_GET_DEVICEINFO; extern unsigned IOCTL_USB_GET_DEVICEINFO_OLD; extern unsigned IOCTL_USB_SET_SHORT_XFER; extern unsigned IOCTL_USB_SET_TIMEOUT; extern unsigned IOCTL_USB_SET_BULK_RA; extern unsigned IOCTL_USB_SET_BULK_WB; extern unsigned IOCTL_USB_SET_BULK_RA_OPT; extern unsigned IOCTL_USB_SET_BULK_WB_OPT; extern unsigned IOCTL_USB_GET_CM_OVER_DATA; extern unsigned IOCTL_USB_SET_CM_OVER_DATA; extern unsigned IOCTL_UTOPPYIOTURBO; extern unsigned IOCTL_UTOPPYIOCANCEL; extern unsigned IOCTL_UTOPPYIOREBOOT; extern unsigned IOCTL_UTOPPYIOSTATS; extern unsigned IOCTL_UTOPPYIORENAME; extern unsigned IOCTL_UTOPPYIOMKDIR; extern unsigned IOCTL_UTOPPYIODELETE; extern unsigned IOCTL_UTOPPYIOREADDIR; extern unsigned IOCTL_UTOPPYIOREADFILE; extern unsigned IOCTL_UTOPPYIOWRITEFILE; extern unsigned IOCTL_DIOSXDCMD; extern unsigned IOCTL_VT_OPENQRY; extern unsigned IOCTL_VT_SETMODE; extern unsigned IOCTL_VT_GETMODE; extern unsigned IOCTL_VT_RELDISP; extern unsigned IOCTL_VT_ACTIVATE; extern unsigned IOCTL_VT_WAITACTIVE; extern unsigned IOCTL_VT_GETACTIVE; extern unsigned IOCTL_VT_GETSTATE; extern unsigned IOCTL_KDGETKBENT; extern unsigned IOCTL_KDGKBMODE; extern unsigned IOCTL_KDSKBMODE; extern unsigned IOCTL_KDMKTONE; extern unsigned IOCTL_KDSETMODE; extern unsigned IOCTL_KDENABIO; extern unsigned IOCTL_KDDISABIO; extern unsigned IOCTL_KDGKBTYPE; extern unsigned IOCTL_KDGETLED; extern unsigned IOCTL_KDSETLED; extern unsigned IOCTL_KDSETRAD; extern unsigned IOCTL_VGAPCVTID; extern unsigned IOCTL_CONS_GETVERS; extern unsigned IOCTL_WSKBDIO_GTYPE; extern unsigned IOCTL_WSKBDIO_BELL; extern unsigned IOCTL_WSKBDIO_COMPLEXBELL; extern unsigned IOCTL_WSKBDIO_SETBELL; extern unsigned IOCTL_WSKBDIO_GETBELL; extern unsigned IOCTL_WSKBDIO_SETDEFAULTBELL; extern unsigned IOCTL_WSKBDIO_GETDEFAULTBELL; extern unsigned IOCTL_WSKBDIO_SETKEYREPEAT; extern unsigned IOCTL_WSKBDIO_GETKEYREPEAT; extern unsigned IOCTL_WSKBDIO_SETDEFAULTKEYREPEAT; extern unsigned IOCTL_WSKBDIO_GETDEFAULTKEYREPEAT; extern unsigned IOCTL_WSKBDIO_SETLEDS; extern unsigned IOCTL_WSKBDIO_GETLEDS; extern unsigned IOCTL_WSKBDIO_GETMAP; extern unsigned IOCTL_WSKBDIO_SETMAP; extern unsigned IOCTL_WSKBDIO_GETENCODING; extern unsigned IOCTL_WSKBDIO_SETENCODING; extern unsigned IOCTL_WSKBDIO_SETMODE; extern unsigned IOCTL_WSKBDIO_GETMODE; extern unsigned IOCTL_WSKBDIO_SETKEYCLICK; extern unsigned IOCTL_WSKBDIO_GETKEYCLICK; extern unsigned IOCTL_WSKBDIO_GETSCROLL; extern unsigned IOCTL_WSKBDIO_SETSCROLL; extern unsigned IOCTL_WSKBDIO_SETVERSION; extern unsigned IOCTL_WSMOUSEIO_GTYPE; extern unsigned IOCTL_WSMOUSEIO_SRES; extern unsigned IOCTL_WSMOUSEIO_SSCALE; extern unsigned IOCTL_WSMOUSEIO_SRATE; extern unsigned IOCTL_WSMOUSEIO_SCALIBCOORDS; extern unsigned IOCTL_WSMOUSEIO_GCALIBCOORDS; extern unsigned IOCTL_WSMOUSEIO_GETID; extern unsigned IOCTL_WSMOUSEIO_GETREPEAT; extern unsigned IOCTL_WSMOUSEIO_SETREPEAT; extern unsigned IOCTL_WSMOUSEIO_SETVERSION; extern unsigned IOCTL_WSDISPLAYIO_GTYPE; extern unsigned IOCTL_WSDISPLAYIO_GINFO; extern unsigned IOCTL_WSDISPLAYIO_GETCMAP; extern unsigned IOCTL_WSDISPLAYIO_PUTCMAP; extern unsigned IOCTL_WSDISPLAYIO_GVIDEO; extern unsigned IOCTL_WSDISPLAYIO_SVIDEO; extern unsigned IOCTL_WSDISPLAYIO_GCURPOS; extern unsigned IOCTL_WSDISPLAYIO_SCURPOS; extern unsigned IOCTL_WSDISPLAYIO_GCURMAX; extern unsigned IOCTL_WSDISPLAYIO_GCURSOR; extern unsigned IOCTL_WSDISPLAYIO_SCURSOR; extern unsigned IOCTL_WSDISPLAYIO_GMODE; extern unsigned IOCTL_WSDISPLAYIO_SMODE; extern unsigned IOCTL_WSDISPLAYIO_LDFONT; extern unsigned IOCTL_WSDISPLAYIO_ADDSCREEN; extern unsigned IOCTL_WSDISPLAYIO_DELSCREEN; extern unsigned IOCTL_WSDISPLAYIO_SFONT; extern unsigned IOCTL__O_WSDISPLAYIO_SETKEYBOARD; extern unsigned IOCTL_WSDISPLAYIO_GETPARAM; extern unsigned IOCTL_WSDISPLAYIO_SETPARAM; extern unsigned IOCTL_WSDISPLAYIO_GETACTIVESCREEN; extern unsigned IOCTL_WSDISPLAYIO_GETWSCHAR; extern unsigned IOCTL_WSDISPLAYIO_PUTWSCHAR; extern unsigned IOCTL_WSDISPLAYIO_DGSCROLL; extern unsigned IOCTL_WSDISPLAYIO_DSSCROLL; extern unsigned IOCTL_WSDISPLAYIO_GMSGATTRS; extern unsigned IOCTL_WSDISPLAYIO_SMSGATTRS; extern unsigned IOCTL_WSDISPLAYIO_GBORDER; extern unsigned IOCTL_WSDISPLAYIO_SBORDER; extern unsigned IOCTL_WSDISPLAYIO_SSPLASH; extern unsigned IOCTL_WSDISPLAYIO_SPROGRESS; extern unsigned IOCTL_WSDISPLAYIO_LINEBYTES; extern unsigned IOCTL_WSDISPLAYIO_SETVERSION; extern unsigned IOCTL_WSMUXIO_ADD_DEVICE; extern unsigned IOCTL_WSMUXIO_REMOVE_DEVICE; extern unsigned IOCTL_WSMUXIO_LIST_DEVICES; extern unsigned IOCTL_WSMUXIO_INJECTEVENT; extern unsigned IOCTL_WSDISPLAYIO_GET_BUSID; extern unsigned IOCTL_WSDISPLAYIO_GET_EDID; extern unsigned IOCTL_WSDISPLAYIO_SET_POLLING; extern unsigned IOCTL_WSDISPLAYIO_GET_FBINFO; extern unsigned IOCTL_WSDISPLAYIO_DOBLIT; extern unsigned IOCTL_WSDISPLAYIO_WAITBLIT; extern unsigned IOCTL_BIOCLOCATE; extern unsigned IOCTL_BIOCINQ; extern unsigned IOCTL_BIOCDISK_NOVOL; extern unsigned IOCTL_BIOCDISK; extern unsigned IOCTL_BIOCVOL; extern unsigned IOCTL_BIOCALARM; extern unsigned IOCTL_BIOCBLINK; extern unsigned IOCTL_BIOCSETSTATE; extern unsigned IOCTL_BIOCVOLOPS; extern unsigned IOCTL_MD_GETCONF; extern unsigned IOCTL_MD_SETCONF; extern unsigned IOCTL_CCDIOCSET; extern unsigned IOCTL_CCDIOCCLR; extern unsigned IOCTL_CGDIOCSET; extern unsigned IOCTL_CGDIOCCLR; extern unsigned IOCTL_CGDIOCGET; extern unsigned IOCTL_FSSIOCSET; extern unsigned IOCTL_FSSIOCGET; extern unsigned IOCTL_FSSIOCCLR; extern unsigned IOCTL_FSSIOFSET; extern unsigned IOCTL_FSSIOFGET; extern unsigned IOCTL_BTDEV_ATTACH; extern unsigned IOCTL_BTDEV_DETACH; extern unsigned IOCTL_BTSCO_GETINFO; extern unsigned IOCTL_KTTCP_IO_SEND; extern unsigned IOCTL_KTTCP_IO_RECV; extern unsigned IOCTL_IOC_LOCKSTAT_GVERSION; extern unsigned IOCTL_IOC_LOCKSTAT_ENABLE; extern unsigned IOCTL_IOC_LOCKSTAT_DISABLE; extern unsigned IOCTL_VNDIOCSET; extern unsigned IOCTL_VNDIOCCLR; extern unsigned IOCTL_VNDIOCGET; extern unsigned IOCTL_SPKRTONE; extern unsigned IOCTL_SPKRTUNE; extern unsigned IOCTL_SPKRGETVOL; extern unsigned IOCTL_SPKRSETVOL; -#if 0 /* interfaces are WIP */ +#if defined(__x86_64__) extern unsigned IOCTL_NVMM_IOC_CAPABILITY; extern unsigned IOCTL_NVMM_IOC_MACHINE_CREATE; extern unsigned IOCTL_NVMM_IOC_MACHINE_DESTROY; extern unsigned IOCTL_NVMM_IOC_MACHINE_CONFIGURE; extern unsigned IOCTL_NVMM_IOC_VCPU_CREATE; extern unsigned IOCTL_NVMM_IOC_VCPU_DESTROY; extern unsigned IOCTL_NVMM_IOC_VCPU_SETSTATE; extern unsigned IOCTL_NVMM_IOC_VCPU_GETSTATE; extern unsigned IOCTL_NVMM_IOC_VCPU_INJECT; extern unsigned IOCTL_NVMM_IOC_VCPU_RUN; extern unsigned IOCTL_NVMM_IOC_GPA_MAP; extern unsigned IOCTL_NVMM_IOC_GPA_UNMAP; extern unsigned IOCTL_NVMM_IOC_HVA_MAP; extern unsigned IOCTL_NVMM_IOC_HVA_UNMAP; +extern unsigned IOCTL_NVMM_IOC_CTL; #endif extern unsigned IOCTL_AUTOFSREQUEST; extern unsigned IOCTL_AUTOFSDONE; extern unsigned IOCTL_BIOCGBLEN; extern unsigned IOCTL_BIOCSBLEN; extern unsigned IOCTL_BIOCSETF; extern unsigned IOCTL_BIOCFLUSH; extern unsigned IOCTL_BIOCPROMISC; extern unsigned IOCTL_BIOCGDLT; extern unsigned IOCTL_BIOCGETIF; extern unsigned IOCTL_BIOCSETIF; extern unsigned IOCTL_BIOCGSTATS; extern unsigned IOCTL_BIOCGSTATSOLD; extern unsigned IOCTL_BIOCIMMEDIATE; extern unsigned IOCTL_BIOCVERSION; extern unsigned IOCTL_BIOCSTCPF; extern unsigned IOCTL_BIOCSUDPF; extern unsigned IOCTL_BIOCGHDRCMPLT; extern unsigned IOCTL_BIOCSHDRCMPLT; extern unsigned IOCTL_BIOCSDLT; extern unsigned IOCTL_BIOCGDLTLIST; extern unsigned IOCTL_BIOCGDIRECTION; extern unsigned IOCTL_BIOCSDIRECTION; extern unsigned IOCTL_BIOCSRTIMEOUT; extern unsigned IOCTL_BIOCGRTIMEOUT; extern unsigned IOCTL_BIOCGFEEDBACK; extern unsigned IOCTL_BIOCSFEEDBACK; extern unsigned IOCTL_GRESADDRS; extern unsigned IOCTL_GRESADDRD; extern unsigned IOCTL_GREGADDRS; extern unsigned IOCTL_GREGADDRD; extern unsigned IOCTL_GRESPROTO; extern unsigned IOCTL_GREGPROTO; extern unsigned IOCTL_GRESSOCK; extern unsigned IOCTL_GREDSOCK; extern unsigned IOCTL_PPPIOCGRAWIN; extern unsigned IOCTL_PPPIOCGFLAGS; extern unsigned IOCTL_PPPIOCSFLAGS; extern unsigned IOCTL_PPPIOCGASYNCMAP; extern unsigned IOCTL_PPPIOCSASYNCMAP; extern unsigned IOCTL_PPPIOCGUNIT; extern unsigned IOCTL_PPPIOCGRASYNCMAP; extern unsigned IOCTL_PPPIOCSRASYNCMAP; extern unsigned IOCTL_PPPIOCGMRU; extern unsigned IOCTL_PPPIOCSMRU; extern unsigned IOCTL_PPPIOCSMAXCID; extern unsigned IOCTL_PPPIOCGXASYNCMAP; extern unsigned IOCTL_PPPIOCSXASYNCMAP; extern unsigned IOCTL_PPPIOCXFERUNIT; extern unsigned IOCTL_PPPIOCSCOMPRESS; extern unsigned IOCTL_PPPIOCGNPMODE; extern unsigned IOCTL_PPPIOCSNPMODE; extern unsigned IOCTL_PPPIOCGIDLE; extern unsigned IOCTL_PPPIOCGMTU; extern unsigned IOCTL_PPPIOCSMTU; extern unsigned IOCTL_SIOCGPPPSTATS; extern unsigned IOCTL_SIOCGPPPCSTATS; extern unsigned IOCTL_IOC_NPF_VERSION; extern unsigned IOCTL_IOC_NPF_SWITCH; extern unsigned IOCTL_IOC_NPF_LOAD; extern unsigned IOCTL_IOC_NPF_TABLE; extern unsigned IOCTL_IOC_NPF_STATS; extern unsigned IOCTL_IOC_NPF_SAVE; extern unsigned IOCTL_IOC_NPF_RULE; extern unsigned IOCTL_IOC_NPF_CONN_LOOKUP; extern unsigned IOCTL_PPPOESETPARMS; extern unsigned IOCTL_PPPOEGETPARMS; extern unsigned IOCTL_PPPOEGETSESSION; extern unsigned IOCTL_SPPPGETAUTHCFG; extern unsigned IOCTL_SPPPSETAUTHCFG; extern unsigned IOCTL_SPPPGETLCPCFG; extern unsigned IOCTL_SPPPSETLCPCFG; extern unsigned IOCTL_SPPPGETSTATUS; extern unsigned IOCTL_SPPPGETSTATUSNCP; extern unsigned IOCTL_SPPPGETIDLETO; extern unsigned IOCTL_SPPPSETIDLETO; extern unsigned IOCTL_SPPPGETAUTHFAILURES; extern unsigned IOCTL_SPPPSETAUTHFAILURE; extern unsigned IOCTL_SPPPSETDNSOPTS; extern unsigned IOCTL_SPPPGETDNSOPTS; extern unsigned IOCTL_SPPPGETDNSADDRS; extern unsigned IOCTL_SPPPSETKEEPALIVE; extern unsigned IOCTL_SPPPGETKEEPALIVE; extern unsigned IOCTL_SRT_GETNRT; extern unsigned IOCTL_SRT_GETRT; extern unsigned IOCTL_SRT_SETRT; extern unsigned IOCTL_SRT_DELRT; extern unsigned IOCTL_SRT_SFLAGS; extern unsigned IOCTL_SRT_GFLAGS; extern unsigned IOCTL_SRT_SGFLAGS; extern unsigned IOCTL_SRT_DEBUG; extern unsigned IOCTL_TAPGIFNAME; extern unsigned IOCTL_TUNSDEBUG; extern unsigned IOCTL_TUNGDEBUG; extern unsigned IOCTL_TUNSIFMODE; extern unsigned IOCTL_TUNSLMODE; extern unsigned IOCTL_TUNSIFHEAD; extern unsigned IOCTL_TUNGIFHEAD; extern unsigned IOCTL_DIOCSTART; extern unsigned IOCTL_DIOCSTOP; extern unsigned IOCTL_DIOCADDRULE; extern unsigned IOCTL_DIOCGETRULES; extern unsigned IOCTL_DIOCGETRULE; extern unsigned IOCTL_DIOCSETLCK; extern unsigned IOCTL_DIOCCLRSTATES; extern unsigned IOCTL_DIOCGETSTATE; extern unsigned IOCTL_DIOCSETSTATUSIF; extern unsigned IOCTL_DIOCGETSTATUS; extern unsigned IOCTL_DIOCCLRSTATUS; extern unsigned IOCTL_DIOCNATLOOK; extern unsigned IOCTL_DIOCSETDEBUG; extern unsigned IOCTL_DIOCGETSTATES; extern unsigned IOCTL_DIOCCHANGERULE; extern unsigned IOCTL_DIOCSETTIMEOUT; extern unsigned IOCTL_DIOCGETTIMEOUT; extern unsigned IOCTL_DIOCADDSTATE; extern unsigned IOCTL_DIOCCLRRULECTRS; extern unsigned IOCTL_DIOCGETLIMIT; extern unsigned IOCTL_DIOCSETLIMIT; extern unsigned IOCTL_DIOCKILLSTATES; extern unsigned IOCTL_DIOCSTARTALTQ; extern unsigned IOCTL_DIOCSTOPALTQ; extern unsigned IOCTL_DIOCADDALTQ; extern unsigned IOCTL_DIOCGETALTQS; extern unsigned IOCTL_DIOCGETALTQ; extern unsigned IOCTL_DIOCCHANGEALTQ; extern unsigned IOCTL_DIOCGETQSTATS; extern unsigned IOCTL_DIOCBEGINADDRS; extern unsigned IOCTL_DIOCADDADDR; extern unsigned IOCTL_DIOCGETADDRS; extern unsigned IOCTL_DIOCGETADDR; extern unsigned IOCTL_DIOCCHANGEADDR; extern unsigned IOCTL_DIOCADDSTATES; extern unsigned IOCTL_DIOCGETRULESETS; extern unsigned IOCTL_DIOCGETRULESET; extern unsigned IOCTL_DIOCRCLRTABLES; extern unsigned IOCTL_DIOCRADDTABLES; extern unsigned IOCTL_DIOCRDELTABLES; extern unsigned IOCTL_DIOCRGETTABLES; extern unsigned IOCTL_DIOCRGETTSTATS; extern unsigned IOCTL_DIOCRCLRTSTATS; extern unsigned IOCTL_DIOCRCLRADDRS; extern unsigned IOCTL_DIOCRADDADDRS; extern unsigned IOCTL_DIOCRDELADDRS; extern unsigned IOCTL_DIOCRSETADDRS; extern unsigned IOCTL_DIOCRGETADDRS; extern unsigned IOCTL_DIOCRGETASTATS; extern unsigned IOCTL_DIOCRCLRASTATS; extern unsigned IOCTL_DIOCRTSTADDRS; extern unsigned IOCTL_DIOCRSETTFLAGS; extern unsigned IOCTL_DIOCRINADEFINE; extern unsigned IOCTL_DIOCOSFPFLUSH; extern unsigned IOCTL_DIOCOSFPADD; extern unsigned IOCTL_DIOCOSFPGET; extern unsigned IOCTL_DIOCXBEGIN; extern unsigned IOCTL_DIOCXCOMMIT; extern unsigned IOCTL_DIOCXROLLBACK; extern unsigned IOCTL_DIOCGETSRCNODES; extern unsigned IOCTL_DIOCCLRSRCNODES; extern unsigned IOCTL_DIOCSETHOSTID; extern unsigned IOCTL_DIOCIGETIFACES; extern unsigned IOCTL_DIOCSETIFFLAG; extern unsigned IOCTL_DIOCCLRIFFLAG; extern unsigned IOCTL_DIOCKILLSRCNODES; extern unsigned IOCTL_SLIOCGUNIT; extern unsigned IOCTL_SIOCGBTINFO; extern unsigned IOCTL_SIOCGBTINFOA; extern unsigned IOCTL_SIOCNBTINFO; extern unsigned IOCTL_SIOCSBTFLAGS; extern unsigned IOCTL_SIOCSBTPOLICY; extern unsigned IOCTL_SIOCSBTPTYPE; extern unsigned IOCTL_SIOCGBTSTATS; extern unsigned IOCTL_SIOCZBTSTATS; extern unsigned IOCTL_SIOCBTDUMP; extern unsigned IOCTL_SIOCSBTSCOMTU; extern unsigned IOCTL_SIOCGBTFEAT; extern unsigned IOCTL_SIOCADNAT; extern unsigned IOCTL_SIOCRMNAT; extern unsigned IOCTL_SIOCGNATS; extern unsigned IOCTL_SIOCGNATL; extern unsigned IOCTL_SIOCPURGENAT; extern unsigned IOCTL_SIOCCONNECTX; extern unsigned IOCTL_SIOCCONNECTXDEL; extern unsigned IOCTL_SIOCSIFINFO_FLAGS; extern unsigned IOCTL_SIOCAADDRCTL_POLICY; extern unsigned IOCTL_SIOCDADDRCTL_POLICY; extern unsigned IOCTL_SMBIOC_OPENSESSION; extern unsigned IOCTL_SMBIOC_OPENSHARE; extern unsigned IOCTL_SMBIOC_REQUEST; extern unsigned IOCTL_SMBIOC_SETFLAGS; extern unsigned IOCTL_SMBIOC_LOOKUP; extern unsigned IOCTL_SMBIOC_READ; extern unsigned IOCTL_SMBIOC_WRITE; extern unsigned IOCTL_AGPIOC_INFO; extern unsigned IOCTL_AGPIOC_ACQUIRE; extern unsigned IOCTL_AGPIOC_RELEASE; extern unsigned IOCTL_AGPIOC_SETUP; extern unsigned IOCTL_AGPIOC_ALLOCATE; extern unsigned IOCTL_AGPIOC_DEALLOCATE; extern unsigned IOCTL_AGPIOC_BIND; extern unsigned IOCTL_AGPIOC_UNBIND; extern unsigned IOCTL_AUDIO_GETINFO; extern unsigned IOCTL_AUDIO_SETINFO; extern unsigned IOCTL_AUDIO_DRAIN; extern unsigned IOCTL_AUDIO_FLUSH; extern unsigned IOCTL_AUDIO_WSEEK; extern unsigned IOCTL_AUDIO_RERROR; extern unsigned IOCTL_AUDIO_GETDEV; extern unsigned IOCTL_AUDIO_GETENC; extern unsigned IOCTL_AUDIO_GETFD; extern unsigned IOCTL_AUDIO_SETFD; extern unsigned IOCTL_AUDIO_PERROR; extern unsigned IOCTL_AUDIO_GETIOFFS; extern unsigned IOCTL_AUDIO_GETOOFFS; extern unsigned IOCTL_AUDIO_GETPROPS; extern unsigned IOCTL_AUDIO_GETBUFINFO; extern unsigned IOCTL_AUDIO_SETCHAN; extern unsigned IOCTL_AUDIO_GETCHAN; +extern unsigned IOCTL_AUDIO_QUERYFORMAT; +extern unsigned IOCTL_AUDIO_GETFORMAT; +extern unsigned IOCTL_AUDIO_SETFORMAT; extern unsigned IOCTL_AUDIO_MIXER_READ; extern unsigned IOCTL_AUDIO_MIXER_WRITE; extern unsigned IOCTL_AUDIO_MIXER_DEVINFO; extern unsigned IOCTL_ATAIOCCOMMAND; extern unsigned IOCTL_ATABUSIOSCAN; extern unsigned IOCTL_ATABUSIORESET; extern unsigned IOCTL_ATABUSIODETACH; extern unsigned IOCTL_CDIOCPLAYTRACKS; extern unsigned IOCTL_CDIOCPLAYBLOCKS; extern unsigned IOCTL_CDIOCREADSUBCHANNEL; extern unsigned IOCTL_CDIOREADTOCHEADER; extern unsigned IOCTL_CDIOREADTOCENTRIES; extern unsigned IOCTL_CDIOREADMSADDR; extern unsigned IOCTL_CDIOCSETPATCH; extern unsigned IOCTL_CDIOCGETVOL; extern unsigned IOCTL_CDIOCSETVOL; extern unsigned IOCTL_CDIOCSETMONO; extern unsigned IOCTL_CDIOCSETSTEREO; extern unsigned IOCTL_CDIOCSETMUTE; extern unsigned IOCTL_CDIOCSETLEFT; extern unsigned IOCTL_CDIOCSETRIGHT; extern unsigned IOCTL_CDIOCSETDEBUG; extern unsigned IOCTL_CDIOCCLRDEBUG; extern unsigned IOCTL_CDIOCPAUSE; extern unsigned IOCTL_CDIOCRESUME; extern unsigned IOCTL_CDIOCRESET; extern unsigned IOCTL_CDIOCSTART; extern unsigned IOCTL_CDIOCSTOP; extern unsigned IOCTL_CDIOCEJECT; extern unsigned IOCTL_CDIOCALLOW; extern unsigned IOCTL_CDIOCPREVENT; extern unsigned IOCTL_CDIOCCLOSE; extern unsigned IOCTL_CDIOCPLAYMSF; extern unsigned IOCTL_CDIOCLOADUNLOAD; extern unsigned IOCTL_CHIOMOVE; extern unsigned IOCTL_CHIOEXCHANGE; extern unsigned IOCTL_CHIOPOSITION; extern unsigned IOCTL_CHIOGPICKER; extern unsigned IOCTL_CHIOSPICKER; extern unsigned IOCTL_CHIOGPARAMS; extern unsigned IOCTL_CHIOIELEM; extern unsigned IOCTL_OCHIOGSTATUS; extern unsigned IOCTL_CHIOGSTATUS; extern unsigned IOCTL_CHIOSVOLTAG; extern unsigned IOCTL_CLOCKCTL_SETTIMEOFDAY; extern unsigned IOCTL_CLOCKCTL_ADJTIME; extern unsigned IOCTL_CLOCKCTL_CLOCK_SETTIME; extern unsigned IOCTL_CLOCKCTL_NTP_ADJTIME; extern unsigned IOCTL_IOC_CPU_SETSTATE; extern unsigned IOCTL_IOC_CPU_GETSTATE; extern unsigned IOCTL_IOC_CPU_GETCOUNT; extern unsigned IOCTL_IOC_CPU_MAPID; extern unsigned IOCTL_IOC_CPU_UCODE_GET_VERSION; extern unsigned IOCTL_IOC_CPU_UCODE_APPLY; extern unsigned IOCTL_DIOCGDINFO; extern unsigned IOCTL_DIOCSDINFO; extern unsigned IOCTL_DIOCWDINFO; extern unsigned IOCTL_DIOCRFORMAT; extern unsigned IOCTL_DIOCWFORMAT; extern unsigned IOCTL_DIOCSSTEP; extern unsigned IOCTL_DIOCSRETRIES; extern unsigned IOCTL_DIOCKLABEL; extern unsigned IOCTL_DIOCWLABEL; extern unsigned IOCTL_DIOCSBAD; extern unsigned IOCTL_DIOCEJECT; extern unsigned IOCTL_ODIOCEJECT; extern unsigned IOCTL_DIOCLOCK; extern unsigned IOCTL_DIOCGDEFLABEL; extern unsigned IOCTL_DIOCCLRLABEL; extern unsigned IOCTL_DIOCGCACHE; extern unsigned IOCTL_DIOCSCACHE; extern unsigned IOCTL_DIOCCACHESYNC; extern unsigned IOCTL_DIOCBSLIST; extern unsigned IOCTL_DIOCBSFLUSH; extern unsigned IOCTL_DIOCAWEDGE; extern unsigned IOCTL_DIOCGWEDGEINFO; extern unsigned IOCTL_DIOCDWEDGE; extern unsigned IOCTL_DIOCLWEDGES; extern unsigned IOCTL_DIOCGSTRATEGY; extern unsigned IOCTL_DIOCSSTRATEGY; extern unsigned IOCTL_DIOCGDISKINFO; extern unsigned IOCTL_DIOCTUR; extern unsigned IOCTL_DIOCMWEDGES; extern unsigned IOCTL_DIOCGSECTORSIZE; extern unsigned IOCTL_DIOCGMEDIASIZE; +extern unsigned IOCTL_DIOCRMWEDGES; extern unsigned IOCTL_DRVDETACHDEV; extern unsigned IOCTL_DRVRESCANBUS; extern unsigned IOCTL_DRVCTLCOMMAND; extern unsigned IOCTL_DRVRESUMEDEV; extern unsigned IOCTL_DRVLISTDEV; extern unsigned IOCTL_DRVGETEVENT; extern unsigned IOCTL_DRVSUSPENDDEV; extern unsigned IOCTL_DVD_READ_STRUCT; extern unsigned IOCTL_DVD_WRITE_STRUCT; extern unsigned IOCTL_DVD_AUTH; extern unsigned IOCTL_ENVSYS_GETDICTIONARY; extern unsigned IOCTL_ENVSYS_SETDICTIONARY; extern unsigned IOCTL_ENVSYS_REMOVEPROPS; extern unsigned IOCTL_ENVSYS_GTREDATA; extern unsigned IOCTL_ENVSYS_GTREINFO; extern unsigned IOCTL_KFILTER_BYFILTER; extern unsigned IOCTL_KFILTER_BYNAME; extern unsigned IOCTL_FDIOCGETOPTS; extern unsigned IOCTL_FDIOCSETOPTS; extern unsigned IOCTL_FDIOCSETFORMAT; extern unsigned IOCTL_FDIOCGETFORMAT; extern unsigned IOCTL_FDIOCFORMAT_TRACK; extern unsigned IOCTL_FIOCLEX; extern unsigned IOCTL_FIONCLEX; extern unsigned IOCTL_FIOSEEKDATA; extern unsigned IOCTL_FIOSEEKHOLE; extern unsigned IOCTL_FIONREAD; extern unsigned IOCTL_FIONBIO; extern unsigned IOCTL_FIOASYNC; extern unsigned IOCTL_FIOSETOWN; extern unsigned IOCTL_FIOGETOWN; extern unsigned IOCTL_OFIOGETBMAP; extern unsigned IOCTL_FIOGETBMAP; extern unsigned IOCTL_FIONWRITE; extern unsigned IOCTL_FIONSPACE; extern unsigned IOCTL_GPIOINFO; extern unsigned IOCTL_GPIOSET; extern unsigned IOCTL_GPIOUNSET; extern unsigned IOCTL_GPIOREAD; extern unsigned IOCTL_GPIOWRITE; extern unsigned IOCTL_GPIOTOGGLE; extern unsigned IOCTL_GPIOATTACH; extern unsigned IOCTL_PTIOCNETBSD; extern unsigned IOCTL_PTIOCSUNOS; extern unsigned IOCTL_PTIOCLINUX; extern unsigned IOCTL_PTIOCFREEBSD; extern unsigned IOCTL_PTIOCULTRIX; extern unsigned IOCTL_TIOCHPCL; extern unsigned IOCTL_TIOCGETP; extern unsigned IOCTL_TIOCSETP; extern unsigned IOCTL_TIOCSETN; extern unsigned IOCTL_TIOCSETC; extern unsigned IOCTL_TIOCGETC; extern unsigned IOCTL_TIOCLBIS; extern unsigned IOCTL_TIOCLBIC; extern unsigned IOCTL_TIOCLSET; extern unsigned IOCTL_TIOCLGET; extern unsigned IOCTL_TIOCSLTC; extern unsigned IOCTL_TIOCGLTC; extern unsigned IOCTL_OTIOCCONS; extern unsigned IOCTL_JOY_SETTIMEOUT; extern unsigned IOCTL_JOY_GETTIMEOUT; extern unsigned IOCTL_JOY_SET_X_OFFSET; extern unsigned IOCTL_JOY_SET_Y_OFFSET; extern unsigned IOCTL_JOY_GET_X_OFFSET; extern unsigned IOCTL_JOY_GET_Y_OFFSET; extern unsigned IOCTL_OKIOCGSYMBOL; extern unsigned IOCTL_OKIOCGVALUE; extern unsigned IOCTL_KIOCGSIZE; extern unsigned IOCTL_KIOCGVALUE; extern unsigned IOCTL_KIOCGSYMBOL; extern unsigned IOCTL_LUAINFO; extern unsigned IOCTL_LUACREATE; extern unsigned IOCTL_LUADESTROY; extern unsigned IOCTL_LUAREQUIRE; extern unsigned IOCTL_LUALOAD; extern unsigned IOCTL_MIDI_PRETIME; extern unsigned IOCTL_MIDI_MPUMODE; extern unsigned IOCTL_MIDI_MPUCMD; extern unsigned IOCTL_SEQUENCER_RESET; extern unsigned IOCTL_SEQUENCER_SYNC; extern unsigned IOCTL_SEQUENCER_INFO; extern unsigned IOCTL_SEQUENCER_CTRLRATE; extern unsigned IOCTL_SEQUENCER_GETOUTCOUNT; extern unsigned IOCTL_SEQUENCER_GETINCOUNT; extern unsigned IOCTL_SEQUENCER_RESETSAMPLES; extern unsigned IOCTL_SEQUENCER_NRSYNTHS; extern unsigned IOCTL_SEQUENCER_NRMIDIS; extern unsigned IOCTL_SEQUENCER_THRESHOLD; extern unsigned IOCTL_SEQUENCER_MEMAVL; extern unsigned IOCTL_SEQUENCER_PANIC; extern unsigned IOCTL_SEQUENCER_OUTOFBAND; extern unsigned IOCTL_SEQUENCER_GETTIME; extern unsigned IOCTL_SEQUENCER_TMR_TIMEBASE; extern unsigned IOCTL_SEQUENCER_TMR_START; extern unsigned IOCTL_SEQUENCER_TMR_STOP; extern unsigned IOCTL_SEQUENCER_TMR_CONTINUE; extern unsigned IOCTL_SEQUENCER_TMR_TEMPO; extern unsigned IOCTL_SEQUENCER_TMR_SOURCE; extern unsigned IOCTL_SEQUENCER_TMR_METRONOME; extern unsigned IOCTL_SEQUENCER_TMR_SELECT; +extern unsigned IOCTL_SPI_IOCTL_CONFIGURE; +extern unsigned IOCTL_SPI_IOCTL_TRANSFER; extern unsigned IOCTL_MTIOCTOP; extern unsigned IOCTL_MTIOCGET; extern unsigned IOCTL_MTIOCIEOT; extern unsigned IOCTL_MTIOCEEOT; extern unsigned IOCTL_MTIOCRDSPOS; extern unsigned IOCTL_MTIOCRDHPOS; extern unsigned IOCTL_MTIOCSLOCATE; extern unsigned IOCTL_MTIOCHLOCATE; extern unsigned IOCTL_POWER_EVENT_RECVDICT; extern unsigned IOCTL_POWER_IOC_GET_TYPE; extern unsigned IOCTL_RIOCGINFO; extern unsigned IOCTL_RIOCSINFO; extern unsigned IOCTL_RIOCSSRCH; extern unsigned IOCTL_RNDGETENTCNT; extern unsigned IOCTL_RNDGETSRCNUM; extern unsigned IOCTL_RNDGETSRCNAME; extern unsigned IOCTL_RNDCTL; extern unsigned IOCTL_RNDADDDATA; extern unsigned IOCTL_RNDGETPOOLSTAT; extern unsigned IOCTL_RNDGETESTNUM; extern unsigned IOCTL_RNDGETESTNAME; extern unsigned IOCTL_SCIOCGET; extern unsigned IOCTL_SCIOCSET; extern unsigned IOCTL_SCIOCRESTART; extern unsigned IOCTL_SCIOC_USE_ADF; extern unsigned IOCTL_SCIOCCOMMAND; extern unsigned IOCTL_SCIOCDEBUG; extern unsigned IOCTL_SCIOCIDENTIFY; extern unsigned IOCTL_OSCIOCIDENTIFY; extern unsigned IOCTL_SCIOCDECONFIG; extern unsigned IOCTL_SCIOCRECONFIG; extern unsigned IOCTL_SCIOCRESET; extern unsigned IOCTL_SCBUSIOSCAN; extern unsigned IOCTL_SCBUSIORESET; extern unsigned IOCTL_SCBUSIODETACH; extern unsigned IOCTL_SCBUSACCEL; extern unsigned IOCTL_SCBUSIOLLSCAN; extern unsigned IOCTL_SIOCSHIWAT; extern unsigned IOCTL_SIOCGHIWAT; extern unsigned IOCTL_SIOCSLOWAT; extern unsigned IOCTL_SIOCGLOWAT; extern unsigned IOCTL_SIOCATMARK; extern unsigned IOCTL_SIOCSPGRP; extern unsigned IOCTL_SIOCGPGRP; extern unsigned IOCTL_SIOCPEELOFF; extern unsigned IOCTL_SIOCADDRT; extern unsigned IOCTL_SIOCDELRT; extern unsigned IOCTL_SIOCSIFADDR; extern unsigned IOCTL_SIOCGIFADDR; extern unsigned IOCTL_SIOCSIFDSTADDR; extern unsigned IOCTL_SIOCGIFDSTADDR; extern unsigned IOCTL_SIOCSIFFLAGS; extern unsigned IOCTL_SIOCGIFFLAGS; extern unsigned IOCTL_SIOCGIFBRDADDR; extern unsigned IOCTL_SIOCSIFBRDADDR; extern unsigned IOCTL_SIOCGIFCONF; extern unsigned IOCTL_SIOCGIFNETMASK; extern unsigned IOCTL_SIOCSIFNETMASK; extern unsigned IOCTL_SIOCGIFMETRIC; extern unsigned IOCTL_SIOCSIFMETRIC; extern unsigned IOCTL_SIOCDIFADDR; extern unsigned IOCTL_SIOCAIFADDR; extern unsigned IOCTL_SIOCGIFALIAS; extern unsigned IOCTL_SIOCGIFAFLAG_IN; extern unsigned IOCTL_SIOCALIFADDR; extern unsigned IOCTL_SIOCGLIFADDR; extern unsigned IOCTL_SIOCDLIFADDR; extern unsigned IOCTL_SIOCSIFADDRPREF; extern unsigned IOCTL_SIOCGIFADDRPREF; extern unsigned IOCTL_SIOCADDMULTI; extern unsigned IOCTL_SIOCDELMULTI; extern unsigned IOCTL_SIOCGETVIFCNT; extern unsigned IOCTL_SIOCGETSGCNT; extern unsigned IOCTL_SIOCSIFMEDIA; extern unsigned IOCTL_SIOCGIFMEDIA; extern unsigned IOCTL_SIOCSIFGENERIC; extern unsigned IOCTL_SIOCGIFGENERIC; extern unsigned IOCTL_SIOCSIFPHYADDR; extern unsigned IOCTL_SIOCGIFPSRCADDR; extern unsigned IOCTL_SIOCGIFPDSTADDR; extern unsigned IOCTL_SIOCDIFPHYADDR; extern unsigned IOCTL_SIOCSLIFPHYADDR; extern unsigned IOCTL_SIOCGLIFPHYADDR; extern unsigned IOCTL_SIOCSIFMTU; extern unsigned IOCTL_SIOCGIFMTU; extern unsigned IOCTL_SIOCSDRVSPEC; extern unsigned IOCTL_SIOCGDRVSPEC; extern unsigned IOCTL_SIOCIFCREATE; extern unsigned IOCTL_SIOCIFDESTROY; extern unsigned IOCTL_SIOCIFGCLONERS; extern unsigned IOCTL_SIOCGIFDLT; extern unsigned IOCTL_SIOCGIFCAP; extern unsigned IOCTL_SIOCSIFCAP; extern unsigned IOCTL_SIOCSVH; extern unsigned IOCTL_SIOCGVH; extern unsigned IOCTL_SIOCINITIFADDR; extern unsigned IOCTL_SIOCGIFDATA; extern unsigned IOCTL_SIOCZIFDATA; extern unsigned IOCTL_SIOCGLINKSTR; extern unsigned IOCTL_SIOCSLINKSTR; extern unsigned IOCTL_SIOCGETHERCAP; extern unsigned IOCTL_SIOCGIFINDEX; extern unsigned IOCTL_SIOCSETHERCAP; +extern unsigned IOCTL_SIOCSIFDESCR; +extern unsigned IOCTL_SIOCGIFDESCR; extern unsigned IOCTL_SIOCGUMBINFO; extern unsigned IOCTL_SIOCSUMBPARAM; extern unsigned IOCTL_SIOCGUMBPARAM; extern unsigned IOCTL_SIOCSETPFSYNC; extern unsigned IOCTL_SIOCGETPFSYNC; extern unsigned IOCTL_PPS_IOC_CREATE; extern unsigned IOCTL_PPS_IOC_DESTROY; extern unsigned IOCTL_PPS_IOC_SETPARAMS; extern unsigned IOCTL_PPS_IOC_GETPARAMS; extern unsigned IOCTL_PPS_IOC_GETCAP; extern unsigned IOCTL_PPS_IOC_FETCH; extern unsigned IOCTL_PPS_IOC_KCBIND; extern unsigned IOCTL_TIOCEXCL; extern unsigned IOCTL_TIOCNXCL; extern unsigned IOCTL_TIOCFLUSH; extern unsigned IOCTL_TIOCGETA; extern unsigned IOCTL_TIOCSETA; extern unsigned IOCTL_TIOCSETAW; extern unsigned IOCTL_TIOCSETAF; extern unsigned IOCTL_TIOCGETD; extern unsigned IOCTL_TIOCSETD; extern unsigned IOCTL_TIOCGLINED; extern unsigned IOCTL_TIOCSLINED; extern unsigned IOCTL_TIOCSBRK; extern unsigned IOCTL_TIOCCBRK; extern unsigned IOCTL_TIOCSDTR; extern unsigned IOCTL_TIOCCDTR; extern unsigned IOCTL_TIOCGPGRP; extern unsigned IOCTL_TIOCSPGRP; extern unsigned IOCTL_TIOCOUTQ; extern unsigned IOCTL_TIOCSTI; extern unsigned IOCTL_TIOCNOTTY; extern unsigned IOCTL_TIOCPKT; extern unsigned IOCTL_TIOCSTOP; extern unsigned IOCTL_TIOCSTART; extern unsigned IOCTL_TIOCMSET; extern unsigned IOCTL_TIOCMBIS; extern unsigned IOCTL_TIOCMBIC; extern unsigned IOCTL_TIOCMGET; extern unsigned IOCTL_TIOCREMOTE; extern unsigned IOCTL_TIOCGWINSZ; extern unsigned IOCTL_TIOCSWINSZ; extern unsigned IOCTL_TIOCUCNTL; extern unsigned IOCTL_TIOCSTAT; extern unsigned IOCTL_TIOCGSID; extern unsigned IOCTL_TIOCCONS; extern unsigned IOCTL_TIOCSCTTY; extern unsigned IOCTL_TIOCEXT; extern unsigned IOCTL_TIOCSIG; extern unsigned IOCTL_TIOCDRAIN; extern unsigned IOCTL_TIOCGFLAGS; extern unsigned IOCTL_TIOCSFLAGS; extern unsigned IOCTL_TIOCDCDTIMESTAMP; extern unsigned IOCTL_TIOCRCVFRAME; extern unsigned IOCTL_TIOCXMTFRAME; extern unsigned IOCTL_TIOCPTMGET; extern unsigned IOCTL_TIOCGRANTPT; extern unsigned IOCTL_TIOCPTSNAME; extern unsigned IOCTL_TIOCSQSIZE; extern unsigned IOCTL_TIOCGQSIZE; extern unsigned IOCTL_VERIEXEC_LOAD; extern unsigned IOCTL_VERIEXEC_TABLESIZE; extern unsigned IOCTL_VERIEXEC_DELETE; extern unsigned IOCTL_VERIEXEC_QUERY; extern unsigned IOCTL_VERIEXEC_DUMP; extern unsigned IOCTL_VERIEXEC_FLUSH; extern unsigned IOCTL_VIDIOC_QUERYCAP; extern unsigned IOCTL_VIDIOC_RESERVED; extern unsigned IOCTL_VIDIOC_ENUM_FMT; extern unsigned IOCTL_VIDIOC_G_FMT; extern unsigned IOCTL_VIDIOC_S_FMT; extern unsigned IOCTL_VIDIOC_REQBUFS; extern unsigned IOCTL_VIDIOC_QUERYBUF; extern unsigned IOCTL_VIDIOC_G_FBUF; extern unsigned IOCTL_VIDIOC_S_FBUF; extern unsigned IOCTL_VIDIOC_OVERLAY; extern unsigned IOCTL_VIDIOC_QBUF; extern unsigned IOCTL_VIDIOC_DQBUF; extern unsigned IOCTL_VIDIOC_STREAMON; extern unsigned IOCTL_VIDIOC_STREAMOFF; extern unsigned IOCTL_VIDIOC_G_PARM; extern unsigned IOCTL_VIDIOC_S_PARM; extern unsigned IOCTL_VIDIOC_G_STD; extern unsigned IOCTL_VIDIOC_S_STD; extern unsigned IOCTL_VIDIOC_ENUMSTD; extern unsigned IOCTL_VIDIOC_ENUMINPUT; extern unsigned IOCTL_VIDIOC_G_CTRL; extern unsigned IOCTL_VIDIOC_S_CTRL; extern unsigned IOCTL_VIDIOC_G_TUNER; extern unsigned IOCTL_VIDIOC_S_TUNER; extern unsigned IOCTL_VIDIOC_G_AUDIO; extern unsigned IOCTL_VIDIOC_S_AUDIO; extern unsigned IOCTL_VIDIOC_QUERYCTRL; extern unsigned IOCTL_VIDIOC_QUERYMENU; extern unsigned IOCTL_VIDIOC_G_INPUT; extern unsigned IOCTL_VIDIOC_S_INPUT; extern unsigned IOCTL_VIDIOC_G_OUTPUT; extern unsigned IOCTL_VIDIOC_S_OUTPUT; extern unsigned IOCTL_VIDIOC_ENUMOUTPUT; extern unsigned IOCTL_VIDIOC_G_AUDOUT; extern unsigned IOCTL_VIDIOC_S_AUDOUT; extern unsigned IOCTL_VIDIOC_G_MODULATOR; extern unsigned IOCTL_VIDIOC_S_MODULATOR; extern unsigned IOCTL_VIDIOC_G_FREQUENCY; extern unsigned IOCTL_VIDIOC_S_FREQUENCY; extern unsigned IOCTL_VIDIOC_CROPCAP; extern unsigned IOCTL_VIDIOC_G_CROP; extern unsigned IOCTL_VIDIOC_S_CROP; extern unsigned IOCTL_VIDIOC_G_JPEGCOMP; extern unsigned IOCTL_VIDIOC_S_JPEGCOMP; extern unsigned IOCTL_VIDIOC_QUERYSTD; extern unsigned IOCTL_VIDIOC_TRY_FMT; extern unsigned IOCTL_VIDIOC_ENUMAUDIO; extern unsigned IOCTL_VIDIOC_ENUMAUDOUT; extern unsigned IOCTL_VIDIOC_G_PRIORITY; extern unsigned IOCTL_VIDIOC_S_PRIORITY; extern unsigned IOCTL_VIDIOC_ENUM_FRAMESIZES; extern unsigned IOCTL_VIDIOC_ENUM_FRAMEINTERVALS; extern unsigned IOCTL_WDOGIOC_GMODE; extern unsigned IOCTL_WDOGIOC_SMODE; extern unsigned IOCTL_WDOGIOC_WHICH; extern unsigned IOCTL_WDOGIOC_TICKLE; extern unsigned IOCTL_WDOGIOC_GTICKLER; extern unsigned IOCTL_WDOGIOC_GWDOGS; +extern unsigned IOCTL_KCOV_IOC_SETBUFSIZE; +extern unsigned IOCTL_KCOV_IOC_ENABLE; +extern unsigned IOCTL_KCOV_IOC_DISABLE; +extern unsigned IOCTL_IPMICTL_RECEIVE_MSG_TRUNC; +extern unsigned IOCTL_IPMICTL_RECEIVE_MSG; +extern unsigned IOCTL_IPMICTL_SEND_COMMAND; +extern unsigned IOCTL_IPMICTL_REGISTER_FOR_CMD; +extern unsigned IOCTL_IPMICTL_UNREGISTER_FOR_CMD; +extern unsigned IOCTL_IPMICTL_SET_GETS_EVENTS_CMD; +extern unsigned IOCTL_IPMICTL_SET_MY_ADDRESS_CMD; +extern unsigned IOCTL_IPMICTL_GET_MY_ADDRESS_CMD; +extern unsigned IOCTL_IPMICTL_SET_MY_LUN_CMD; +extern unsigned IOCTL_IPMICTL_GET_MY_LUN_CMD; extern unsigned IOCTL_SNDCTL_DSP_RESET; extern unsigned IOCTL_SNDCTL_DSP_SYNC; extern unsigned IOCTL_SNDCTL_DSP_SPEED; extern unsigned IOCTL_SOUND_PCM_READ_RATE; extern unsigned IOCTL_SNDCTL_DSP_STEREO; extern unsigned IOCTL_SNDCTL_DSP_GETBLKSIZE; extern unsigned IOCTL_SNDCTL_DSP_SETFMT; extern unsigned IOCTL_SOUND_PCM_READ_BITS; extern unsigned IOCTL_SNDCTL_DSP_CHANNELS; extern unsigned IOCTL_SOUND_PCM_READ_CHANNELS; extern unsigned IOCTL_SOUND_PCM_WRITE_FILTER; extern unsigned IOCTL_SOUND_PCM_READ_FILTER; extern unsigned IOCTL_SNDCTL_DSP_POST; extern unsigned IOCTL_SNDCTL_DSP_SUBDIVIDE; extern unsigned IOCTL_SNDCTL_DSP_SETFRAGMENT; extern unsigned IOCTL_SNDCTL_DSP_GETFMTS; extern unsigned IOCTL_SNDCTL_DSP_GETOSPACE; extern unsigned IOCTL_SNDCTL_DSP_GETISPACE; extern unsigned IOCTL_SNDCTL_DSP_NONBLOCK; extern unsigned IOCTL_SNDCTL_DSP_GETCAPS; extern unsigned IOCTL_SNDCTL_DSP_GETTRIGGER; extern unsigned IOCTL_SNDCTL_DSP_SETTRIGGER; extern unsigned IOCTL_SNDCTL_DSP_GETIPTR; extern unsigned IOCTL_SNDCTL_DSP_GETOPTR; extern unsigned IOCTL_SNDCTL_DSP_MAPINBUF; extern unsigned IOCTL_SNDCTL_DSP_MAPOUTBUF; extern unsigned IOCTL_SNDCTL_DSP_SETSYNCRO; extern unsigned IOCTL_SNDCTL_DSP_SETDUPLEX; extern unsigned IOCTL_SNDCTL_DSP_PROFILE; extern unsigned IOCTL_SNDCTL_DSP_GETODELAY; extern unsigned IOCTL_SOUND_MIXER_INFO; extern unsigned IOCTL_SOUND_OLD_MIXER_INFO; extern unsigned IOCTL_OSS_GETVERSION; extern unsigned IOCTL_SNDCTL_SYSINFO; extern unsigned IOCTL_SNDCTL_AUDIOINFO; extern unsigned IOCTL_SNDCTL_ENGINEINFO; extern unsigned IOCTL_SNDCTL_DSP_GETPLAYVOL; extern unsigned IOCTL_SNDCTL_DSP_SETPLAYVOL; extern unsigned IOCTL_SNDCTL_DSP_GETRECVOL; extern unsigned IOCTL_SNDCTL_DSP_SETRECVOL; extern unsigned IOCTL_SNDCTL_DSP_SKIP; extern unsigned IOCTL_SNDCTL_DSP_SILENCE; extern const int si_SEGV_MAPERR; extern const int si_SEGV_ACCERR; extern const unsigned SHA1_CTX_sz; extern const unsigned SHA1_return_length; extern const unsigned MD4_CTX_sz; extern const unsigned MD4_return_length; extern const unsigned RMD160_CTX_sz; extern const unsigned RMD160_return_length; extern const unsigned MD5_CTX_sz; extern const unsigned MD5_return_length; extern const unsigned fpos_t_sz; extern const unsigned MD2_CTX_sz; extern const unsigned MD2_return_length; #define SHA2_EXTERN(LEN) \ extern const unsigned SHA##LEN##_CTX_sz; \ extern const unsigned SHA##LEN##_return_length; \ extern const unsigned SHA##LEN##_block_length; \ extern const unsigned SHA##LEN##_digest_length SHA2_EXTERN(224); SHA2_EXTERN(256); SHA2_EXTERN(384); SHA2_EXTERN(512); #undef SHA2_EXTERN extern const int unvis_valid; extern const int unvis_validpush; struct __sanitizer_cdbr { void (*unmap)(void *, void *, uptr); void *cookie; u8 *mmap_base; uptr mmap_size; u8 *hash_base; u8 *offset_base; u8 *data_base; u32 data_size; u32 entries; u32 entries_index; u32 seed; u8 offset_size; u8 index_size; u32 entries_m; u32 entries_index_m; u8 entries_s1, entries_s2; u8 entries_index_s1, entries_index_s2; }; struct __sanitizer_cdbw { uptr data_counter; uptr data_allocated; uptr data_size; uptr *data_len; void **data_ptr; uptr hash_size; void *hash; uptr key_counter; }; } // namespace __sanitizer #define CHECK_TYPE_SIZE(TYPE) \ COMPILER_CHECK(sizeof(__sanitizer_##TYPE) == sizeof(TYPE)) #define CHECK_SIZE_AND_OFFSET(CLASS, MEMBER) \ COMPILER_CHECK(sizeof(((__sanitizer_##CLASS *)NULL)->MEMBER) == \ sizeof(((CLASS *)NULL)->MEMBER)); \ COMPILER_CHECK(offsetof(__sanitizer_##CLASS, MEMBER) == \ offsetof(CLASS, MEMBER)) // For sigaction, which is a function and struct at the same time, // and thus requires explicit "struct" in sizeof() expression. #define CHECK_STRUCT_SIZE_AND_OFFSET(CLASS, MEMBER) \ COMPILER_CHECK(sizeof(((struct __sanitizer_##CLASS *)NULL)->MEMBER) == \ sizeof(((struct CLASS *)NULL)->MEMBER)); \ COMPILER_CHECK(offsetof(struct __sanitizer_##CLASS, MEMBER) == \ offsetof(struct CLASS, MEMBER)) #define SIGACTION_SYMNAME __sigaction14 #endif // SANITIZER_NETBSD #endif Index: vendor/compiler-rt/dist-release_90/lib/tsan/rtl/tsan_rtl.cc =================================================================== --- vendor/compiler-rt/dist-release_90/lib/tsan/rtl/tsan_rtl.cc (revision 351306) +++ vendor/compiler-rt/dist-release_90/lib/tsan/rtl/tsan_rtl.cc (revision 351307) @@ -1,1099 +1,1100 @@ //===-- tsan_rtl.cc -------------------------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // This file is a part of ThreadSanitizer (TSan), a race detector. // // Main file (entry points) for the TSan run-time. //===----------------------------------------------------------------------===// #include "sanitizer_common/sanitizer_atomic.h" #include "sanitizer_common/sanitizer_common.h" #include "sanitizer_common/sanitizer_file.h" #include "sanitizer_common/sanitizer_libc.h" #include "sanitizer_common/sanitizer_stackdepot.h" #include "sanitizer_common/sanitizer_placement_new.h" #include "sanitizer_common/sanitizer_symbolizer.h" #include "tsan_defs.h" #include "tsan_platform.h" #include "tsan_rtl.h" #include "tsan_mman.h" #include "tsan_suppressions.h" #include "tsan_symbolize.h" #include "ubsan/ubsan_init.h" #ifdef __SSE3__ // transitively includes , // and it's prohibited to include std headers into tsan runtime. // So we do this dirty trick. #define _MM_MALLOC_H_INCLUDED #define __MM_MALLOC_H #include typedef __m128i m128; #endif volatile int __tsan_resumed = 0; extern "C" void __tsan_resume() { __tsan_resumed = 1; } namespace __tsan { #if !SANITIZER_GO && !SANITIZER_MAC __attribute__((tls_model("initial-exec"))) THREADLOCAL char cur_thread_placeholder[sizeof(ThreadState)] ALIGNED(64); #endif static char ctx_placeholder[sizeof(Context)] ALIGNED(64); Context *ctx; // Can be overriden by a front-end. #ifdef TSAN_EXTERNAL_HOOKS bool OnFinalize(bool failed); void OnInitialize(); #else SANITIZER_WEAK_CXX_DEFAULT_IMPL bool OnFinalize(bool failed) { return failed; } SANITIZER_WEAK_CXX_DEFAULT_IMPL void OnInitialize() {} #endif static char thread_registry_placeholder[sizeof(ThreadRegistry)]; static ThreadContextBase *CreateThreadContext(u32 tid) { // Map thread trace when context is created. char name[50]; internal_snprintf(name, sizeof(name), "trace %u", tid); MapThreadTrace(GetThreadTrace(tid), TraceSize() * sizeof(Event), name); const uptr hdr = GetThreadTraceHeader(tid); internal_snprintf(name, sizeof(name), "trace header %u", tid); MapThreadTrace(hdr, sizeof(Trace), name); new((void*)hdr) Trace(); // We are going to use only a small part of the trace with the default // value of history_size. However, the constructor writes to the whole trace. // Unmap the unused part. uptr hdr_end = hdr + sizeof(Trace); hdr_end -= sizeof(TraceHeader) * (kTraceParts - TraceParts()); hdr_end = RoundUp(hdr_end, GetPageSizeCached()); if (hdr_end < hdr + sizeof(Trace)) UnmapOrDie((void*)hdr_end, hdr + sizeof(Trace) - hdr_end); void *mem = internal_alloc(MBlockThreadContex, sizeof(ThreadContext)); return new(mem) ThreadContext(tid); } #if !SANITIZER_GO static const u32 kThreadQuarantineSize = 16; #else static const u32 kThreadQuarantineSize = 64; #endif Context::Context() : initialized() , report_mtx(MutexTypeReport, StatMtxReport) , nreported() , nmissed_expected() , thread_registry(new(thread_registry_placeholder) ThreadRegistry( CreateThreadContext, kMaxTid, kThreadQuarantineSize, kMaxTidReuse)) , racy_mtx(MutexTypeRacy, StatMtxRacy) , racy_stacks() , racy_addresses() , fired_suppressions_mtx(MutexTypeFired, StatMtxFired) , clock_alloc("clock allocator") { fired_suppressions.reserve(8); } // The objects are allocated in TLS, so one may rely on zero-initialization. ThreadState::ThreadState(Context *ctx, int tid, int unique_id, u64 epoch, unsigned reuse_count, uptr stk_addr, uptr stk_size, uptr tls_addr, uptr tls_size) : fast_state(tid, epoch) // Do not touch these, rely on zero initialization, // they may be accessed before the ctor. // , ignore_reads_and_writes() // , ignore_interceptors() , clock(tid, reuse_count) #if !SANITIZER_GO , jmp_bufs() #endif , tid(tid) , unique_id(unique_id) , stk_addr(stk_addr) , stk_size(stk_size) , tls_addr(tls_addr) , tls_size(tls_size) #if !SANITIZER_GO , last_sleep_clock(tid) #endif { } #if !SANITIZER_GO static void MemoryProfiler(Context *ctx, fd_t fd, int i) { uptr n_threads; uptr n_running_threads; ctx->thread_registry->GetNumberOfThreads(&n_threads, &n_running_threads); InternalMmapVector buf(4096); WriteMemoryProfile(buf.data(), buf.size(), n_threads, n_running_threads); WriteToFile(fd, buf.data(), internal_strlen(buf.data())); } static void BackgroundThread(void *arg) { // This is a non-initialized non-user thread, nothing to see here. // We don't use ScopedIgnoreInterceptors, because we want ignores to be // enabled even when the thread function exits (e.g. during pthread thread // shutdown code). + cur_thread_init(); cur_thread()->ignore_interceptors++; const u64 kMs2Ns = 1000 * 1000; fd_t mprof_fd = kInvalidFd; if (flags()->profile_memory && flags()->profile_memory[0]) { if (internal_strcmp(flags()->profile_memory, "stdout") == 0) { mprof_fd = 1; } else if (internal_strcmp(flags()->profile_memory, "stderr") == 0) { mprof_fd = 2; } else { InternalScopedString filename(kMaxPathLength); filename.append("%s.%d", flags()->profile_memory, (int)internal_getpid()); fd_t fd = OpenFile(filename.data(), WrOnly); if (fd == kInvalidFd) { Printf("ThreadSanitizer: failed to open memory profile file '%s'\n", &filename[0]); } else { mprof_fd = fd; } } } u64 last_flush = NanoTime(); uptr last_rss = 0; for (int i = 0; atomic_load(&ctx->stop_background_thread, memory_order_relaxed) == 0; i++) { SleepForMillis(100); u64 now = NanoTime(); // Flush memory if requested. if (flags()->flush_memory_ms > 0) { if (last_flush + flags()->flush_memory_ms * kMs2Ns < now) { VPrintf(1, "ThreadSanitizer: periodic memory flush\n"); FlushShadowMemory(); last_flush = NanoTime(); } } // GetRSS can be expensive on huge programs, so don't do it every 100ms. if (flags()->memory_limit_mb > 0) { uptr rss = GetRSS(); uptr limit = uptr(flags()->memory_limit_mb) << 20; VPrintf(1, "ThreadSanitizer: memory flush check" " RSS=%llu LAST=%llu LIMIT=%llu\n", (u64)rss >> 20, (u64)last_rss >> 20, (u64)limit >> 20); if (2 * rss > limit + last_rss) { VPrintf(1, "ThreadSanitizer: flushing memory due to RSS\n"); FlushShadowMemory(); rss = GetRSS(); VPrintf(1, "ThreadSanitizer: memory flushed RSS=%llu\n", (u64)rss>>20); } last_rss = rss; } // Write memory profile if requested. if (mprof_fd != kInvalidFd) MemoryProfiler(ctx, mprof_fd, i); // Flush symbolizer cache if requested. if (flags()->flush_symbolizer_ms > 0) { u64 last = atomic_load(&ctx->last_symbolize_time_ns, memory_order_relaxed); if (last != 0 && last + flags()->flush_symbolizer_ms * kMs2Ns < now) { Lock l(&ctx->report_mtx); ScopedErrorReportLock l2; SymbolizeFlush(); atomic_store(&ctx->last_symbolize_time_ns, 0, memory_order_relaxed); } } } } static void StartBackgroundThread() { ctx->background_thread = internal_start_thread(&BackgroundThread, 0); } #ifndef __mips__ static void StopBackgroundThread() { atomic_store(&ctx->stop_background_thread, 1, memory_order_relaxed); internal_join_thread(ctx->background_thread); ctx->background_thread = 0; } #endif #endif void DontNeedShadowFor(uptr addr, uptr size) { ReleaseMemoryPagesToOS(MemToShadow(addr), MemToShadow(addr + size)); } void MapShadow(uptr addr, uptr size) { // Global data is not 64K aligned, but there are no adjacent mappings, // so we can get away with unaligned mapping. // CHECK_EQ(addr, addr & ~((64 << 10) - 1)); // windows wants 64K alignment const uptr kPageSize = GetPageSizeCached(); uptr shadow_begin = RoundDownTo((uptr)MemToShadow(addr), kPageSize); uptr shadow_end = RoundUpTo((uptr)MemToShadow(addr + size), kPageSize); if (!MmapFixedNoReserve(shadow_begin, shadow_end - shadow_begin, "shadow")) Die(); // Meta shadow is 2:1, so tread carefully. static bool data_mapped = false; static uptr mapped_meta_end = 0; uptr meta_begin = (uptr)MemToMeta(addr); uptr meta_end = (uptr)MemToMeta(addr + size); meta_begin = RoundDownTo(meta_begin, 64 << 10); meta_end = RoundUpTo(meta_end, 64 << 10); if (!data_mapped) { // First call maps data+bss. data_mapped = true; if (!MmapFixedNoReserve(meta_begin, meta_end - meta_begin, "meta shadow")) Die(); } else { // Mapping continous heap. // Windows wants 64K alignment. meta_begin = RoundDownTo(meta_begin, 64 << 10); meta_end = RoundUpTo(meta_end, 64 << 10); if (meta_end <= mapped_meta_end) return; if (meta_begin < mapped_meta_end) meta_begin = mapped_meta_end; if (!MmapFixedNoReserve(meta_begin, meta_end - meta_begin, "meta shadow")) Die(); mapped_meta_end = meta_end; } VPrintf(2, "mapped meta shadow for (%p-%p) at (%p-%p)\n", addr, addr+size, meta_begin, meta_end); } void MapThreadTrace(uptr addr, uptr size, const char *name) { DPrintf("#0: Mapping trace at %p-%p(0x%zx)\n", addr, addr + size, size); CHECK_GE(addr, TraceMemBeg()); CHECK_LE(addr + size, TraceMemEnd()); CHECK_EQ(addr, addr & ~((64 << 10) - 1)); // windows wants 64K alignment if (!MmapFixedNoReserve(addr, size, name)) { Printf("FATAL: ThreadSanitizer can not mmap thread trace (%p/%p)\n", addr, size); Die(); } } static void CheckShadowMapping() { uptr beg, end; for (int i = 0; GetUserRegion(i, &beg, &end); i++) { // Skip cases for empty regions (heap definition for architectures that // do not use 64-bit allocator). if (beg == end) continue; VPrintf(3, "checking shadow region %p-%p\n", beg, end); uptr prev = 0; for (uptr p0 = beg; p0 <= end; p0 += (end - beg) / 4) { for (int x = -(int)kShadowCell; x <= (int)kShadowCell; x += kShadowCell) { const uptr p = RoundDown(p0 + x, kShadowCell); if (p < beg || p >= end) continue; const uptr s = MemToShadow(p); const uptr m = (uptr)MemToMeta(p); VPrintf(3, " checking pointer %p: shadow=%p meta=%p\n", p, s, m); CHECK(IsAppMem(p)); CHECK(IsShadowMem(s)); CHECK_EQ(p, ShadowToMem(s)); CHECK(IsMetaMem(m)); if (prev) { // Ensure that shadow and meta mappings are linear within a single // user range. Lots of code that processes memory ranges assumes it. const uptr prev_s = MemToShadow(prev); const uptr prev_m = (uptr)MemToMeta(prev); CHECK_EQ(s - prev_s, (p - prev) * kShadowMultiplier); CHECK_EQ((m - prev_m) / kMetaShadowSize, (p - prev) / kMetaShadowCell); } prev = p; } } } } #if !SANITIZER_GO static void OnStackUnwind(const SignalContext &sig, const void *, BufferedStackTrace *stack) { stack->Unwind(sig.pc, sig.bp, sig.context, common_flags()->fast_unwind_on_fatal); } static void TsanOnDeadlySignal(int signo, void *siginfo, void *context) { HandleDeadlySignal(siginfo, context, GetTid(), &OnStackUnwind, nullptr); } #endif void Initialize(ThreadState *thr) { // Thread safe because done before all threads exist. static bool is_initialized = false; if (is_initialized) return; is_initialized = true; // We are not ready to handle interceptors yet. ScopedIgnoreInterceptors ignore; SanitizerToolName = "ThreadSanitizer"; // Install tool-specific callbacks in sanitizer_common. SetCheckFailedCallback(TsanCheckFailed); ctx = new(ctx_placeholder) Context; const char *env_name = SANITIZER_GO ? "GORACE" : "TSAN_OPTIONS"; const char *options = GetEnv(env_name); CacheBinaryName(); CheckASLR(); InitializeFlags(&ctx->flags, options, env_name); AvoidCVE_2016_2143(); __sanitizer::InitializePlatformEarly(); __tsan::InitializePlatformEarly(); #if !SANITIZER_GO // Re-exec ourselves if we need to set additional env or command line args. MaybeReexec(); InitializeAllocator(); ReplaceSystemMalloc(); #endif if (common_flags()->detect_deadlocks) ctx->dd = DDetector::Create(flags()); Processor *proc = ProcCreate(); ProcWire(proc, thr); InitializeInterceptors(); CheckShadowMapping(); InitializePlatform(); InitializeMutex(); InitializeDynamicAnnotations(); #if !SANITIZER_GO InitializeShadowMemory(); InitializeAllocatorLate(); InstallDeadlySignalHandlers(TsanOnDeadlySignal); #endif // Setup correct file descriptor for error reports. __sanitizer_set_report_path(common_flags()->log_path); InitializeSuppressions(); #if !SANITIZER_GO InitializeLibIgnore(); Symbolizer::GetOrInit()->AddHooks(EnterSymbolizer, ExitSymbolizer); #endif VPrintf(1, "***** Running under ThreadSanitizer v2 (pid %d) *****\n", (int)internal_getpid()); // Initialize thread 0. int tid = ThreadCreate(thr, 0, 0, true); CHECK_EQ(tid, 0); ThreadStart(thr, tid, GetTid(), ThreadType::Regular); #if TSAN_CONTAINS_UBSAN __ubsan::InitAsPlugin(); #endif ctx->initialized = true; #if !SANITIZER_GO Symbolizer::LateInitialize(); #endif if (flags()->stop_on_start) { Printf("ThreadSanitizer is suspended at startup (pid %d)." " Call __tsan_resume().\n", (int)internal_getpid()); while (__tsan_resumed == 0) {} } OnInitialize(); } void MaybeSpawnBackgroundThread() { // On MIPS, TSan initialization is run before // __pthread_initialize_minimal_internal() is finished, so we can not spawn // new threads. #if !SANITIZER_GO && !defined(__mips__) static atomic_uint32_t bg_thread = {}; if (atomic_load(&bg_thread, memory_order_relaxed) == 0 && atomic_exchange(&bg_thread, 1, memory_order_relaxed) == 0) { StartBackgroundThread(); SetSandboxingCallback(StopBackgroundThread); } #endif } int Finalize(ThreadState *thr) { bool failed = false; if (common_flags()->print_module_map == 1) PrintModuleMap(); if (flags()->atexit_sleep_ms > 0 && ThreadCount(thr) > 1) SleepForMillis(flags()->atexit_sleep_ms); // Wait for pending reports. ctx->report_mtx.Lock(); { ScopedErrorReportLock l; } ctx->report_mtx.Unlock(); #if !SANITIZER_GO if (Verbosity()) AllocatorPrintStats(); #endif ThreadFinalize(thr); if (ctx->nreported) { failed = true; #if !SANITIZER_GO Printf("ThreadSanitizer: reported %d warnings\n", ctx->nreported); #else Printf("Found %d data race(s)\n", ctx->nreported); #endif } if (ctx->nmissed_expected) { failed = true; Printf("ThreadSanitizer: missed %d expected races\n", ctx->nmissed_expected); } if (common_flags()->print_suppressions) PrintMatchedSuppressions(); #if !SANITIZER_GO if (flags()->print_benign) PrintMatchedBenignRaces(); #endif failed = OnFinalize(failed); #if TSAN_COLLECT_STATS StatAggregate(ctx->stat, thr->stat); StatOutput(ctx->stat); #endif return failed ? common_flags()->exitcode : 0; } #if !SANITIZER_GO void ForkBefore(ThreadState *thr, uptr pc) { ctx->thread_registry->Lock(); ctx->report_mtx.Lock(); } void ForkParentAfter(ThreadState *thr, uptr pc) { ctx->report_mtx.Unlock(); ctx->thread_registry->Unlock(); } void ForkChildAfter(ThreadState *thr, uptr pc) { ctx->report_mtx.Unlock(); ctx->thread_registry->Unlock(); uptr nthread = 0; ctx->thread_registry->GetNumberOfThreads(0, 0, &nthread /* alive threads */); VPrintf(1, "ThreadSanitizer: forked new process with pid %d," " parent had %d threads\n", (int)internal_getpid(), (int)nthread); if (nthread == 1) { StartBackgroundThread(); } else { // We've just forked a multi-threaded process. We cannot reasonably function // after that (some mutexes may be locked before fork). So just enable // ignores for everything in the hope that we will exec soon. ctx->after_multithreaded_fork = true; thr->ignore_interceptors++; ThreadIgnoreBegin(thr, pc); ThreadIgnoreSyncBegin(thr, pc); } } #endif #if SANITIZER_GO NOINLINE void GrowShadowStack(ThreadState *thr) { const int sz = thr->shadow_stack_end - thr->shadow_stack; const int newsz = 2 * sz; uptr *newstack = (uptr*)internal_alloc(MBlockShadowStack, newsz * sizeof(uptr)); internal_memcpy(newstack, thr->shadow_stack, sz * sizeof(uptr)); internal_free(thr->shadow_stack); thr->shadow_stack = newstack; thr->shadow_stack_pos = newstack + sz; thr->shadow_stack_end = newstack + newsz; } #endif u32 CurrentStackId(ThreadState *thr, uptr pc) { if (!thr->is_inited) // May happen during bootstrap. return 0; if (pc != 0) { #if !SANITIZER_GO DCHECK_LT(thr->shadow_stack_pos, thr->shadow_stack_end); #else if (thr->shadow_stack_pos == thr->shadow_stack_end) GrowShadowStack(thr); #endif thr->shadow_stack_pos[0] = pc; thr->shadow_stack_pos++; } u32 id = StackDepotPut( StackTrace(thr->shadow_stack, thr->shadow_stack_pos - thr->shadow_stack)); if (pc != 0) thr->shadow_stack_pos--; return id; } void TraceSwitch(ThreadState *thr) { #if !SANITIZER_GO if (ctx->after_multithreaded_fork) return; #endif thr->nomalloc++; Trace *thr_trace = ThreadTrace(thr->tid); Lock l(&thr_trace->mtx); unsigned trace = (thr->fast_state.epoch() / kTracePartSize) % TraceParts(); TraceHeader *hdr = &thr_trace->headers[trace]; hdr->epoch0 = thr->fast_state.epoch(); ObtainCurrentStack(thr, 0, &hdr->stack0); hdr->mset0 = thr->mset; thr->nomalloc--; } Trace *ThreadTrace(int tid) { return (Trace*)GetThreadTraceHeader(tid); } uptr TraceTopPC(ThreadState *thr) { Event *events = (Event*)GetThreadTrace(thr->tid); uptr pc = events[thr->fast_state.GetTracePos()]; return pc; } uptr TraceSize() { return (uptr)(1ull << (kTracePartSizeBits + flags()->history_size + 1)); } uptr TraceParts() { return TraceSize() / kTracePartSize; } #if !SANITIZER_GO extern "C" void __tsan_trace_switch() { TraceSwitch(cur_thread()); } extern "C" void __tsan_report_race() { ReportRace(cur_thread()); } #endif ALWAYS_INLINE Shadow LoadShadow(u64 *p) { u64 raw = atomic_load((atomic_uint64_t*)p, memory_order_relaxed); return Shadow(raw); } ALWAYS_INLINE void StoreShadow(u64 *sp, u64 s) { atomic_store((atomic_uint64_t*)sp, s, memory_order_relaxed); } ALWAYS_INLINE void StoreIfNotYetStored(u64 *sp, u64 *s) { StoreShadow(sp, *s); *s = 0; } ALWAYS_INLINE void HandleRace(ThreadState *thr, u64 *shadow_mem, Shadow cur, Shadow old) { thr->racy_state[0] = cur.raw(); thr->racy_state[1] = old.raw(); thr->racy_shadow_addr = shadow_mem; #if !SANITIZER_GO HACKY_CALL(__tsan_report_race); #else ReportRace(thr); #endif } static inline bool HappensBefore(Shadow old, ThreadState *thr) { return thr->clock.get(old.TidWithIgnore()) >= old.epoch(); } ALWAYS_INLINE void MemoryAccessImpl1(ThreadState *thr, uptr addr, int kAccessSizeLog, bool kAccessIsWrite, bool kIsAtomic, u64 *shadow_mem, Shadow cur) { StatInc(thr, StatMop); StatInc(thr, kAccessIsWrite ? StatMopWrite : StatMopRead); StatInc(thr, (StatType)(StatMop1 + kAccessSizeLog)); // This potentially can live in an MMX/SSE scratch register. // The required intrinsics are: // __m128i _mm_move_epi64(__m128i*); // _mm_storel_epi64(u64*, __m128i); u64 store_word = cur.raw(); bool stored = false; // scan all the shadow values and dispatch to 4 categories: // same, replace, candidate and race (see comments below). // we consider only 3 cases regarding access sizes: // equal, intersect and not intersect. initially I considered // larger and smaller as well, it allowed to replace some // 'candidates' with 'same' or 'replace', but I think // it's just not worth it (performance- and complexity-wise). Shadow old(0); // It release mode we manually unroll the loop, // because empirically gcc generates better code this way. // However, we can't afford unrolling in debug mode, because the function // consumes almost 4K of stack. Gtest gives only 4K of stack to death test // threads, which is not enough for the unrolled loop. #if SANITIZER_DEBUG for (int idx = 0; idx < 4; idx++) { #include "tsan_update_shadow_word_inl.h" } #else int idx = 0; #include "tsan_update_shadow_word_inl.h" idx = 1; if (stored) { #include "tsan_update_shadow_word_inl.h" } else { #include "tsan_update_shadow_word_inl.h" } idx = 2; if (stored) { #include "tsan_update_shadow_word_inl.h" } else { #include "tsan_update_shadow_word_inl.h" } idx = 3; if (stored) { #include "tsan_update_shadow_word_inl.h" } else { #include "tsan_update_shadow_word_inl.h" } #endif // we did not find any races and had already stored // the current access info, so we are done if (LIKELY(stored)) return; // choose a random candidate slot and replace it StoreShadow(shadow_mem + (cur.epoch() % kShadowCnt), store_word); StatInc(thr, StatShadowReplace); return; RACE: HandleRace(thr, shadow_mem, cur, old); return; } void UnalignedMemoryAccess(ThreadState *thr, uptr pc, uptr addr, int size, bool kAccessIsWrite, bool kIsAtomic) { while (size) { int size1 = 1; int kAccessSizeLog = kSizeLog1; if (size >= 8 && (addr & ~7) == ((addr + 7) & ~7)) { size1 = 8; kAccessSizeLog = kSizeLog8; } else if (size >= 4 && (addr & ~7) == ((addr + 3) & ~7)) { size1 = 4; kAccessSizeLog = kSizeLog4; } else if (size >= 2 && (addr & ~7) == ((addr + 1) & ~7)) { size1 = 2; kAccessSizeLog = kSizeLog2; } MemoryAccess(thr, pc, addr, kAccessSizeLog, kAccessIsWrite, kIsAtomic); addr += size1; size -= size1; } } ALWAYS_INLINE bool ContainsSameAccessSlow(u64 *s, u64 a, u64 sync_epoch, bool is_write) { Shadow cur(a); for (uptr i = 0; i < kShadowCnt; i++) { Shadow old(LoadShadow(&s[i])); if (Shadow::Addr0AndSizeAreEqual(cur, old) && old.TidWithIgnore() == cur.TidWithIgnore() && old.epoch() > sync_epoch && old.IsAtomic() == cur.IsAtomic() && old.IsRead() <= cur.IsRead()) return true; } return false; } #if defined(__SSE3__) #define SHUF(v0, v1, i0, i1, i2, i3) _mm_castps_si128(_mm_shuffle_ps( \ _mm_castsi128_ps(v0), _mm_castsi128_ps(v1), \ (i0)*1 + (i1)*4 + (i2)*16 + (i3)*64)) ALWAYS_INLINE bool ContainsSameAccessFast(u64 *s, u64 a, u64 sync_epoch, bool is_write) { // This is an optimized version of ContainsSameAccessSlow. // load current access into access[0:63] const m128 access = _mm_cvtsi64_si128(a); // duplicate high part of access in addr0: // addr0[0:31] = access[32:63] // addr0[32:63] = access[32:63] // addr0[64:95] = access[32:63] // addr0[96:127] = access[32:63] const m128 addr0 = SHUF(access, access, 1, 1, 1, 1); // load 4 shadow slots const m128 shadow0 = _mm_load_si128((__m128i*)s); const m128 shadow1 = _mm_load_si128((__m128i*)s + 1); // load high parts of 4 shadow slots into addr_vect: // addr_vect[0:31] = shadow0[32:63] // addr_vect[32:63] = shadow0[96:127] // addr_vect[64:95] = shadow1[32:63] // addr_vect[96:127] = shadow1[96:127] m128 addr_vect = SHUF(shadow0, shadow1, 1, 3, 1, 3); if (!is_write) { // set IsRead bit in addr_vect const m128 rw_mask1 = _mm_cvtsi64_si128(1<<15); const m128 rw_mask = SHUF(rw_mask1, rw_mask1, 0, 0, 0, 0); addr_vect = _mm_or_si128(addr_vect, rw_mask); } // addr0 == addr_vect? const m128 addr_res = _mm_cmpeq_epi32(addr0, addr_vect); // epoch1[0:63] = sync_epoch const m128 epoch1 = _mm_cvtsi64_si128(sync_epoch); // epoch[0:31] = sync_epoch[0:31] // epoch[32:63] = sync_epoch[0:31] // epoch[64:95] = sync_epoch[0:31] // epoch[96:127] = sync_epoch[0:31] const m128 epoch = SHUF(epoch1, epoch1, 0, 0, 0, 0); // load low parts of shadow cell epochs into epoch_vect: // epoch_vect[0:31] = shadow0[0:31] // epoch_vect[32:63] = shadow0[64:95] // epoch_vect[64:95] = shadow1[0:31] // epoch_vect[96:127] = shadow1[64:95] const m128 epoch_vect = SHUF(shadow0, shadow1, 0, 2, 0, 2); // epoch_vect >= sync_epoch? const m128 epoch_res = _mm_cmpgt_epi32(epoch_vect, epoch); // addr_res & epoch_res const m128 res = _mm_and_si128(addr_res, epoch_res); // mask[0] = res[7] // mask[1] = res[15] // ... // mask[15] = res[127] const int mask = _mm_movemask_epi8(res); return mask != 0; } #endif ALWAYS_INLINE bool ContainsSameAccess(u64 *s, u64 a, u64 sync_epoch, bool is_write) { #if defined(__SSE3__) bool res = ContainsSameAccessFast(s, a, sync_epoch, is_write); // NOTE: this check can fail if the shadow is concurrently mutated // by other threads. But it still can be useful if you modify // ContainsSameAccessFast and want to ensure that it's not completely broken. // DCHECK_EQ(res, ContainsSameAccessSlow(s, a, sync_epoch, is_write)); return res; #else return ContainsSameAccessSlow(s, a, sync_epoch, is_write); #endif } ALWAYS_INLINE USED void MemoryAccess(ThreadState *thr, uptr pc, uptr addr, int kAccessSizeLog, bool kAccessIsWrite, bool kIsAtomic) { u64 *shadow_mem = (u64*)MemToShadow(addr); DPrintf2("#%d: MemoryAccess: @%p %p size=%d" " is_write=%d shadow_mem=%p {%zx, %zx, %zx, %zx}\n", (int)thr->fast_state.tid(), (void*)pc, (void*)addr, (int)(1 << kAccessSizeLog), kAccessIsWrite, shadow_mem, (uptr)shadow_mem[0], (uptr)shadow_mem[1], (uptr)shadow_mem[2], (uptr)shadow_mem[3]); #if SANITIZER_DEBUG if (!IsAppMem(addr)) { Printf("Access to non app mem %zx\n", addr); DCHECK(IsAppMem(addr)); } if (!IsShadowMem((uptr)shadow_mem)) { Printf("Bad shadow addr %p (%zx)\n", shadow_mem, addr); DCHECK(IsShadowMem((uptr)shadow_mem)); } #endif if (!SANITIZER_GO && !kAccessIsWrite && *shadow_mem == kShadowRodata) { // Access to .rodata section, no races here. // Measurements show that it can be 10-20% of all memory accesses. StatInc(thr, StatMop); StatInc(thr, kAccessIsWrite ? StatMopWrite : StatMopRead); StatInc(thr, (StatType)(StatMop1 + kAccessSizeLog)); StatInc(thr, StatMopRodata); return; } FastState fast_state = thr->fast_state; if (UNLIKELY(fast_state.GetIgnoreBit())) { StatInc(thr, StatMop); StatInc(thr, kAccessIsWrite ? StatMopWrite : StatMopRead); StatInc(thr, (StatType)(StatMop1 + kAccessSizeLog)); StatInc(thr, StatMopIgnored); return; } Shadow cur(fast_state); cur.SetAddr0AndSizeLog(addr & 7, kAccessSizeLog); cur.SetWrite(kAccessIsWrite); cur.SetAtomic(kIsAtomic); if (LIKELY(ContainsSameAccess(shadow_mem, cur.raw(), thr->fast_synch_epoch, kAccessIsWrite))) { StatInc(thr, StatMop); StatInc(thr, kAccessIsWrite ? StatMopWrite : StatMopRead); StatInc(thr, (StatType)(StatMop1 + kAccessSizeLog)); StatInc(thr, StatMopSame); return; } if (kCollectHistory) { fast_state.IncrementEpoch(); thr->fast_state = fast_state; TraceAddEvent(thr, fast_state, EventTypeMop, pc); cur.IncrementEpoch(); } MemoryAccessImpl1(thr, addr, kAccessSizeLog, kAccessIsWrite, kIsAtomic, shadow_mem, cur); } // Called by MemoryAccessRange in tsan_rtl_thread.cc ALWAYS_INLINE USED void MemoryAccessImpl(ThreadState *thr, uptr addr, int kAccessSizeLog, bool kAccessIsWrite, bool kIsAtomic, u64 *shadow_mem, Shadow cur) { if (LIKELY(ContainsSameAccess(shadow_mem, cur.raw(), thr->fast_synch_epoch, kAccessIsWrite))) { StatInc(thr, StatMop); StatInc(thr, kAccessIsWrite ? StatMopWrite : StatMopRead); StatInc(thr, (StatType)(StatMop1 + kAccessSizeLog)); StatInc(thr, StatMopSame); return; } MemoryAccessImpl1(thr, addr, kAccessSizeLog, kAccessIsWrite, kIsAtomic, shadow_mem, cur); } static void MemoryRangeSet(ThreadState *thr, uptr pc, uptr addr, uptr size, u64 val) { (void)thr; (void)pc; if (size == 0) return; // FIXME: fix me. uptr offset = addr % kShadowCell; if (offset) { offset = kShadowCell - offset; if (size <= offset) return; addr += offset; size -= offset; } DCHECK_EQ(addr % 8, 0); // If a user passes some insane arguments (memset(0)), // let it just crash as usual. if (!IsAppMem(addr) || !IsAppMem(addr + size - 1)) return; // Don't want to touch lots of shadow memory. // If a program maps 10MB stack, there is no need reset the whole range. size = (size + (kShadowCell - 1)) & ~(kShadowCell - 1); // UnmapOrDie/MmapFixedNoReserve does not work on Windows. if (SANITIZER_WINDOWS || size < common_flags()->clear_shadow_mmap_threshold) { u64 *p = (u64*)MemToShadow(addr); CHECK(IsShadowMem((uptr)p)); CHECK(IsShadowMem((uptr)(p + size * kShadowCnt / kShadowCell - 1))); // FIXME: may overwrite a part outside the region for (uptr i = 0; i < size / kShadowCell * kShadowCnt;) { p[i++] = val; for (uptr j = 1; j < kShadowCnt; j++) p[i++] = 0; } } else { // The region is big, reset only beginning and end. const uptr kPageSize = GetPageSizeCached(); u64 *begin = (u64*)MemToShadow(addr); u64 *end = begin + size / kShadowCell * kShadowCnt; u64 *p = begin; // Set at least first kPageSize/2 to page boundary. while ((p < begin + kPageSize / kShadowSize / 2) || ((uptr)p % kPageSize)) { *p++ = val; for (uptr j = 1; j < kShadowCnt; j++) *p++ = 0; } // Reset middle part. u64 *p1 = p; p = RoundDown(end, kPageSize); UnmapOrDie((void*)p1, (uptr)p - (uptr)p1); if (!MmapFixedNoReserve((uptr)p1, (uptr)p - (uptr)p1)) Die(); // Set the ending. while (p < end) { *p++ = val; for (uptr j = 1; j < kShadowCnt; j++) *p++ = 0; } } } void MemoryResetRange(ThreadState *thr, uptr pc, uptr addr, uptr size) { MemoryRangeSet(thr, pc, addr, size, 0); } void MemoryRangeFreed(ThreadState *thr, uptr pc, uptr addr, uptr size) { // Processing more than 1k (4k of shadow) is expensive, // can cause excessive memory consumption (user does not necessary touch // the whole range) and most likely unnecessary. if (size > 1024) size = 1024; CHECK_EQ(thr->is_freeing, false); thr->is_freeing = true; MemoryAccessRange(thr, pc, addr, size, true); thr->is_freeing = false; if (kCollectHistory) { thr->fast_state.IncrementEpoch(); TraceAddEvent(thr, thr->fast_state, EventTypeMop, pc); } Shadow s(thr->fast_state); s.ClearIgnoreBit(); s.MarkAsFreed(); s.SetWrite(true); s.SetAddr0AndSizeLog(0, 3); MemoryRangeSet(thr, pc, addr, size, s.raw()); } void MemoryRangeImitateWrite(ThreadState *thr, uptr pc, uptr addr, uptr size) { if (kCollectHistory) { thr->fast_state.IncrementEpoch(); TraceAddEvent(thr, thr->fast_state, EventTypeMop, pc); } Shadow s(thr->fast_state); s.ClearIgnoreBit(); s.SetWrite(true); s.SetAddr0AndSizeLog(0, 3); MemoryRangeSet(thr, pc, addr, size, s.raw()); } ALWAYS_INLINE USED void FuncEntry(ThreadState *thr, uptr pc) { StatInc(thr, StatFuncEnter); DPrintf2("#%d: FuncEntry %p\n", (int)thr->fast_state.tid(), (void*)pc); if (kCollectHistory) { thr->fast_state.IncrementEpoch(); TraceAddEvent(thr, thr->fast_state, EventTypeFuncEnter, pc); } // Shadow stack maintenance can be replaced with // stack unwinding during trace switch (which presumably must be faster). DCHECK_GE(thr->shadow_stack_pos, thr->shadow_stack); #if !SANITIZER_GO DCHECK_LT(thr->shadow_stack_pos, thr->shadow_stack_end); #else if (thr->shadow_stack_pos == thr->shadow_stack_end) GrowShadowStack(thr); #endif thr->shadow_stack_pos[0] = pc; thr->shadow_stack_pos++; } ALWAYS_INLINE USED void FuncExit(ThreadState *thr) { StatInc(thr, StatFuncExit); DPrintf2("#%d: FuncExit\n", (int)thr->fast_state.tid()); if (kCollectHistory) { thr->fast_state.IncrementEpoch(); TraceAddEvent(thr, thr->fast_state, EventTypeFuncExit, 0); } DCHECK_GT(thr->shadow_stack_pos, thr->shadow_stack); #if !SANITIZER_GO DCHECK_LT(thr->shadow_stack_pos, thr->shadow_stack_end); #endif thr->shadow_stack_pos--; } void ThreadIgnoreBegin(ThreadState *thr, uptr pc, bool save_stack) { DPrintf("#%d: ThreadIgnoreBegin\n", thr->tid); thr->ignore_reads_and_writes++; CHECK_GT(thr->ignore_reads_and_writes, 0); thr->fast_state.SetIgnoreBit(); #if !SANITIZER_GO if (save_stack && !ctx->after_multithreaded_fork) thr->mop_ignore_set.Add(CurrentStackId(thr, pc)); #endif } void ThreadIgnoreEnd(ThreadState *thr, uptr pc) { DPrintf("#%d: ThreadIgnoreEnd\n", thr->tid); CHECK_GT(thr->ignore_reads_and_writes, 0); thr->ignore_reads_and_writes--; if (thr->ignore_reads_and_writes == 0) { thr->fast_state.ClearIgnoreBit(); #if !SANITIZER_GO thr->mop_ignore_set.Reset(); #endif } } #if !SANITIZER_GO extern "C" SANITIZER_INTERFACE_ATTRIBUTE uptr __tsan_testonly_shadow_stack_current_size() { ThreadState *thr = cur_thread(); return thr->shadow_stack_pos - thr->shadow_stack; } #endif void ThreadIgnoreSyncBegin(ThreadState *thr, uptr pc, bool save_stack) { DPrintf("#%d: ThreadIgnoreSyncBegin\n", thr->tid); thr->ignore_sync++; CHECK_GT(thr->ignore_sync, 0); #if !SANITIZER_GO if (save_stack && !ctx->after_multithreaded_fork) thr->sync_ignore_set.Add(CurrentStackId(thr, pc)); #endif } void ThreadIgnoreSyncEnd(ThreadState *thr, uptr pc) { DPrintf("#%d: ThreadIgnoreSyncEnd\n", thr->tid); CHECK_GT(thr->ignore_sync, 0); thr->ignore_sync--; #if !SANITIZER_GO if (thr->ignore_sync == 0) thr->sync_ignore_set.Reset(); #endif } bool MD5Hash::operator==(const MD5Hash &other) const { return hash[0] == other.hash[0] && hash[1] == other.hash[1]; } #if SANITIZER_DEBUG void build_consistency_debug() {} #else void build_consistency_release() {} #endif #if TSAN_COLLECT_STATS void build_consistency_stats() {} #else void build_consistency_nostats() {} #endif } // namespace __tsan #if !SANITIZER_GO // Must be included in this file to make sure everything is inlined. #include "tsan_interface_inl.h" #endif