diff --git a/containerd-1.5.9-sw.patch b/containerd-1.5.9-sw.patch new file mode 100644 index 0000000000000000000000000000000000000000..7d7a447807f967fd80e036cc98ee20540ca001f3 --- /dev/null +++ b/containerd-1.5.9-sw.patch @@ -0,0 +1,14775 @@ +diff -urN containerd-1.5.9.org/Makefile.linux containerd-1.5.9.sw/Makefile.linux +--- containerd-1.5.9.org/Makefile.linux 2024-04-18 02:22:28.760948126 +0000 ++++ containerd-1.5.9.sw/Makefile.linux 2024-04-18 02:54:32.225972541 +0000 +@@ -20,7 +20,7 @@ + + # check GOOS for cross compile builds + ifeq ($(GOOS),linux) +- ifneq ($(GOARCH),$(filter $(GOARCH),mips mipsle mips64 mips64le ppc64 riscv64)) ++ ifneq ($(GOARCH),$(filter $(GOARCH),mips mipsle mips64 mips64le ppc64 riscv64 sw64)) + GO_GCFLAGS += -buildmode=pie + endif + endif +diff -urN containerd-1.5.9.org/contrib/seccomp/seccomp_default.go containerd-1.5.9.sw/contrib/seccomp/seccomp_default.go +--- containerd-1.5.9.org/contrib/seccomp/seccomp_default.go 2024-04-18 02:22:28.810948175 +0000 ++++ containerd-1.5.9.sw/contrib/seccomp/seccomp_default.go 2024-04-18 02:32:36.271541259 +0000 +@@ -42,6 +42,8 @@ + return []specs.Arch{specs.ArchMIPSEL, specs.ArchMIPSEL64, specs.ArchMIPSEL64N32} + case "s390x": + return []specs.Arch{specs.ArchS390, specs.ArchS390X} ++ case "sw64": ++ return []specs.Arch{specs.ArchSW_64} + default: + return []specs.Arch{} + } +@@ -462,6 +464,65 @@ + + // include by arch + switch runtime.GOARCH { ++ case "sw64": ++ s.Syscalls = append(s.Syscalls, specs.LinuxSyscall{ ++ Names: []string{ ++ "dipc", ++ "getdtablesize", ++ "gethostname", ++ "getpagesize", ++ "getsysinfo", ++ "getxgid", ++ "getxpid", ++ "getxuid", ++ "odd_getpriority", ++ "odd_sigprocmask", ++ "old_adjtimex", ++ "osf_brk", ++ "osf_fstat", ++ "osf_fstatfs", ++ "osf_fstatfs64", ++ "osf_getdirentries", ++ "osf_getdomainname", ++ "osf_getitimer", ++ "osf_getpriority", ++ "osf_getrusage", ++ "osf_getsysinfo", ++ "osf_gettimeofday", ++ "osf_lstat", ++ "osf_proplist_syscall", ++ "osf_select", ++ "osf_set_program_attributes", ++ "osf_setitimer", ++ "osf_setsysinfo", ++ "osf_shmat", ++ "osf_sigprocmask", ++ "osf_sigstack", ++ "osf_stat", ++ "osf_statfs", ++ "osf_statfs64", ++ "osf_sysinfo", ++ "osf_usleep_thread", ++ "osf_utimes", ++ "osf_utsname", ++ "osf_wait4", ++ "pkey_alloc", ++ "pkey_free", ++ "pkey_mprotect", ++ "sethae", ++ "setpgrp", ++ "setsysinfo", ++ "sigaction", ++ "sigpending", ++ "sigsuspend", ++ "sys_epoll_create", ++ "sys_epoll_ctl", ++ "sys_epoll_wait", ++ "timerfd", ++ }, ++ Action: specs.ActAllow, ++ Args: []specs.LinuxSeccompArg{}, ++ }) + case "ppc64le": + s.Syscalls = append(s.Syscalls, specs.LinuxSyscall{ + Names: []string{ +@@ -535,6 +596,7 @@ + "fspick", + "lookup_dcookie", + "mount", ++ "osf_mount", + "move_mount", + "name_to_handle_at", + "open_tree", +@@ -605,6 +667,7 @@ + s.Syscalls = append(s.Syscalls, specs.LinuxSyscall{ + Names: []string{ + "settimeofday", ++ "osf_settimeofday", + "stime", + "clock_settime", + }, +diff -urN containerd-1.5.9.org/platforms/database.go containerd-1.5.9.sw/platforms/database.go +--- containerd-1.5.9.org/platforms/database.go 2024-04-18 02:22:28.710948078 +0000 ++++ containerd-1.5.9.sw/platforms/database.go 2024-04-18 02:30:46.811434389 +0000 +@@ -60,7 +60,7 @@ + // The arch value should be normalized before being passed to this function. + func isKnownArch(arch string) bool { + switch arch { +- case "386", "amd64", "amd64p32", "arm", "armbe", "arm64", "arm64be", "ppc64", "ppc64le", "mips", "mipsle", "mips64", "mips64le", "mips64p32", "mips64p32le", "ppc", "riscv", "riscv64", "s390", "s390x", "sparc", "sparc64", "wasm": ++ case "386", "amd64", "amd64p32", "arm", "armbe", "arm64", "arm64be", "ppc64", "ppc64le", "mips", "mipsle", "mips64", "mips64le", "mips64p32", "mips64p32le", "ppc", "riscv", "riscv64", "s390", "s390x", "sparc", "sparc64", "wasm", "sw64": + return true + } + return false +diff -urN containerd-1.5.9.org/vendor/github.com/containerd/fifo/handle_linux.go containerd-1.5.9.sw/vendor/github.com/containerd/fifo/handle_linux.go +--- containerd-1.5.9.org/vendor/github.com/containerd/fifo/handle_linux.go 2024-04-18 02:22:29.200948556 +0000 ++++ containerd-1.5.9.sw/vendor/github.com/containerd/fifo/handle_linux.go 2024-04-18 02:28:07.911279250 +0000 +@@ -19,6 +19,7 @@ + package fifo + + import ( ++ "runtime" + "fmt" + "os" + "sync" +@@ -28,7 +29,7 @@ + ) + + //nolint:golint +-const O_PATH = 010000000 ++//const O_PATH = 010000000 + + type handle struct { + f *os.File +@@ -40,6 +41,10 @@ + } + + func getHandle(fn string) (*handle, error) { ++ var O_PATH = 010000000 ++ if runtime.GOARCH == "sw64" { ++ O_PATH = 040000000 ++ } + f, err := os.OpenFile(fn, O_PATH, 0) + if err != nil { + return nil, errors.Wrapf(err, "failed to open %v with O_PATH", fn) +diff -urN containerd-1.5.9.org/vendor/github.com/containers/ocicrypt/crypto/pkcs11/utils.go containerd-1.5.9.sw/vendor/github.com/containers/ocicrypt/crypto/pkcs11/utils.go +--- containerd-1.5.9.org/vendor/github.com/containers/ocicrypt/crypto/pkcs11/utils.go 2024-04-18 02:22:29.210948566 +0000 ++++ containerd-1.5.9.sw/vendor/github.com/containers/ocicrypt/crypto/pkcs11/utils.go 2024-04-18 02:23:49.411026868 +0000 +@@ -108,6 +108,8 @@ + ht = "powerpc64le" + case "s390x": + ht = "s390x" ++ case "sw64": ++ ht = "sw64" + } + } + return ht, ot, st +diff -urN containerd-1.5.9.org/vendor/github.com/opencontainers/runtime-spec/specs-go/config.go containerd-1.5.9.sw/vendor/github.com/opencontainers/runtime-spec/specs-go/config.go +--- containerd-1.5.9.org/vendor/github.com/opencontainers/runtime-spec/specs-go/config.go 2024-04-18 02:22:29.110948468 +0000 ++++ containerd-1.5.9.sw/vendor/github.com/opencontainers/runtime-spec/specs-go/config.go 2024-04-18 02:23:49.541026995 +0000 +@@ -619,6 +619,7 @@ + ArchX86 Arch = "SCMP_ARCH_X86" + ArchX86_64 Arch = "SCMP_ARCH_X86_64" + ArchX32 Arch = "SCMP_ARCH_X32" ++ ArchSW_64 Arch = "SCMP_ARCH_SW_64" + ArchARM Arch = "SCMP_ARCH_ARM" + ArchAARCH64 Arch = "SCMP_ARCH_AARCH64" + ArchMIPS Arch = "SCMP_ARCH_MIPS" +diff -urN containerd-1.5.9.org/vendor/github.com/prometheus/procfs/cpuinfo.go containerd-1.5.9.sw/vendor/github.com/prometheus/procfs/cpuinfo.go +--- containerd-1.5.9.org/vendor/github.com/prometheus/procfs/cpuinfo.go 2024-04-18 02:22:29.130948488 +0000 ++++ containerd-1.5.9.sw/vendor/github.com/prometheus/procfs/cpuinfo.go 2024-04-18 02:23:49.601027053 +0000 +@@ -479,3 +479,76 @@ + } + return "" + } ++ ++func parseCPUInfoSW64(info []byte) ([]CPUInfo, error) { ++ scanner := bufio.NewScanner(bytes.NewReader(info)) ++ ++ // find the first "processor" line ++ firstLine := firstNonEmptyLine(scanner) ++ if !strings.HasPrefix(firstLine, "processor") || !strings.Contains(firstLine, ":") { ++ return nil, fmt.Errorf("invalid cpuinfo file: %q", firstLine) ++ } ++ field := strings.SplitN(firstLine, ": ", 2) ++ v, err := strconv.ParseUint(field[1], 0, 32) ++ if err != nil { ++ return nil, err ++ } ++ firstcpu := CPUInfo{Processor: uint(v)} ++ cpuinfo := []CPUInfo{firstcpu} ++ i := 0 ++ ++ for scanner.Scan() { ++ line := scanner.Text() ++ if !strings.Contains(line, ":") { ++ continue ++ } ++ field := strings.SplitN(line, ": ", 2) ++ switch strings.TrimSpace(field[0]) { ++ case "processor": ++ cpuinfo = append(cpuinfo, CPUInfo{}) // start of the next processor ++ i++ ++ v, err := strconv.ParseUint(field[1], 0, 32) ++ if err != nil { ++ return nil, err ++ } ++ cpuinfo[i].Processor = uint(v) ++ case "vendor", "vendor_id": ++ cpuinfo[i].VendorID = field[1] ++ case "cpu family": ++ cpuinfo[i].CPUFamily = field[1] ++ case "model": ++ cpuinfo[i].Model = field[1] ++ case "model name": ++ cpuinfo[i].ModelName = field[1] ++ case "cpu MHz": ++ v, err := strconv.ParseFloat(field[1], 64) ++ if err != nil { ++ return nil, err ++ } ++ cpuinfo[i].CPUMHz = v ++ case "cache size": ++ cpuinfo[i].CacheSize = field[1] ++ case "physical id": ++ cpuinfo[i].PhysicalID = field[1] ++ case "flags": ++ cpuinfo[i].Flags = strings.Fields(field[1]) ++ case "bugs": ++ cpuinfo[i].Bugs = strings.Fields(field[1]) ++ case "bogomips": ++ v, err := strconv.ParseFloat(field[1], 64) ++ if err != nil { ++ return nil, err ++ } ++ cpuinfo[i].BogoMips = v ++ case "cache_alignment": ++ v, err := strconv.ParseUint(field[1], 0, 32) ++ if err != nil { ++ return nil, err ++ } ++ cpuinfo[i].CacheAlignment = uint(v) ++ case "address sizes": ++ cpuinfo[i].AddressSizes = field[1] ++ } ++ } ++ return cpuinfo, nil ++} +diff -urN containerd-1.5.9.org/vendor/github.com/prometheus/procfs/cpuinfo_others.go containerd-1.5.9.sw/vendor/github.com/prometheus/procfs/cpuinfo_others.go +--- containerd-1.5.9.org/vendor/github.com/prometheus/procfs/cpuinfo_others.go 2024-04-18 02:22:29.130948488 +0000 ++++ containerd-1.5.9.sw/vendor/github.com/prometheus/procfs/cpuinfo_others.go 2024-04-18 02:28:08.121279455 +0000 +@@ -12,7 +12,7 @@ + // limitations under the License. + + // +build linux +-// +build !386,!amd64,!arm,!arm64,!mips,!mips64,!mips64le,!mipsle,!ppc64,!ppc64le,!riscv64,!s390x ++// +build !386,!amd64,!arm,!arm64,!mips,!mips64,!mips64le,!mipsle,!ppc64,!ppc64le,!riscv64,!s390x,!sw64 + + package procfs + +diff -urN containerd-1.5.9.org/vendor/github.com/prometheus/procfs/cpuinfo_sw64.go containerd-1.5.9.sw/vendor/github.com/prometheus/procfs/cpuinfo_sw64.go +--- containerd-1.5.9.org/vendor/github.com/prometheus/procfs/cpuinfo_sw64.go 1970-01-01 00:00:00.000000000 +0000 ++++ containerd-1.5.9.sw/vendor/github.com/prometheus/procfs/cpuinfo_sw64.go 2024-04-18 02:28:08.131279465 +0000 +@@ -0,0 +1,7 @@ ++//go:build linux && sw64 ++// +build linux ++// +build sw64 ++ ++package procfs ++ ++var parseCPUInfo = parseCPUInfoSW64 +diff -urN containerd-1.5.9.org/vendor/go.etcd.io/bbolt/bolt_sw64.go containerd-1.5.9.sw/vendor/go.etcd.io/bbolt/bolt_sw64.go +--- containerd-1.5.9.org/vendor/go.etcd.io/bbolt/bolt_sw64.go 1970-01-01 00:00:00.000000000 +0000 ++++ containerd-1.5.9.sw/vendor/go.etcd.io/bbolt/bolt_sw64.go 2024-04-18 02:28:08.221279553 +0000 +@@ -0,0 +1,10 @@ ++//go:build sw64 ++// +build sw64 ++ ++package bbolt ++ ++// maxMapSize represents the largest mmap size supported by Bolt. ++const maxMapSize = 0xFFFFFFFFFFFF // 256TB ++ ++// maxAllocSize is the size used when creating array pointers. ++const maxAllocSize = 0x7FFFFFFF +diff -urN containerd-1.5.9.org/vendor/golang.org/x/sys/unix/asm_linux_sw64.s containerd-1.5.9.sw/vendor/golang.org/x/sys/unix/asm_linux_sw64.s +--- containerd-1.5.9.org/vendor/golang.org/x/sys/unix/asm_linux_sw64.s 1970-01-01 00:00:00.000000000 +0000 ++++ containerd-1.5.9.sw/vendor/golang.org/x/sys/unix/asm_linux_sw64.s 2024-04-18 02:28:08.301279631 +0000 +@@ -0,0 +1,57 @@ ++// Copyright 2015 The Go Authors. All rights reserved. ++// Use of this source code is governed by a BSD-style ++// license that can be found in the LICENSE file. ++ ++// +build linux ++// +build sw64 ++// +build !gccgo ++ ++#include "textflag.h" ++ ++// ++// System calls for sw64, Linux ++// ++// Just jump to package syscall's implementation for all these functions. ++// The runtime may know about them. ++ ++#define SYSCALL SYS_CALL_B $131 ++ ++TEXT ·Syscall(SB),NOSPLIT|NOFRAME,$0-56 ++ JMP syscall·Syscall(SB) ++ ++TEXT ·Syscall6(SB),NOSPLIT|NOFRAME,$0-80 ++ JMP syscall·Syscall6(SB) ++ ++TEXT ·SyscallNoError(SB),NOSPLIT,$0-48 ++ CALL runtime·entersyscall(SB) ++ LDL R16, a1+8(FP) ++ LDL R17, a2+16(FP) ++ LDL R18, a3+24(FP) ++ LDI R19, ZERO ++ LDI R20, ZERO ++ LDI R21, ZERO ++ LDL R0, trap+0(FP) // syscall entry ++ SYSCALL ++ STL R0, r1+32(FP) ++ STL R20, r2+40(FP) ++ CALL runtime·exitsyscall(SB) ++ RET ++ ++TEXT ·RawSyscall(SB),NOSPLIT|NOFRAME,$0-56 ++ JMP syscall·RawSyscall(SB) ++ ++TEXT ·RawSyscall6(SB),NOSPLIT|NOFRAME,$0-80 ++ JMP syscall·RawSyscall6(SB) ++ ++TEXT ·RawSyscallNoError(SB),NOSPLIT|NOFRAME,$0-48 ++ LDL R16, a1+8(FP) ++ LDL R17, a2+16(FP) ++ LDL R18, a3+24(FP) ++ LDI R19, ZERO ++ LDI R20, ZERO ++ LDI R21, ZERO ++ LDL R0, trap+0(FP) // syscall entry ++ SYSCALL ++ STL R0, r1+32(FP) ++ STL R20, r2+40(FP) ++ RET +diff -urN containerd-1.5.9.org/vendor/golang.org/x/sys/unix/endian_little.go containerd-1.5.9.sw/vendor/golang.org/x/sys/unix/endian_little.go +--- containerd-1.5.9.org/vendor/golang.org/x/sys/unix/endian_little.go 2024-04-18 02:22:29.480948829 +0000 ++++ containerd-1.5.9.sw/vendor/golang.org/x/sys/unix/endian_little.go 2024-04-18 02:28:08.551279875 +0000 +@@ -2,8 +2,8 @@ + // Use of this source code is governed by a BSD-style + // license that can be found in the LICENSE file. + // +-//go:build 386 || amd64 || amd64p32 || alpha || arm || arm64 || mipsle || mips64le || mips64p32le || nios2 || ppc64le || riscv || riscv64 || sh +-// +build 386 amd64 amd64p32 alpha arm arm64 mipsle mips64le mips64p32le nios2 ppc64le riscv riscv64 sh ++//go:build sw64 || 386 || amd64 || amd64p32 || alpha || arm || arm64 || mipsle || mips64le || mips64p32le || nios2 || ppc64le || riscv || riscv64 || sh ++// +build sw64 386 amd64 amd64p32 alpha arm arm64 mipsle mips64le mips64p32le nios2 ppc64le riscv riscv64 sh + + package unix + +diff -urN containerd-1.5.9.org/vendor/golang.org/x/sys/unix/mkerrors_sw64.sh containerd-1.5.9.sw/vendor/golang.org/x/sys/unix/mkerrors_sw64.sh +--- containerd-1.5.9.org/vendor/golang.org/x/sys/unix/mkerrors_sw64.sh 1970-01-01 00:00:00.000000000 +0000 ++++ containerd-1.5.9.sw/vendor/golang.org/x/sys/unix/mkerrors_sw64.sh 2024-04-18 02:24:28.011064554 +0000 +@@ -0,0 +1,661 @@ ++#!/usr/bin/env bash ++# Copyright 2009 The Go Authors. All rights reserved. ++# Use of this source code is governed by a BSD-style ++# license that can be found in the LICENSE file. ++ ++# Generate Go code listing errors and other #defined constant ++# values (ENAMETOOLONG etc.), by asking the preprocessor ++# about the definitions. ++ ++unset LANG ++export LC_ALL=C ++export LC_CTYPE=C ++ ++if test -z "$GOARCH" -o -z "$GOOS"; then ++ echo 1>&2 "GOARCH or GOOS not defined in environment" ++ exit 1 ++fi ++ ++# Check that we are using the new build system if we should ++#if [[ "$GOOS" = "linux" ]] && [[ "$GOLANG_SYS_BUILD" != "docker" ]]; then ++# echo 1>&2 "In the Docker based build system, mkerrors should not be called directly." ++# echo 1>&2 "See README.md" ++# exit 1 ++#fi ++ ++if [[ "$GOOS" = "aix" ]]; then ++ CC=${CC:-gcc} ++else ++ CC=${CC:-cc} ++fi ++ ++if [[ "$GOOS" = "solaris" ]]; then ++ # Assumes GNU versions of utilities in PATH. ++ export PATH=/usr/gnu/bin:$PATH ++fi ++ ++uname=$(uname) ++ ++includes_AIX=' ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++ ++#define AF_LOCAL AF_UNIX ++' ++ ++includes_Darwin=' ++#define _DARWIN_C_SOURCE ++#define KERNEL ++#define _DARWIN_USE_64_BIT_INODE ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++' ++ ++includes_DragonFly=' ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++' ++ ++includes_FreeBSD=' ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++ ++#if __FreeBSD__ >= 10 ++#define IFT_CARP 0xf8 // IFT_CARP is deprecated in FreeBSD 10 ++#undef SIOCAIFADDR ++#define SIOCAIFADDR _IOW(105, 26, struct oifaliasreq) // ifaliasreq contains if_data ++#undef SIOCSIFPHYADDR ++#define SIOCSIFPHYADDR _IOW(105, 70, struct oifaliasreq) // ifaliasreq contains if_data ++#endif ++' ++ ++includes_Linux=' ++#define _LARGEFILE_SOURCE ++#define _LARGEFILE64_SOURCE ++#ifndef __LP64__ ++#define _FILE_OFFSET_BITS 64 ++#endif ++#define _GNU_SOURCE ++ ++// is broken on powerpc64, as it fails to include definitions of ++// these structures. We just include them copied from . ++#if defined(__powerpc__) ++struct sgttyb { ++ char sg_ispeed; ++ char sg_ospeed; ++ char sg_erase; ++ char sg_kill; ++ short sg_flags; ++}; ++ ++struct tchars { ++ char t_intrc; ++ char t_quitc; ++ char t_startc; ++ char t_stopc; ++ char t_eofc; ++ char t_brkc; ++}; ++ ++struct ltchars { ++ char t_suspc; ++ char t_dsuspc; ++ char t_rprntc; ++ char t_flushc; ++ char t_werasc; ++ char t_lnextc; ++}; ++#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 ++ ++#if defined(__sparc__) ++// On sparc{,64}, the kernel defines struct termios2 itself which clashes with the ++// definition in glibc. As only the error constants are needed here, include the ++// generic termibits.h (which is included by termbits.h on sparc). ++#include ++#else ++#include ++#endif ++ ++#ifndef MSG_FASTOPEN ++#define MSG_FASTOPEN 0x20000000 ++#endif ++ ++#ifndef PTRACE_GETREGS ++#define PTRACE_GETREGS 0xc ++#endif ++ ++#ifndef PTRACE_SETREGS ++#define PTRACE_SETREGS 0xd ++#endif ++ ++#ifndef SOL_NETLINK ++#define SOL_NETLINK 270 ++#endif ++ ++#ifdef SOL_BLUETOOTH ++// SPARC includes this in /usr/include/sparc64-linux-gnu/bits/socket.h ++// but it is already in bluetooth_linux.go ++#undef SOL_BLUETOOTH ++#endif ++ ++// Certain constants are missing from the fs/crypto UAPI ++#define FS_KEY_DESC_PREFIX "fscrypt:" ++#define FS_KEY_DESC_PREFIX_SIZE 8 ++#define FS_MAX_KEY_SIZE 64 ++' ++ ++includes_NetBSD=' ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++ ++// Needed since refers to it... ++#define schedppq 1 ++' ++ ++includes_OpenBSD=' ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++ ++// We keep some constants not supported in OpenBSD 5.5 and beyond for ++// the promise of compatibility. ++#define EMUL_ENABLED 0x1 ++#define EMUL_NATIVE 0x2 ++#define IPV6_FAITH 0x1d ++#define IPV6_OPTIONS 0x1 ++#define IPV6_RTHDR_STRICT 0x1 ++#define IPV6_SOCKOPT_RESERVED1 0x3 ++#define SIOCGIFGENERIC 0xc020693a ++#define SIOCSIFGENERIC 0x80206939 ++#define WALTSIG 0x4 ++' ++ ++includes_SunOS=' ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++' ++ ++ ++includes=' ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++' ++ccflags="$@" ++ ++# Write go tool cgo -godefs input. ++( ++ echo package unix ++ echo ++ echo '/*' ++ indirect="includes_$(uname)" ++ echo "${!indirect} $includes" ++ echo '*/' ++ echo 'import "C"' ++ echo 'import "syscall"' ++ echo ++ echo 'const (' ++ ++ # The gcc command line prints all the #defines ++ # it encounters while processing the input ++ echo "${!indirect} $includes" | $CC -x c - -E -dM $ccflags | ++ awk ' ++ $1 != "#define" || $2 ~ /\(/ || $3 == "" {next} ++ ++ $2 ~ /^E([ABCD]X|[BIS]P|[SD]I|S|FL)$/ {next} # 386 registers ++ $2 ~ /^(SIGEV_|SIGSTKSZ|SIGRT(MIN|MAX))/ {next} ++ $2 ~ /^(SCM_SRCRT)$/ {next} ++ $2 ~ /^(MAP_FAILED)$/ {next} ++ $2 ~ /^ELF_.*$/ {next}# contains ELF_ARCH, etc. ++ ++ $2 ~ /^EXTATTR_NAMESPACE_NAMES/ || ++ $2 ~ /^EXTATTR_NAMESPACE_[A-Z]+_STRING/ {next} ++ ++ $2 !~ /^ECCAPBITS/ && ++ $2 !~ /^ETH_/ && ++ $2 !~ /^EPROC_/ && ++ $2 !~ /^EQUIV_/ && ++ $2 !~ /^EXPR_/ && ++ $2 ~ /^E[A-Z0-9_]+$/ || ++ $2 ~ /^B[0-9_]+$/ || ++ $2 ~ /^(OLD|NEW)DEV$/ || ++ $2 == "BOTHER" || ++ $2 ~ /^CI?BAUD(EX)?$/ || ++ $2 == "IBSHIFT" || ++ $2 ~ /^V[A-Z0-9]+$/ || ++ $2 ~ /^CS[A-Z0-9]/ || ++ $2 ~ /^I(SIG|CANON|CRNL|UCLC|EXTEN|MAXBEL|STRIP|UTF8)$/ || ++ $2 ~ /^IGN/ || ++ $2 ~ /^IX(ON|ANY|OFF)$/ || ++ $2 ~ /^IN(LCR|PCK)$/ || ++ $2 !~ "X86_CR3_PCID_NOFLUSH" && ++ $2 ~ /(^FLU?SH)|(FLU?SH$)/ || ++ $2 ~ /^C(LOCAL|READ|MSPAR|RTSCTS)$/ || ++ $2 == "BRKINT" || ++ $2 == "HUPCL" || ++ $2 == "PENDIN" || ++ $2 == "TOSTOP" || ++ $2 == "XCASE" || ++ $2 == "ALTWERASE" || ++ $2 == "NOKERNINFO" || ++ $2 ~ /^PAR/ || ++ $2 ~ /^SIG[^_]/ || ++ $2 ~ /^O[CNPFPL][A-Z]+[^_][A-Z]+$/ || ++ $2 ~ /^(NL|CR|TAB|BS|VT|FF)DLY$/ || ++ $2 ~ /^(NL|CR|TAB|BS|VT|FF)[0-9]$/ || ++ $2 ~ /^O?XTABS$/ || ++ $2 ~ /^TC[IO](ON|OFF)$/ || ++ $2 ~ /^IN_/ || ++ $2 ~ /^LOCK_(SH|EX|NB|UN)$/ || ++ $2 ~ /^(AF|SOCK|SO|SOL|IPPROTO|IP|IPV6|ICMP6|TCP|EVFILT|NOTE|EV|SHUT|PROT|MAP|MFD|T?PACKET|MSG|SCM|MCL|DT|MADV|PR)_/ || ++ $2 ~ /^TP_STATUS_/ || ++ $2 ~ /^FALLOC_/ || ++ $2 == "ICMPV6_FILTER" || ++ $2 == "SOMAXCONN" || ++ $2 == "NAME_MAX" || ++ $2 == "IFNAMSIZ" || ++ $2 ~ /^CTL_(HW|KERN|MAXNAME|NET|QUERY)$/ || ++ $2 ~ /^KERN_(HOSTNAME|OS(RELEASE|TYPE)|VERSION)$/ || ++ $2 ~ /^HW_MACHINE$/ || ++ $2 ~ /^SYSCTL_VERS/ || ++ $2 !~ "MNT_BITS" && ++ $2 ~ /^(MS|MNT|UMOUNT)_/ || ++ $2 ~ /^TUN(SET|GET|ATTACH|DETACH)/ || ++ $2 ~ /^(O|F|[ES]?FD|NAME|S|PTRACE|PT)_/ || ++ $2 ~ /^KEXEC_/ || ++ $2 ~ /^LINUX_REBOOT_CMD_/ || ++ $2 ~ /^LINUX_REBOOT_MAGIC[12]$/ || ++ $2 ~ /^MODULE_INIT_/ || ++ $2 !~ "NLA_TYPE_MASK" && ++ $2 ~ /^(NETLINK|NLM|NLMSG|NLA|IFA|IFAN|RT|RTC|RTCF|RTN|RTPROT|RTNH|ARPHRD|ETH_P|NETNSA)_/ || ++ $2 ~ /^SIOC/ || ++ ($2 ~ /^TIOC/ && $0 !~ /struct/ && $3 !~ "FIONREAD") || ++ $2 ~ /^TCGET/ || ++ $2 ~ /^TCSET/ || ++ $2 ~ /^TC(FLSH|SBRKP?|XONC)$/ || ++ $2 !~ "RTF_BITS" && ++ $2 ~ /^(IFF|IFT|NET_RT|RTM|RTF|RTV|RTA|RTAX)_/ || ++ $2 ~ /^BIOC/ || ++ $2 ~ /^RUSAGE_(SELF|CHILDREN|THREAD)/ || ++ $2 ~ /^RLIMIT_(AS|CORE|CPU|DATA|FSIZE|LOCKS|MEMLOCK|MSGQUEUE|NICE|NOFILE|NPROC|RSS|RTPRIO|RTTIME|SIGPENDING|STACK)|RLIM_INFINITY/ || ++ $2 ~ /^PRIO_(PROCESS|PGRP|USER)/ || ++ $2 ~ /^CLONE_[A-Z_]+/ || ++ $2 !~ /^(BPF_TIMEVAL)$/ && ++ $2 ~ /^(BPF|DLT)_/ || ++ $2 ~ /^(CLOCK|TIMER)_/ || ++ $2 ~ /^CAN_/ || ++ $2 ~ /^CAP_/ || ++ $2 ~ /^ALG_/ || ++ $2 ~ /^FS_(POLICY_FLAGS|KEY_DESC|ENCRYPTION_MODE|[A-Z0-9_]+_KEY_SIZE|IOC_(GET|SET)_ENCRYPTION)/ || ++ $2 ~ /^GRND_/ || ++ $2 ~ /^RND/ || ++ $2 ~ /^KEY_(SPEC|REQKEY_DEFL)_/ || ++ $2 ~ /^KEYCTL_/ || ++ $2 ~ /^PERF_EVENT_IOC_/ || ++ $2 ~ /^SECCOMP_MODE_/ || ++ $2 ~ /^SPLICE_/ || ++ $2 ~ /^SYNC_FILE_RANGE_/ || ++ $2 !~ /^AUDIT_RECORD_MAGIC/ && ++ $2 !~ /IOC_MAGIC/ && ++ $2 ~ /^[A-Z][A-Z0-9_]+_MAGIC2?$/ || ++ $2 ~ /^(VM|VMADDR)_/ || ++ $2 ~ /^IOCTL_VM_SOCKETS_/ || ++ $2 ~ /^(TASKSTATS|TS)_/ || ++ $2 ~ /^CGROUPSTATS_/ || ++ $2 ~ /^GENL_/ || ++ $2 ~ /^STATX_/ || ++ $2 ~ /^RENAME/ || ++ $2 ~ /^UBI_IOC[A-Z]/ || ++ $2 ~ /^UTIME_/ || ++ $2 ~ /^XATTR_(CREATE|REPLACE|NO(DEFAULT|FOLLOW|SECURITY)|SHOWCOMPRESSION)/ || ++ $2 ~ /^ATTR_(BIT_MAP_COUNT|(CMN|VOL|FILE)_)/ || ++ $2 ~ /^FSOPT_/ || ++ $2 ~ /^WDIOC_/ || ++ $2 ~ /^NFN/ || ++ $2 ~ /^XDP_/ || ++ $2 ~ /^(HDIO|WIN|SMART)_/ || ++ $2 ~ /^CRYPTO_/ || ++ $2 !~ "WMESGLEN" && ++ $2 ~ /^W[A-Z0-9]+$/ || ++ $2 ~/^PPPIOC/ || ++ $2 ~ /^FAN_|FANOTIFY_/ || ++ $2 ~ /^BLK[A-Z]*(GET$|SET$|BUF$|PART$|SIZE)/ {printf("\t%s = C.%s\n", $2, $2)} ++ $2 ~ /^__WCOREFLAG$/ {next} ++ $2 ~ /^__W[A-Z0-9]+$/ {printf("\t%s = C.%s\n", substr($2,3), $2)} ++ ++ {next} ++ ' | sort ++ ++ echo ')' ++) >_const.go ++ ++# Pull out the error names for later. ++errors=$( ++ echo '#include ' | $CC -x c - -E -dM $ccflags | ++ awk '$1=="#define" && $2 ~ /^E[A-Z0-9_]+$/ { print $2 }' | ++ sort ++) ++ ++# Pull out the signal names for later. ++signals=$( ++ echo '#include ' | $CC -x c - -E -dM $ccflags | ++ awk '$1=="#define" && $2 ~ /^SIG[A-Z0-9]+$/ { print $2 }' | ++ egrep -v '(SIGSTKSIZE|SIGSTKSZ|SIGRT|SIGMAX64)' | ++ sort ++) ++ ++# Again, writing regexps to a file. ++echo '#include ' | $CC -x c - -E -dM $ccflags | ++ awk '$1=="#define" && $2 ~ /^E[A-Z0-9_]+$/ { print "^\t" $2 "[ \t]*=" }' | ++ sort >_error.grep ++echo '#include ' | $CC -x c - -E -dM $ccflags | ++ awk '$1=="#define" && $2 ~ /^SIG[A-Z0-9]+$/ { print "^\t" $2 "[ \t]*=" }' | ++ egrep -v '(SIGSTKSIZE|SIGSTKSZ|SIGRT|SIGMAX64)' | ++ sort >_signal.grep ++ ++echo '// mkerrors.sh' "$@" ++echo '// Code generated by the command above; see README.md. DO NOT EDIT.' ++echo ++echo "// +build ${GOARCH},${GOOS}" ++echo ++go tool cgo -godefs -- "$@" _const.go >_error.out ++cat _error.out | grep -vf _error.grep | grep -vf _signal.grep ++echo ++echo '// Errors' ++echo 'const (' ++cat _error.out | grep -f _error.grep | sed 's/=\(.*\)/= syscall.Errno(\1)/' ++echo ')' ++ ++echo ++echo '// Signals' ++echo 'const (' ++cat _error.out | grep -f _signal.grep | sed 's/=\(.*\)/= syscall.Signal(\1)/' ++echo ')' ++ ++# Run C program to print error and syscall strings. ++( ++ echo -E " ++#include ++#include ++#include ++#include ++#include ++#include ++ ++#define nelem(x) (sizeof(x)/sizeof((x)[0])) ++ ++enum { A = 'A', Z = 'Z', a = 'a', z = 'z' }; // avoid need for single quotes below ++ ++struct tuple { ++ int num; ++ const char *name; ++}; ++ ++struct tuple errors[] = { ++" ++ for i in $errors ++ do ++ echo -E ' {'$i', "'$i'" },' ++ done ++ ++ echo -E " ++}; ++ ++struct tuple signals[] = { ++" ++ for i in $signals ++ do ++ echo -E ' {'$i', "'$i'" },' ++ done ++ ++ # Use -E because on some systems bash builtin interprets \n itself. ++ echo -E ' ++}; ++ ++static int ++tuplecmp(const void *a, const void *b) ++{ ++ return ((struct tuple *)a)->num - ((struct tuple *)b)->num; ++} ++ ++int ++main(void) ++{ ++ int i, e; ++ char buf[1024], *p; ++ ++ printf("\n\n// Error table\n"); ++ printf("var errorList = [...]struct {\n"); ++ printf("\tnum syscall.Errno\n"); ++ printf("\tname string\n"); ++ printf("\tdesc string\n"); ++ printf("} {\n"); ++ qsort(errors, nelem(errors), sizeof errors[0], tuplecmp); ++ for(i=0; i 0 && errors[i-1].num == e) ++ continue; ++ strcpy(buf, strerror(e)); ++ // lowercase first letter: Bad -> bad, but STREAM -> STREAM. ++ if(A <= buf[0] && buf[0] <= Z && a <= buf[1] && buf[1] <= z) ++ buf[0] += a - A; ++ printf("\t{ %d, \"%s\", \"%s\" },\n", e, errors[i].name, buf); ++ } ++ printf("}\n\n"); ++ ++ printf("\n\n// Signal table\n"); ++ printf("var signalList = [...]struct {\n"); ++ printf("\tnum syscall.Signal\n"); ++ printf("\tname string\n"); ++ printf("\tdesc string\n"); ++ printf("} {\n"); ++ qsort(signals, nelem(signals), sizeof signals[0], tuplecmp); ++ for(i=0; i 0 && signals[i-1].num == e) ++ continue; ++ strcpy(buf, strsignal(e)); ++ // lowercase first letter: Bad -> bad, but STREAM -> STREAM. ++ if(A <= buf[0] && buf[0] <= Z && a <= buf[1] && buf[1] <= z) ++ buf[0] += a - A; ++ // cut trailing : number. ++ p = strrchr(buf, ":"[0]); ++ if(p) ++ *p = '\0'; ++ printf("\t{ %d, \"%s\", \"%s\" },\n", e, signals[i].name, buf); ++ } ++ printf("}\n\n"); ++ ++ return 0; ++} ++ ++' ++) >_errors.c ++ ++$CC $ccflags -o _errors _errors.c && $GORUN ./_errors && rm -f _errors.c _errors _const.go _error.grep _signal.grep _error.out +diff -urN containerd-1.5.9.org/vendor/golang.org/x/sys/unix/syscall_linux_sw64.go containerd-1.5.9.sw/vendor/golang.org/x/sys/unix/syscall_linux_sw64.go +--- containerd-1.5.9.org/vendor/golang.org/x/sys/unix/syscall_linux_sw64.go 1970-01-01 00:00:00.000000000 +0000 ++++ containerd-1.5.9.sw/vendor/golang.org/x/sys/unix/syscall_linux_sw64.go 2024-04-18 02:28:08.491279816 +0000 +@@ -0,0 +1,173 @@ ++// Copyright 2009 The Go Authors. All rights reserved. ++// Use of this source code is governed by a BSD-style ++// license that can be found in the LICENSE file. ++ ++//go:build linux && sw64 ++// +build linux,sw64 ++ ++package unix ++ ++ ++const ( ++ //generate by handle in zerrors_linux_sw64.go ++ //_snyh_TODO: this should be generate by improving build script ++ TIOCGWINSZ = 0x40087468 ++) ++ ++const ( ++ //ALL OF THIS constants are WORKAROUND, and should be removing ++ SYS_NEWFSTATAT = SYS_FSTATAT64 ++ SYS_MOUNT_SETATTR = 442 ++) ++ ++//sysnb getxpid() (pid int, ppid int) ++// TODO(snyh): correct handle Getppid and Getpid ++// currently manually remove the implements of Getpid and Getppid ++// in zsyscall_linux_sw64.go ++func Getpid() (pid int) { pid, _ = getxpid(); return } ++func Getppid() (ppid int) { _, ppid = getxpid(); return } ++ ++// TODO(snyh): correct handle Utime ++func Utime(path string, buf *Utimbuf) error { ++ tv := [2]Timeval{ ++ {Sec: buf.Actime}, ++ {Sec: buf.Modtime}, ++ } ++ return utimes(path, &tv) ++} ++ ++//sys Fstat64(fd int, st *Stat_t) (err error) ++//sys Lstat64(path string, st *Stat_t) (err error) ++//sys Stat64(path string, st *Stat_t) (err error) ++func Fstat(fd int, st *Stat_t) (err error) { return Fstat64(fd, st) } ++func Lstat(path string, st *Stat_t) (err error) { return Lstat64(path, st) } ++func Stat(path string, st *Stat_t) (err error) { return Stat64(path, st) } ++ ++//sys getxuid() (uid int, euid int) ++func Getuid() (uid int) { uid, _ = getxuid(); return } ++func Geteuid() (euid int) { _, euid = getxuid(); return } ++ ++//sys getxgid() (gid int, egid int) ++func Getgid() (gid int) { gid, _ = getxgid(); return } ++func Getegid() (egid int) { _, egid = getxgid(); return } ++ ++//sys Statfs(path string, buf *Statfs_t) (err error) ++//sys Fstatfs(fd int, buf *Statfs_t) (err error) ++//sys Fchown(fd int, uid int, gid int) (err error) ++//sys Ftruncate(fd int, length int64) (err error) ++//sysnb Getrlimit(resource int, rlim *Rlimit) (err error) ++//sys Lchown(path string, uid int, gid int) (err error) ++//sys Listen(s int, n int) (err error) ++//sys pread(fd int, p []byte, offset int64) (n int, err error) = SYS_PREAD64 ++//sys pwrite(fd int, p []byte, offset int64) (n int, err error) = SYS_PWRITE64 ++//sys Seek(fd int, offset int64, whence int) (off int64, err error) = SYS_LSEEK ++//sys sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) ++//sys setfsgid(gid int) (prev int, err error) ++//sys setfsuid(uid int) (prev int, err error) ++//sysnb Setrlimit(resource int, rlim *Rlimit) (err error) ++//sys Shutdown(fd int, how int) (err error) ++//sys Splice(rfd int, roff *int64, wfd int, woff *int64, len int, flags int) (n int64, err error) ++ ++//sys SyncFileRange(fd int, off int64, n int64, flags int) (err error) ++//sys Truncate(path string, length int64) (err error) ++//sys accept(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (fd int, err error) ++//sys accept4(s int, rsa *RawSockaddrAny, addrlen *_Socklen, flags int) (fd int, err error) ++//sys bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) ++//sys connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) ++//sysnb getgroups(n int, list *_Gid_t) (nn int, err error) ++//sysnb setgroups(n int, list *_Gid_t) (err error) ++//sys getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error) ++//sys setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error) ++//sysnb socket(domain int, typ int, proto int) (fd int, err error) ++//sysnb socketpair(domain int, typ int, proto int, fd *[2]int32) (err error) ++//sysnb getpeername(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) ++//sysnb getsockname(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) ++//sys recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Socklen) (n int, err error) ++//sys sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (err error) ++//sys recvmsg(s int, msg *Msghdr, flags int) (n int, err error) ++//sys sendmsg(s int, msg *Msghdr, flags int) (n int, err error) ++//sys mmap(addr uintptr, length uintptr, prot int, flags int, fd int, offset int64) (xaddr uintptr, err error) ++ ++//sysnb Gettimeofday(tv *Timeval) (err error) ++ ++func Time(t *Time_t) (tt Time_t, err error) { ++ var tv Timeval ++ err = Gettimeofday(&tv) ++ if err != nil { ++ return 0, err ++ } ++ if t != nil { ++ *t = Time_t(tv.Sec) ++ } ++ return Time_t(tv.Sec), nil ++} ++ ++func setTimespec(sec, nsec int64) Timespec { ++ return Timespec{Sec: sec, Nsec: nsec} ++} ++ ++func setTimeval(sec, usec int64) Timeval { ++ return Timeval{Sec: sec, Usec: usec} ++} ++ ++func Ioperm(from int, num int, on int) (err error) { ++ return ENOSYS ++} ++ ++func Iopl(level int) (err error) { ++ return ENOSYS ++} ++ ++// func (r *PtraceRegs) PC() uint64 { return r.Epc } ++// func (r *PtraceRegs) SetPC(pc uint64) { r.Epc = pc } ++ ++func (iov *Iovec) SetLen(length int) { ++ iov.Len = uint64(length) ++} ++ ++func (msghdr *Msghdr) SetControllen(length int) { ++ msghdr.Controllen = uint64(length) ++} ++ ++func (msghdr *Msghdr) SetIovlen(length int) { ++ msghdr.Iovlen = uint64(length) ++} ++ ++func (cmsg *Cmsghdr) SetLen(length int) { ++ cmsg.Len = uint64(length) ++} ++ ++ ++//sys EpollWait(epfd int, events []EpollEvent, msec int) (n int, err error) ++//sys Fadvise(fd int, offset int64, length int64, advice int) (err error) = SYS_FADVISE64 ++//sys Fstatat(dirfd int, path string, stat *Stat_t, flags int) (err error) = SYS_NEWFSTATAT ++func Select(nfd int, r *FdSet, w *FdSet, e *FdSet, timeout *Timeval) (n int, err error) { ++ var ts *Timespec ++ if timeout != nil { ++ ts = &Timespec{Sec: timeout.Sec, Nsec: timeout.Usec * 1000} ++ } ++ return Pselect(nfd, r, w, e, ts, nil) ++} ++ ++//sys Ustat(dev int, ubuf *Ustat_t) (err error) ++//sys futimesat(dirfd int, path string, times *[2]Timeval) (err error) ++//sys utimes(path string, times *[2]Timeval) (err error) ++ ++//sys Renameat(olddirfd int, oldpath string, newdirfd int, newpath string) (err error) ++ ++func (rsa *RawSockaddrNFCLLCP) SetServiceNameLen(length int) { ++ rsa.Service_name_len = uint64(length) ++} ++ ++//sysnb pipe2(p *[2]_C_int, flags int) (err error) ++ ++func Pipe2(p []int, flags int) (err error) { ++ if len(p) != 2 { ++ return EINVAL ++ } ++ var pp [2]_C_int ++ err = pipe2(&pp, flags) ++ p[0] = int(pp[0]) ++ p[1] = int(pp[1]) ++ return ++} +diff -urN containerd-1.5.9.org/vendor/golang.org/x/sys/unix/zerrors_linux.go containerd-1.5.9.sw/vendor/golang.org/x/sys/unix/zerrors_linux.go +--- containerd-1.5.9.org/vendor/golang.org/x/sys/unix/zerrors_linux.go 2024-04-18 02:22:29.510948859 +0000 ++++ containerd-1.5.9.sw/vendor/golang.org/x/sys/unix/zerrors_linux.go 2024-04-18 02:23:50.041027483 +0000 +@@ -1,7 +1,8 @@ + // Code generated by mkmerge.go; DO NOT EDIT. + +-//go:build linux ++//go:build linux && !sw64 + // +build linux ++// +build !sw64 + + package unix + +diff -urN containerd-1.5.9.org/vendor/golang.org/x/sys/unix/zerrors_linux_sw64.go containerd-1.5.9.sw/vendor/golang.org/x/sys/unix/zerrors_linux_sw64.go +--- containerd-1.5.9.org/vendor/golang.org/x/sys/unix/zerrors_linux_sw64.go 1970-01-01 00:00:00.000000000 +0000 ++++ containerd-1.5.9.sw/vendor/golang.org/x/sys/unix/zerrors_linux_sw64.go 2024-04-18 02:28:08.301279631 +0000 +@@ -0,0 +1,4107 @@ ++// mkerrors.sh -Wall -Werror -static -I/tmp/sw64/include ++// Code generated by the command above; see README.md. DO NOT EDIT. ++ ++//go:build sw64 && linux ++// +build sw64,linux ++ ++// Code generated by cmd/cgo -godefs; DO NOT EDIT. ++// cgo -godefs -- -Wall -Werror -static -I/tmp/sw64/include _const.go ++ ++package unix ++ ++import "syscall" ++ ++const ( ++ AAFS_MAGIC = 0x5a3c69f0 ++ ADFS_SUPER_MAGIC = 0xadf5 ++ AFFS_SUPER_MAGIC = 0xadff ++ AFS_FS_MAGIC = 0x6b414653 ++ AFS_SUPER_MAGIC = 0x5346414f ++ AF_ALG = 0x26 ++ AF_APPLETALK = 0x5 ++ AF_ASH = 0x12 ++ AF_ATMPVC = 0x8 ++ AF_ATMSVC = 0x14 ++ AF_AX25 = 0x3 ++ AF_BLUETOOTH = 0x1f ++ AF_BRIDGE = 0x7 ++ AF_CAIF = 0x25 ++ AF_CAN = 0x1d ++ AF_DECnet = 0xc ++ AF_ECONET = 0x13 ++ AF_FILE = 0x1 ++ AF_IB = 0x1b ++ AF_IEEE802154 = 0x24 ++ AF_INET = 0x2 ++ AF_INET6 = 0xa ++ AF_IPX = 0x4 ++ AF_IRDA = 0x17 ++ AF_ISDN = 0x22 ++ AF_IUCV = 0x20 ++ AF_KCM = 0x29 ++ AF_KEY = 0xf ++ AF_LLC = 0x1a ++ AF_LOCAL = 0x1 ++ AF_MAX = 0x2e ++ AF_MCTP = 0x2d ++ AF_MPLS = 0x1c ++ AF_NETBEUI = 0xd ++ AF_NETLINK = 0x10 ++ AF_NETROM = 0x6 ++ AF_NFC = 0x27 ++ AF_PACKET = 0x11 ++ AF_PHONET = 0x23 ++ AF_PPPOX = 0x18 ++ AF_QIPCRTR = 0x2a ++ AF_RDS = 0x15 ++ AF_ROSE = 0xb ++ AF_ROUTE = 0x10 ++ AF_RXRPC = 0x21 ++ AF_SECURITY = 0xe ++ AF_SMC = 0x2b ++ AF_SNA = 0x16 ++ AF_TIPC = 0x1e ++ AF_UNIX = 0x1 ++ AF_UNSPEC = 0x0 ++ AF_VSOCK = 0x28 ++ AF_WANPIPE = 0x19 ++ AF_X25 = 0x9 ++ AF_XDP = 0x2c ++ ALG_OP_DECRYPT = 0x0 ++ ALG_OP_ENCRYPT = 0x1 ++ ALG_SET_AEAD_ASSOCLEN = 0x4 ++ ALG_SET_AEAD_AUTHSIZE = 0x5 ++ ALG_SET_DRBG_ENTROPY = 0x6 ++ ALG_SET_IV = 0x2 ++ ALG_SET_KEY = 0x1 ++ ALG_SET_OP = 0x3 ++ ANON_INODE_FS_MAGIC = 0x9041934 ++ ARPHRD_6LOWPAN = 0x339 ++ ARPHRD_ADAPT = 0x108 ++ ARPHRD_APPLETLK = 0x8 ++ ARPHRD_ARCNET = 0x7 ++ ARPHRD_ASH = 0x30d ++ ARPHRD_ATM = 0x13 ++ ARPHRD_AX25 = 0x3 ++ ARPHRD_BIF = 0x307 ++ ARPHRD_CAIF = 0x336 ++ ARPHRD_CAN = 0x118 ++ ARPHRD_CHAOS = 0x5 ++ ARPHRD_CISCO = 0x201 ++ ARPHRD_CSLIP = 0x101 ++ ARPHRD_CSLIP6 = 0x103 ++ ARPHRD_DDCMP = 0x205 ++ ARPHRD_DLCI = 0xf ++ ARPHRD_ECONET = 0x30e ++ ARPHRD_EETHER = 0x2 ++ ARPHRD_ETHER = 0x1 ++ ARPHRD_EUI64 = 0x1b ++ ARPHRD_FCAL = 0x311 ++ ARPHRD_FCFABRIC = 0x313 ++ ARPHRD_FCPL = 0x312 ++ ARPHRD_FCPP = 0x310 ++ ARPHRD_FDDI = 0x306 ++ ARPHRD_FRAD = 0x302 ++ ARPHRD_HDLC = 0x201 ++ ARPHRD_HIPPI = 0x30c ++ ARPHRD_HWX25 = 0x110 ++ ARPHRD_IEEE1394 = 0x18 ++ ARPHRD_IEEE802 = 0x6 ++ ARPHRD_IEEE80211 = 0x321 ++ ARPHRD_IEEE80211_PRISM = 0x322 ++ ARPHRD_IEEE80211_RADIOTAP = 0x323 ++ ARPHRD_IEEE802154 = 0x324 ++ ARPHRD_IEEE802154_MONITOR = 0x325 ++ ARPHRD_IEEE802_TR = 0x320 ++ ARPHRD_INFINIBAND = 0x20 ++ ARPHRD_IP6GRE = 0x337 ++ ARPHRD_IPDDP = 0x309 ++ ARPHRD_IPGRE = 0x30a ++ ARPHRD_IRDA = 0x30f ++ ARPHRD_LAPB = 0x204 ++ ARPHRD_LOCALTLK = 0x305 ++ ARPHRD_LOOPBACK = 0x304 ++ ARPHRD_METRICOM = 0x17 ++ ARPHRD_NETLINK = 0x338 ++ ARPHRD_NETROM = 0x0 ++ ARPHRD_NONE = 0xfffe ++ ARPHRD_PHONET = 0x334 ++ ARPHRD_PHONET_PIPE = 0x335 ++ ARPHRD_PIMREG = 0x30b ++ ARPHRD_PPP = 0x200 ++ ARPHRD_PRONET = 0x4 ++ ARPHRD_RAWHDLC = 0x206 ++ ARPHRD_RAWIP = 0x207 ++ ARPHRD_ROSE = 0x10e ++ ARPHRD_RSRVD = 0x104 ++ ARPHRD_SIT = 0x308 ++ ARPHRD_SKIP = 0x303 ++ ARPHRD_SLIP = 0x100 ++ ARPHRD_SLIP6 = 0x102 ++ ARPHRD_TUNNEL = 0x300 ++ ARPHRD_TUNNEL6 = 0x301 ++ ARPHRD_VOID = 0xffff ++ ARPHRD_VSOCKMON = 0x33a ++ ARPHRD_X25 = 0x10f ++ AUDIT_ADD = 0x3eb ++ AUDIT_ADD_RULE = 0x3f3 ++ AUDIT_ALWAYS = 0x2 ++ AUDIT_ANOM_ABEND = 0x6a5 ++ AUDIT_ANOM_CREAT = 0x6a7 ++ AUDIT_ANOM_LINK = 0x6a6 ++ AUDIT_ANOM_PROMISCUOUS = 0x6a4 ++ AUDIT_ARCH = 0xb ++ AUDIT_ARCH_AARCH64 = 0xc00000b7 ++ AUDIT_ARCH_ALPHA = 0xc0009026 ++ AUDIT_ARCH_ARCOMPACT = 0x4000005d ++ AUDIT_ARCH_ARCOMPACTBE = 0x5d ++ AUDIT_ARCH_ARCV2 = 0x400000c3 ++ AUDIT_ARCH_ARCV2BE = 0xc3 ++ AUDIT_ARCH_ARM = 0x40000028 ++ AUDIT_ARCH_ARMEB = 0x28 ++ AUDIT_ARCH_C6X = 0x4000008c ++ AUDIT_ARCH_C6XBE = 0x8c ++ AUDIT_ARCH_CRIS = 0x4000004c ++ AUDIT_ARCH_CSKY = 0x400000fc ++ AUDIT_ARCH_FRV = 0x5441 ++ AUDIT_ARCH_H8300 = 0x2e ++ AUDIT_ARCH_HEXAGON = 0xa4 ++ AUDIT_ARCH_I386 = 0x40000003 ++ AUDIT_ARCH_IA64 = 0xc0000032 ++ AUDIT_ARCH_M32R = 0x58 ++ AUDIT_ARCH_M68K = 0x4 ++ AUDIT_ARCH_MICROBLAZE = 0xbd ++ AUDIT_ARCH_MIPS = 0x8 ++ AUDIT_ARCH_MIPS64 = 0x80000008 ++ AUDIT_ARCH_MIPS64N32 = 0xa0000008 ++ AUDIT_ARCH_MIPSEL = 0x40000008 ++ AUDIT_ARCH_MIPSEL64 = 0xc0000008 ++ AUDIT_ARCH_MIPSEL64N32 = 0xe0000008 ++ AUDIT_ARCH_NDS32 = 0x400000a7 ++ AUDIT_ARCH_NDS32BE = 0xa7 ++ AUDIT_ARCH_NIOS2 = 0x40000071 ++ AUDIT_ARCH_OPENRISC = 0x5c ++ AUDIT_ARCH_PARISC = 0xf ++ AUDIT_ARCH_PARISC64 = 0x8000000f ++ AUDIT_ARCH_PPC = 0x14 ++ AUDIT_ARCH_PPC64 = 0x80000015 ++ AUDIT_ARCH_PPC64LE = 0xc0000015 ++ AUDIT_ARCH_RISCV32 = 0x400000f3 ++ AUDIT_ARCH_RISCV64 = 0xc00000f3 ++ AUDIT_ARCH_S390 = 0x16 ++ AUDIT_ARCH_S390X = 0x80000016 ++ AUDIT_ARCH_SH = 0x2a ++ AUDIT_ARCH_SH64 = 0x8000002a ++ AUDIT_ARCH_SHEL = 0x4000002a ++ AUDIT_ARCH_SHEL64 = 0xc000002a ++ AUDIT_ARCH_SPARC = 0x2 ++ AUDIT_ARCH_SPARC64 = 0x8000002b ++ AUDIT_ARCH_SW64 = 0xc0009916 ++ AUDIT_ARCH_TILEGX = 0xc00000bf ++ AUDIT_ARCH_TILEGX32 = 0x400000bf ++ AUDIT_ARCH_TILEPRO = 0x400000bc ++ AUDIT_ARCH_UNICORE = 0x4000006e ++ AUDIT_ARCH_X86_64 = 0xc000003e ++ AUDIT_ARCH_XTENSA = 0x5e ++ AUDIT_ARG0 = 0xc8 ++ AUDIT_ARG1 = 0xc9 ++ AUDIT_ARG2 = 0xca ++ AUDIT_ARG3 = 0xcb ++ AUDIT_AVC = 0x578 ++ AUDIT_AVC_PATH = 0x57a ++ AUDIT_BITMASK_SIZE = 0x40 ++ AUDIT_BIT_MASK = 0x8000000 ++ AUDIT_BIT_TEST = 0x48000000 ++ AUDIT_BPF = 0x536 ++ AUDIT_BPRM_FCAPS = 0x529 ++ AUDIT_CAPSET = 0x52a ++ AUDIT_CLASS_CHATTR = 0x2 ++ AUDIT_CLASS_CHATTR_32 = 0x3 ++ AUDIT_CLASS_DIR_WRITE = 0x0 ++ AUDIT_CLASS_DIR_WRITE_32 = 0x1 ++ AUDIT_CLASS_READ = 0x4 ++ AUDIT_CLASS_READ_32 = 0x5 ++ AUDIT_CLASS_SIGNAL = 0x8 ++ AUDIT_CLASS_SIGNAL_32 = 0x9 ++ AUDIT_CLASS_WRITE = 0x6 ++ AUDIT_CLASS_WRITE_32 = 0x7 ++ AUDIT_COMPARE_AUID_TO_EUID = 0x10 ++ AUDIT_COMPARE_AUID_TO_FSUID = 0xe ++ AUDIT_COMPARE_AUID_TO_OBJ_UID = 0x5 ++ AUDIT_COMPARE_AUID_TO_SUID = 0xf ++ AUDIT_COMPARE_EGID_TO_FSGID = 0x17 ++ AUDIT_COMPARE_EGID_TO_OBJ_GID = 0x4 ++ AUDIT_COMPARE_EGID_TO_SGID = 0x18 ++ AUDIT_COMPARE_EUID_TO_FSUID = 0x12 ++ AUDIT_COMPARE_EUID_TO_OBJ_UID = 0x3 ++ AUDIT_COMPARE_EUID_TO_SUID = 0x11 ++ AUDIT_COMPARE_FSGID_TO_OBJ_GID = 0x9 ++ AUDIT_COMPARE_FSUID_TO_OBJ_UID = 0x8 ++ AUDIT_COMPARE_GID_TO_EGID = 0x14 ++ AUDIT_COMPARE_GID_TO_FSGID = 0x15 ++ AUDIT_COMPARE_GID_TO_OBJ_GID = 0x2 ++ AUDIT_COMPARE_GID_TO_SGID = 0x16 ++ AUDIT_COMPARE_SGID_TO_FSGID = 0x19 ++ AUDIT_COMPARE_SGID_TO_OBJ_GID = 0x7 ++ AUDIT_COMPARE_SUID_TO_FSUID = 0x13 ++ AUDIT_COMPARE_SUID_TO_OBJ_UID = 0x6 ++ AUDIT_COMPARE_UID_TO_AUID = 0xa ++ AUDIT_COMPARE_UID_TO_EUID = 0xb ++ AUDIT_COMPARE_UID_TO_FSUID = 0xc ++ AUDIT_COMPARE_UID_TO_OBJ_UID = 0x1 ++ AUDIT_COMPARE_UID_TO_SUID = 0xd ++ AUDIT_CONFIG_CHANGE = 0x519 ++ AUDIT_CWD = 0x51b ++ AUDIT_DAEMON_ABORT = 0x4b2 ++ AUDIT_DAEMON_CONFIG = 0x4b3 ++ AUDIT_DAEMON_END = 0x4b1 ++ AUDIT_DAEMON_START = 0x4b0 ++ AUDIT_DEL = 0x3ec ++ AUDIT_DEL_RULE = 0x3f4 ++ AUDIT_DEVMAJOR = 0x64 ++ AUDIT_DEVMINOR = 0x65 ++ AUDIT_DIR = 0x6b ++ AUDIT_EGID = 0x6 ++ AUDIT_EOE = 0x528 ++ AUDIT_EQUAL = 0x40000000 ++ AUDIT_EUID = 0x2 ++ AUDIT_EVENT_LISTENER = 0x537 ++ AUDIT_EXE = 0x70 ++ AUDIT_EXECVE = 0x51d ++ AUDIT_EXIT = 0x67 ++ AUDIT_FAIL_PANIC = 0x2 ++ AUDIT_FAIL_PRINTK = 0x1 ++ AUDIT_FAIL_SILENT = 0x0 ++ AUDIT_FANOTIFY = 0x533 ++ AUDIT_FD_PAIR = 0x525 ++ AUDIT_FEATURE_BITMAP_ALL = 0x7f ++ AUDIT_FEATURE_BITMAP_BACKLOG_LIMIT = 0x1 ++ AUDIT_FEATURE_BITMAP_BACKLOG_WAIT_TIME = 0x2 ++ AUDIT_FEATURE_BITMAP_EXCLUDE_EXTEND = 0x8 ++ AUDIT_FEATURE_BITMAP_EXECUTABLE_PATH = 0x4 ++ AUDIT_FEATURE_BITMAP_FILTER_FS = 0x40 ++ AUDIT_FEATURE_BITMAP_LOST_RESET = 0x20 ++ AUDIT_FEATURE_BITMAP_SESSIONID_FILTER = 0x10 ++ AUDIT_FEATURE_CHANGE = 0x530 ++ AUDIT_FEATURE_LOGINUID_IMMUTABLE = 0x1 ++ AUDIT_FEATURE_ONLY_UNSET_LOGINUID = 0x0 ++ AUDIT_FEATURE_VERSION = 0x1 ++ AUDIT_FIELD_COMPARE = 0x6f ++ AUDIT_FILETYPE = 0x6c ++ AUDIT_FILTERKEY = 0xd2 ++ AUDIT_FILTER_ENTRY = 0x2 ++ AUDIT_FILTER_EXCLUDE = 0x5 ++ AUDIT_FILTER_EXIT = 0x4 ++ AUDIT_FILTER_FS = 0x6 ++ AUDIT_FILTER_PREPEND = 0x10 ++ AUDIT_FILTER_TASK = 0x1 ++ AUDIT_FILTER_TYPE = 0x5 ++ AUDIT_FILTER_USER = 0x0 ++ AUDIT_FILTER_WATCH = 0x3 ++ AUDIT_FIRST_KERN_ANOM_MSG = 0x6a4 ++ AUDIT_FIRST_USER_MSG = 0x44c ++ AUDIT_FIRST_USER_MSG2 = 0x834 ++ AUDIT_FSGID = 0x8 ++ AUDIT_FSTYPE = 0x1a ++ AUDIT_FSUID = 0x4 ++ AUDIT_GET = 0x3e8 ++ AUDIT_GET_FEATURE = 0x3fb ++ AUDIT_GID = 0x5 ++ AUDIT_GREATER_THAN = 0x20000000 ++ AUDIT_GREATER_THAN_OR_EQUAL = 0x60000000 ++ AUDIT_INODE = 0x66 ++ AUDIT_INTEGRITY_DATA = 0x708 ++ AUDIT_INTEGRITY_EVM_XATTR = 0x70e ++ AUDIT_INTEGRITY_HASH = 0x70b ++ AUDIT_INTEGRITY_METADATA = 0x709 ++ AUDIT_INTEGRITY_PCR = 0x70c ++ AUDIT_INTEGRITY_POLICY_RULE = 0x70f ++ AUDIT_INTEGRITY_RULE = 0x70d ++ AUDIT_INTEGRITY_STATUS = 0x70a ++ AUDIT_IPC = 0x517 ++ AUDIT_IPC_SET_PERM = 0x51f ++ AUDIT_KERNEL = 0x7d0 ++ AUDIT_KERNEL_OTHER = 0x524 ++ AUDIT_KERN_MODULE = 0x532 ++ AUDIT_LAST_FEATURE = 0x1 ++ AUDIT_LAST_KERN_ANOM_MSG = 0x707 ++ AUDIT_LAST_USER_MSG = 0x4af ++ AUDIT_LAST_USER_MSG2 = 0xbb7 ++ AUDIT_LESS_THAN = 0x10000000 ++ AUDIT_LESS_THAN_OR_EQUAL = 0x50000000 ++ AUDIT_LIST = 0x3ea ++ AUDIT_LIST_RULES = 0x3f5 ++ AUDIT_LOGIN = 0x3ee ++ AUDIT_LOGINUID = 0x9 ++ AUDIT_LOGINUID_SET = 0x18 ++ AUDIT_MAC_CALIPSO_ADD = 0x58a ++ AUDIT_MAC_CALIPSO_DEL = 0x58b ++ AUDIT_MAC_CIPSOV4_ADD = 0x57f ++ AUDIT_MAC_CIPSOV4_DEL = 0x580 ++ AUDIT_MAC_CONFIG_CHANGE = 0x57d ++ AUDIT_MAC_IPSEC_ADDSA = 0x583 ++ AUDIT_MAC_IPSEC_ADDSPD = 0x585 ++ AUDIT_MAC_IPSEC_DELSA = 0x584 ++ AUDIT_MAC_IPSEC_DELSPD = 0x586 ++ AUDIT_MAC_IPSEC_EVENT = 0x587 ++ AUDIT_MAC_MAP_ADD = 0x581 ++ AUDIT_MAC_MAP_DEL = 0x582 ++ AUDIT_MAC_POLICY_LOAD = 0x57b ++ AUDIT_MAC_STATUS = 0x57c ++ AUDIT_MAC_UNLBL_ALLOW = 0x57e ++ AUDIT_MAC_UNLBL_STCADD = 0x588 ++ AUDIT_MAC_UNLBL_STCDEL = 0x589 ++ AUDIT_MAKE_EQUIV = 0x3f7 ++ AUDIT_MAX_FIELDS = 0x40 ++ AUDIT_MAX_FIELD_COMPARE = 0x19 ++ AUDIT_MAX_KEY_LEN = 0x100 ++ AUDIT_MESSAGE_TEXT_MAX = 0x2170 ++ AUDIT_MMAP = 0x52b ++ AUDIT_MQ_GETSETATTR = 0x523 ++ AUDIT_MQ_NOTIFY = 0x522 ++ AUDIT_MQ_OPEN = 0x520 ++ AUDIT_MQ_SENDRECV = 0x521 ++ AUDIT_MSGTYPE = 0xc ++ AUDIT_NEGATE = 0x80000000 ++ AUDIT_NETFILTER_CFG = 0x52d ++ AUDIT_NETFILTER_PKT = 0x52c ++ AUDIT_NEVER = 0x0 ++ AUDIT_NLGRP_MAX = 0x1 ++ AUDIT_NOT_EQUAL = 0x30000000 ++ AUDIT_NR_FILTERS = 0x7 ++ AUDIT_OBJ_GID = 0x6e ++ AUDIT_OBJ_LEV_HIGH = 0x17 ++ AUDIT_OBJ_LEV_LOW = 0x16 ++ AUDIT_OBJ_PID = 0x526 ++ AUDIT_OBJ_ROLE = 0x14 ++ AUDIT_OBJ_TYPE = 0x15 ++ AUDIT_OBJ_UID = 0x6d ++ AUDIT_OBJ_USER = 0x13 ++ AUDIT_OPERATORS = 0x78000000 ++ AUDIT_PATH = 0x516 ++ AUDIT_PERM = 0x6a ++ AUDIT_PERM_ATTR = 0x8 ++ AUDIT_PERM_EXEC = 0x1 ++ AUDIT_PERM_READ = 0x4 ++ AUDIT_PERM_WRITE = 0x2 ++ AUDIT_PERS = 0xa ++ AUDIT_PID = 0x0 ++ AUDIT_POSSIBLE = 0x1 ++ AUDIT_PPID = 0x12 ++ AUDIT_PROCTITLE = 0x52f ++ AUDIT_REPLACE = 0x531 ++ AUDIT_SADDR_FAM = 0x71 ++ AUDIT_SECCOMP = 0x52e ++ AUDIT_SELINUX_ERR = 0x579 ++ AUDIT_SESSIONID = 0x19 ++ AUDIT_SET = 0x3e9 ++ AUDIT_SET_FEATURE = 0x3fa ++ AUDIT_SGID = 0x7 ++ AUDIT_SID_UNSET = 0xffffffff ++ AUDIT_SIGNAL_INFO = 0x3f2 ++ AUDIT_SOCKADDR = 0x51a ++ AUDIT_SOCKETCALL = 0x518 ++ AUDIT_STATUS_BACKLOG_LIMIT = 0x10 ++ AUDIT_STATUS_BACKLOG_WAIT_TIME = 0x20 ++ AUDIT_STATUS_BACKLOG_WAIT_TIME_ACTUAL = 0x80 ++ AUDIT_STATUS_ENABLED = 0x1 ++ AUDIT_STATUS_FAILURE = 0x2 ++ AUDIT_STATUS_LOST = 0x40 ++ AUDIT_STATUS_PID = 0x4 ++ AUDIT_STATUS_RATE_LIMIT = 0x8 ++ AUDIT_SUBJ_CLR = 0x11 ++ AUDIT_SUBJ_ROLE = 0xe ++ AUDIT_SUBJ_SEN = 0x10 ++ AUDIT_SUBJ_TYPE = 0xf ++ AUDIT_SUBJ_USER = 0xd ++ AUDIT_SUCCESS = 0x68 ++ AUDIT_SUID = 0x3 ++ AUDIT_SYSCALL = 0x514 ++ AUDIT_SYSCALL_CLASSES = 0x10 ++ AUDIT_TIME_ADJNTPVAL = 0x535 ++ AUDIT_TIME_INJOFFSET = 0x534 ++ AUDIT_TRIM = 0x3f6 ++ AUDIT_TTY = 0x527 ++ AUDIT_TTY_GET = 0x3f8 ++ AUDIT_TTY_SET = 0x3f9 ++ AUDIT_UID = 0x1 ++ AUDIT_UID_UNSET = 0xffffffff ++ AUDIT_UNUSED_BITS = 0x7fffc00 ++ AUDIT_USER = 0x3ed ++ AUDIT_USER_AVC = 0x453 ++ AUDIT_USER_TTY = 0x464 ++ AUDIT_VERSION_BACKLOG_LIMIT = 0x1 ++ AUDIT_VERSION_BACKLOG_WAIT_TIME = 0x2 ++ AUDIT_VERSION_LATEST = 0x7f ++ AUDIT_WATCH = 0x69 ++ AUDIT_WATCH_INS = 0x3ef ++ AUDIT_WATCH_LIST = 0x3f1 ++ AUDIT_WATCH_REM = 0x3f0 ++ AUTOFS_SUPER_MAGIC = 0x187 ++ B0 = 0x0 ++ B1000000 = 0x17 ++ B110 = 0x3 ++ B115200 = 0x11 ++ B1152000 = 0x18 ++ B1200 = 0x9 ++ B134 = 0x4 ++ B150 = 0x5 ++ B1500000 = 0x19 ++ B1800 = 0xa ++ B19200 = 0xe ++ B200 = 0x6 ++ B2000000 = 0x1a ++ B230400 = 0x12 ++ B2400 = 0xb ++ B2500000 = 0x1b ++ B300 = 0x7 ++ B3000000 = 0x1c ++ B3500000 = 0x1d ++ B38400 = 0xf ++ B4000000 = 0x1e ++ B460800 = 0x13 ++ B4800 = 0xc ++ B50 = 0x1 ++ B500000 = 0x14 ++ B57600 = 0x10 ++ B576000 = 0x15 ++ B600 = 0x8 ++ B75 = 0x2 ++ B921600 = 0x16 ++ B9600 = 0xd ++ BALLOON_KVM_MAGIC = 0x13661366 ++ BDEVFS_MAGIC = 0x62646576 ++ BINDERFS_SUPER_MAGIC = 0x6c6f6f70 ++ BINFMTFS_MAGIC = 0x42494e4d ++ BLKBSZGET = 0x40081270 ++ BLKBSZSET = 0x80081271 ++ BLKFLSBUF = 0x20001261 ++ BLKFRAGET = 0x20001265 ++ BLKFRASET = 0x20001264 ++ BLKGETSIZE = 0x20001260 ++ BLKGETSIZE64 = 0x40081272 ++ BLKPBSZGET = 0x2000127b ++ BLKRAGET = 0x20001263 ++ BLKRASET = 0x20001262 ++ BLKROGET = 0x2000125e ++ BLKROSET = 0x2000125d ++ BLKRRPART = 0x2000125f ++ BLKSECTGET = 0x20001267 ++ BLKSECTSET = 0x20001266 ++ BLKSSZGET = 0x20001268 ++ BPF_A = 0x10 ++ BPF_ABS = 0x20 ++ BPF_ADD = 0x0 ++ BPF_ALU = 0x4 ++ BPF_ALU64 = 0x7 ++ BPF_AND = 0x50 ++ BPF_ARSH = 0xc0 ++ BPF_B = 0x10 ++ BPF_BUILD_ID_SIZE = 0x14 ++ BPF_CALL = 0x80 ++ BPF_DIV = 0x30 ++ BPF_DW = 0x18 ++ BPF_END = 0xd0 ++ BPF_EXIT = 0x90 ++ BPF_FROM_BE = 0x8 ++ BPF_FROM_LE = 0x0 ++ BPF_FS_MAGIC = 0xcafe4a11 ++ BPF_F_ALLOW_MULTI = 0x2 ++ BPF_F_ALLOW_OVERRIDE = 0x1 ++ BPF_F_ANY_ALIGNMENT = 0x2 ++ BPF_F_QUERY_EFFECTIVE = 0x1 ++ BPF_F_REPLACE = 0x4 ++ BPF_F_SLEEPABLE = 0x10 ++ BPF_F_STRICT_ALIGNMENT = 0x1 ++ BPF_F_TEST_RND_HI32 = 0x4 ++ BPF_F_TEST_RUN_ON_CPU = 0x1 ++ BPF_F_TEST_STATE_FREQ = 0x8 ++ BPF_H = 0x8 ++ BPF_IMM = 0x0 ++ BPF_IND = 0x40 ++ BPF_JA = 0x0 ++ BPF_JEQ = 0x10 ++ BPF_JGE = 0x30 ++ BPF_JGT = 0x20 ++ BPF_JLE = 0xb0 ++ BPF_JLT = 0xa0 ++ BPF_JMP = 0x5 ++ BPF_JMP32 = 0x6 ++ BPF_JNE = 0x50 ++ BPF_JSET = 0x40 ++ BPF_JSGE = 0x70 ++ BPF_JSGT = 0x60 ++ BPF_JSLE = 0xd0 ++ BPF_JSLT = 0xc0 ++ BPF_K = 0x0 ++ BPF_LD = 0x0 ++ BPF_LDX = 0x1 ++ BPF_LEN = 0x80 ++ BPF_LL_OFF = -0x200000 ++ BPF_LSH = 0x60 ++ BPF_MAJOR_VERSION = 0x1 ++ BPF_MAXINSNS = 0x1000 ++ BPF_MEM = 0x60 ++ BPF_MEMWORDS = 0x10 ++ BPF_MINOR_VERSION = 0x1 ++ BPF_MISC = 0x7 ++ BPF_MOD = 0x90 ++ BPF_MOV = 0xb0 ++ BPF_MSH = 0xa0 ++ BPF_MUL = 0x20 ++ BPF_NEG = 0x80 ++ BPF_NET_OFF = -0x100000 ++ BPF_OBJ_NAME_LEN = 0x10 ++ BPF_OR = 0x40 ++ BPF_PSEUDO_BTF_ID = 0x3 ++ BPF_PSEUDO_CALL = 0x1 ++ BPF_PSEUDO_MAP_FD = 0x1 ++ BPF_PSEUDO_MAP_VALUE = 0x2 ++ BPF_RET = 0x6 ++ BPF_RSH = 0x70 ++ BPF_ST = 0x2 ++ BPF_STX = 0x3 ++ BPF_SUB = 0x10 ++ BPF_TAG_SIZE = 0x8 ++ BPF_TAX = 0x0 ++ BPF_TO_BE = 0x8 ++ BPF_TO_LE = 0x0 ++ BPF_TXA = 0x80 ++ BPF_W = 0x0 ++ BPF_X = 0x8 ++ BPF_XADD = 0xc0 ++ BPF_XOR = 0xa0 ++ BRKINT = 0x2 ++ BS0 = 0x0 ++ BS1 = 0x8000 ++ BSDLY = 0x8000 ++ BTRFS_SUPER_MAGIC = 0x9123683e ++ BTRFS_TEST_MAGIC = 0x73727279 ++ BUS_BLUETOOTH = 0x5 ++ BUS_HIL = 0x4 ++ BUS_USB = 0x3 ++ BUS_VIRTUAL = 0x6 ++ CAN_BCM = 0x2 ++ CAN_CTRLMODE_3_SAMPLES = 0x4 ++ CAN_CTRLMODE_BERR_REPORTING = 0x10 ++ CAN_CTRLMODE_FD = 0x20 ++ CAN_CTRLMODE_FD_NON_ISO = 0x80 ++ CAN_CTRLMODE_LISTENONLY = 0x2 ++ CAN_CTRLMODE_LOOPBACK = 0x1 ++ CAN_CTRLMODE_ONE_SHOT = 0x8 ++ CAN_CTRLMODE_PRESUME_ACK = 0x40 ++ CAN_EFF_FLAG = 0x80000000 ++ CAN_EFF_ID_BITS = 0x1d ++ CAN_EFF_MASK = 0x1fffffff ++ CAN_ERR_ACK = 0x20 ++ CAN_ERR_BUSERROR = 0x80 ++ CAN_ERR_BUSOFF = 0x40 ++ CAN_ERR_CRTL = 0x4 ++ CAN_ERR_CRTL_ACTIVE = 0x40 ++ CAN_ERR_CRTL_RX_OVERFLOW = 0x1 ++ CAN_ERR_CRTL_RX_PASSIVE = 0x10 ++ CAN_ERR_CRTL_RX_WARNING = 0x4 ++ CAN_ERR_CRTL_TX_OVERFLOW = 0x2 ++ CAN_ERR_CRTL_TX_PASSIVE = 0x20 ++ CAN_ERR_CRTL_TX_WARNING = 0x8 ++ CAN_ERR_CRTL_UNSPEC = 0x0 ++ CAN_ERR_DLC = 0x8 ++ CAN_ERR_FLAG = 0x20000000 ++ CAN_ERR_LOSTARB = 0x2 ++ CAN_ERR_LOSTARB_UNSPEC = 0x0 ++ CAN_ERR_MASK = 0x1fffffff ++ CAN_ERR_PROT = 0x8 ++ CAN_ERR_PROT_ACTIVE = 0x40 ++ CAN_ERR_PROT_BIT = 0x1 ++ CAN_ERR_PROT_BIT0 = 0x8 ++ CAN_ERR_PROT_BIT1 = 0x10 ++ CAN_ERR_PROT_FORM = 0x2 ++ CAN_ERR_PROT_LOC_ACK = 0x19 ++ CAN_ERR_PROT_LOC_ACK_DEL = 0x1b ++ CAN_ERR_PROT_LOC_CRC_DEL = 0x18 ++ CAN_ERR_PROT_LOC_CRC_SEQ = 0x8 ++ CAN_ERR_PROT_LOC_DATA = 0xa ++ CAN_ERR_PROT_LOC_DLC = 0xb ++ CAN_ERR_PROT_LOC_EOF = 0x1a ++ CAN_ERR_PROT_LOC_ID04_00 = 0xe ++ CAN_ERR_PROT_LOC_ID12_05 = 0xf ++ CAN_ERR_PROT_LOC_ID17_13 = 0x7 ++ CAN_ERR_PROT_LOC_ID20_18 = 0x6 ++ CAN_ERR_PROT_LOC_ID28_21 = 0x2 ++ CAN_ERR_PROT_LOC_IDE = 0x5 ++ CAN_ERR_PROT_LOC_INTERM = 0x12 ++ CAN_ERR_PROT_LOC_RES0 = 0x9 ++ CAN_ERR_PROT_LOC_RES1 = 0xd ++ CAN_ERR_PROT_LOC_RTR = 0xc ++ CAN_ERR_PROT_LOC_SOF = 0x3 ++ CAN_ERR_PROT_LOC_SRTR = 0x4 ++ CAN_ERR_PROT_LOC_UNSPEC = 0x0 ++ CAN_ERR_PROT_OVERLOAD = 0x20 ++ CAN_ERR_PROT_STUFF = 0x4 ++ CAN_ERR_PROT_TX = 0x80 ++ CAN_ERR_PROT_UNSPEC = 0x0 ++ CAN_ERR_RESTARTED = 0x100 ++ CAN_ERR_TRX = 0x10 ++ CAN_ERR_TRX_CANH_NO_WIRE = 0x4 ++ CAN_ERR_TRX_CANH_SHORT_TO_BAT = 0x5 ++ CAN_ERR_TRX_CANH_SHORT_TO_GND = 0x7 ++ CAN_ERR_TRX_CANH_SHORT_TO_VCC = 0x6 ++ CAN_ERR_TRX_CANL_NO_WIRE = 0x40 ++ CAN_ERR_TRX_CANL_SHORT_TO_BAT = 0x50 ++ CAN_ERR_TRX_CANL_SHORT_TO_CANH = 0x80 ++ CAN_ERR_TRX_CANL_SHORT_TO_GND = 0x70 ++ CAN_ERR_TRX_CANL_SHORT_TO_VCC = 0x60 ++ CAN_ERR_TRX_UNSPEC = 0x0 ++ CAN_ERR_TX_TIMEOUT = 0x1 ++ CAN_INV_FILTER = 0x20000000 ++ CAN_ISOTP = 0x6 ++ CAN_J1939 = 0x7 ++ CAN_MAX_DLC = 0x8 ++ CAN_MAX_DLEN = 0x8 ++ CAN_MCNET = 0x5 ++ CAN_MTU = 0x10 ++ CAN_NPROTO = 0x8 ++ CAN_RAW = 0x1 ++ CAN_RAW_FILTER_MAX = 0x200 ++ CAN_RTR_FLAG = 0x40000000 ++ CAN_SFF_ID_BITS = 0xb ++ CAN_SFF_MASK = 0x7ff ++ CAN_TERMINATION_DISABLED = 0x0 ++ CAN_TP16 = 0x3 ++ CAN_TP20 = 0x4 ++ CAP_AUDIT_CONTROL = 0x1e ++ CAP_AUDIT_READ = 0x25 ++ CAP_AUDIT_WRITE = 0x1d ++ CAP_BLOCK_SUSPEND = 0x24 ++ CAP_BPF = 0x27 ++ CAP_CHECKPOINT_RESTORE = 0x28 ++ CAP_CHOWN = 0x0 ++ CAP_DAC_OVERRIDE = 0x1 ++ CAP_DAC_READ_SEARCH = 0x2 ++ CAP_FOWNER = 0x3 ++ CAP_FSETID = 0x4 ++ CAP_IPC_LOCK = 0xe ++ CAP_IPC_OWNER = 0xf ++ CAP_KILL = 0x5 ++ CAP_LAST_CAP = 0x28 ++ CAP_LEASE = 0x1c ++ CAP_LINUX_IMMUTABLE = 0x9 ++ CAP_MAC_ADMIN = 0x21 ++ CAP_MAC_OVERRIDE = 0x20 ++ CAP_MKNOD = 0x1b ++ CAP_NET_ADMIN = 0xc ++ CAP_NET_BIND_SERVICE = 0xa ++ CAP_NET_BROADCAST = 0xb ++ CAP_NET_RAW = 0xd ++ CAP_PERFMON = 0x26 ++ CAP_SETFCAP = 0x1f ++ CAP_SETGID = 0x6 ++ CAP_SETPCAP = 0x8 ++ CAP_SETUID = 0x7 ++ CAP_SYSLOG = 0x22 ++ CAP_SYS_ADMIN = 0x15 ++ CAP_SYS_BOOT = 0x16 ++ CAP_SYS_CHROOT = 0x12 ++ CAP_SYS_MODULE = 0x10 ++ CAP_SYS_NICE = 0x17 ++ CAP_SYS_PACCT = 0x14 ++ CAP_SYS_PTRACE = 0x13 ++ CAP_SYS_RAWIO = 0x11 ++ CAP_SYS_RESOURCE = 0x18 ++ CAP_SYS_TIME = 0x19 ++ CAP_SYS_TTY_CONFIG = 0x1a ++ CAP_WAKE_ALARM = 0x23 ++ CBAUD = 0x1f ++ CBAUDEX = 0x0 ++ CFLUSH = 0xf ++ CGROUP2_SUPER_MAGIC = 0x63677270 ++ CGROUP_SUPER_MAGIC = 0x27e0eb ++ CLOCAL = 0x8000 ++ CLOCK_BOOTTIME = 0x7 ++ CLOCK_BOOTTIME_ALARM = 0x9 ++ CLOCK_DEFAULT = 0x0 ++ CLOCK_EXT = 0x1 ++ CLOCK_INT = 0x2 ++ CLOCK_MONOTONIC = 0x1 ++ CLOCK_MONOTONIC_COARSE = 0x6 ++ CLOCK_MONOTONIC_RAW = 0x4 ++ CLOCK_PROCESS_CPUTIME_ID = 0x2 ++ CLOCK_REALTIME = 0x0 ++ CLOCK_REALTIME_ALARM = 0x8 ++ CLOCK_REALTIME_COARSE = 0x5 ++ CLOCK_TAI = 0xb ++ CLOCK_THREAD_CPUTIME_ID = 0x3 ++ CLOCK_TXFROMRX = 0x4 ++ CLOCK_TXINT = 0x3 ++ CLONE_ARGS_SIZE_VER0 = 0x40 ++ CLONE_ARGS_SIZE_VER1 = 0x50 ++ CLONE_ARGS_SIZE_VER2 = 0x58 ++ CLONE_CHILD_CLEARTID = 0x200000 ++ CLONE_CHILD_SETTID = 0x1000000 ++ CLONE_CLEAR_SIGHAND = 0x100000000 ++ CLONE_DETACHED = 0x400000 ++ CLONE_FILES = 0x400 ++ CLONE_FS = 0x200 ++ CLONE_INTO_CGROUP = 0x200000000 ++ CLONE_IO = 0x80000000 ++ CLONE_NEWCGROUP = 0x2000000 ++ CLONE_NEWIPC = 0x8000000 ++ CLONE_NEWNET = 0x40000000 ++ CLONE_NEWNS = 0x20000 ++ CLONE_NEWPID = 0x20000000 ++ CLONE_NEWTIME = 0x80 ++ CLONE_NEWUSER = 0x10000000 ++ CLONE_NEWUTS = 0x4000000 ++ CLONE_PARENT = 0x8000 ++ CLONE_PARENT_SETTID = 0x100000 ++ CLONE_PIDFD = 0x1000 ++ CLONE_PTRACE = 0x2000 ++ CLONE_SETTLS = 0x80000 ++ CLONE_SIGHAND = 0x800 ++ CLONE_SYSVSEM = 0x40000 ++ CLONE_THREAD = 0x10000 ++ CLONE_UNTRACED = 0x800000 ++ CLONE_VFORK = 0x4000 ++ CLONE_VM = 0x100 ++ CMSPAR = 0x40000000 ++ CODA_SUPER_MAGIC = 0x73757245 ++ CR0 = 0x0 ++ CR1 = 0x1000 ++ CR2 = 0x2000 ++ CR3 = 0x3000 ++ CRAMFS_MAGIC = 0x28cd3d45 ++ CRDLY = 0x3000 ++ CREAD = 0x800 ++ CRTSCTS = 0x80000000 ++ CRYPTO_MAX_NAME = 0x40 ++ CRYPTO_MSG_MAX = 0x15 ++ CRYPTO_NR_MSGTYPES = 0x6 ++ CRYPTO_REPORT_MAXSIZE = 0x160 ++ CS5 = 0x0 ++ CS6 = 0x100 ++ CS7 = 0x200 ++ CS8 = 0x300 ++ CSIGNAL = 0xff ++ CSIZE = 0x300 ++ CSTART = 0x11 ++ CSTATUS = 0x0 ++ CSTOP = 0x13 ++ CSTOPB = 0x400 ++ CSUSP = 0x1a ++ DAXFS_MAGIC = 0x64646178 ++ DEBUGFS_MAGIC = 0x64626720 ++ DEVLINK_CMD_ESWITCH_MODE_GET = 0x1d ++ DEVLINK_CMD_ESWITCH_MODE_SET = 0x1e ++ DEVLINK_FLASH_OVERWRITE_IDENTIFIERS = 0x2 ++ DEVLINK_FLASH_OVERWRITE_SETTINGS = 0x1 ++ DEVLINK_GENL_MCGRP_CONFIG_NAME = "config" ++ DEVLINK_GENL_NAME = "devlink" ++ DEVLINK_GENL_VERSION = 0x1 ++ DEVLINK_SB_THRESHOLD_TO_ALPHA_MAX = 0x14 ++ DEVLINK_SUPPORTED_FLASH_OVERWRITE_SECTIONS = 0x3 ++ DEVMEM_MAGIC = 0x454d444d ++ DEVPTS_SUPER_MAGIC = 0x1cd1 ++ DMA_BUF_MAGIC = 0x444d4142 ++ DM_ACTIVE_PRESENT_FLAG = 0x20 ++ DM_BUFFER_FULL_FLAG = 0x100 ++ DM_CONTROL_NODE = "control" ++ DM_DATA_OUT_FLAG = 0x10000 ++ DM_DEFERRED_REMOVE = 0x20000 ++ DM_DEV_ARM_POLL = 0xc138fd10 ++ DM_DEV_CREATE = 0xc138fd03 ++ DM_DEV_REMOVE = 0xc138fd04 ++ DM_DEV_RENAME = 0xc138fd05 ++ DM_DEV_SET_GEOMETRY = 0xc138fd0f ++ DM_DEV_STATUS = 0xc138fd07 ++ DM_DEV_SUSPEND = 0xc138fd06 ++ DM_DEV_WAIT = 0xc138fd08 ++ DM_DIR = "mapper" ++ DM_GET_TARGET_VERSION = 0xc138fd11 ++ DM_INACTIVE_PRESENT_FLAG = 0x40 ++ DM_INTERNAL_SUSPEND_FLAG = 0x40000 ++ DM_IOCTL = 0xfd ++ DM_LIST_DEVICES = 0xc138fd02 ++ DM_LIST_VERSIONS = 0xc138fd0d ++ DM_MAX_TYPE_NAME = 0x10 ++ DM_NAME_LEN = 0x80 ++ DM_NOFLUSH_FLAG = 0x800 ++ DM_PERSISTENT_DEV_FLAG = 0x8 ++ DM_QUERY_INACTIVE_TABLE_FLAG = 0x1000 ++ DM_READONLY_FLAG = 0x1 ++ DM_REMOVE_ALL = 0xc138fd01 ++ DM_SECURE_DATA_FLAG = 0x8000 ++ DM_SKIP_BDGET_FLAG = 0x200 ++ DM_SKIP_LOCKFS_FLAG = 0x400 ++ DM_STATUS_TABLE_FLAG = 0x10 ++ DM_SUSPEND_FLAG = 0x2 ++ DM_TABLE_CLEAR = 0xc138fd0a ++ DM_TABLE_DEPS = 0xc138fd0b ++ DM_TABLE_LOAD = 0xc138fd09 ++ DM_TABLE_STATUS = 0xc138fd0c ++ DM_TARGET_MSG = 0xc138fd0e ++ DM_UEVENT_GENERATED_FLAG = 0x2000 ++ DM_UUID_FLAG = 0x4000 ++ DM_UUID_LEN = 0x81 ++ DM_VERSION = 0xc138fd00 ++ DM_VERSION_EXTRA = "-ioctl (2020-10-01)" ++ DM_VERSION_MAJOR = 0x4 ++ DM_VERSION_MINOR = 0x2b ++ DM_VERSION_PATCHLEVEL = 0x0 ++ DT_BLK = 0x6 ++ DT_CHR = 0x2 ++ DT_DIR = 0x4 ++ DT_FIFO = 0x1 ++ DT_LNK = 0xa ++ DT_REG = 0x8 ++ DT_SOCK = 0xc ++ DT_UNKNOWN = 0x0 ++ DT_WHT = 0xe ++ ECCGETLAYOUT = 0x41484d11 ++ ECCGETSTATS = 0x40104d12 ++ ECHO = 0x8 ++ ECHOCTL = 0x40 ++ ECHOE = 0x2 ++ ECHOK = 0x4 ++ ECHOKE = 0x1 ++ ECHONL = 0x10 ++ ECHOPRT = 0x20 ++ ECRYPTFS_SUPER_MAGIC = 0xf15f ++ EFD_CLOEXEC = 0x200000 ++ EFD_NONBLOCK = 0x4 ++ EFD_SEMAPHORE = 0x1 ++ EFIVARFS_MAGIC = 0xde5e81e4 ++ EFS_SUPER_MAGIC = 0x414a53 ++ EM_386 = 0x3 ++ EM_486 = 0x6 ++ EM_68K = 0x4 ++ EM_860 = 0x7 ++ EM_88K = 0x5 ++ EM_AARCH64 = 0xb7 ++ EM_ALPHA = 0x9026 ++ EM_ALTERA_NIOS2 = 0x71 ++ EM_ARCOMPACT = 0x5d ++ EM_ARCV2 = 0xc3 ++ EM_ARM = 0x28 ++ EM_BLACKFIN = 0x6a ++ EM_BPF = 0xf7 ++ EM_CRIS = 0x4c ++ EM_CSKY = 0xfc ++ EM_CYGNUS_M32R = 0x9041 ++ EM_CYGNUS_MN10300 = 0xbeef ++ EM_FRV = 0x5441 ++ EM_H8_300 = 0x2e ++ EM_HEXAGON = 0xa4 ++ EM_IA_64 = 0x32 ++ EM_M32 = 0x1 ++ EM_M32R = 0x58 ++ EM_MICROBLAZE = 0xbd ++ EM_MIPS = 0x8 ++ EM_MIPS_RS3_LE = 0xa ++ EM_MIPS_RS4_BE = 0xa ++ EM_MN10300 = 0x59 ++ EM_NDS32 = 0xa7 ++ EM_NONE = 0x0 ++ EM_OPENRISC = 0x5c ++ EM_PARISC = 0xf ++ EM_PPC = 0x14 ++ EM_PPC64 = 0x15 ++ EM_RISCV = 0xf3 ++ EM_S390 = 0x16 ++ EM_S390_OLD = 0xa390 ++ EM_SH = 0x2a ++ EM_SPARC = 0x2 ++ EM_SPARC32PLUS = 0x12 ++ EM_SPARCV9 = 0x2b ++ EM_SPU = 0x17 ++ EM_SW64 = 0x9916 ++ EM_TILEGX = 0xbf ++ EM_TILEPRO = 0xbc ++ EM_TI_C6000 = 0x8c ++ EM_UNICORE = 0x6e ++ EM_X86_64 = 0x3e ++ EM_XTENSA = 0x5e ++ ENCODING_DEFAULT = 0x0 ++ ENCODING_FM_MARK = 0x3 ++ ENCODING_FM_SPACE = 0x4 ++ ENCODING_MANCHESTER = 0x5 ++ ENCODING_NRZ = 0x1 ++ ENCODING_NRZI = 0x2 ++ EPOLLERR = 0x8 ++ EPOLLET = 0x80000000 ++ EPOLLEXCLUSIVE = 0x10000000 ++ EPOLLHUP = 0x10 ++ EPOLLIN = 0x1 ++ EPOLLMSG = 0x400 ++ EPOLLONESHOT = 0x40000000 ++ EPOLLOUT = 0x4 ++ EPOLLPRI = 0x2 ++ EPOLLRDBAND = 0x80 ++ EPOLLRDHUP = 0x2000 ++ EPOLLRDNORM = 0x40 ++ EPOLLWAKEUP = 0x20000000 ++ EPOLLWRBAND = 0x200 ++ EPOLLWRNORM = 0x100 ++ EPOLL_CLOEXEC = 0x200000 ++ EPOLL_CTL_ADD = 0x1 ++ EPOLL_CTL_DEL = 0x2 ++ EPOLL_CTL_MOD = 0x3 ++ EROFS_SUPER_MAGIC_V1 = 0xe0f5e1e2 ++ ESP_V4_FLOW = 0xa ++ ESP_V6_FLOW = 0xc ++ ETHER_FLOW = 0x12 ++ ETHTOOL_BUSINFO_LEN = 0x20 ++ ETHTOOL_EROMVERS_LEN = 0x20 ++ ETHTOOL_FEC_AUTO = 0x2 ++ ETHTOOL_FEC_BASER = 0x10 ++ ETHTOOL_FEC_LLRS = 0x20 ++ ETHTOOL_FEC_NONE = 0x1 ++ ETHTOOL_FEC_OFF = 0x4 ++ ETHTOOL_FEC_RS = 0x8 ++ ETHTOOL_FLAG_ALL = 0x7 ++ ETHTOOL_FLAG_COMPACT_BITSETS = 0x1 ++ ETHTOOL_FLAG_OMIT_REPLY = 0x2 ++ ETHTOOL_FLAG_STATS = 0x4 ++ ETHTOOL_FLASHDEV = 0x33 ++ ETHTOOL_FLASH_MAX_FILENAME = 0x80 ++ ETHTOOL_FWVERS_LEN = 0x20 ++ ETHTOOL_F_COMPAT = 0x4 ++ ETHTOOL_F_UNSUPPORTED = 0x1 ++ ETHTOOL_F_WISH = 0x2 ++ ETHTOOL_GCHANNELS = 0x3c ++ ETHTOOL_GCOALESCE = 0xe ++ ETHTOOL_GDRVINFO = 0x3 ++ ETHTOOL_GEEE = 0x44 ++ ETHTOOL_GEEPROM = 0xb ++ ETHTOOL_GENL_NAME = "ethtool" ++ ETHTOOL_GENL_VERSION = 0x1 ++ ETHTOOL_GET_DUMP_DATA = 0x40 ++ ETHTOOL_GET_DUMP_FLAG = 0x3f ++ ETHTOOL_GET_TS_INFO = 0x41 ++ ETHTOOL_GFEATURES = 0x3a ++ ETHTOOL_GFECPARAM = 0x50 ++ ETHTOOL_GFLAGS = 0x25 ++ ETHTOOL_GGRO = 0x2b ++ ETHTOOL_GGSO = 0x23 ++ ETHTOOL_GLINK = 0xa ++ ETHTOOL_GLINKSETTINGS = 0x4c ++ ETHTOOL_GMODULEEEPROM = 0x43 ++ ETHTOOL_GMODULEINFO = 0x42 ++ ETHTOOL_GMSGLVL = 0x7 ++ ETHTOOL_GPAUSEPARAM = 0x12 ++ ETHTOOL_GPERMADDR = 0x20 ++ ETHTOOL_GPFLAGS = 0x27 ++ ETHTOOL_GPHYSTATS = 0x4a ++ ETHTOOL_GREGS = 0x4 ++ ETHTOOL_GRINGPARAM = 0x10 ++ ETHTOOL_GRSSH = 0x46 ++ ETHTOOL_GRXCLSRLALL = 0x30 ++ ETHTOOL_GRXCLSRLCNT = 0x2e ++ ETHTOOL_GRXCLSRULE = 0x2f ++ ETHTOOL_GRXCSUM = 0x14 ++ ETHTOOL_GRXFH = 0x29 ++ ETHTOOL_GRXFHINDIR = 0x38 ++ ETHTOOL_GRXNTUPLE = 0x36 ++ ETHTOOL_GRXRINGS = 0x2d ++ ETHTOOL_GSET = 0x1 ++ ETHTOOL_GSG = 0x18 ++ ETHTOOL_GSSET_INFO = 0x37 ++ ETHTOOL_GSTATS = 0x1d ++ ETHTOOL_GSTRINGS = 0x1b ++ ETHTOOL_GTSO = 0x1e ++ ETHTOOL_GTUNABLE = 0x48 ++ ETHTOOL_GTXCSUM = 0x16 ++ ETHTOOL_GUFO = 0x21 ++ ETHTOOL_GWOL = 0x5 ++ ETHTOOL_MCGRP_MONITOR_NAME = "monitor" ++ ETHTOOL_NWAY_RST = 0x9 ++ ETHTOOL_PERQUEUE = 0x4b ++ ETHTOOL_PHYS_ID = 0x1c ++ ETHTOOL_PHY_EDPD_DFLT_TX_MSECS = 0xffff ++ ETHTOOL_PHY_EDPD_DISABLE = 0x0 ++ ETHTOOL_PHY_EDPD_NO_TX = 0xfffe ++ ETHTOOL_PHY_FAST_LINK_DOWN_OFF = 0xff ++ ETHTOOL_PHY_FAST_LINK_DOWN_ON = 0x0 ++ ETHTOOL_PHY_GTUNABLE = 0x4e ++ ETHTOOL_PHY_STUNABLE = 0x4f ++ ETHTOOL_RESET = 0x34 ++ ETHTOOL_RXNTUPLE_ACTION_CLEAR = -0x2 ++ ETHTOOL_RXNTUPLE_ACTION_DROP = -0x1 ++ ETHTOOL_RX_FLOW_SPEC_RING = 0xffffffff ++ ETHTOOL_RX_FLOW_SPEC_RING_VF = 0xff00000000 ++ ETHTOOL_RX_FLOW_SPEC_RING_VF_OFF = 0x20 ++ ETHTOOL_SCHANNELS = 0x3d ++ ETHTOOL_SCOALESCE = 0xf ++ ETHTOOL_SEEE = 0x45 ++ ETHTOOL_SEEPROM = 0xc ++ ETHTOOL_SET_DUMP = 0x3e ++ ETHTOOL_SFEATURES = 0x3b ++ ETHTOOL_SFECPARAM = 0x51 ++ ETHTOOL_SFLAGS = 0x26 ++ ETHTOOL_SGRO = 0x2c ++ ETHTOOL_SGSO = 0x24 ++ ETHTOOL_SLINKSETTINGS = 0x4d ++ ETHTOOL_SMSGLVL = 0x8 ++ ETHTOOL_SPAUSEPARAM = 0x13 ++ ETHTOOL_SPFLAGS = 0x28 ++ ETHTOOL_SRINGPARAM = 0x11 ++ ETHTOOL_SRSSH = 0x47 ++ ETHTOOL_SRXCLSRLDEL = 0x31 ++ ETHTOOL_SRXCLSRLINS = 0x32 ++ ETHTOOL_SRXCSUM = 0x15 ++ ETHTOOL_SRXFH = 0x2a ++ ETHTOOL_SRXFHINDIR = 0x39 ++ ETHTOOL_SRXNTUPLE = 0x35 ++ ETHTOOL_SSET = 0x2 ++ ETHTOOL_SSG = 0x19 ++ ETHTOOL_STSO = 0x1f ++ ETHTOOL_STUNABLE = 0x49 ++ ETHTOOL_STXCSUM = 0x17 ++ ETHTOOL_SUFO = 0x22 ++ ETHTOOL_SWOL = 0x6 ++ ETHTOOL_TEST = 0x1a ++ ETH_P_1588 = 0x88f7 ++ ETH_P_8021AD = 0x88a8 ++ ETH_P_8021AH = 0x88e7 ++ ETH_P_8021Q = 0x8100 ++ ETH_P_80221 = 0x8917 ++ ETH_P_802_2 = 0x4 ++ ETH_P_802_3 = 0x1 ++ ETH_P_802_3_MIN = 0x600 ++ ETH_P_802_EX1 = 0x88b5 ++ ETH_P_AARP = 0x80f3 ++ ETH_P_AF_IUCV = 0xfbfb ++ ETH_P_ALL = 0x3 ++ ETH_P_AOE = 0x88a2 ++ ETH_P_ARCNET = 0x1a ++ ETH_P_ARP = 0x806 ++ ETH_P_ATALK = 0x809b ++ ETH_P_ATMFATE = 0x8884 ++ ETH_P_ATMMPOA = 0x884c ++ ETH_P_AX25 = 0x2 ++ ETH_P_BATMAN = 0x4305 ++ ETH_P_BPQ = 0x8ff ++ ETH_P_CAIF = 0xf7 ++ ETH_P_CAN = 0xc ++ ETH_P_CANFD = 0xd ++ ETH_P_CONTROL = 0x16 ++ ETH_P_CUST = 0x6006 ++ ETH_P_DDCMP = 0x6 ++ ETH_P_DEC = 0x6000 ++ ETH_P_DIAG = 0x6005 ++ ETH_P_DNA_DL = 0x6001 ++ ETH_P_DNA_RC = 0x6002 ++ ETH_P_DNA_RT = 0x6003 ++ ETH_P_DSA = 0x1b ++ ETH_P_DSA_8021Q = 0xdadb ++ ETH_P_ECONET = 0x18 ++ ETH_P_EDSA = 0xdada ++ ETH_P_ERSPAN = 0x88be ++ ETH_P_ERSPAN2 = 0x22eb ++ ETH_P_FCOE = 0x8906 ++ ETH_P_FIP = 0x8914 ++ ETH_P_HDLC = 0x19 ++ ETH_P_HSR = 0x892f ++ ETH_P_IBOE = 0x8915 ++ ETH_P_IEEE802154 = 0xf6 ++ ETH_P_IEEEPUP = 0xa00 ++ ETH_P_IEEEPUPAT = 0xa01 ++ ETH_P_IFE = 0xed3e ++ ETH_P_IP = 0x800 ++ ETH_P_IPV6 = 0x86dd ++ ETH_P_IPX = 0x8137 ++ ETH_P_IRDA = 0x17 ++ ETH_P_LAT = 0x6004 ++ ETH_P_LINK_CTL = 0x886c ++ ETH_P_LLDP = 0x88cc ++ ETH_P_LOCALTALK = 0x9 ++ ETH_P_LOOP = 0x60 ++ ETH_P_LOOPBACK = 0x9000 ++ ETH_P_MACSEC = 0x88e5 ++ ETH_P_MAP = 0xf9 ++ ETH_P_MOBITEX = 0x15 ++ ETH_P_MPLS_MC = 0x8848 ++ ETH_P_MPLS_UC = 0x8847 ++ ETH_P_MRP = 0x88e3 ++ ETH_P_MVRP = 0x88f5 ++ ETH_P_NCSI = 0x88f8 ++ ETH_P_NSH = 0x894f ++ ETH_P_PAE = 0x888e ++ ETH_P_PAUSE = 0x8808 ++ ETH_P_PHONET = 0xf5 ++ ETH_P_PPPTALK = 0x10 ++ ETH_P_PPP_DISC = 0x8863 ++ ETH_P_PPP_MP = 0x8 ++ ETH_P_PPP_SES = 0x8864 ++ ETH_P_PREAUTH = 0x88c7 ++ ETH_P_PRP = 0x88fb ++ ETH_P_PUP = 0x200 ++ ETH_P_PUPAT = 0x201 ++ ETH_P_QINQ1 = 0x9100 ++ ETH_P_QINQ2 = 0x9200 ++ ETH_P_QINQ3 = 0x9300 ++ ETH_P_RARP = 0x8035 ++ ETH_P_SCA = 0x6007 ++ ETH_P_SLOW = 0x8809 ++ ETH_P_SNAP = 0x5 ++ ETH_P_TDLS = 0x890d ++ ETH_P_TEB = 0x6558 ++ ETH_P_TIPC = 0x88ca ++ ETH_P_TRAILER = 0x1c ++ ETH_P_TR_802_2 = 0x11 ++ ETH_P_TSN = 0x22f0 ++ ETH_P_WAN_PPP = 0x7 ++ ETH_P_WCCP = 0x883e ++ ETH_P_X25 = 0x805 ++ ETH_P_XDSA = 0xf8 ++ EV_ABS = 0x3 ++ EV_CNT = 0x20 ++ EV_FF = 0x15 ++ EV_FF_STATUS = 0x17 ++ EV_KEY = 0x1 ++ EV_LED = 0x11 ++ EV_MAX = 0x1f ++ EV_MSC = 0x4 ++ EV_PWR = 0x16 ++ EV_REL = 0x2 ++ EV_REP = 0x14 ++ EV_SND = 0x12 ++ EV_SW = 0x5 ++ EV_SYN = 0x0 ++ EV_VERSION = 0x10001 ++ EXABYTE_ENABLE_NEST = 0xf0 ++ EXT2_SUPER_MAGIC = 0xef53 ++ EXT3_SUPER_MAGIC = 0xef53 ++ EXT4_SUPER_MAGIC = 0xef53 ++ EXTA = 0xe ++ EXTB = 0xf ++ EXTPROC = 0x10000000 ++ F2FS_SUPER_MAGIC = 0xf2f52010 ++ FALLOC_FL_COLLAPSE_RANGE = 0x8 ++ FALLOC_FL_INSERT_RANGE = 0x20 ++ FALLOC_FL_KEEP_SIZE = 0x1 ++ FALLOC_FL_NO_HIDE_STALE = 0x4 ++ FALLOC_FL_PUNCH_HOLE = 0x2 ++ FALLOC_FL_UNSHARE_RANGE = 0x40 ++ FALLOC_FL_ZERO_RANGE = 0x10 ++ FANOTIFY_METADATA_VERSION = 0x3 ++ FAN_ACCESS = 0x1 ++ FAN_ACCESS_PERM = 0x20000 ++ FAN_ALLOW = 0x1 ++ FAN_ALL_CLASS_BITS = 0xc ++ FAN_ALL_EVENTS = 0x3b ++ FAN_ALL_INIT_FLAGS = 0x3f ++ FAN_ALL_MARK_FLAGS = 0xff ++ FAN_ALL_OUTGOING_EVENTS = 0x3403b ++ FAN_ALL_PERM_EVENTS = 0x30000 ++ FAN_ATTRIB = 0x4 ++ FAN_AUDIT = 0x10 ++ FAN_CLASS_CONTENT = 0x4 ++ FAN_CLASS_NOTIF = 0x0 ++ FAN_CLASS_PRE_CONTENT = 0x8 ++ FAN_CLOEXEC = 0x1 ++ FAN_CLOSE = 0x18 ++ FAN_CLOSE_NOWRITE = 0x10 ++ FAN_CLOSE_WRITE = 0x8 ++ FAN_CREATE = 0x100 ++ FAN_DELETE = 0x200 ++ FAN_DELETE_SELF = 0x400 ++ FAN_DENY = 0x2 ++ FAN_ENABLE_AUDIT = 0x40 ++ FAN_EVENT_INFO_TYPE_DFID = 0x3 ++ FAN_EVENT_INFO_TYPE_DFID_NAME = 0x2 ++ FAN_EVENT_INFO_TYPE_FID = 0x1 ++ FAN_EVENT_METADATA_LEN = 0x18 ++ FAN_EVENT_ON_CHILD = 0x8000000 ++ FAN_MARK_ADD = 0x1 ++ FAN_MARK_DONT_FOLLOW = 0x4 ++ FAN_MARK_FILESYSTEM = 0x100 ++ FAN_MARK_FLUSH = 0x80 ++ FAN_MARK_IGNORED_MASK = 0x20 ++ FAN_MARK_IGNORED_SURV_MODIFY = 0x40 ++ FAN_MARK_INODE = 0x0 ++ FAN_MARK_MOUNT = 0x10 ++ FAN_MARK_ONLYDIR = 0x8 ++ FAN_MARK_REMOVE = 0x2 ++ FAN_MODIFY = 0x2 ++ FAN_MOVE = 0xc0 ++ FAN_MOVED_FROM = 0x40 ++ FAN_MOVED_TO = 0x80 ++ FAN_MOVE_SELF = 0x800 ++ FAN_NOFD = -0x1 ++ FAN_NONBLOCK = 0x2 ++ FAN_ONDIR = 0x40000000 ++ FAN_OPEN = 0x20 ++ FAN_OPEN_EXEC = 0x1000 ++ FAN_OPEN_EXEC_PERM = 0x40000 ++ FAN_OPEN_PERM = 0x10000 ++ FAN_Q_OVERFLOW = 0x4000 ++ FAN_REPORT_DFID_NAME = 0xc00 ++ FAN_REPORT_DIR_FID = 0x400 ++ FAN_REPORT_FID = 0x200 ++ FAN_REPORT_NAME = 0x800 ++ FAN_REPORT_TID = 0x100 ++ FAN_UNLIMITED_MARKS = 0x20 ++ FAN_UNLIMITED_QUEUE = 0x10 ++ FD_CLOEXEC = 0x1 ++ FD_SETSIZE = 0x400 ++ FF0 = 0x0 ++ FF1 = 0x4000 ++ FFDLY = 0x4000 ++ FIB_RULE_DEV_DETACHED = 0x8 ++ FIB_RULE_FIND_SADDR = 0x10000 ++ FIB_RULE_IIF_DETACHED = 0x8 ++ FIB_RULE_INVERT = 0x2 ++ FIB_RULE_OIF_DETACHED = 0x10 ++ FIB_RULE_PERMANENT = 0x1 ++ FIB_RULE_UNRESOLVED = 0x4 ++ FICLONE = 0x80049409 ++ FICLONERANGE = 0x8020940d ++ FIDEDUPERANGE = 0xc0189436 ++ FLUSHO = 0x800000 ++ FSCRYPT_KEY_DESCRIPTOR_SIZE = 0x8 ++ FSCRYPT_KEY_DESC_PREFIX = "fscrypt:" ++ FSCRYPT_KEY_DESC_PREFIX_SIZE = 0x8 ++ FSCRYPT_KEY_IDENTIFIER_SIZE = 0x10 ++ FSCRYPT_KEY_REMOVAL_STATUS_FLAG_FILES_BUSY = 0x1 ++ FSCRYPT_KEY_REMOVAL_STATUS_FLAG_OTHER_USERS = 0x2 ++ FSCRYPT_KEY_SPEC_TYPE_DESCRIPTOR = 0x1 ++ FSCRYPT_KEY_SPEC_TYPE_IDENTIFIER = 0x2 ++ FSCRYPT_KEY_STATUS_ABSENT = 0x1 ++ FSCRYPT_KEY_STATUS_FLAG_ADDED_BY_SELF = 0x1 ++ FSCRYPT_KEY_STATUS_INCOMPLETELY_REMOVED = 0x3 ++ FSCRYPT_KEY_STATUS_PRESENT = 0x2 ++ FSCRYPT_MAX_KEY_SIZE = 0x40 ++ FSCRYPT_MODE_ADIANTUM = 0x9 ++ FSCRYPT_MODE_AES_128_CBC = 0x5 ++ FSCRYPT_MODE_AES_128_CTS = 0x6 ++ FSCRYPT_MODE_AES_256_CTS = 0x4 ++ FSCRYPT_MODE_AES_256_XTS = 0x1 ++ FSCRYPT_POLICY_FLAGS_PAD_16 = 0x2 ++ FSCRYPT_POLICY_FLAGS_PAD_32 = 0x3 ++ FSCRYPT_POLICY_FLAGS_PAD_4 = 0x0 ++ FSCRYPT_POLICY_FLAGS_PAD_8 = 0x1 ++ FSCRYPT_POLICY_FLAGS_PAD_MASK = 0x3 ++ FSCRYPT_POLICY_FLAGS_VALID = 0x1f ++ FSCRYPT_POLICY_FLAG_DIRECT_KEY = 0x4 ++ FSCRYPT_POLICY_FLAG_IV_INO_LBLK_32 = 0x10 ++ FSCRYPT_POLICY_FLAG_IV_INO_LBLK_64 = 0x8 ++ FSCRYPT_POLICY_V1 = 0x0 ++ FSCRYPT_POLICY_V2 = 0x2 ++ FS_ENCRYPTION_MODE_ADIANTUM = 0x9 ++ FS_ENCRYPTION_MODE_AES_128_CBC = 0x5 ++ FS_ENCRYPTION_MODE_AES_128_CTS = 0x6 ++ FS_ENCRYPTION_MODE_AES_256_CBC = 0x3 ++ FS_ENCRYPTION_MODE_AES_256_CTS = 0x4 ++ FS_ENCRYPTION_MODE_AES_256_GCM = 0x2 ++ FS_ENCRYPTION_MODE_AES_256_XTS = 0x1 ++ FS_ENCRYPTION_MODE_INVALID = 0x0 ++ FS_ENCRYPTION_MODE_SPECK128_256_CTS = 0x8 ++ FS_ENCRYPTION_MODE_SPECK128_256_XTS = 0x7 ++ FS_IOC_ADD_ENCRYPTION_KEY = 0xc0506617 ++ FS_IOC_ENABLE_VERITY = 0x80806685 ++ FS_IOC_GETFLAGS = 0x40086601 ++ FS_IOC_GET_ENCRYPTION_KEY_STATUS = 0xc080661a ++ FS_IOC_GET_ENCRYPTION_NONCE = 0x4010661b ++ FS_IOC_GET_ENCRYPTION_POLICY = 0x800c6615 ++ FS_IOC_GET_ENCRYPTION_POLICY_EX = 0xc0096616 ++ FS_IOC_GET_ENCRYPTION_PWSALT = 0x80106614 ++ FS_IOC_MEASURE_VERITY = 0xc0046686 ++ FS_IOC_REMOVE_ENCRYPTION_KEY = 0xc0406618 ++ FS_IOC_REMOVE_ENCRYPTION_KEY_ALL_USERS = 0xc0406619 ++ FS_IOC_SETFLAGS = 0x80086602 ++ FS_IOC_SET_ENCRYPTION_POLICY = 0x400c6613 ++ FS_KEY_DESCRIPTOR_SIZE = 0x8 ++ FS_KEY_DESC_PREFIX = "fscrypt:" ++ FS_KEY_DESC_PREFIX_SIZE = 0x8 ++ FS_MAX_KEY_SIZE = 0x40 ++ FS_POLICY_FLAGS_PAD_16 = 0x2 ++ FS_POLICY_FLAGS_PAD_32 = 0x3 ++ FS_POLICY_FLAGS_PAD_4 = 0x0 ++ FS_POLICY_FLAGS_PAD_8 = 0x1 ++ FS_POLICY_FLAGS_PAD_MASK = 0x3 ++ FS_POLICY_FLAGS_VALID = 0x1f ++ FS_VERITY_FL = 0x100000 ++ FS_VERITY_HASH_ALG_SHA256 = 0x1 ++ FS_VERITY_HASH_ALG_SHA512 = 0x2 ++ FUTEXFS_SUPER_MAGIC = 0xbad1dea ++ F_ADD_SEALS = 0x409 ++ F_DUPFD = 0x0 ++ F_DUPFD_CLOEXEC = 0x406 ++ F_EXLCK = 0x10 ++ F_GETFD = 0x1 ++ F_GETFL = 0x3 ++ F_GETLEASE = 0x401 ++ F_GETLK = 0x7 ++ F_GETLK64 = 0x7 ++ F_GETOWN = 0x6 ++ F_GETOWN_EX = 0x10 ++ F_GETPIPE_SZ = 0x408 ++ F_GETSIG = 0xb ++ F_GET_FILE_RW_HINT = 0x40d ++ F_GET_RW_HINT = 0x40b ++ F_GET_SEALS = 0x40a ++ F_LOCK = 0x1 ++ F_NOTIFY = 0x402 ++ F_OFD_GETLK = 0x24 ++ F_OFD_SETLK = 0x25 ++ F_OFD_SETLKW = 0x26 ++ F_OK = 0x0 ++ F_RDLCK = 0x1 ++ F_SEAL_FUTURE_WRITE = 0x10 ++ F_SEAL_GROW = 0x4 ++ F_SEAL_SEAL = 0x1 ++ F_SEAL_SHRINK = 0x2 ++ F_SEAL_WRITE = 0x8 ++ F_SETFD = 0x2 ++ F_SETFL = 0x4 ++ F_SETLEASE = 0x400 ++ F_SETLK = 0x8 ++ F_SETLK64 = 0x8 ++ F_SETLKW = 0x9 ++ F_SETLKW64 = 0x9 ++ F_SETOWN = 0x5 ++ F_SETOWN_EX = 0xf ++ F_SETPIPE_SZ = 0x407 ++ F_SETSIG = 0xa ++ F_SET_FILE_RW_HINT = 0x40e ++ F_SET_RW_HINT = 0x40c ++ F_SHLCK = 0x20 ++ F_TEST = 0x3 ++ F_TLOCK = 0x2 ++ F_ULOCK = 0x0 ++ F_UNLCK = 0x8 ++ F_WRLCK = 0x2 ++ GENL_ADMIN_PERM = 0x1 ++ GENL_CMD_CAP_DO = 0x2 ++ GENL_CMD_CAP_DUMP = 0x4 ++ GENL_CMD_CAP_HASPOL = 0x8 ++ GENL_HDRLEN = 0x4 ++ GENL_ID_CTRL = 0x10 ++ GENL_ID_PMCRAID = 0x12 ++ GENL_ID_VFS_DQUOT = 0x11 ++ GENL_MAX_ID = 0x3ff ++ GENL_MIN_ID = 0x10 ++ GENL_NAMSIZ = 0x10 ++ GENL_START_ALLOC = 0x13 ++ GENL_UNS_ADMIN_PERM = 0x10 ++ GRND_INSECURE = 0x4 ++ GRND_NONBLOCK = 0x1 ++ GRND_RANDOM = 0x2 ++ HDIO_DRIVE_CMD = 0x31f ++ HDIO_DRIVE_CMD_AEB = 0x31e ++ HDIO_DRIVE_CMD_HDR_SIZE = 0x4 ++ HDIO_DRIVE_HOB_HDR_SIZE = 0x8 ++ HDIO_DRIVE_RESET = 0x31c ++ HDIO_DRIVE_TASK = 0x31e ++ HDIO_DRIVE_TASKFILE = 0x31d ++ HDIO_DRIVE_TASK_HDR_SIZE = 0x8 ++ HDIO_GETGEO = 0x301 ++ HDIO_GET_32BIT = 0x309 ++ HDIO_GET_ACOUSTIC = 0x30f ++ HDIO_GET_ADDRESS = 0x310 ++ HDIO_GET_BUSSTATE = 0x31a ++ HDIO_GET_DMA = 0x30b ++ HDIO_GET_IDENTITY = 0x30d ++ HDIO_GET_KEEPSETTINGS = 0x308 ++ HDIO_GET_MULTCOUNT = 0x304 ++ HDIO_GET_NICE = 0x30c ++ HDIO_GET_NOWERR = 0x30a ++ HDIO_GET_QDMA = 0x305 ++ HDIO_GET_UNMASKINTR = 0x302 ++ HDIO_GET_WCACHE = 0x30e ++ HDIO_OBSOLETE_IDENTITY = 0x307 ++ HDIO_SCAN_HWIF = 0x328 ++ HDIO_SET_32BIT = 0x324 ++ HDIO_SET_ACOUSTIC = 0x32c ++ HDIO_SET_ADDRESS = 0x32f ++ HDIO_SET_BUSSTATE = 0x32d ++ HDIO_SET_DMA = 0x326 ++ HDIO_SET_KEEPSETTINGS = 0x323 ++ HDIO_SET_MULTCOUNT = 0x321 ++ HDIO_SET_NICE = 0x329 ++ HDIO_SET_NOWERR = 0x325 ++ HDIO_SET_PIO_MODE = 0x327 ++ HDIO_SET_QDMA = 0x32e ++ HDIO_SET_UNMASKINTR = 0x322 ++ HDIO_SET_WCACHE = 0x32b ++ HDIO_SET_XFER = 0x306 ++ HDIO_TRISTATE_HWIF = 0x31b ++ HDIO_UNREGISTER_HWIF = 0x32a ++ HIDIOCGRAWINFO = 0x40084803 ++ HIDIOCGRDESC = 0x50044802 ++ HIDIOCGRDESCSIZE = 0x40044801 ++ HID_MAX_DESCRIPTOR_SIZE = 0x1000 ++ HOSTFS_SUPER_MAGIC = 0xc0ffee ++ HPFS_SUPER_MAGIC = 0xf995e849 ++ HUGETLBFS_MAGIC = 0x958458f6 ++ HUPCL = 0x4000 ++ ICANON = 0x100 ++ ICRNL = 0x100 ++ IEXTEN = 0x400 ++ IFA_F_DADFAILED = 0x8 ++ IFA_F_DEPRECATED = 0x20 ++ IFA_F_HOMEADDRESS = 0x10 ++ IFA_F_MANAGETEMPADDR = 0x100 ++ IFA_F_MCAUTOJOIN = 0x400 ++ IFA_F_NODAD = 0x2 ++ IFA_F_NOPREFIXROUTE = 0x200 ++ IFA_F_OPTIMISTIC = 0x4 ++ IFA_F_PERMANENT = 0x80 ++ IFA_F_SECONDARY = 0x1 ++ IFA_F_STABLE_PRIVACY = 0x800 ++ IFA_F_TEMPORARY = 0x1 ++ IFA_F_TENTATIVE = 0x40 ++ IFA_MAX = 0xa ++ IFF_ALLMULTI = 0x200 ++ IFF_ATTACH_QUEUE = 0x200 ++ IFF_AUTOMEDIA = 0x4000 ++ IFF_BROADCAST = 0x2 ++ IFF_DEBUG = 0x4 ++ IFF_DETACH_QUEUE = 0x400 ++ IFF_DORMANT = 0x20000 ++ IFF_DYNAMIC = 0x8000 ++ IFF_ECHO = 0x40000 ++ IFF_LOOPBACK = 0x8 ++ IFF_LOWER_UP = 0x10000 ++ IFF_MASTER = 0x400 ++ IFF_MULTICAST = 0x1000 ++ IFF_MULTI_QUEUE = 0x100 ++ IFF_NAPI = 0x10 ++ IFF_NAPI_FRAGS = 0x20 ++ IFF_NOARP = 0x80 ++ IFF_NOFILTER = 0x1000 ++ IFF_NOTRAILERS = 0x20 ++ IFF_NO_PI = 0x1000 ++ IFF_ONE_QUEUE = 0x2000 ++ IFF_PERSIST = 0x800 ++ IFF_POINTOPOINT = 0x10 ++ IFF_PORTSEL = 0x2000 ++ IFF_PROMISC = 0x100 ++ IFF_RUNNING = 0x40 ++ IFF_SLAVE = 0x800 ++ IFF_TAP = 0x2 ++ IFF_TUN = 0x1 ++ IFF_TUN_EXCL = 0x8000 ++ IFF_UP = 0x1 ++ IFF_VNET_HDR = 0x4000 ++ IFF_VOLATILE = 0x70c5a ++ IFNAMSIZ = 0x10 ++ IGNBRK = 0x1 ++ IGNCR = 0x80 ++ IGNPAR = 0x4 ++ IMAXBEL = 0x2000 ++ INLCR = 0x40 ++ INPCK = 0x10 ++ IN_ACCESS = 0x1 ++ IN_ALL_EVENTS = 0xfff ++ IN_ATTRIB = 0x4 ++ IN_CLASSA_HOST = 0xffffff ++ IN_CLASSA_MAX = 0x80 ++ IN_CLASSA_NET = 0xff000000 ++ IN_CLASSA_NSHIFT = 0x18 ++ IN_CLASSB_HOST = 0xffff ++ IN_CLASSB_MAX = 0x10000 ++ IN_CLASSB_NET = 0xffff0000 ++ IN_CLASSB_NSHIFT = 0x10 ++ IN_CLASSC_HOST = 0xff ++ IN_CLASSC_NET = 0xffffff00 ++ IN_CLASSC_NSHIFT = 0x8 ++ IN_CLOEXEC = 0x200000 ++ IN_CLOSE = 0x18 ++ IN_CLOSE_NOWRITE = 0x10 ++ IN_CLOSE_WRITE = 0x8 ++ IN_CREATE = 0x100 ++ IN_DELETE = 0x200 ++ IN_DELETE_SELF = 0x400 ++ IN_DONT_FOLLOW = 0x2000000 ++ IN_EXCL_UNLINK = 0x4000000 ++ IN_IGNORED = 0x8000 ++ IN_ISDIR = 0x40000000 ++ IN_LOOPBACKNET = 0x7f ++ IN_MASK_ADD = 0x20000000 ++ IN_MASK_CREATE = 0x10000000 ++ IN_MODIFY = 0x2 ++ IN_MOVE = 0xc0 ++ IN_MOVED_FROM = 0x40 ++ IN_MOVED_TO = 0x80 ++ IN_MOVE_SELF = 0x800 ++ IN_NONBLOCK = 0x4 ++ IN_ONESHOT = 0x80000000 ++ IN_ONLYDIR = 0x1000000 ++ IN_OPEN = 0x20 ++ IN_Q_OVERFLOW = 0x4000 ++ IN_UNMOUNT = 0x2000 ++ IOCTL_VM_SOCKETS_GET_LOCAL_CID = 0x200007b9 ++ IPPROTO_AH = 0x33 ++ IPPROTO_BEETPH = 0x5e ++ IPPROTO_COMP = 0x6c ++ IPPROTO_DCCP = 0x21 ++ IPPROTO_DSTOPTS = 0x3c ++ IPPROTO_EGP = 0x8 ++ IPPROTO_ENCAP = 0x62 ++ IPPROTO_ESP = 0x32 ++ IPPROTO_ETHERNET = 0x8f ++ IPPROTO_FRAGMENT = 0x2c ++ IPPROTO_GRE = 0x2f ++ IPPROTO_HOPOPTS = 0x0 ++ IPPROTO_ICMP = 0x1 ++ IPPROTO_ICMPV6 = 0x3a ++ IPPROTO_IDP = 0x16 ++ IPPROTO_IGMP = 0x2 ++ IPPROTO_IP = 0x0 ++ IPPROTO_IPIP = 0x4 ++ IPPROTO_IPV6 = 0x29 ++ IPPROTO_L2TP = 0x73 ++ IPPROTO_MH = 0x87 ++ IPPROTO_MPLS = 0x89 ++ IPPROTO_MPTCP = 0x106 ++ IPPROTO_MTP = 0x5c ++ IPPROTO_NONE = 0x3b ++ IPPROTO_PIM = 0x67 ++ IPPROTO_PUP = 0xc ++ IPPROTO_RAW = 0xff ++ IPPROTO_ROUTING = 0x2b ++ IPPROTO_RSVP = 0x2e ++ IPPROTO_SCTP = 0x84 ++ IPPROTO_TCP = 0x6 ++ IPPROTO_TP = 0x1d ++ IPPROTO_UDP = 0x11 ++ IPPROTO_UDPLITE = 0x88 ++ IPV6_2292DSTOPTS = 0x4 ++ IPV6_2292HOPLIMIT = 0x8 ++ IPV6_2292HOPOPTS = 0x3 ++ IPV6_2292PKTINFO = 0x2 ++ IPV6_2292PKTOPTIONS = 0x6 ++ IPV6_2292RTHDR = 0x5 ++ IPV6_ADDRFORM = 0x1 ++ IPV6_ADDR_PREFERENCES = 0x48 ++ IPV6_ADD_MEMBERSHIP = 0x14 ++ IPV6_AUTHHDR = 0xa ++ IPV6_AUTOFLOWLABEL = 0x46 ++ IPV6_CHECKSUM = 0x7 ++ IPV6_DONTFRAG = 0x3e ++ IPV6_DROP_MEMBERSHIP = 0x15 ++ IPV6_DSTOPTS = 0x3b ++ IPV6_FLOW = 0x11 ++ IPV6_FREEBIND = 0x4e ++ IPV6_HDRINCL = 0x24 ++ IPV6_HOPLIMIT = 0x34 ++ IPV6_HOPOPTS = 0x36 ++ IPV6_IPSEC_POLICY = 0x22 ++ IPV6_JOIN_ANYCAST = 0x1b ++ IPV6_JOIN_GROUP = 0x14 ++ IPV6_LEAVE_ANYCAST = 0x1c ++ IPV6_LEAVE_GROUP = 0x15 ++ IPV6_MINHOPCOUNT = 0x49 ++ IPV6_MTU = 0x18 ++ IPV6_MTU_DISCOVER = 0x17 ++ IPV6_MULTICAST_ALL = 0x1d ++ IPV6_MULTICAST_HOPS = 0x12 ++ IPV6_MULTICAST_IF = 0x11 ++ IPV6_MULTICAST_LOOP = 0x13 ++ IPV6_NEXTHOP = 0x9 ++ IPV6_ORIGDSTADDR = 0x4a ++ IPV6_PATHMTU = 0x3d ++ IPV6_PKTINFO = 0x32 ++ IPV6_PMTUDISC_DO = 0x2 ++ IPV6_PMTUDISC_DONT = 0x0 ++ IPV6_PMTUDISC_INTERFACE = 0x4 ++ IPV6_PMTUDISC_OMIT = 0x5 ++ IPV6_PMTUDISC_PROBE = 0x3 ++ IPV6_PMTUDISC_WANT = 0x1 ++ IPV6_RECVDSTOPTS = 0x3a ++ IPV6_RECVERR = 0x19 ++ IPV6_RECVERR_RFC4884 = 0x1f ++ IPV6_RECVFRAGSIZE = 0x4d ++ IPV6_RECVHOPLIMIT = 0x33 ++ IPV6_RECVHOPOPTS = 0x35 ++ IPV6_RECVORIGDSTADDR = 0x4a ++ IPV6_RECVPATHMTU = 0x3c ++ IPV6_RECVPKTINFO = 0x31 ++ IPV6_RECVRTHDR = 0x38 ++ IPV6_RECVTCLASS = 0x42 ++ IPV6_ROUTER_ALERT = 0x16 ++ IPV6_ROUTER_ALERT_ISOLATE = 0x1e ++ IPV6_RTHDR = 0x39 ++ IPV6_RTHDRDSTOPTS = 0x37 ++ IPV6_RTHDR_LOOSE = 0x0 ++ IPV6_RTHDR_STRICT = 0x1 ++ IPV6_RTHDR_TYPE_0 = 0x0 ++ IPV6_RXDSTOPTS = 0x3b ++ IPV6_RXHOPOPTS = 0x36 ++ IPV6_TCLASS = 0x43 ++ IPV6_TRANSPARENT = 0x4b ++ IPV6_UNICAST_HOPS = 0x10 ++ IPV6_UNICAST_IF = 0x4c ++ IPV6_USER_FLOW = 0xe ++ IPV6_V6ONLY = 0x1a ++ IPV6_XFRM_POLICY = 0x23 ++ IP_ADD_MEMBERSHIP = 0x23 ++ IP_ADD_SOURCE_MEMBERSHIP = 0x27 ++ IP_BIND_ADDRESS_NO_PORT = 0x18 ++ IP_BLOCK_SOURCE = 0x26 ++ IP_CHECKSUM = 0x17 ++ IP_DEFAULT_MULTICAST_LOOP = 0x1 ++ IP_DEFAULT_MULTICAST_TTL = 0x1 ++ IP_DF = 0x4000 ++ IP_DROP_MEMBERSHIP = 0x24 ++ IP_DROP_SOURCE_MEMBERSHIP = 0x28 ++ IP_FREEBIND = 0xf ++ IP_HDRINCL = 0x3 ++ IP_IPSEC_POLICY = 0x10 ++ IP_MAXPACKET = 0xffff ++ IP_MAX_MEMBERSHIPS = 0x14 ++ IP_MF = 0x2000 ++ IP_MINTTL = 0x15 ++ IP_MSFILTER = 0x29 ++ IP_MSS = 0x240 ++ IP_MTU = 0xe ++ IP_MTU_DISCOVER = 0xa ++ IP_MULTICAST_ALL = 0x31 ++ IP_MULTICAST_IF = 0x20 ++ IP_MULTICAST_LOOP = 0x22 ++ IP_MULTICAST_TTL = 0x21 ++ IP_NODEFRAG = 0x16 ++ IP_OFFMASK = 0x1fff ++ IP_OPTIONS = 0x4 ++ IP_ORIGDSTADDR = 0x14 ++ IP_PASSSEC = 0x12 ++ IP_PKTINFO = 0x8 ++ IP_PKTOPTIONS = 0x9 ++ IP_PMTUDISC = 0xa ++ IP_PMTUDISC_DO = 0x2 ++ IP_PMTUDISC_DONT = 0x0 ++ IP_PMTUDISC_INTERFACE = 0x4 ++ IP_PMTUDISC_OMIT = 0x5 ++ IP_PMTUDISC_PROBE = 0x3 ++ IP_PMTUDISC_WANT = 0x1 ++ IP_RECVERR = 0xb ++ IP_RECVERR_RFC4884 = 0x1a ++ IP_RECVFRAGSIZE = 0x19 ++ IP_RECVOPTS = 0x6 ++ IP_RECVORIGDSTADDR = 0x14 ++ IP_RECVRETOPTS = 0x7 ++ IP_RECVTOS = 0xd ++ IP_RECVTTL = 0xc ++ IP_RETOPTS = 0x7 ++ IP_RF = 0x8000 ++ IP_ROUTER_ALERT = 0x5 ++ IP_TOS = 0x1 ++ IP_TRANSPARENT = 0x13 ++ IP_TTL = 0x2 ++ IP_UNBLOCK_SOURCE = 0x25 ++ IP_UNICAST_IF = 0x32 ++ IP_USER_FLOW = 0xd ++ IP_XFRM_POLICY = 0x11 ++ ISIG = 0x80 ++ ISOFS_SUPER_MAGIC = 0x9660 ++ ISTRIP = 0x20 ++ ITIMER_PROF = 0x2 ++ ITIMER_REAL = 0x0 ++ ITIMER_VIRTUAL = 0x1 ++ IUCLC = 0x1000 ++ IUTF8 = 0x4000 ++ IXANY = 0x800 ++ IXOFF = 0x400 ++ IXON = 0x200 ++ JFFS2_SUPER_MAGIC = 0x72b6 ++ KCMPROTO_CONNECTED = 0x0 ++ KCM_RECV_DISABLE = 0x1 ++ KEXEC_ARCH_386 = 0x30000 ++ KEXEC_ARCH_68K = 0x40000 ++ KEXEC_ARCH_AARCH64 = 0xb70000 ++ KEXEC_ARCH_ARM = 0x280000 ++ KEXEC_ARCH_DEFAULT = 0x0 ++ KEXEC_ARCH_IA_64 = 0x320000 ++ KEXEC_ARCH_MASK = 0xffff0000 ++ KEXEC_ARCH_MIPS = 0x80000 ++ KEXEC_ARCH_MIPS_LE = 0xa0000 ++ KEXEC_ARCH_PARISC = 0xf0000 ++ KEXEC_ARCH_PPC = 0x140000 ++ KEXEC_ARCH_PPC64 = 0x150000 ++ KEXEC_ARCH_S390 = 0x160000 ++ KEXEC_ARCH_SH = 0x2a0000 ++ KEXEC_ARCH_SW64 = 0x99160000 ++ KEXEC_ARCH_X86_64 = 0x3e0000 ++ KEXEC_FILE_NO_INITRAMFS = 0x4 ++ KEXEC_FILE_ON_CRASH = 0x2 ++ KEXEC_FILE_UNLOAD = 0x1 ++ KEXEC_ON_CRASH = 0x1 ++ KEXEC_PRESERVE_CONTEXT = 0x2 ++ KEXEC_SEGMENT_MAX = 0x10 ++ KEYCTL_ASSUME_AUTHORITY = 0x10 ++ KEYCTL_CAPABILITIES = 0x1f ++ KEYCTL_CAPS0_BIG_KEY = 0x10 ++ KEYCTL_CAPS0_CAPABILITIES = 0x1 ++ KEYCTL_CAPS0_DIFFIE_HELLMAN = 0x4 ++ KEYCTL_CAPS0_INVALIDATE = 0x20 ++ KEYCTL_CAPS0_MOVE = 0x80 ++ KEYCTL_CAPS0_PERSISTENT_KEYRINGS = 0x2 ++ KEYCTL_CAPS0_PUBLIC_KEY = 0x8 ++ KEYCTL_CAPS0_RESTRICT_KEYRING = 0x40 ++ KEYCTL_CAPS1_NOTIFICATIONS = 0x4 ++ KEYCTL_CAPS1_NS_KEYRING_NAME = 0x1 ++ KEYCTL_CAPS1_NS_KEY_TAG = 0x2 ++ KEYCTL_CHOWN = 0x4 ++ KEYCTL_CLEAR = 0x7 ++ KEYCTL_DESCRIBE = 0x6 ++ KEYCTL_DH_COMPUTE = 0x17 ++ KEYCTL_GET_KEYRING_ID = 0x0 ++ KEYCTL_GET_PERSISTENT = 0x16 ++ KEYCTL_GET_SECURITY = 0x11 ++ KEYCTL_INSTANTIATE = 0xc ++ KEYCTL_INSTANTIATE_IOV = 0x14 ++ KEYCTL_INVALIDATE = 0x15 ++ KEYCTL_JOIN_SESSION_KEYRING = 0x1 ++ KEYCTL_LINK = 0x8 ++ KEYCTL_MOVE = 0x1e ++ KEYCTL_MOVE_EXCL = 0x1 ++ KEYCTL_NEGATE = 0xd ++ KEYCTL_PKEY_DECRYPT = 0x1a ++ KEYCTL_PKEY_ENCRYPT = 0x19 ++ KEYCTL_PKEY_QUERY = 0x18 ++ KEYCTL_PKEY_SIGN = 0x1b ++ KEYCTL_PKEY_VERIFY = 0x1c ++ KEYCTL_READ = 0xb ++ KEYCTL_REJECT = 0x13 ++ KEYCTL_RESTRICT_KEYRING = 0x1d ++ KEYCTL_REVOKE = 0x3 ++ KEYCTL_SEARCH = 0xa ++ KEYCTL_SESSION_TO_PARENT = 0x12 ++ KEYCTL_SETPERM = 0x5 ++ KEYCTL_SET_REQKEY_KEYRING = 0xe ++ KEYCTL_SET_TIMEOUT = 0xf ++ KEYCTL_SUPPORTS_DECRYPT = 0x2 ++ KEYCTL_SUPPORTS_ENCRYPT = 0x1 ++ KEYCTL_SUPPORTS_SIGN = 0x4 ++ KEYCTL_SUPPORTS_VERIFY = 0x8 ++ KEYCTL_UNLINK = 0x9 ++ KEYCTL_UPDATE = 0x2 ++ KEYCTL_WATCH_KEY = 0x20 ++ KEY_REQKEY_DEFL_DEFAULT = 0x0 ++ KEY_REQKEY_DEFL_GROUP_KEYRING = 0x6 ++ KEY_REQKEY_DEFL_NO_CHANGE = -0x1 ++ KEY_REQKEY_DEFL_PROCESS_KEYRING = 0x2 ++ KEY_REQKEY_DEFL_REQUESTOR_KEYRING = 0x7 ++ KEY_REQKEY_DEFL_SESSION_KEYRING = 0x3 ++ KEY_REQKEY_DEFL_THREAD_KEYRING = 0x1 ++ KEY_REQKEY_DEFL_USER_KEYRING = 0x4 ++ KEY_REQKEY_DEFL_USER_SESSION_KEYRING = 0x5 ++ KEY_SPEC_GROUP_KEYRING = -0x6 ++ KEY_SPEC_PROCESS_KEYRING = -0x2 ++ KEY_SPEC_REQKEY_AUTH_KEY = -0x7 ++ KEY_SPEC_REQUESTOR_KEYRING = -0x8 ++ KEY_SPEC_SESSION_KEYRING = -0x3 ++ KEY_SPEC_THREAD_KEYRING = -0x1 ++ KEY_SPEC_USER_KEYRING = -0x4 ++ KEY_SPEC_USER_SESSION_KEYRING = -0x5 ++ LINUX_REBOOT_CMD_CAD_OFF = 0x0 ++ LINUX_REBOOT_CMD_CAD_ON = 0x89abcdef ++ LINUX_REBOOT_CMD_HALT = 0xcdef0123 ++ LINUX_REBOOT_CMD_KEXEC = 0x45584543 ++ LINUX_REBOOT_CMD_POWER_OFF = 0x4321fedc ++ LINUX_REBOOT_CMD_RESTART = 0x1234567 ++ LINUX_REBOOT_CMD_RESTART2 = 0xa1b2c3d4 ++ LINUX_REBOOT_CMD_SW_SUSPEND = 0xd000fce2 ++ LINUX_REBOOT_MAGIC1 = 0xfee1dead ++ LINUX_REBOOT_MAGIC2 = 0x28121969 ++ LOCK_EX = 0x2 ++ LOCK_NB = 0x4 ++ LOCK_SH = 0x1 ++ LOCK_UN = 0x8 ++ LOOP_CLR_FD = 0x4c01 ++ LOOP_CONFIGURE = 0x4c0a ++ LOOP_CTL_ADD = 0x4c80 ++ LOOP_CTL_GET_FREE = 0x4c82 ++ LOOP_CTL_REMOVE = 0x4c81 ++ LOOP_GET_STATUS = 0x4c03 ++ LOOP_GET_STATUS64 = 0x4c05 ++ LOOP_SET_BLOCK_SIZE = 0x4c09 ++ LOOP_SET_CAPACITY = 0x4c07 ++ LOOP_SET_DIRECT_IO = 0x4c08 ++ LOOP_SET_FD = 0x4c00 ++ LOOP_SET_STATUS = 0x4c02 ++ LOOP_SET_STATUS64 = 0x4c04 ++ LOOP_SET_STATUS_CLEARABLE_FLAGS = 0x4 ++ LOOP_SET_STATUS_SETTABLE_FLAGS = 0xc ++ LO_KEY_SIZE = 0x20 ++ LO_NAME_SIZE = 0x40 ++ LWTUNNEL_IP6_MAX = 0x8 ++ LWTUNNEL_IP_MAX = 0x8 ++ LWTUNNEL_IP_OPTS_MAX = 0x3 ++ LWTUNNEL_IP_OPT_ERSPAN_MAX = 0x4 ++ LWTUNNEL_IP_OPT_GENEVE_MAX = 0x3 ++ LWTUNNEL_IP_OPT_VXLAN_MAX = 0x1 ++ MADV_COLD = 0x14 ++ MADV_DODUMP = 0x11 ++ MADV_DOFORK = 0xb ++ MADV_DONTDUMP = 0x10 ++ MADV_DONTFORK = 0xa ++ MADV_DONTNEED = 0x6 ++ MADV_FREE = 0x8 ++ MADV_HUGEPAGE = 0xe ++ MADV_HWPOISON = 0x64 ++ MADV_KEEPONFORK = 0x13 ++ MADV_MERGEABLE = 0xc ++ MADV_NOHUGEPAGE = 0xf ++ MADV_NORMAL = 0x0 ++ MADV_PAGEOUT = 0x15 ++ MADV_POPULATE_READ = 0x16 ++ MADV_POPULATE_WRITE = 0x17 ++ MADV_RANDOM = 0x1 ++ MADV_REMOVE = 0x9 ++ MADV_SEQUENTIAL = 0x2 ++ MADV_UNMERGEABLE = 0xd ++ MADV_WILLNEED = 0x3 ++ MADV_WIPEONFORK = 0x12 ++ MAP_ANON = 0x10 ++ MAP_ANONYMOUS = 0x10 ++ MAP_DENYWRITE = 0x2000 ++ MAP_EXECUTABLE = 0x4000 ++ MAP_FILE = 0x0 ++ MAP_FIXED = 0x100 ++ MAP_FIXED_NOREPLACE = 0x200000 ++ MAP_GROWSDOWN = 0x1000 ++ MAP_HUGETLB = 0x100000 ++ MAP_HUGE_MASK = 0x3f ++ MAP_HUGE_SHIFT = 0x1a ++ MAP_LOCKED = 0x8000 ++ MAP_NONBLOCK = 0x40000 ++ MAP_NORESERVE = 0x10000 ++ MAP_POPULATE = 0x20000 ++ MAP_PRIVATE = 0x2 ++ MAP_SHARED = 0x1 ++ MAP_SHARED_VALIDATE = 0x3 ++ MAP_STACK = 0x80000 ++ MAP_TYPE = 0xf ++ MCAST_BLOCK_SOURCE = 0x2b ++ MCAST_EXCLUDE = 0x0 ++ MCAST_INCLUDE = 0x1 ++ MCAST_JOIN_GROUP = 0x2a ++ MCAST_JOIN_SOURCE_GROUP = 0x2e ++ MCAST_LEAVE_GROUP = 0x2d ++ MCAST_LEAVE_SOURCE_GROUP = 0x2f ++ MCAST_MSFILTER = 0x30 ++ MCAST_UNBLOCK_SOURCE = 0x2c ++ MCL_CURRENT = 0x2000 ++ MCL_FUTURE = 0x4000 ++ MCL_ONFAULT = 0x8000 ++ MEMERASE = 0x80084d02 ++ MEMERASE64 = 0x80104d14 ++ MEMGETBADBLOCK = 0x80084d0b ++ MEMGETINFO = 0x40204d01 ++ MEMGETOOBSEL = 0x40c84d0a ++ MEMGETREGIONCOUNT = 0x40044d07 ++ MEMGETREGIONINFO = 0xc0104d08 ++ MEMISLOCKED = 0x40084d17 ++ MEMLOCK = 0x80084d05 ++ MEMREADOOB = 0xc0104d04 ++ MEMREADOOB64 = 0xc0184d16 ++ MEMSETBADBLOCK = 0x80084d0c ++ MEMUNLOCK = 0x80084d06 ++ MEMWRITE = 0xc0304d18 ++ MEMWRITEOOB = 0xc0104d03 ++ MEMWRITEOOB64 = 0xc0184d15 ++ MFD_ALLOW_SEALING = 0x2 ++ MFD_CLOEXEC = 0x1 ++ MFD_HUGETLB = 0x4 ++ MFD_HUGE_16GB = -0x78000000 ++ MFD_HUGE_16MB = 0x60000000 ++ MFD_HUGE_1GB = 0x78000000 ++ MFD_HUGE_1MB = 0x50000000 ++ MFD_HUGE_256MB = 0x70000000 ++ MFD_HUGE_2GB = 0x7c000000 ++ MFD_HUGE_2MB = 0x54000000 ++ MFD_HUGE_32MB = 0x64000000 ++ MFD_HUGE_512KB = 0x4c000000 ++ MFD_HUGE_512MB = 0x74000000 ++ MFD_HUGE_64KB = 0x40000000 ++ MFD_HUGE_8MB = 0x5c000000 ++ MFD_HUGE_MASK = 0x3f ++ MFD_HUGE_SHIFT = 0x1a ++ MINIX2_SUPER_MAGIC = 0x2468 ++ MINIX2_SUPER_MAGIC2 = 0x2478 ++ MINIX3_SUPER_MAGIC = 0x4d5a ++ MINIX_SUPER_MAGIC = 0x137f ++ MINIX_SUPER_MAGIC2 = 0x138f ++ MNT_DETACH = 0x2 ++ MNT_EXPIRE = 0x4 ++ MNT_FORCE = 0x1 ++ MODULE_INIT_IGNORE_MODVERSIONS = 0x1 ++ MODULE_INIT_IGNORE_VERMAGIC = 0x2 ++ MOUNT_ATTR_NOATIME = 0x10 ++ MOUNT_ATTR_NODEV = 0x4 ++ MOUNT_ATTR_NODIRATIME = 0x80 ++ MOUNT_ATTR_NOEXEC = 0x8 ++ MOUNT_ATTR_NOSUID = 0x2 ++ MOUNT_ATTR_RDONLY = 0x1 ++ MOUNT_ATTR_RELATIME = 0x0 ++ MOUNT_ATTR_STRICTATIME = 0x20 ++ MOUNT_ATTR__ATIME = 0x70 ++ MREMAP_DONTUNMAP = 0x4 ++ MREMAP_FIXED = 0x2 ++ MREMAP_MAYMOVE = 0x1 ++ MSDOS_SUPER_MAGIC = 0x4d44 ++ MSG_BATCH = 0x40000 ++ MSG_CMSG_CLOEXEC = 0x40000000 ++ MSG_CONFIRM = 0x800 ++ MSG_CTRUNC = 0x8 ++ MSG_DONTROUTE = 0x4 ++ MSG_DONTWAIT = 0x40 ++ MSG_EOR = 0x80 ++ MSG_ERRQUEUE = 0x2000 ++ MSG_FASTOPEN = 0x20000000 ++ MSG_FIN = 0x200 ++ MSG_MORE = 0x8000 ++ MSG_NOSIGNAL = 0x4000 ++ MSG_OOB = 0x1 ++ MSG_PEEK = 0x2 ++ MSG_PROXY = 0x10 ++ MSG_RST = 0x1000 ++ MSG_SYN = 0x400 ++ MSG_TRUNC = 0x20 ++ MSG_TRYHARD = 0x4 ++ MSG_WAITALL = 0x100 ++ MSG_WAITFORONE = 0x10000 ++ MSG_ZEROCOPY = 0x4000000 ++ MS_ACTIVE = 0x40000000 ++ MS_ASYNC = 0x1 ++ MS_BIND = 0x1000 ++ MS_BORN = 0x20000000 ++ MS_DIRSYNC = 0x80 ++ MS_INVALIDATE = 0x4 ++ MS_I_VERSION = 0x800000 ++ MS_KERNMOUNT = 0x400000 ++ MS_LAZYTIME = 0x2000000 ++ MS_MANDLOCK = 0x40 ++ MS_MGC_MSK = 0xffff0000 ++ MS_MGC_VAL = 0xc0ed0000 ++ MS_MOVE = 0x2000 ++ MS_NOATIME = 0x400 ++ MS_NODEV = 0x4 ++ MS_NODIRATIME = 0x800 ++ MS_NOEXEC = 0x8 ++ MS_NOREMOTELOCK = 0x8000000 ++ MS_NOSEC = 0x10000000 ++ MS_NOSUID = 0x2 ++ MS_NOSYMFOLLOW = 0x100 ++ MS_NOUSER = -0x80000000 ++ MS_POSIXACL = 0x10000 ++ MS_PRIVATE = 0x40000 ++ MS_RDONLY = 0x1 ++ MS_REC = 0x4000 ++ MS_RELATIME = 0x200000 ++ MS_REMOUNT = 0x20 ++ MS_RMT_MASK = 0x2800051 ++ MS_SHARED = 0x100000 ++ MS_SILENT = 0x8000 ++ MS_SLAVE = 0x80000 ++ MS_STRICTATIME = 0x1000000 ++ MS_SUBMOUNT = 0x4000000 ++ MS_SYNC = 0x2 ++ MS_SYNCHRONOUS = 0x10 ++ MS_UNBINDABLE = 0x20000 ++ MS_VERBOSE = 0x8000 ++ MTDFILEMODE = 0x20004d13 ++ MTD_ABSENT = 0x0 ++ MTD_BIT_WRITEABLE = 0x800 ++ MTD_CAP_NANDFLASH = 0x400 ++ MTD_CAP_NORFLASH = 0xc00 ++ MTD_CAP_NVRAM = 0x1c00 ++ MTD_CAP_RAM = 0x1c00 ++ MTD_CAP_ROM = 0x0 ++ MTD_DATAFLASH = 0x6 ++ MTD_INODE_FS_MAGIC = 0x11307854 ++ MTD_MAX_ECCPOS_ENTRIES = 0x40 ++ MTD_MAX_OOBFREE_ENTRIES = 0x8 ++ MTD_MLCNANDFLASH = 0x8 ++ MTD_NANDECC_AUTOPLACE = 0x2 ++ MTD_NANDECC_AUTOPL_USR = 0x4 ++ MTD_NANDECC_OFF = 0x0 ++ MTD_NANDECC_PLACE = 0x1 ++ MTD_NANDECC_PLACEONLY = 0x3 ++ MTD_NANDFLASH = 0x4 ++ MTD_NORFLASH = 0x3 ++ MTD_NO_ERASE = 0x1000 ++ MTD_OTP_FACTORY = 0x1 ++ MTD_OTP_OFF = 0x0 ++ MTD_OTP_USER = 0x2 ++ MTD_POWERUP_LOCK = 0x2000 ++ MTD_RAM = 0x1 ++ MTD_ROM = 0x2 ++ MTD_SLC_ON_MLC_EMULATION = 0x4000 ++ MTD_UBIVOLUME = 0x7 ++ MTD_WRITEABLE = 0x400 ++ NAME_MAX = 0xff ++ NCP_SUPER_MAGIC = 0x564c ++ NETLINK_ADD_MEMBERSHIP = 0x1 ++ NETLINK_AUDIT = 0x9 ++ NETLINK_BROADCAST_ERROR = 0x4 ++ NETLINK_CAP_ACK = 0xa ++ NETLINK_CONNECTOR = 0xb ++ NETLINK_CRYPTO = 0x15 ++ NETLINK_DNRTMSG = 0xe ++ NETLINK_DROP_MEMBERSHIP = 0x2 ++ NETLINK_ECRYPTFS = 0x13 ++ NETLINK_EXT_ACK = 0xb ++ NETLINK_FIB_LOOKUP = 0xa ++ NETLINK_FIREWALL = 0x3 ++ NETLINK_GENERIC = 0x10 ++ NETLINK_GET_STRICT_CHK = 0xc ++ NETLINK_INET_DIAG = 0x4 ++ NETLINK_IP6_FW = 0xd ++ NETLINK_ISCSI = 0x8 ++ NETLINK_KOBJECT_UEVENT = 0xf ++ NETLINK_LISTEN_ALL_NSID = 0x8 ++ NETLINK_LIST_MEMBERSHIPS = 0x9 ++ NETLINK_NETFILTER = 0xc ++ NETLINK_NFLOG = 0x5 ++ NETLINK_NO_ENOBUFS = 0x5 ++ NETLINK_PKTINFO = 0x3 ++ NETLINK_RDMA = 0x14 ++ NETLINK_ROUTE = 0x0 ++ NETLINK_RX_RING = 0x6 ++ NETLINK_SCSITRANSPORT = 0x12 ++ NETLINK_SELINUX = 0x7 ++ NETLINK_SMC = 0x16 ++ NETLINK_SOCK_DIAG = 0x4 ++ NETLINK_TX_RING = 0x7 ++ NETLINK_UNUSED = 0x1 ++ NETLINK_USERSOCK = 0x2 ++ NETLINK_XFRM = 0x6 ++ NETNSA_MAX = 0x5 ++ NETNSA_NSID_NOT_ASSIGNED = -0x1 ++ NFC_ATR_REQ_GB_MAXSIZE = 0x30 ++ NFC_ATR_REQ_MAXSIZE = 0x40 ++ NFC_ATR_RES_GB_MAXSIZE = 0x2f ++ NFC_ATR_RES_MAXSIZE = 0x40 ++ NFC_COMM_ACTIVE = 0x0 ++ NFC_COMM_PASSIVE = 0x1 ++ NFC_DEVICE_NAME_MAXSIZE = 0x8 ++ NFC_DIRECTION_RX = 0x0 ++ NFC_DIRECTION_TX = 0x1 ++ NFC_FIRMWARE_NAME_MAXSIZE = 0x20 ++ NFC_GB_MAXSIZE = 0x30 ++ NFC_GENL_MCAST_EVENT_NAME = "events" ++ NFC_GENL_NAME = "nfc" ++ NFC_GENL_VERSION = 0x1 ++ NFC_HEADER_SIZE = 0x1 ++ NFC_ISO15693_UID_MAXSIZE = 0x8 ++ NFC_LLCP_MAX_SERVICE_NAME = 0x3f ++ NFC_LLCP_MIUX = 0x1 ++ NFC_LLCP_REMOTE_LTO = 0x3 ++ NFC_LLCP_REMOTE_MIU = 0x2 ++ NFC_LLCP_REMOTE_RW = 0x4 ++ NFC_LLCP_RW = 0x0 ++ NFC_NFCID1_MAXSIZE = 0xa ++ NFC_NFCID2_MAXSIZE = 0x8 ++ NFC_NFCID3_MAXSIZE = 0xa ++ NFC_PROTO_FELICA = 0x3 ++ NFC_PROTO_FELICA_MASK = 0x8 ++ NFC_PROTO_ISO14443 = 0x4 ++ NFC_PROTO_ISO14443_B = 0x6 ++ NFC_PROTO_ISO14443_B_MASK = 0x40 ++ NFC_PROTO_ISO14443_MASK = 0x10 ++ NFC_PROTO_ISO15693 = 0x7 ++ NFC_PROTO_ISO15693_MASK = 0x80 ++ NFC_PROTO_JEWEL = 0x1 ++ NFC_PROTO_JEWEL_MASK = 0x2 ++ NFC_PROTO_MAX = 0x8 ++ NFC_PROTO_MIFARE = 0x2 ++ NFC_PROTO_MIFARE_MASK = 0x4 ++ NFC_PROTO_NFC_DEP = 0x5 ++ NFC_PROTO_NFC_DEP_MASK = 0x20 ++ NFC_RAW_HEADER_SIZE = 0x2 ++ NFC_RF_INITIATOR = 0x0 ++ NFC_RF_NONE = 0x2 ++ NFC_RF_TARGET = 0x1 ++ NFC_SENSB_RES_MAXSIZE = 0xc ++ NFC_SENSF_RES_MAXSIZE = 0x12 ++ NFC_SE_DISABLED = 0x0 ++ NFC_SE_EMBEDDED = 0x2 ++ NFC_SE_ENABLED = 0x1 ++ NFC_SE_UICC = 0x1 ++ NFC_SOCKPROTO_LLCP = 0x1 ++ NFC_SOCKPROTO_MAX = 0x2 ++ NFC_SOCKPROTO_RAW = 0x0 ++ NFDBITS = 0x40 ++ NFNETLINK_V0 = 0x0 ++ NFNLGRP_ACCT_QUOTA = 0x8 ++ NFNLGRP_CONNTRACK_DESTROY = 0x3 ++ NFNLGRP_CONNTRACK_EXP_DESTROY = 0x6 ++ NFNLGRP_CONNTRACK_EXP_NEW = 0x4 ++ NFNLGRP_CONNTRACK_EXP_UPDATE = 0x5 ++ NFNLGRP_CONNTRACK_NEW = 0x1 ++ NFNLGRP_CONNTRACK_UPDATE = 0x2 ++ NFNLGRP_MAX = 0x9 ++ NFNLGRP_NFTABLES = 0x7 ++ NFNLGRP_NFTRACE = 0x9 ++ NFNLGRP_NONE = 0x0 ++ NFNL_BATCH_MAX = 0x1 ++ NFNL_MSG_BATCH_BEGIN = 0x10 ++ NFNL_MSG_BATCH_END = 0x11 ++ NFNL_NFA_NEST = 0x8000 ++ NFNL_SUBSYS_ACCT = 0x7 ++ NFNL_SUBSYS_COUNT = 0xc ++ NFNL_SUBSYS_CTHELPER = 0x9 ++ NFNL_SUBSYS_CTNETLINK = 0x1 ++ NFNL_SUBSYS_CTNETLINK_EXP = 0x2 ++ NFNL_SUBSYS_CTNETLINK_TIMEOUT = 0x8 ++ NFNL_SUBSYS_IPSET = 0x6 ++ NFNL_SUBSYS_NFTABLES = 0xa ++ NFNL_SUBSYS_NFT_COMPAT = 0xb ++ NFNL_SUBSYS_NONE = 0x0 ++ NFNL_SUBSYS_OSF = 0x5 ++ NFNL_SUBSYS_QUEUE = 0x3 ++ NFNL_SUBSYS_ULOG = 0x4 ++ NFS_SUPER_MAGIC = 0x6969 ++ NILFS_SUPER_MAGIC = 0x3434 ++ NL0 = 0x0 ++ NL1 = 0x100 ++ NL2 = 0x200 ++ NL3 = 0x300 ++ NLA_ALIGNTO = 0x4 ++ NLA_F_NESTED = 0x8000 ++ NLA_F_NET_BYTEORDER = 0x4000 ++ NLA_HDRLEN = 0x4 ++ NLDLY = 0x300 ++ NLMSG_ALIGNTO = 0x4 ++ NLMSG_DONE = 0x3 ++ NLMSG_ERROR = 0x2 ++ NLMSG_HDRLEN = 0x10 ++ NLMSG_MIN_TYPE = 0x10 ++ NLMSG_NOOP = 0x1 ++ NLMSG_OVERRUN = 0x4 ++ NLM_F_ACK = 0x4 ++ NLM_F_ACK_TLVS = 0x200 ++ NLM_F_APPEND = 0x800 ++ NLM_F_ATOMIC = 0x400 ++ NLM_F_CAPPED = 0x100 ++ NLM_F_CREATE = 0x400 ++ NLM_F_DUMP = 0x300 ++ NLM_F_DUMP_FILTERED = 0x20 ++ NLM_F_DUMP_INTR = 0x10 ++ NLM_F_ECHO = 0x8 ++ NLM_F_EXCL = 0x200 ++ NLM_F_MATCH = 0x200 ++ NLM_F_MULTI = 0x2 ++ NLM_F_NONREC = 0x100 ++ NLM_F_REPLACE = 0x100 ++ NLM_F_REQUEST = 0x1 ++ NLM_F_ROOT = 0x100 ++ NOFLSH = 0x80000000 ++ NSFS_MAGIC = 0x6e736673 ++ NS_GET_NSTYPE = 0x2000b703 ++ NS_GET_OWNER_UID = 0x2000b704 ++ NS_GET_PARENT = 0x2000b702 ++ NS_GET_USERNS = 0x2000b701 ++ OCFS2_SUPER_MAGIC = 0x7461636f ++ OCRNL = 0x8 ++ OFDEL = 0x80 ++ OFILL = 0x40 ++ OLCUC = 0x4 ++ ONLCR = 0x2 ++ ONLRET = 0x20 ++ ONOCR = 0x10 ++ OPENPROM_SUPER_MAGIC = 0x9fa1 ++ OPOST = 0x1 ++ OTPGETREGIONCOUNT = 0x80044d0e ++ OTPGETREGIONINFO = 0x800c4d0f ++ OTPLOCK = 0x400c4d10 ++ OTPSELECT = 0x40044d0d ++ OVERLAYFS_SUPER_MAGIC = 0x794c7630 ++ O_ACCMODE = 0x3 ++ O_APPEND = 0x8 ++ O_ASYNC = 0x2000 ++ O_CLOEXEC = 0x200000 ++ O_CREAT = 0x200 ++ O_DIRECT = 0x80000 ++ O_DIRECTORY = 0x8000 ++ O_DSYNC = 0x4000 ++ O_EXCL = 0x800 ++ O_FSYNC = 0x404000 ++ O_LARGEFILE = 0x0 ++ O_NDELAY = 0x4 ++ O_NOATIME = 0x100000 ++ O_NOCTTY = 0x1000 ++ O_NOFOLLOW = 0x10000 ++ O_NONBLOCK = 0x4 ++ O_PATH = 0x800000 ++ O_RDONLY = 0x0 ++ O_RDWR = 0x2 ++ O_RSYNC = 0x404000 ++ O_SYNC = 0x404000 ++ O_TMPFILE = 0x1008000 ++ O_TRUNC = 0x400 ++ O_WRONLY = 0x1 ++ PACKET_ADD_MEMBERSHIP = 0x1 ++ PACKET_AUXDATA = 0x8 ++ PACKET_BROADCAST = 0x1 ++ PACKET_COPY_THRESH = 0x7 ++ PACKET_DROP_MEMBERSHIP = 0x2 ++ PACKET_FANOUT = 0x12 ++ PACKET_FANOUT_CBPF = 0x6 ++ PACKET_FANOUT_CPU = 0x2 ++ PACKET_FANOUT_DATA = 0x16 ++ PACKET_FANOUT_EBPF = 0x7 ++ PACKET_FANOUT_FLAG_DEFRAG = 0x8000 ++ PACKET_FANOUT_FLAG_ROLLOVER = 0x1000 ++ PACKET_FANOUT_FLAG_UNIQUEID = 0x2000 ++ PACKET_FANOUT_HASH = 0x0 ++ PACKET_FANOUT_LB = 0x1 ++ PACKET_FANOUT_QM = 0x5 ++ PACKET_FANOUT_RND = 0x4 ++ PACKET_FANOUT_ROLLOVER = 0x3 ++ PACKET_FASTROUTE = 0x6 ++ PACKET_HDRLEN = 0xb ++ PACKET_HOST = 0x0 ++ PACKET_IGNORE_OUTGOING = 0x17 ++ PACKET_KERNEL = 0x7 ++ PACKET_LOOPBACK = 0x5 ++ PACKET_LOSS = 0xe ++ PACKET_MR_ALLMULTI = 0x2 ++ PACKET_MR_MULTICAST = 0x0 ++ PACKET_MR_PROMISC = 0x1 ++ PACKET_MR_UNICAST = 0x3 ++ PACKET_MULTICAST = 0x2 ++ PACKET_ORIGDEV = 0x9 ++ PACKET_OTHERHOST = 0x3 ++ PACKET_OUTGOING = 0x4 ++ PACKET_QDISC_BYPASS = 0x14 ++ PACKET_RECV_OUTPUT = 0x3 ++ PACKET_RESERVE = 0xc ++ PACKET_ROLLOVER_STATS = 0x15 ++ PACKET_RX_RING = 0x5 ++ PACKET_STATISTICS = 0x6 ++ PACKET_TIMESTAMP = 0x11 ++ PACKET_TX_HAS_OFF = 0x13 ++ PACKET_TX_RING = 0xd ++ PACKET_TX_TIMESTAMP = 0x10 ++ PACKET_USER = 0x6 ++ PACKET_VERSION = 0xa ++ PACKET_VNET_HDR = 0xf ++ PARENB = 0x1000 ++ PARITY_CRC16_PR0 = 0x2 ++ PARITY_CRC16_PR0_CCITT = 0x4 ++ PARITY_CRC16_PR1 = 0x3 ++ PARITY_CRC16_PR1_CCITT = 0x5 ++ PARITY_CRC32_PR0_CCITT = 0x6 ++ PARITY_CRC32_PR1_CCITT = 0x7 ++ PARITY_DEFAULT = 0x0 ++ PARITY_NONE = 0x1 ++ PARMRK = 0x8 ++ PARODD = 0x2000 ++ PENDIN = 0x20000000 ++ PERF_ATTR_SIZE_VER0 = 0x40 ++ PERF_ATTR_SIZE_VER1 = 0x48 ++ PERF_ATTR_SIZE_VER2 = 0x50 ++ PERF_ATTR_SIZE_VER3 = 0x60 ++ PERF_ATTR_SIZE_VER4 = 0x68 ++ PERF_ATTR_SIZE_VER5 = 0x70 ++ PERF_ATTR_SIZE_VER6 = 0x78 ++ PERF_AUX_FLAG_COLLISION = 0x8 ++ PERF_AUX_FLAG_OVERWRITE = 0x2 ++ PERF_AUX_FLAG_PARTIAL = 0x4 ++ PERF_AUX_FLAG_TRUNCATED = 0x1 ++ PERF_EVENT_IOC_DISABLE = 0x20002401 ++ PERF_EVENT_IOC_ENABLE = 0x20002400 ++ PERF_EVENT_IOC_ID = 0x40082407 ++ PERF_EVENT_IOC_MODIFY_ATTRIBUTES = 0x8008240b ++ PERF_EVENT_IOC_PAUSE_OUTPUT = 0x80042409 ++ PERF_EVENT_IOC_PERIOD = 0x80082404 ++ PERF_EVENT_IOC_QUERY_BPF = 0xc008240a ++ PERF_EVENT_IOC_REFRESH = 0x20002402 ++ PERF_EVENT_IOC_RESET = 0x20002403 ++ PERF_EVENT_IOC_SET_BPF = 0x80042408 ++ PERF_EVENT_IOC_SET_FILTER = 0x80082406 ++ PERF_EVENT_IOC_SET_OUTPUT = 0x20002405 ++ PERF_FLAG_FD_CLOEXEC = 0x8 ++ PERF_FLAG_FD_NO_GROUP = 0x1 ++ PERF_FLAG_FD_OUTPUT = 0x2 ++ PERF_FLAG_PID_CGROUP = 0x4 ++ PERF_MAX_CONTEXTS_PER_STACK = 0x8 ++ PERF_MAX_STACK_DEPTH = 0x7f ++ PERF_MEM_LOCK_LOCKED = 0x2 ++ PERF_MEM_LOCK_NA = 0x1 ++ PERF_MEM_LOCK_SHIFT = 0x18 ++ PERF_MEM_LVLNUM_ANY_CACHE = 0xb ++ PERF_MEM_LVLNUM_L1 = 0x1 ++ PERF_MEM_LVLNUM_L2 = 0x2 ++ PERF_MEM_LVLNUM_L3 = 0x3 ++ PERF_MEM_LVLNUM_L4 = 0x4 ++ PERF_MEM_LVLNUM_LFB = 0xc ++ PERF_MEM_LVLNUM_NA = 0xf ++ PERF_MEM_LVLNUM_PMEM = 0xe ++ PERF_MEM_LVLNUM_RAM = 0xd ++ PERF_MEM_LVLNUM_SHIFT = 0x21 ++ PERF_MEM_LVL_HIT = 0x2 ++ PERF_MEM_LVL_IO = 0x1000 ++ PERF_MEM_LVL_L1 = 0x8 ++ PERF_MEM_LVL_L2 = 0x20 ++ PERF_MEM_LVL_L3 = 0x40 ++ PERF_MEM_LVL_LFB = 0x10 ++ PERF_MEM_LVL_LOC_RAM = 0x80 ++ PERF_MEM_LVL_MISS = 0x4 ++ PERF_MEM_LVL_NA = 0x1 ++ PERF_MEM_LVL_REM_CCE1 = 0x400 ++ PERF_MEM_LVL_REM_CCE2 = 0x800 ++ PERF_MEM_LVL_REM_RAM1 = 0x100 ++ PERF_MEM_LVL_REM_RAM2 = 0x200 ++ PERF_MEM_LVL_SHIFT = 0x5 ++ PERF_MEM_LVL_UNC = 0x2000 ++ PERF_MEM_OP_EXEC = 0x10 ++ PERF_MEM_OP_LOAD = 0x2 ++ PERF_MEM_OP_NA = 0x1 ++ PERF_MEM_OP_PFETCH = 0x8 ++ PERF_MEM_OP_SHIFT = 0x0 ++ PERF_MEM_OP_STORE = 0x4 ++ PERF_MEM_REMOTE_REMOTE = 0x1 ++ PERF_MEM_REMOTE_SHIFT = 0x25 ++ PERF_MEM_SNOOPX_FWD = 0x1 ++ PERF_MEM_SNOOPX_SHIFT = 0x26 ++ PERF_MEM_SNOOP_HIT = 0x4 ++ PERF_MEM_SNOOP_HITM = 0x10 ++ PERF_MEM_SNOOP_MISS = 0x8 ++ PERF_MEM_SNOOP_NA = 0x1 ++ PERF_MEM_SNOOP_NONE = 0x2 ++ PERF_MEM_SNOOP_SHIFT = 0x13 ++ PERF_MEM_TLB_HIT = 0x2 ++ PERF_MEM_TLB_L1 = 0x8 ++ PERF_MEM_TLB_L2 = 0x10 ++ PERF_MEM_TLB_MISS = 0x4 ++ PERF_MEM_TLB_NA = 0x1 ++ PERF_MEM_TLB_OS = 0x40 ++ PERF_MEM_TLB_SHIFT = 0x1a ++ PERF_MEM_TLB_WK = 0x20 ++ PERF_RECORD_KSYMBOL_FLAGS_UNREGISTER = 0x1 ++ PERF_RECORD_MISC_COMM_EXEC = 0x2000 ++ PERF_RECORD_MISC_CPUMODE_MASK = 0x7 ++ PERF_RECORD_MISC_CPUMODE_UNKNOWN = 0x0 ++ PERF_RECORD_MISC_EXACT_IP = 0x4000 ++ PERF_RECORD_MISC_EXT_RESERVED = 0x8000 ++ PERF_RECORD_MISC_FORK_EXEC = 0x2000 ++ PERF_RECORD_MISC_GUEST_KERNEL = 0x4 ++ PERF_RECORD_MISC_GUEST_USER = 0x5 ++ PERF_RECORD_MISC_HYPERVISOR = 0x3 ++ PERF_RECORD_MISC_KERNEL = 0x1 ++ PERF_RECORD_MISC_MMAP_DATA = 0x2000 ++ PERF_RECORD_MISC_PROC_MAP_PARSE_TIMEOUT = 0x1000 ++ PERF_RECORD_MISC_SWITCH_OUT = 0x2000 ++ PERF_RECORD_MISC_SWITCH_OUT_PREEMPT = 0x4000 ++ PERF_RECORD_MISC_USER = 0x2 ++ PERF_SAMPLE_BRANCH_PLM_ALL = 0x7 ++ PIPEFS_MAGIC = 0x50495045 ++ PPC_CMM_MAGIC = 0xc7571590 ++ PPPIOCATTACH = 0x8004743d ++ PPPIOCATTCHAN = 0x80047438 ++ PPPIOCCONNECT = 0x8004743a ++ PPPIOCDETACH = 0x8004743c ++ PPPIOCDISCONN = 0x20007439 ++ PPPIOCGASYNCMAP = 0x40047458 ++ PPPIOCGCHAN = 0x40047437 ++ PPPIOCGDEBUG = 0x40047441 ++ PPPIOCGFLAGS = 0x4004745a ++ PPPIOCGIDLE = 0x4010743f ++ PPPIOCGIDLE32 = 0x4008743f ++ PPPIOCGIDLE64 = 0x4010743f ++ PPPIOCGL2TPSTATS = 0x40487436 ++ PPPIOCGMRU = 0x40047453 ++ PPPIOCGNPMODE = 0xc008744c ++ PPPIOCGRASYNCMAP = 0x40047455 ++ PPPIOCGUNIT = 0x40047456 ++ PPPIOCGXASYNCMAP = 0x40207450 ++ PPPIOCNEWUNIT = 0xc004743e ++ PPPIOCSACTIVE = 0x80107446 ++ PPPIOCSASYNCMAP = 0x80047457 ++ PPPIOCSCOMPRESS = 0x8010744d ++ PPPIOCSDEBUG = 0x80047440 ++ PPPIOCSFLAGS = 0x80047459 ++ PPPIOCSMAXCID = 0x80047451 ++ PPPIOCSMRRU = 0x8004743b ++ PPPIOCSMRU = 0x80047452 ++ PPPIOCSNPMODE = 0x8008744b ++ PPPIOCSPASS = 0x80107447 ++ PPPIOCSRASYNCMAP = 0x80047454 ++ PPPIOCSXASYNCMAP = 0x8020744f ++ PPPIOCXFERUNIT = 0x2000744e ++ PRIO_PGRP = 0x1 ++ PRIO_PROCESS = 0x0 ++ PRIO_USER = 0x2 ++ PROC_SUPER_MAGIC = 0x9fa0 ++ PROT_EXEC = 0x4 ++ PROT_GROWSDOWN = 0x1000000 ++ PROT_GROWSUP = 0x2000000 ++ PROT_NONE = 0x0 ++ PROT_READ = 0x1 ++ PROT_WRITE = 0x2 ++ PR_CAPBSET_DROP = 0x18 ++ PR_CAPBSET_READ = 0x17 ++ PR_CAP_AMBIENT = 0x2f ++ PR_CAP_AMBIENT_CLEAR_ALL = 0x4 ++ PR_CAP_AMBIENT_IS_SET = 0x1 ++ PR_CAP_AMBIENT_LOWER = 0x3 ++ PR_CAP_AMBIENT_RAISE = 0x2 ++ PR_ENDIAN_BIG = 0x0 ++ PR_ENDIAN_LITTLE = 0x1 ++ PR_ENDIAN_PPC_LITTLE = 0x2 ++ PR_FPEMU_NOPRINT = 0x1 ++ PR_FPEMU_SIGFPE = 0x2 ++ PR_FP_EXC_ASYNC = 0x2 ++ PR_FP_EXC_DISABLED = 0x0 ++ PR_FP_EXC_DIV = 0x10000 ++ PR_FP_EXC_INV = 0x100000 ++ PR_FP_EXC_NONRECOV = 0x1 ++ PR_FP_EXC_OVF = 0x20000 ++ PR_FP_EXC_PRECISE = 0x3 ++ PR_FP_EXC_RES = 0x80000 ++ PR_FP_EXC_SW_ENABLE = 0x80 ++ PR_FP_EXC_UND = 0x40000 ++ PR_FP_MODE_FR = 0x1 ++ PR_FP_MODE_FRE = 0x2 ++ PR_GET_CHILD_SUBREAPER = 0x25 ++ PR_GET_DUMPABLE = 0x3 ++ PR_GET_ENDIAN = 0x13 ++ PR_GET_FPEMU = 0x9 ++ PR_GET_FPEXC = 0xb ++ PR_GET_FP_MODE = 0x2e ++ PR_GET_IO_FLUSHER = 0x3a ++ PR_GET_KEEPCAPS = 0x7 ++ PR_GET_NAME = 0x10 ++ PR_GET_NO_NEW_PRIVS = 0x27 ++ PR_GET_PDEATHSIG = 0x2 ++ PR_GET_SECCOMP = 0x15 ++ PR_GET_SECUREBITS = 0x1b ++ PR_GET_SPECULATION_CTRL = 0x34 ++ PR_GET_TAGGED_ADDR_CTRL = 0x38 ++ PR_GET_THP_DISABLE = 0x2a ++ PR_GET_TID_ADDRESS = 0x28 ++ PR_GET_TIMERSLACK = 0x1e ++ PR_GET_TIMING = 0xd ++ PR_GET_TSC = 0x19 ++ PR_GET_UNALIGN = 0x5 ++ PR_MCE_KILL = 0x21 ++ PR_MCE_KILL_CLEAR = 0x0 ++ PR_MCE_KILL_DEFAULT = 0x2 ++ PR_MCE_KILL_EARLY = 0x1 ++ PR_MCE_KILL_GET = 0x22 ++ PR_MCE_KILL_LATE = 0x0 ++ PR_MCE_KILL_SET = 0x1 ++ PR_MPX_DISABLE_MANAGEMENT = 0x2c ++ PR_MPX_ENABLE_MANAGEMENT = 0x2b ++ PR_MTE_TAG_MASK = 0x7fff8 ++ PR_MTE_TAG_SHIFT = 0x3 ++ PR_MTE_TCF_ASYNC = 0x4 ++ PR_MTE_TCF_MASK = 0x6 ++ PR_MTE_TCF_NONE = 0x0 ++ PR_MTE_TCF_SHIFT = 0x1 ++ PR_MTE_TCF_SYNC = 0x2 ++ PR_PAC_APDAKEY = 0x4 ++ PR_PAC_APDBKEY = 0x8 ++ PR_PAC_APGAKEY = 0x10 ++ PR_PAC_APIAKEY = 0x1 ++ PR_PAC_APIBKEY = 0x2 ++ PR_PAC_RESET_KEYS = 0x36 ++ PR_SET_CHILD_SUBREAPER = 0x24 ++ PR_SET_DUMPABLE = 0x4 ++ PR_SET_ENDIAN = 0x14 ++ PR_SET_FPEMU = 0xa ++ PR_SET_FPEXC = 0xc ++ PR_SET_FP_MODE = 0x2d ++ PR_SET_IO_FLUSHER = 0x39 ++ PR_SET_KEEPCAPS = 0x8 ++ PR_SET_MM = 0x23 ++ PR_SET_MM_ARG_END = 0x9 ++ PR_SET_MM_ARG_START = 0x8 ++ PR_SET_MM_AUXV = 0xc ++ PR_SET_MM_BRK = 0x7 ++ PR_SET_MM_END_CODE = 0x2 ++ PR_SET_MM_END_DATA = 0x4 ++ PR_SET_MM_ENV_END = 0xb ++ PR_SET_MM_ENV_START = 0xa ++ PR_SET_MM_EXE_FILE = 0xd ++ PR_SET_MM_MAP = 0xe ++ PR_SET_MM_MAP_SIZE = 0xf ++ PR_SET_MM_START_BRK = 0x6 ++ PR_SET_MM_START_CODE = 0x1 ++ PR_SET_MM_START_DATA = 0x3 ++ PR_SET_MM_START_STACK = 0x5 ++ PR_SET_NAME = 0xf ++ PR_SET_NO_NEW_PRIVS = 0x26 ++ PR_SET_PDEATHSIG = 0x1 ++ PR_SET_PTRACER = 0x59616d61 ++ PR_SET_PTRACER_ANY = 0xffffffffffffffff ++ PR_SET_SECCOMP = 0x16 ++ PR_SET_SECUREBITS = 0x1c ++ PR_SET_SPECULATION_CTRL = 0x35 ++ PR_SET_TAGGED_ADDR_CTRL = 0x37 ++ PR_SET_THP_DISABLE = 0x29 ++ PR_SET_TIMERSLACK = 0x1d ++ PR_SET_TIMING = 0xe ++ PR_SET_TSC = 0x1a ++ PR_SET_UNALIGN = 0x6 ++ PR_SPEC_DISABLE = 0x4 ++ PR_SPEC_DISABLE_NOEXEC = 0x10 ++ PR_SPEC_ENABLE = 0x2 ++ PR_SPEC_FORCE_DISABLE = 0x8 ++ PR_SPEC_INDIRECT_BRANCH = 0x1 ++ PR_SPEC_NOT_AFFECTED = 0x0 ++ PR_SPEC_PRCTL = 0x1 ++ PR_SPEC_STORE_BYPASS = 0x0 ++ PR_SVE_GET_VL = 0x33 ++ PR_SVE_SET_VL = 0x32 ++ PR_SVE_SET_VL_ONEXEC = 0x40000 ++ PR_SVE_VL_INHERIT = 0x20000 ++ PR_SVE_VL_LEN_MASK = 0xffff ++ PR_TAGGED_ADDR_ENABLE = 0x1 ++ PR_TASK_PERF_EVENTS_DISABLE = 0x1f ++ PR_TASK_PERF_EVENTS_ENABLE = 0x20 ++ PR_TIMING_STATISTICAL = 0x0 ++ PR_TIMING_TIMESTAMP = 0x1 ++ PR_TSC_ENABLE = 0x1 ++ PR_TSC_SIGSEGV = 0x2 ++ PR_UNALIGN_NOPRINT = 0x1 ++ PR_UNALIGN_SIGBUS = 0x2 ++ PSTOREFS_MAGIC = 0x6165676c ++ PTRACE_ATTACH = 0x10 ++ PTRACE_CONT = 0x7 ++ PTRACE_DETACH = 0x11 ++ PTRACE_EVENTMSG_SYSCALL_ENTRY = 0x1 ++ PTRACE_EVENTMSG_SYSCALL_EXIT = 0x2 ++ PTRACE_EVENT_CLONE = 0x3 ++ PTRACE_EVENT_EXEC = 0x4 ++ PTRACE_EVENT_EXIT = 0x6 ++ PTRACE_EVENT_FORK = 0x1 ++ PTRACE_EVENT_SECCOMP = 0x7 ++ PTRACE_EVENT_STOP = 0x80 ++ PTRACE_EVENT_VFORK = 0x2 ++ PTRACE_EVENT_VFORK_DONE = 0x5 ++ PTRACE_GETEVENTMSG = 0x4201 ++ PTRACE_GETREGS = 0xc ++ PTRACE_GETREGSET = 0x4204 ++ PTRACE_GETSIGINFO = 0x4202 ++ PTRACE_GETSIGMASK = 0x420a ++ PTRACE_GET_SYSCALL_INFO = 0x420e ++ PTRACE_INTERRUPT = 0x4207 ++ PTRACE_KILL = 0x8 ++ PTRACE_LISTEN = 0x4208 ++ PTRACE_O_EXITKILL = 0x100000 ++ PTRACE_O_MASK = 0x3000ff ++ PTRACE_O_SUSPEND_SECCOMP = 0x200000 ++ PTRACE_O_TRACECLONE = 0x8 ++ PTRACE_O_TRACEEXEC = 0x10 ++ PTRACE_O_TRACEEXIT = 0x40 ++ PTRACE_O_TRACEFORK = 0x2 ++ PTRACE_O_TRACESECCOMP = 0x80 ++ PTRACE_O_TRACESYSGOOD = 0x1 ++ PTRACE_O_TRACEVFORK = 0x4 ++ PTRACE_O_TRACEVFORKDONE = 0x20 ++ PTRACE_PEEKDATA = 0x2 ++ PTRACE_PEEKSIGINFO = 0x4209 ++ PTRACE_PEEKSIGINFO_SHARED = 0x1 ++ PTRACE_PEEKTEXT = 0x1 ++ PTRACE_PEEKUSR = 0x3 ++ PTRACE_POKEDATA = 0x5 ++ PTRACE_POKETEXT = 0x4 ++ PTRACE_POKEUSR = 0x6 ++ PTRACE_SECCOMP_GET_FILTER = 0x420c ++ PTRACE_SECCOMP_GET_METADATA = 0x420d ++ PTRACE_SEIZE = 0x4206 ++ PTRACE_SETOPTIONS = 0x4200 ++ PTRACE_SETREGS = 0xd ++ PTRACE_SETREGSET = 0x4205 ++ PTRACE_SETSIGINFO = 0x4203 ++ PTRACE_SETSIGMASK = 0x420b ++ PTRACE_SINGLESTEP = 0x9 ++ PTRACE_SYSCALL = 0x18 ++ PTRACE_SYSCALL_INFO_ENTRY = 0x1 ++ PTRACE_SYSCALL_INFO_EXIT = 0x2 ++ PTRACE_SYSCALL_INFO_NONE = 0x0 ++ PTRACE_SYSCALL_INFO_SECCOMP = 0x3 ++ PTRACE_TRACEME = 0x0 ++ PT_DA_MASK = 0xa4 ++ PT_DA_MATCH = 0xa3 ++ PT_DC_CTL = 0xa7 ++ PT_DV_MASK = 0xa6 ++ PT_DV_MATCH = 0xa5 ++ PT_F31_V1 = 0x62 ++ PT_F31_V2 = 0x82 ++ PT_FPCR = 0x3f ++ PT_FPREG_BASE = 0x20 ++ PT_FPREG_END = 0x3e ++ PT_PC = 0x40 ++ PT_REG_BASE = 0x0 ++ PT_REG_END = 0x1d ++ PT_TP = 0x41 ++ PT_UNIQUE = 0x41 ++ PT_USP = 0x1e ++ PT_VECREG_BASE = 0x43 ++ PT_VECREG_END = 0xa1 ++ P_ALL = 0x0 ++ P_PGID = 0x2 ++ P_PID = 0x1 ++ P_PIDFD = 0x3 ++ QNX4_SUPER_MAGIC = 0x2f ++ QNX6_SUPER_MAGIC = 0x68191122 ++ RAMFS_MAGIC = 0x858458f6 ++ RAW_PAYLOAD_DIGITAL = 0x3 ++ RAW_PAYLOAD_HCI = 0x2 ++ RAW_PAYLOAD_LLCP = 0x0 ++ RAW_PAYLOAD_NCI = 0x1 ++ RAW_PAYLOAD_PROPRIETARY = 0x4 ++ RDTGROUP_SUPER_MAGIC = 0x7655821 ++ REISERFS_SUPER_MAGIC = 0x52654973 ++ RENAME_EXCHANGE = 0x2 ++ RENAME_NOREPLACE = 0x1 ++ RENAME_WHITEOUT = 0x4 ++ RLIMIT_AS = 0x7 ++ RLIMIT_CORE = 0x4 ++ RLIMIT_CPU = 0x0 ++ RLIMIT_DATA = 0x2 ++ RLIMIT_FSIZE = 0x1 ++ RLIMIT_LOCKS = 0xa ++ RLIMIT_MEMLOCK = 0x9 ++ RLIMIT_MSGQUEUE = 0xc ++ RLIMIT_NICE = 0xd ++ RLIMIT_NOFILE = 0x6 ++ RLIMIT_NPROC = 0x8 ++ RLIMIT_RSS = 0x5 ++ RLIMIT_RTPRIO = 0xe ++ RLIMIT_RTTIME = 0xf ++ RLIMIT_SIGPENDING = 0xb ++ RLIMIT_STACK = 0x3 ++ RLIM_INFINITY = 0xffffffffffffffff ++ RNDADDENTROPY = 0x80085203 ++ RNDADDTOENTCNT = 0x80045201 ++ RNDCLEARPOOL = 0x20005206 ++ RNDGETENTCNT = 0x40045200 ++ RNDGETPOOL = 0x40085202 ++ RNDRESEEDCRNG = 0x20005207 ++ RNDZAPENTCNT = 0x20005204 ++ RTAX_ADVMSS = 0x8 ++ RTAX_CC_ALGO = 0x10 ++ RTAX_CWND = 0x7 ++ RTAX_FASTOPEN_NO_COOKIE = 0x11 ++ RTAX_FEATURES = 0xc ++ RTAX_FEATURE_ALLFRAG = 0x8 ++ RTAX_FEATURE_ECN = 0x1 ++ RTAX_FEATURE_MASK = 0xf ++ RTAX_FEATURE_SACK = 0x2 ++ RTAX_FEATURE_TIMESTAMP = 0x4 ++ RTAX_HOPLIMIT = 0xa ++ RTAX_INITCWND = 0xb ++ RTAX_INITRWND = 0xe ++ RTAX_LOCK = 0x1 ++ RTAX_MAX = 0x11 ++ RTAX_MTU = 0x2 ++ RTAX_QUICKACK = 0xf ++ RTAX_REORDERING = 0x9 ++ RTAX_RTO_MIN = 0xd ++ RTAX_RTT = 0x4 ++ RTAX_RTTVAR = 0x5 ++ RTAX_SSTHRESH = 0x6 ++ RTAX_UNSPEC = 0x0 ++ RTAX_WINDOW = 0x3 ++ RTA_ALIGNTO = 0x4 ++ RTA_MAX = 0x1e ++ RTCF_DIRECTSRC = 0x4000000 ++ RTCF_DOREDIRECT = 0x1000000 ++ RTCF_LOG = 0x2000000 ++ RTCF_MASQ = 0x400000 ++ RTCF_NAT = 0x800000 ++ RTCF_VALVE = 0x200000 ++ RTC_AF = 0x20 ++ RTC_AIE_OFF = 0x20007002 ++ RTC_AIE_ON = 0x20007001 ++ RTC_ALM_READ = 0x40247008 ++ RTC_ALM_SET = 0x80247007 ++ RTC_EPOCH_READ = 0x4008700d ++ RTC_EPOCH_SET = 0x8008700e ++ RTC_IRQF = 0x80 ++ RTC_IRQP_READ = 0x4008700b ++ RTC_IRQP_SET = 0x8008700c ++ RTC_MAX_FREQ = 0x2000 ++ RTC_PF = 0x40 ++ RTC_PIE_OFF = 0x20007006 ++ RTC_PIE_ON = 0x20007005 ++ RTC_PLL_GET = 0x40207011 ++ RTC_PLL_SET = 0x80207012 ++ RTC_RD_TIME = 0x40247009 ++ RTC_SET_TIME = 0x8024700a ++ RTC_UF = 0x10 ++ RTC_UIE_OFF = 0x20007004 ++ RTC_UIE_ON = 0x20007003 ++ RTC_VL_CLR = 0x20007014 ++ RTC_VL_READ = 0x40047013 ++ RTC_WIE_OFF = 0x20007010 ++ RTC_WIE_ON = 0x2000700f ++ RTC_WKALM_RD = 0x40287010 ++ RTC_WKALM_SET = 0x8028700f ++ RTF_ADDRCLASSMASK = 0xf8000000 ++ RTF_ADDRCONF = 0x40000 ++ RTF_ALLONLINK = 0x20000 ++ RTF_BROADCAST = 0x10000000 ++ RTF_CACHE = 0x1000000 ++ RTF_DEFAULT = 0x10000 ++ RTF_DYNAMIC = 0x10 ++ RTF_FLOW = 0x2000000 ++ RTF_GATEWAY = 0x2 ++ RTF_HOST = 0x4 ++ RTF_INTERFACE = 0x40000000 ++ RTF_IRTT = 0x100 ++ RTF_LINKRT = 0x100000 ++ RTF_LOCAL = 0x80000000 ++ RTF_MODIFIED = 0x20 ++ RTF_MSS = 0x40 ++ RTF_MTU = 0x40 ++ RTF_MULTICAST = 0x20000000 ++ RTF_NAT = 0x8000000 ++ RTF_NOFORWARD = 0x1000 ++ RTF_NONEXTHOP = 0x200000 ++ RTF_NOPMTUDISC = 0x4000 ++ RTF_POLICY = 0x4000000 ++ RTF_REINSTATE = 0x8 ++ RTF_REJECT = 0x200 ++ RTF_STATIC = 0x400 ++ RTF_THROW = 0x2000 ++ RTF_UP = 0x1 ++ RTF_WINDOW = 0x80 ++ RTF_XRESOLVE = 0x800 ++ RTMGRP_DECnet_IFADDR = 0x1000 ++ RTMGRP_DECnet_ROUTE = 0x4000 ++ RTMGRP_IPV4_IFADDR = 0x10 ++ RTMGRP_IPV4_MROUTE = 0x20 ++ RTMGRP_IPV4_ROUTE = 0x40 ++ RTMGRP_IPV4_RULE = 0x80 ++ RTMGRP_IPV6_IFADDR = 0x100 ++ RTMGRP_IPV6_IFINFO = 0x800 ++ RTMGRP_IPV6_MROUTE = 0x200 ++ RTMGRP_IPV6_PREFIX = 0x20000 ++ RTMGRP_IPV6_ROUTE = 0x400 ++ RTMGRP_LINK = 0x1 ++ RTMGRP_NEIGH = 0x4 ++ RTMGRP_NOTIFY = 0x2 ++ RTMGRP_TC = 0x8 ++ RTM_BASE = 0x10 ++ RTM_DELACTION = 0x31 ++ RTM_DELADDR = 0x15 ++ RTM_DELADDRLABEL = 0x49 ++ RTM_DELCHAIN = 0x65 ++ RTM_DELLINK = 0x11 ++ RTM_DELLINKPROP = 0x6d ++ RTM_DELMDB = 0x55 ++ RTM_DELNEIGH = 0x1d ++ RTM_DELNETCONF = 0x51 ++ RTM_DELNEXTHOP = 0x69 ++ RTM_DELNSID = 0x59 ++ RTM_DELQDISC = 0x25 ++ RTM_DELROUTE = 0x19 ++ RTM_DELRULE = 0x21 ++ RTM_DELTCLASS = 0x29 ++ RTM_DELTFILTER = 0x2d ++ RTM_DELVLAN = 0x71 ++ RTM_F_CLONED = 0x200 ++ RTM_F_EQUALIZE = 0x400 ++ RTM_F_FIB_MATCH = 0x2000 ++ RTM_F_LOOKUP_TABLE = 0x1000 ++ RTM_F_NOTIFY = 0x100 ++ RTM_F_OFFLOAD = 0x4000 ++ RTM_F_PREFIX = 0x800 ++ RTM_F_TRAP = 0x8000 ++ RTM_GETACTION = 0x32 ++ RTM_GETADDR = 0x16 ++ RTM_GETADDRLABEL = 0x4a ++ RTM_GETANYCAST = 0x3e ++ RTM_GETCHAIN = 0x66 ++ RTM_GETDCB = 0x4e ++ RTM_GETLINK = 0x12 ++ RTM_GETLINKPROP = 0x6e ++ RTM_GETMDB = 0x56 ++ RTM_GETMULTICAST = 0x3a ++ RTM_GETNEIGH = 0x1e ++ RTM_GETNEIGHTBL = 0x42 ++ RTM_GETNETCONF = 0x52 ++ RTM_GETNEXTHOP = 0x6a ++ RTM_GETNSID = 0x5a ++ RTM_GETQDISC = 0x26 ++ RTM_GETROUTE = 0x1a ++ RTM_GETRULE = 0x22 ++ RTM_GETSTATS = 0x5e ++ RTM_GETTCLASS = 0x2a ++ RTM_GETTFILTER = 0x2e ++ RTM_GETVLAN = 0x72 ++ RTM_MAX = 0x73 ++ RTM_NEWACTION = 0x30 ++ RTM_NEWADDR = 0x14 ++ RTM_NEWADDRLABEL = 0x48 ++ RTM_NEWCACHEREPORT = 0x60 ++ RTM_NEWCHAIN = 0x64 ++ RTM_NEWLINK = 0x10 ++ RTM_NEWLINKPROP = 0x6c ++ RTM_NEWMDB = 0x54 ++ RTM_NEWNDUSEROPT = 0x44 ++ RTM_NEWNEIGH = 0x1c ++ RTM_NEWNEIGHTBL = 0x40 ++ RTM_NEWNETCONF = 0x50 ++ RTM_NEWNEXTHOP = 0x68 ++ RTM_NEWNSID = 0x58 ++ RTM_NEWNVLAN = 0x70 ++ RTM_NEWPREFIX = 0x34 ++ RTM_NEWQDISC = 0x24 ++ RTM_NEWROUTE = 0x18 ++ RTM_NEWRULE = 0x20 ++ RTM_NEWSTATS = 0x5c ++ RTM_NEWTCLASS = 0x28 ++ RTM_NEWTFILTER = 0x2c ++ RTM_NR_FAMILIES = 0x19 ++ RTM_NR_MSGTYPES = 0x64 ++ RTM_SETDCB = 0x4f ++ RTM_SETLINK = 0x13 ++ RTM_SETNEIGHTBL = 0x43 ++ RTNH_ALIGNTO = 0x4 ++ RTNH_COMPARE_MASK = 0x19 ++ RTNH_F_DEAD = 0x1 ++ RTNH_F_LINKDOWN = 0x10 ++ RTNH_F_OFFLOAD = 0x8 ++ RTNH_F_ONLINK = 0x4 ++ RTNH_F_PERVASIVE = 0x2 ++ RTNH_F_UNRESOLVED = 0x20 ++ RTN_MAX = 0xb ++ RTPROT_BABEL = 0x2a ++ RTPROT_BGP = 0xba ++ RTPROT_BIRD = 0xc ++ RTPROT_BOOT = 0x3 ++ RTPROT_DHCP = 0x10 ++ RTPROT_DNROUTED = 0xd ++ RTPROT_EIGRP = 0xc0 ++ RTPROT_GATED = 0x8 ++ RTPROT_ISIS = 0xbb ++ RTPROT_KEEPALIVED = 0x12 ++ RTPROT_KERNEL = 0x2 ++ RTPROT_MROUTED = 0x11 ++ RTPROT_MRT = 0xa ++ RTPROT_NTK = 0xf ++ RTPROT_OSPF = 0xbc ++ RTPROT_RA = 0x9 ++ RTPROT_REDIRECT = 0x1 ++ RTPROT_RIP = 0xbd ++ RTPROT_STATIC = 0x4 ++ RTPROT_UNSPEC = 0x0 ++ RTPROT_XORP = 0xe ++ RTPROT_ZEBRA = 0xb ++ RT_CLASS_DEFAULT = 0xfd ++ RT_CLASS_LOCAL = 0xff ++ RT_CLASS_MAIN = 0xfe ++ RT_CLASS_MAX = 0xff ++ RT_CLASS_UNSPEC = 0x0 ++ RUSAGE_CHILDREN = -0x1 ++ RUSAGE_SELF = 0x0 ++ RUSAGE_THREAD = 0x1 ++ RWF_APPEND = 0x10 ++ RWF_DSYNC = 0x2 ++ RWF_HIPRI = 0x1 ++ RWF_NOWAIT = 0x8 ++ RWF_SUPPORTED = 0x1f ++ RWF_SYNC = 0x4 ++ RWF_WRITE_LIFE_NOT_SET = 0x0 ++ SCM_CREDENTIALS = 0x2 ++ SCM_RIGHTS = 0x1 ++ SCM_TIMESTAMP = 0x1d ++ SCM_TIMESTAMPING = 0x25 ++ SCM_TIMESTAMPING_OPT_STATS = 0x36 ++ SCM_TIMESTAMPING_PKTINFO = 0x3a ++ SCM_TIMESTAMPNS = 0x23 ++ SCM_TXTIME = 0x3d ++ SCM_WIFI_STATUS = 0x29 ++ SC_LOG_FLUSH = 0x100000 ++ SECCOMP_MODE_DISABLED = 0x0 ++ SECCOMP_MODE_FILTER = 0x2 ++ SECCOMP_MODE_STRICT = 0x1 ++ SECURITYFS_MAGIC = 0x73636673 ++ SEEK_CUR = 0x1 ++ SEEK_DATA = 0x3 ++ SEEK_END = 0x2 ++ SEEK_HOLE = 0x4 ++ SEEK_MAX = 0x4 ++ SEEK_SET = 0x0 ++ SELINUX_MAGIC = 0xf97cff8c ++ SFD_CLOEXEC = 0x200000 ++ SFD_NONBLOCK = 0x4 ++ SHUT_RD = 0x0 ++ SHUT_RDWR = 0x2 ++ SHUT_WR = 0x1 ++ SIOCADDDLCI = 0x8980 ++ SIOCADDMULTI = 0x8931 ++ SIOCADDRT = 0x890b ++ SIOCATMARK = 0x40047307 ++ SIOCBONDCHANGEACTIVE = 0x8995 ++ SIOCBONDENSLAVE = 0x8990 ++ SIOCBONDINFOQUERY = 0x8994 ++ SIOCBONDRELEASE = 0x8991 ++ SIOCBONDSETHWADDR = 0x8992 ++ SIOCBONDSLAVEINFOQUERY = 0x8993 ++ SIOCBRADDBR = 0x89a0 ++ SIOCBRADDIF = 0x89a2 ++ SIOCBRDELBR = 0x89a1 ++ SIOCBRDELIF = 0x89a3 ++ SIOCDARP = 0x8953 ++ SIOCDELDLCI = 0x8981 ++ SIOCDELMULTI = 0x8932 ++ SIOCDELRT = 0x890c ++ SIOCDEVPRIVATE = 0x89f0 ++ SIOCDIFADDR = 0x8936 ++ SIOCDRARP = 0x8960 ++ SIOCETHTOOL = 0x8946 ++ SIOCGARP = 0x8954 ++ SIOCGETLINKNAME = 0x89e0 ++ SIOCGETNODEID = 0x89e1 ++ SIOCGHWTSTAMP = 0x89b1 ++ SIOCGIFADDR = 0x8915 ++ SIOCGIFBR = 0x8940 ++ SIOCGIFBRDADDR = 0x8919 ++ SIOCGIFCONF = 0x8912 ++ SIOCGIFCOUNT = 0x8938 ++ SIOCGIFDSTADDR = 0x8917 ++ SIOCGIFENCAP = 0x8925 ++ SIOCGIFFLAGS = 0x8913 ++ SIOCGIFHWADDR = 0x8927 ++ SIOCGIFINDEX = 0x8933 ++ SIOCGIFMAP = 0x8970 ++ SIOCGIFMEM = 0x891f ++ SIOCGIFMETRIC = 0x891d ++ SIOCGIFMTU = 0x8921 ++ SIOCGIFNAME = 0x8910 ++ SIOCGIFNETMASK = 0x891b ++ SIOCGIFPFLAGS = 0x8935 ++ SIOCGIFSLAVE = 0x8929 ++ SIOCGIFTXQLEN = 0x8942 ++ SIOCGIFVLAN = 0x8982 ++ SIOCGMIIPHY = 0x8947 ++ SIOCGMIIREG = 0x8948 ++ SIOCGPGRP = 0x40047309 ++ SIOCGPPPCSTATS = 0x89f2 ++ SIOCGPPPSTATS = 0x89f0 ++ SIOCGPPPVER = 0x89f1 ++ SIOCGRARP = 0x8961 ++ SIOCGSKNS = 0x894c ++ SIOCGSTAMP = 0x8906 ++ SIOCGSTAMPNS = 0x8907 ++ SIOCGSTAMPNS_NEW = 0x40108907 ++ SIOCGSTAMPNS_OLD = 0x8907 ++ SIOCGSTAMP_NEW = 0x40108906 ++ SIOCGSTAMP_OLD = 0x8906 ++ SIOCINQ = 0x4004667f ++ SIOCKCMATTACH = 0x89e0 ++ SIOCKCMCLONE = 0x89e2 ++ SIOCKCMUNATTACH = 0x89e1 ++ SIOCOUTQ = 0x40047473 ++ SIOCOUTQNSD = 0x894b ++ SIOCPROTOPRIVATE = 0x89e0 ++ SIOCRTMSG = 0x890d ++ SIOCSARP = 0x8955 ++ SIOCSHWTSTAMP = 0x89b0 ++ SIOCSIFADDR = 0x8916 ++ SIOCSIFBR = 0x8941 ++ SIOCSIFBRDADDR = 0x891a ++ SIOCSIFDSTADDR = 0x8918 ++ SIOCSIFENCAP = 0x8926 ++ SIOCSIFFLAGS = 0x8914 ++ SIOCSIFHWADDR = 0x8924 ++ SIOCSIFHWBROADCAST = 0x8937 ++ SIOCSIFLINK = 0x8911 ++ SIOCSIFMAP = 0x8971 ++ SIOCSIFMEM = 0x8920 ++ SIOCSIFMETRIC = 0x891e ++ SIOCSIFMTU = 0x8922 ++ SIOCSIFNAME = 0x8923 ++ SIOCSIFNETMASK = 0x891c ++ SIOCSIFPFLAGS = 0x8934 ++ SIOCSIFSLAVE = 0x8930 ++ SIOCSIFTXQLEN = 0x8943 ++ SIOCSIFVLAN = 0x8983 ++ SIOCSMIIREG = 0x8949 ++ SIOCSPGRP = 0x80047308 ++ SIOCSRARP = 0x8962 ++ SIOCWANDEV = 0x894a ++ SMACK_MAGIC = 0x43415d53 ++ SMART_AUTOSAVE = 0xd2 ++ SMART_AUTO_OFFLINE = 0xdb ++ SMART_DISABLE = 0xd9 ++ SMART_ENABLE = 0xd8 ++ SMART_HCYL_PASS = 0xc2 ++ SMART_IMMEDIATE_OFFLINE = 0xd4 ++ SMART_LCYL_PASS = 0x4f ++ SMART_READ_LOG_SECTOR = 0xd5 ++ SMART_READ_THRESHOLDS = 0xd1 ++ SMART_READ_VALUES = 0xd0 ++ SMART_SAVE = 0xd3 ++ SMART_STATUS = 0xda ++ SMART_WRITE_LOG_SECTOR = 0xd6 ++ SMART_WRITE_THRESHOLDS = 0xd7 ++ SMB_SUPER_MAGIC = 0x517b ++ SOCKFS_MAGIC = 0x534f434b ++ SOCK_CLOEXEC = 0x200000 ++ SOCK_DCCP = 0x6 ++ SOCK_DGRAM = 0x2 ++ SOCK_IOC_TYPE = 0x89 ++ SOCK_NONBLOCK = 0x40000000 ++ SOCK_PACKET = 0xa ++ SOCK_RAW = 0x3 ++ SOCK_RDM = 0x4 ++ SOCK_SEQPACKET = 0x5 ++ SOCK_STREAM = 0x1 ++ SOL_AAL = 0x109 ++ SOL_ALG = 0x117 ++ SOL_ATM = 0x108 ++ SOL_CAIF = 0x116 ++ SOL_CAN_BASE = 0x64 ++ SOL_CAN_RAW = 0x65 ++ SOL_DCCP = 0x10d ++ SOL_DECNET = 0x105 ++ SOL_ICMPV6 = 0x3a ++ SOL_IP = 0x0 ++ SOL_IPV6 = 0x29 ++ SOL_IRDA = 0x10a ++ SOL_IUCV = 0x115 ++ SOL_KCM = 0x119 ++ SOL_LLC = 0x10c ++ SOL_NETBEUI = 0x10b ++ SOL_NETLINK = 0x10e ++ SOL_NFC = 0x118 ++ SOL_PACKET = 0x107 ++ SOL_PNPIPE = 0x113 ++ SOL_PPPOL2TP = 0x111 ++ SOL_RAW = 0xff ++ SOL_RDS = 0x114 ++ SOL_RXRPC = 0x110 ++ SOL_SMC = 0x11e ++ SOL_SOCKET = 0xffff ++ SOL_TCP = 0x6 ++ SOL_TIPC = 0x10f ++ SOL_TLS = 0x11a ++ SOL_X25 = 0x106 ++ SOL_XDP = 0x11b ++ SOMAXCONN = 0x1000 ++ SO_ACCEPTCONN = 0x1014 ++ SO_ATTACH_BPF = 0x32 ++ SO_ATTACH_FILTER = 0x1a ++ SO_ATTACH_REUSEPORT_CBPF = 0x33 ++ SO_ATTACH_REUSEPORT_EBPF = 0x34 ++ SO_BINDTODEVICE = 0x19 ++ SO_BINDTOIFINDEX = 0x3e ++ SO_BPF_EXTENSIONS = 0x30 ++ SO_BROADCAST = 0x20 ++ SO_BSDCOMPAT = 0xe ++ SO_BUSY_POLL = 0x2e ++ SO_CNX_ADVICE = 0x35 ++ SO_COOKIE = 0x39 ++ SO_DEBUG = 0x1 ++ SO_DETACH_BPF = 0x1b ++ SO_DETACH_FILTER = 0x1b ++ SO_DETACH_REUSEPORT_BPF = 0x44 ++ SO_DOMAIN = 0x1029 ++ SO_DONTROUTE = 0x10 ++ SO_EE_CODE_TXTIME_INVALID_PARAM = 0x1 ++ SO_EE_CODE_TXTIME_MISSED = 0x2 ++ SO_EE_CODE_ZEROCOPY_COPIED = 0x1 ++ SO_EE_ORIGIN_ICMP = 0x2 ++ SO_EE_ORIGIN_ICMP6 = 0x3 ++ SO_EE_ORIGIN_LOCAL = 0x1 ++ SO_EE_ORIGIN_NONE = 0x0 ++ SO_EE_ORIGIN_TIMESTAMPING = 0x4 ++ SO_EE_ORIGIN_TXSTATUS = 0x4 ++ SO_EE_ORIGIN_TXTIME = 0x6 ++ SO_EE_ORIGIN_ZEROCOPY = 0x5 ++ SO_EE_RFC4884_FLAG_INVALID = 0x1 ++ SO_ERROR = 0x1007 ++ SO_GET_FILTER = 0x1a ++ SO_INCOMING_CPU = 0x31 ++ SO_INCOMING_NAPI_ID = 0x38 ++ SO_KEEPALIVE = 0x8 ++ SO_LINGER = 0x80 ++ SO_LOCK_FILTER = 0x2c ++ SO_MARK = 0x24 ++ SO_MAX_PACING_RATE = 0x2f ++ SO_MEMINFO = 0x37 ++ SO_NOFCS = 0x2b ++ SO_NO_CHECK = 0xb ++ SO_OOBINLINE = 0x100 ++ SO_PASSCRED = 0x11 ++ SO_PASSSEC = 0x22 ++ SO_PEEK_OFF = 0x2a ++ SO_PEERCRED = 0x12 ++ SO_PEERGROUPS = 0x3b ++ SO_PEERNAME = 0x1c ++ SO_PEERSEC = 0x1e ++ SO_PRIORITY = 0xc ++ SO_PROTOCOL = 0x1028 ++ SO_RCVBUF = 0x1002 ++ SO_RCVBUFFORCE = 0x100b ++ SO_RCVLOWAT = 0x1010 ++ SO_RCVTIMEO = 0x1012 ++ SO_RCVTIMEO_NEW = 0x42 ++ SO_RCVTIMEO_OLD = 0x1012 ++ SO_REUSEADDR = 0x4 ++ SO_REUSEPORT = 0x200 ++ SO_RXQ_OVFL = 0x28 ++ SO_SECURITY_AUTHENTICATION = 0x13 ++ SO_SECURITY_ENCRYPTION_NETWORK = 0x15 ++ SO_SECURITY_ENCRYPTION_TRANSPORT = 0x14 ++ SO_SELECT_ERR_QUEUE = 0x2d ++ SO_SNDBUF = 0x1001 ++ SO_SNDBUFFORCE = 0x100a ++ SO_SNDLOWAT = 0x1011 ++ SO_SNDTIMEO = 0x1013 ++ SO_SNDTIMEO_NEW = 0x43 ++ SO_SNDTIMEO_OLD = 0x1013 ++ SO_TIMESTAMP = 0x1d ++ SO_TIMESTAMPING = 0x25 ++ SO_TIMESTAMPING_NEW = 0x41 ++ SO_TIMESTAMPING_OLD = 0x25 ++ SO_TIMESTAMPNS = 0x23 ++ SO_TIMESTAMPNS_NEW = 0x40 ++ SO_TIMESTAMPNS_OLD = 0x23 ++ SO_TIMESTAMP_NEW = 0x3f ++ SO_TIMESTAMP_OLD = 0x1d ++ SO_TXTIME = 0x3d ++ SO_TYPE = 0x1008 ++ SO_VM_SOCKETS_BUFFER_MAX_SIZE = 0x2 ++ SO_VM_SOCKETS_BUFFER_MIN_SIZE = 0x1 ++ SO_VM_SOCKETS_BUFFER_SIZE = 0x0 ++ SO_VM_SOCKETS_CONNECT_TIMEOUT = 0x6 ++ SO_VM_SOCKETS_NONBLOCK_TXRX = 0x7 ++ SO_VM_SOCKETS_PEER_HOST_VM_ID = 0x3 ++ SO_VM_SOCKETS_TRUSTED = 0x5 ++ SO_WIFI_STATUS = 0x29 ++ SO_ZEROCOPY = 0x3c ++ SPLICE_F_GIFT = 0x8 ++ SPLICE_F_MORE = 0x4 ++ SPLICE_F_MOVE = 0x1 ++ SPLICE_F_NONBLOCK = 0x2 ++ SQUASHFS_MAGIC = 0x73717368 ++ STACK_END_MAGIC = 0x57ac6e9d ++ STATX_ALL = 0xfff ++ STATX_ATIME = 0x20 ++ STATX_ATTR_APPEND = 0x20 ++ STATX_ATTR_AUTOMOUNT = 0x1000 ++ STATX_ATTR_COMPRESSED = 0x4 ++ STATX_ATTR_DAX = 0x200000 ++ STATX_ATTR_ENCRYPTED = 0x800 ++ STATX_ATTR_IMMUTABLE = 0x10 ++ STATX_ATTR_MOUNT_ROOT = 0x2000 ++ STATX_ATTR_NODUMP = 0x40 ++ STATX_ATTR_VERITY = 0x100000 ++ STATX_BASIC_STATS = 0x7ff ++ STATX_BLOCKS = 0x400 ++ STATX_BTIME = 0x800 ++ STATX_CTIME = 0x80 ++ STATX_GID = 0x10 ++ STATX_INO = 0x100 ++ STATX_MNT_ID = 0x1000 ++ STATX_MODE = 0x2 ++ STATX_MTIME = 0x40 ++ STATX_NLINK = 0x4 ++ STATX_SIZE = 0x200 ++ STATX_TYPE = 0x1 ++ STATX_UID = 0x8 ++ STATX__RESERVED = 0x80000000 ++ SYNC_FILE_RANGE_WAIT_AFTER = 0x4 ++ SYNC_FILE_RANGE_WAIT_BEFORE = 0x1 ++ SYNC_FILE_RANGE_WRITE = 0x2 ++ SYNC_FILE_RANGE_WRITE_AND_WAIT = 0x7 ++ SYSFS_MAGIC = 0x62656572 ++ S_BLKSIZE = 0x200 ++ S_IEXEC = 0x40 ++ S_IFBLK = 0x6000 ++ S_IFCHR = 0x2000 ++ S_IFDIR = 0x4000 ++ S_IFIFO = 0x1000 ++ S_IFLNK = 0xa000 ++ S_IFMT = 0xf000 ++ S_IFREG = 0x8000 ++ S_IFSOCK = 0xc000 ++ S_IREAD = 0x100 ++ S_IRGRP = 0x20 ++ S_IROTH = 0x4 ++ S_IRUSR = 0x100 ++ S_IRWXG = 0x38 ++ S_IRWXO = 0x7 ++ S_IRWXU = 0x1c0 ++ S_ISGID = 0x400 ++ S_ISUID = 0x800 ++ S_ISVTX = 0x200 ++ S_IWGRP = 0x10 ++ S_IWOTH = 0x2 ++ S_IWRITE = 0x80 ++ S_IWUSR = 0x80 ++ S_IXGRP = 0x8 ++ S_IXOTH = 0x1 ++ S_IXUSR = 0x40 ++ TAB0 = 0x0 ++ TAB1 = 0x400 ++ TAB2 = 0x800 ++ TAB3 = 0xc00 ++ TABDLY = 0xc00 ++ TASKSTATS_CMD_ATTR_MAX = 0x4 ++ TASKSTATS_CMD_MAX = 0x2 ++ TASKSTATS_GENL_NAME = "TASKSTATS" ++ TASKSTATS_GENL_VERSION = 0x1 ++ TASKSTATS_TYPE_MAX = 0x6 ++ TASKSTATS_VERSION = 0xa ++ TCFLSH = 0x2000741f ++ TCGETA = 0x40127417 ++ TCGETS = 0x402c7413 ++ TCIFLUSH = 0x0 ++ TCIOFF = 0x2 ++ TCIOFLUSH = 0x2 ++ TCION = 0x3 ++ TCOFLUSH = 0x1 ++ TCOOFF = 0x0 ++ TCOON = 0x1 ++ TCPOPT_EOL = 0x0 ++ TCPOPT_MAXSEG = 0x2 ++ TCPOPT_NOP = 0x1 ++ TCPOPT_SACK = 0x5 ++ TCPOPT_SACK_PERMITTED = 0x4 ++ TCPOPT_TIMESTAMP = 0x8 ++ TCPOPT_TSTAMP_HDR = 0x101080a ++ TCPOPT_WINDOW = 0x3 ++ TCP_CC_INFO = 0x1a ++ TCP_CM_INQ = 0x24 ++ TCP_CONGESTION = 0xd ++ TCP_COOKIE_IN_ALWAYS = 0x1 ++ TCP_COOKIE_MAX = 0x10 ++ TCP_COOKIE_MIN = 0x8 ++ TCP_COOKIE_OUT_NEVER = 0x2 ++ TCP_COOKIE_PAIR_SIZE = 0x20 ++ TCP_COOKIE_TRANSACTIONS = 0xf ++ TCP_CORK = 0x3 ++ TCP_DEFER_ACCEPT = 0x9 ++ TCP_FASTOPEN = 0x17 ++ TCP_FASTOPEN_CONNECT = 0x1e ++ TCP_FASTOPEN_KEY = 0x21 ++ TCP_FASTOPEN_NO_COOKIE = 0x22 ++ TCP_INFO = 0xb ++ TCP_INQ = 0x24 ++ TCP_KEEPCNT = 0x6 ++ TCP_KEEPIDLE = 0x4 ++ TCP_KEEPINTVL = 0x5 ++ TCP_LINGER2 = 0x8 ++ TCP_MAXSEG = 0x2 ++ TCP_MAXWIN = 0xffff ++ TCP_MAX_WINSHIFT = 0xe ++ TCP_MD5SIG = 0xe ++ TCP_MD5SIG_EXT = 0x20 ++ TCP_MD5SIG_FLAG_PREFIX = 0x1 ++ TCP_MD5SIG_MAXKEYLEN = 0x50 ++ TCP_MSS = 0x200 ++ TCP_MSS_DEFAULT = 0x218 ++ TCP_MSS_DESIRED = 0x4c4 ++ TCP_NODELAY = 0x1 ++ TCP_NOTSENT_LOWAT = 0x19 ++ TCP_QUEUE_SEQ = 0x15 ++ TCP_QUICKACK = 0xc ++ TCP_REPAIR = 0x13 ++ TCP_REPAIR_OFF = 0x0 ++ TCP_REPAIR_OFF_NO_WP = -0x1 ++ TCP_REPAIR_ON = 0x1 ++ TCP_REPAIR_OPTIONS = 0x16 ++ TCP_REPAIR_QUEUE = 0x14 ++ TCP_REPAIR_WINDOW = 0x1d ++ TCP_SAVED_SYN = 0x1c ++ TCP_SAVE_SYN = 0x1b ++ TCP_SYNCNT = 0x7 ++ TCP_S_DATA_IN = 0x4 ++ TCP_S_DATA_OUT = 0x8 ++ TCP_THIN_DUPACK = 0x11 ++ TCP_THIN_LINEAR_TIMEOUTS = 0x10 ++ TCP_TIMESTAMP = 0x18 ++ TCP_TX_DELAY = 0x25 ++ TCP_ULP = 0x1f ++ TCP_USER_TIMEOUT = 0x12 ++ TCP_V4_FLOW = 0x1 ++ TCP_V6_FLOW = 0x5 ++ TCP_WINDOW_CLAMP = 0xa ++ TCP_ZEROCOPY_RECEIVE = 0x23 ++ TCSAFLUSH = 0x2 ++ TCSBRK = 0x2000741d ++ TCSBRKP = 0x5425 ++ TCSETA = 0x80127418 ++ TCSETAF = 0x8012741c ++ TCSETAW = 0x80127419 ++ TCSETS = 0x802c7414 ++ TCSETSF = 0x802c7416 ++ TCSETSW = 0x802c7415 ++ TCXONC = 0x2000741e ++ TFD_CLOEXEC = 0x200000 ++ TFD_NONBLOCK = 0x4 ++ TFD_TIMER_ABSTIME = 0x1 ++ TFD_TIMER_CANCEL_ON_SET = 0x2 ++ TIMER_ABSTIME = 0x1 ++ TIOCCBRK = 0x5428 ++ TIOCCONS = 0x541d ++ TIOCEXCL = 0x540c ++ TIOCGDEV = 0x40045432 ++ TIOCGETD = 0x5424 ++ TIOCGEXCL = 0x40045440 ++ TIOCGICOUNT = 0x545d ++ TIOCGLCKTRMIOS = 0x5456 ++ TIOCGPGRP = 0x40047477 ++ TIOCGPKT = 0x40045438 ++ TIOCGPTLCK = 0x40045439 ++ TIOCGPTN = 0x40045430 ++ TIOCGPTPEER = 0x20005441 ++ TIOCGSERIAL = 0x541e ++ TIOCGSID = 0x5429 ++ TIOCGSOFTCAR = 0x5419 ++ TIOCLINUX = 0x541c ++ TIOCMBIC = 0x5417 ++ TIOCMBIS = 0x5416 ++ TIOCMGET = 0x5415 ++ TIOCMIWAIT = 0x545c ++ TIOCMSET = 0x5418 ++ TIOCM_CAR = 0x40 ++ TIOCM_CD = 0x40 ++ TIOCM_CTS = 0x20 ++ TIOCM_DSR = 0x100 ++ TIOCM_DTR = 0x2 ++ TIOCM_LE = 0x1 ++ TIOCM_LOOP = 0x8000 ++ TIOCM_OUT1 = 0x2000 ++ TIOCM_OUT2 = 0x4000 ++ TIOCM_RI = 0x80 ++ TIOCM_RNG = 0x80 ++ TIOCM_RTS = 0x4 ++ TIOCM_SR = 0x10 ++ TIOCM_ST = 0x8 ++ TIOCNOTTY = 0x5422 ++ TIOCNXCL = 0x540d ++ TIOCOUTQ = 0x40047473 ++ TIOCPKT = 0x5420 ++ TIOCPKT_DATA = 0x0 ++ TIOCPKT_DOSTOP = 0x20 ++ TIOCPKT_FLUSHREAD = 0x1 ++ TIOCPKT_FLUSHWRITE = 0x2 ++ TIOCPKT_IOCTL = 0x40 ++ TIOCPKT_NOSTOP = 0x10 ++ TIOCPKT_START = 0x8 ++ TIOCPKT_STOP = 0x4 ++ TIOCSBRK = 0x5427 ++ TIOCSCTTY = 0x540e ++ TIOCSERCONFIG = 0x5453 ++ TIOCSERGETLSR = 0x5459 ++ TIOCSERGETMULTI = 0x545a ++ TIOCSERGSTRUCT = 0x5458 ++ TIOCSERGWILD = 0x5454 ++ TIOCSERSETMULTI = 0x545b ++ TIOCSERSWILD = 0x5455 ++ TIOCSER_TEMT = 0x1 ++ TIOCSETD = 0x5423 ++ TIOCSIG = 0x80045436 ++ TIOCSLCKTRMIOS = 0x5457 ++ TIOCSPGRP = 0x80047476 ++ TIOCSPTLCK = 0x80045431 ++ TIOCSSERIAL = 0x541f ++ TIOCSSOFTCAR = 0x541a ++ TIOCSTART = 0x2000746e ++ TIOCSTI = 0x5412 ++ TIOCSTOP = 0x2000746f ++ TIOCSWINSZ = 0x80087467 ++ TIOCVHANGUP = 0x5437 ++ TIPC_ADDR_ID = 0x3 ++ TIPC_ADDR_MCAST = 0x1 ++ TIPC_ADDR_NAME = 0x2 ++ TIPC_ADDR_NAMESEQ = 0x1 ++ TIPC_AEAD_ALG_NAME = 0x20 ++ TIPC_AEAD_KEYLEN_MAX = 0x24 ++ TIPC_AEAD_KEYLEN_MIN = 0x14 ++ TIPC_AEAD_KEY_SIZE_MAX = 0x48 ++ TIPC_CFG_SRV = 0x0 ++ TIPC_CLUSTER_BITS = 0xc ++ TIPC_CLUSTER_MASK = 0xfff000 ++ TIPC_CLUSTER_OFFSET = 0xc ++ TIPC_CLUSTER_SIZE = 0xfff ++ TIPC_CONN_SHUTDOWN = 0x5 ++ TIPC_CONN_TIMEOUT = 0x82 ++ TIPC_CRITICAL_IMPORTANCE = 0x3 ++ TIPC_DESTNAME = 0x3 ++ TIPC_DEST_DROPPABLE = 0x81 ++ TIPC_ERRINFO = 0x1 ++ TIPC_ERR_NO_NAME = 0x1 ++ TIPC_ERR_NO_NODE = 0x3 ++ TIPC_ERR_NO_PORT = 0x2 ++ TIPC_ERR_OVERLOAD = 0x4 ++ TIPC_GROUP_JOIN = 0x87 ++ TIPC_GROUP_LEAVE = 0x88 ++ TIPC_GROUP_LOOPBACK = 0x1 ++ TIPC_GROUP_MEMBER_EVTS = 0x2 ++ TIPC_HIGH_IMPORTANCE = 0x2 ++ TIPC_IMPORTANCE = 0x7f ++ TIPC_LINK_STATE = 0x2 ++ TIPC_LOW_IMPORTANCE = 0x0 ++ TIPC_MAX_BEARER_NAME = 0x20 ++ TIPC_MAX_IF_NAME = 0x10 ++ TIPC_MAX_LINK_NAME = 0x44 ++ TIPC_MAX_MEDIA_NAME = 0x10 ++ TIPC_MAX_USER_MSG_SIZE = 0x101d0 ++ TIPC_MCAST_BROADCAST = 0x85 ++ TIPC_MCAST_REPLICAST = 0x86 ++ TIPC_MEDIUM_IMPORTANCE = 0x1 ++ TIPC_NODEID_LEN = 0x10 ++ TIPC_NODELAY = 0x8a ++ TIPC_NODE_BITS = 0xc ++ TIPC_NODE_MASK = 0xfff ++ TIPC_NODE_OFFSET = 0x0 ++ TIPC_NODE_RECVQ_DEPTH = 0x83 ++ TIPC_NODE_SIZE = 0xfff ++ TIPC_NODE_STATE = 0x0 ++ TIPC_OK = 0x0 ++ TIPC_PUBLISHED = 0x1 ++ TIPC_REKEYING_NOW = 0xffffffff ++ TIPC_RESERVED_TYPES = 0x40 ++ TIPC_RETDATA = 0x2 ++ TIPC_SERVICE_ADDR = 0x2 ++ TIPC_SERVICE_RANGE = 0x1 ++ TIPC_SOCKET_ADDR = 0x3 ++ TIPC_SOCK_RECVQ_DEPTH = 0x84 ++ TIPC_SOCK_RECVQ_USED = 0x89 ++ TIPC_SRC_DROPPABLE = 0x80 ++ TIPC_SUBSCR_TIMEOUT = 0x3 ++ TIPC_SUB_CANCEL = 0x4 ++ TIPC_SUB_PORTS = 0x1 ++ TIPC_SUB_SERVICE = 0x2 ++ TIPC_TOP_SRV = 0x1 ++ TIPC_WAIT_FOREVER = 0xffffffff ++ TIPC_WITHDRAWN = 0x2 ++ TIPC_ZONE_BITS = 0x8 ++ TIPC_ZONE_CLUSTER_MASK = 0xfffff000 ++ TIPC_ZONE_MASK = 0xff000000 ++ TIPC_ZONE_OFFSET = 0x18 ++ TIPC_ZONE_SCOPE = 0x1 ++ TIPC_ZONE_SIZE = 0xff ++ TMPFS_MAGIC = 0x1021994 ++ TOSTOP = 0x400000 ++ TPACKET_ALIGNMENT = 0x10 ++ TPACKET_HDRLEN = 0x34 ++ TP_STATUS_AVAILABLE = 0x0 ++ TP_STATUS_BLK_TMO = 0x20 ++ TP_STATUS_COPY = 0x2 ++ TP_STATUS_CSUMNOTREADY = 0x8 ++ TP_STATUS_CSUM_VALID = 0x80 ++ TP_STATUS_KERNEL = 0x0 ++ TP_STATUS_LOSING = 0x4 ++ TP_STATUS_SENDING = 0x2 ++ TP_STATUS_SEND_REQUEST = 0x1 ++ TP_STATUS_TS_RAW_HARDWARE = 0x80000000 ++ TP_STATUS_TS_SOFTWARE = 0x20000000 ++ TP_STATUS_TS_SYS_HARDWARE = 0x40000000 ++ TP_STATUS_USER = 0x1 ++ TP_STATUS_VLAN_TPID_VALID = 0x40 ++ TP_STATUS_VLAN_VALID = 0x10 ++ TP_STATUS_WRONG_FORMAT = 0x4 ++ TRACEFS_MAGIC = 0x74726163 ++ TS_COMM_LEN = 0x20 ++ TUNATTACHFILTER = 0x801054d5 ++ TUNDETACHFILTER = 0x801054d6 ++ TUNGETDEVNETNS = 0x200054e3 ++ TUNGETFEATURES = 0x400454cf ++ TUNGETFILTER = 0x401054db ++ TUNGETIFF = 0x400454d2 ++ TUNGETSNDBUF = 0x400454d3 ++ TUNGETVNETBE = 0x400454df ++ TUNGETVNETHDRSZ = 0x400454d7 ++ TUNGETVNETLE = 0x400454dd ++ TUNSETCARRIER = 0x800454e2 ++ TUNSETDEBUG = 0x800454c9 ++ TUNSETFILTEREBPF = 0x400454e1 ++ TUNSETGROUP = 0x800454ce ++ TUNSETIFF = 0x800454ca ++ TUNSETIFINDEX = 0x800454da ++ TUNSETLINK = 0x800454cd ++ TUNSETNOCSUM = 0x800454c8 ++ TUNSETOFFLOAD = 0x800454d0 ++ TUNSETOWNER = 0x800454cc ++ TUNSETPERSIST = 0x800454cb ++ TUNSETQUEUE = 0x800454d9 ++ TUNSETSNDBUF = 0x800454d4 ++ TUNSETSTEERINGEBPF = 0x400454e0 ++ TUNSETTXFILTER = 0x800454d1 ++ TUNSETVNETBE = 0x800454de ++ TUNSETVNETHDRSZ = 0x800454d8 ++ TUNSETVNETLE = 0x800454dc ++ UBI_IOCATT = 0x80186f40 ++ UBI_IOCDET = 0x80046f41 ++ UBI_IOCEBCH = 0x80044f02 ++ UBI_IOCEBER = 0x80044f01 ++ UBI_IOCEBISMAP = 0x40044f05 ++ UBI_IOCEBMAP = 0x80084f03 ++ UBI_IOCEBUNMAP = 0x80044f04 ++ UBI_IOCMKVOL = 0x80986f00 ++ UBI_IOCRMVOL = 0x80046f01 ++ UBI_IOCRNVOL = 0x91106f03 ++ UBI_IOCRPEB = 0x80046f04 ++ UBI_IOCRSVOL = 0x800c6f02 ++ UBI_IOCSETVOLPROP = 0x80104f06 ++ UBI_IOCSPEB = 0x80046f05 ++ UBI_IOCVOLCRBLK = 0x80804f07 ++ UBI_IOCVOLRMBLK = 0x20004f08 ++ UBI_IOCVOLUP = 0x80084f00 ++ UDF_SUPER_MAGIC = 0x15013346 ++ UMOUNT_NOFOLLOW = 0x8 ++ USBDEVICE_SUPER_MAGIC = 0x9fa2 ++ UTIME_NOW = 0x3fffffff ++ UTIME_OMIT = 0x3ffffffe ++ V9FS_MAGIC = 0x1021997 ++ VDISCARD = 0xf ++ VEOF = 0x0 ++ VEOL = 0x1 ++ VEOL2 = 0x2 ++ VERASE = 0x3 ++ VINTR = 0x8 ++ VKILL = 0x5 ++ VLNEXT = 0xe ++ VMADDR_CID_ANY = 0xffffffff ++ VMADDR_CID_HOST = 0x2 ++ VMADDR_CID_HYPERVISOR = 0x0 ++ VMADDR_CID_LOCAL = 0x1 ++ VMADDR_PORT_ANY = 0xffffffff ++ VMIN = 0x10 ++ VM_SOCKETS_INVALID_VERSION = 0xffffffff ++ VQUIT = 0x9 ++ VREPRINT = 0x6 ++ VSTART = 0xc ++ VSTOP = 0xd ++ VSUSP = 0xa ++ VSWTC = 0x7 ++ VT0 = 0x0 ++ VT1 = 0x10000 ++ VTDLY = 0x10000 ++ VTIME = 0x11 ++ VWERASE = 0x4 ++ WAKE_MAGIC = 0x20 ++ WALL = 0x40000000 ++ WCLONE = 0x80000000 ++ WCONTINUED = 0x8 ++ WDIOC_GETBOOTSTATUS = 0x40045702 ++ WDIOC_GETPRETIMEOUT = 0x40045709 ++ WDIOC_GETSTATUS = 0x40045701 ++ WDIOC_GETSUPPORT = 0x40285700 ++ WDIOC_GETTEMP = 0x40045703 ++ WDIOC_GETTIMELEFT = 0x4004570a ++ WDIOC_GETTIMEOUT = 0x40045707 ++ WDIOC_KEEPALIVE = 0x40045705 ++ WDIOC_SETOPTIONS = 0x40045704 ++ WDIOC_SETPRETIMEOUT = 0xc0045708 ++ WDIOC_SETTIMEOUT = 0xc0045706 ++ WDIOF_ALARMONLY = 0x400 ++ WDIOF_CARDRESET = 0x20 ++ WDIOF_EXTERN1 = 0x4 ++ WDIOF_EXTERN2 = 0x8 ++ WDIOF_FANFAULT = 0x2 ++ WDIOF_KEEPALIVEPING = 0x8000 ++ WDIOF_MAGICCLOSE = 0x100 ++ WDIOF_OVERHEAT = 0x1 ++ WDIOF_POWEROVER = 0x40 ++ WDIOF_POWERUNDER = 0x10 ++ WDIOF_PRETIMEOUT = 0x200 ++ WDIOF_SETTIMEOUT = 0x80 ++ WDIOF_UNKNOWN = -0x1 ++ WDIOS_DISABLECARD = 0x1 ++ WDIOS_ENABLECARD = 0x2 ++ WDIOS_TEMPPANIC = 0x4 ++ WDIOS_UNKNOWN = -0x1 ++ WEXITED = 0x4 ++ WGALLOWEDIP_A_MAX = 0x3 ++ WGDEVICE_A_MAX = 0x8 ++ WGPEER_A_MAX = 0xa ++ WG_CMD_MAX = 0x1 ++ WG_GENL_NAME = "wireguard" ++ WG_GENL_VERSION = 0x1 ++ WG_KEY_LEN = 0x20 ++ WIN_ACKMEDIACHANGE = 0xdb ++ WIN_CHECKPOWERMODE1 = 0xe5 ++ WIN_CHECKPOWERMODE2 = 0x98 ++ WIN_DEVICE_RESET = 0x8 ++ WIN_DIAGNOSE = 0x90 ++ WIN_DOORLOCK = 0xde ++ WIN_DOORUNLOCK = 0xdf ++ WIN_DOWNLOAD_MICROCODE = 0x92 ++ WIN_FLUSH_CACHE = 0xe7 ++ WIN_FLUSH_CACHE_EXT = 0xea ++ WIN_FORMAT = 0x50 ++ WIN_GETMEDIASTATUS = 0xda ++ WIN_IDENTIFY = 0xec ++ WIN_IDENTIFY_DMA = 0xee ++ WIN_IDLEIMMEDIATE = 0xe1 ++ WIN_INIT = 0x60 ++ WIN_MEDIAEJECT = 0xed ++ WIN_MULTREAD = 0xc4 ++ WIN_MULTREAD_EXT = 0x29 ++ WIN_MULTWRITE = 0xc5 ++ WIN_MULTWRITE_EXT = 0x39 ++ WIN_NOP = 0x0 ++ WIN_PACKETCMD = 0xa0 ++ WIN_PIDENTIFY = 0xa1 ++ WIN_POSTBOOT = 0xdc ++ WIN_PREBOOT = 0xdd ++ WIN_QUEUED_SERVICE = 0xa2 ++ WIN_READ = 0x20 ++ WIN_READDMA = 0xc8 ++ WIN_READDMA_EXT = 0x25 ++ WIN_READDMA_ONCE = 0xc9 ++ WIN_READDMA_QUEUED = 0xc7 ++ WIN_READDMA_QUEUED_EXT = 0x26 ++ WIN_READ_BUFFER = 0xe4 ++ WIN_READ_EXT = 0x24 ++ WIN_READ_LONG = 0x22 ++ WIN_READ_LONG_ONCE = 0x23 ++ WIN_READ_NATIVE_MAX = 0xf8 ++ WIN_READ_NATIVE_MAX_EXT = 0x27 ++ WIN_READ_ONCE = 0x21 ++ WIN_RECAL = 0x10 ++ WIN_RESTORE = 0x10 ++ WIN_SECURITY_DISABLE = 0xf6 ++ WIN_SECURITY_ERASE_PREPARE = 0xf3 ++ WIN_SECURITY_ERASE_UNIT = 0xf4 ++ WIN_SECURITY_FREEZE_LOCK = 0xf5 ++ WIN_SECURITY_SET_PASS = 0xf1 ++ WIN_SECURITY_UNLOCK = 0xf2 ++ WIN_SEEK = 0x70 ++ WIN_SETFEATURES = 0xef ++ WIN_SETIDLE1 = 0xe3 ++ WIN_SETIDLE2 = 0x97 ++ WIN_SETMULT = 0xc6 ++ WIN_SET_MAX = 0xf9 ++ WIN_SET_MAX_EXT = 0x37 ++ WIN_SLEEPNOW1 = 0xe6 ++ WIN_SLEEPNOW2 = 0x99 ++ WIN_SMART = 0xb0 ++ WIN_SPECIFY = 0x91 ++ WIN_SRST = 0x8 ++ WIN_STANDBY = 0xe2 ++ WIN_STANDBY2 = 0x96 ++ WIN_STANDBYNOW1 = 0xe0 ++ WIN_STANDBYNOW2 = 0x94 ++ WIN_VERIFY = 0x40 ++ WIN_VERIFY_EXT = 0x42 ++ WIN_VERIFY_ONCE = 0x41 ++ WIN_WRITE = 0x30 ++ WIN_WRITEDMA = 0xca ++ WIN_WRITEDMA_EXT = 0x35 ++ WIN_WRITEDMA_ONCE = 0xcb ++ WIN_WRITEDMA_QUEUED = 0xcc ++ WIN_WRITEDMA_QUEUED_EXT = 0x36 ++ WIN_WRITE_BUFFER = 0xe8 ++ WIN_WRITE_EXT = 0x34 ++ WIN_WRITE_LONG = 0x32 ++ WIN_WRITE_LONG_ONCE = 0x33 ++ WIN_WRITE_ONCE = 0x31 ++ WIN_WRITE_SAME = 0xe9 ++ WIN_WRITE_VERIFY = 0x3c ++ WNOHANG = 0x1 ++ WNOTHREAD = 0x20000000 ++ WNOWAIT = 0x1000000 ++ WORDSIZE = 0x40 ++ WSTOPPED = 0x2 ++ WUNTRACED = 0x2 ++ XATTR_CREATE = 0x1 ++ XATTR_REPLACE = 0x2 ++ XCASE = 0x4000 ++ XDP_COPY = 0x2 ++ XDP_FLAGS_DRV_MODE = 0x4 ++ XDP_FLAGS_HW_MODE = 0x8 ++ XDP_FLAGS_MASK = 0x1f ++ XDP_FLAGS_MODES = 0xe ++ XDP_FLAGS_REPLACE = 0x10 ++ XDP_FLAGS_SKB_MODE = 0x2 ++ XDP_FLAGS_UPDATE_IF_NOEXIST = 0x1 ++ XDP_MMAP_OFFSETS = 0x1 ++ XDP_OPTIONS = 0x8 ++ XDP_OPTIONS_ZEROCOPY = 0x1 ++ XDP_PACKET_HEADROOM = 0x100 ++ XDP_PGOFF_RX_RING = 0x0 ++ XDP_PGOFF_TX_RING = 0x80000000 ++ XDP_RING_NEED_WAKEUP = 0x1 ++ XDP_RX_RING = 0x2 ++ XDP_SHARED_UMEM = 0x1 ++ XDP_STATISTICS = 0x7 ++ XDP_TX_RING = 0x3 ++ XDP_UMEM_COMPLETION_RING = 0x6 ++ XDP_UMEM_FILL_RING = 0x5 ++ XDP_UMEM_PGOFF_COMPLETION_RING = 0x180000000 ++ XDP_UMEM_PGOFF_FILL_RING = 0x100000000 ++ XDP_UMEM_REG = 0x4 ++ XDP_UMEM_UNALIGNED_CHUNK_FLAG = 0x1 ++ XDP_USE_NEED_WAKEUP = 0x8 ++ XDP_ZEROCOPY = 0x4 ++ XENFS_SUPER_MAGIC = 0xabba1974 ++ XFS_SUPER_MAGIC = 0x58465342 ++ XTABS = 0x40000 ++ Z3FOLD_MAGIC = 0x33 ++ ZONEFS_MAGIC = 0x5a4f4653 ++ ZSMALLOC_MAGIC = 0x58295829 ++ _HIDIOCGRAWNAME = 0x40804804 ++ _HIDIOCGRAWNAME_LEN = 0x80 ++ _HIDIOCGRAWPHYS = 0x40404805 ++ _HIDIOCGRAWPHYS_LEN = 0x40 ++ _HIDIOCGRAWUNIQ = 0x40404808 ++ _HIDIOCGRAWUNIQ_LEN = 0x40 ++) ++ ++// Errors ++const ( ++ E2BIG = syscall.Errno( 0x7) ++ EACCES = syscall.Errno( 0xd) ++ EADDRINUSE = syscall.Errno( 0x30) ++ EADDRNOTAVAIL = syscall.Errno( 0x31) ++ EADV = syscall.Errno( 0x6b) ++ EAFNOSUPPORT = syscall.Errno( 0x2f) ++ EAGAIN = syscall.Errno( 0x23) ++ EALREADY = syscall.Errno( 0x25) ++ EBADE = syscall.Errno( 0x61) ++ EBADF = syscall.Errno( 0x9) ++ EBADFD = syscall.Errno( 0x72) ++ EBADMSG = syscall.Errno( 0x54) ++ EBADR = syscall.Errno( 0x62) ++ EBADRQC = syscall.Errno( 0x65) ++ EBADSLT = syscall.Errno( 0x66) ++ EBFONT = syscall.Errno( 0x68) ++ EBUSY = syscall.Errno( 0x10) ++ ECANCELED = syscall.Errno( 0x83) ++ ECHILD = syscall.Errno( 0xa) ++ ECHRNG = syscall.Errno( 0x58) ++ ECOMM = syscall.Errno( 0x6d) ++ ECONNABORTED = syscall.Errno( 0x35) ++ ECONNREFUSED = syscall.Errno( 0x3d) ++ ECONNRESET = syscall.Errno( 0x36) ++ EDEADLK = syscall.Errno( 0xb) ++ EDEADLOCK = syscall.Errno( 0xb) ++ EDESTADDRREQ = syscall.Errno( 0x27) ++ EDOM = syscall.Errno( 0x21) ++ EDOTDOT = syscall.Errno( 0x6f) ++ EDQUOT = syscall.Errno( 0x45) ++ EEXIST = syscall.Errno( 0x11) ++ EFAULT = syscall.Errno( 0xe) ++ EFBIG = syscall.Errno( 0x1b) ++ EHOSTDOWN = syscall.Errno( 0x40) ++ EHOSTUNREACH = syscall.Errno( 0x41) ++ EHWPOISON = syscall.Errno( 0x8b) ++ EIDRM = syscall.Errno( 0x51) ++ EILSEQ = syscall.Errno( 0x74) ++ EINPROGRESS = syscall.Errno( 0x24) ++ EINTR = syscall.Errno( 0x4) ++ EINVAL = syscall.Errno( 0x16) ++ EIO = syscall.Errno( 0x5) ++ EISCONN = syscall.Errno( 0x38) ++ EISDIR = syscall.Errno( 0x15) ++ EISNAM = syscall.Errno( 0x78) ++ EKEYEXPIRED = syscall.Errno( 0x85) ++ EKEYREJECTED = syscall.Errno( 0x87) ++ EKEYREVOKED = syscall.Errno( 0x86) ++ EL2HLT = syscall.Errno( 0x60) ++ EL2NSYNC = syscall.Errno( 0x59) ++ EL3HLT = syscall.Errno( 0x5a) ++ EL3RST = syscall.Errno( 0x5b) ++ ELIBACC = syscall.Errno( 0x7a) ++ ELIBBAD = syscall.Errno( 0x7b) ++ ELIBEXEC = syscall.Errno( 0x7e) ++ ELIBMAX = syscall.Errno( 0x7d) ++ ELIBSCN = syscall.Errno( 0x7c) ++ ELNRNG = syscall.Errno( 0x5d) ++ ELOOP = syscall.Errno( 0x3e) ++ EMEDIUMTYPE = syscall.Errno( 0x82) ++ EMFILE = syscall.Errno( 0x18) ++ EMLINK = syscall.Errno( 0x1f) ++ EMSGSIZE = syscall.Errno( 0x28) ++ EMULTIHOP = syscall.Errno( 0x6e) ++ ENAMETOOLONG = syscall.Errno( 0x3f) ++ ENAVAIL = syscall.Errno( 0x77) ++ ENETDOWN = syscall.Errno( 0x32) ++ ENETRESET = syscall.Errno( 0x34) ++ ENETUNREACH = syscall.Errno( 0x33) ++ ENFILE = syscall.Errno( 0x17) ++ ENOANO = syscall.Errno( 0x64) ++ ENOBUFS = syscall.Errno( 0x37) ++ ENOCSI = syscall.Errno( 0x5f) ++ ENODATA = syscall.Errno( 0x56) ++ ENODEV = syscall.Errno( 0x13) ++ ENOENT = syscall.Errno( 0x2) ++ ENOEXEC = syscall.Errno( 0x8) ++ ENOKEY = syscall.Errno( 0x84) ++ ENOLCK = syscall.Errno( 0x4d) ++ ENOLINK = syscall.Errno( 0x6a) ++ ENOMEDIUM = syscall.Errno( 0x81) ++ ENOMEM = syscall.Errno( 0xc) ++ ENOMSG = syscall.Errno( 0x50) ++ ENONET = syscall.Errno( 0x69) ++ ENOPKG = syscall.Errno( 0x5c) ++ ENOPROTOOPT = syscall.Errno( 0x2a) ++ ENOSPC = syscall.Errno( 0x1c) ++ ENOSR = syscall.Errno( 0x52) ++ ENOSTR = syscall.Errno( 0x57) ++ ENOSYS = syscall.Errno( 0x4e) ++ ENOTBLK = syscall.Errno( 0xf) ++ ENOTCONN = syscall.Errno( 0x39) ++ ENOTDIR = syscall.Errno( 0x14) ++ ENOTEMPTY = syscall.Errno( 0x42) ++ ENOTNAM = syscall.Errno( 0x76) ++ ENOTRECOVERABLE = syscall.Errno( 0x89) ++ ENOTSOCK = syscall.Errno( 0x26) ++ ENOTSUP = syscall.Errno( 0x2d) ++ ENOTTY = syscall.Errno( 0x19) ++ ENOTUNIQ = syscall.Errno( 0x71) ++ ENXIO = syscall.Errno( 0x6) ++ EOPNOTSUPP = syscall.Errno( 0x2d) ++ EOVERFLOW = syscall.Errno( 0x70) ++ EOWNERDEAD = syscall.Errno( 0x88) ++ EPERM = syscall.Errno( 0x1) ++ EPFNOSUPPORT = syscall.Errno( 0x2e) ++ EPIPE = syscall.Errno( 0x20) ++ EPROTO = syscall.Errno( 0x55) ++ EPROTONOSUPPORT = syscall.Errno( 0x2b) ++ EPROTOTYPE = syscall.Errno( 0x29) ++ ERANGE = syscall.Errno( 0x22) ++ EREMCHG = syscall.Errno( 0x73) ++ EREMOTE = syscall.Errno( 0x47) ++ EREMOTEIO = syscall.Errno( 0x79) ++ ERESTART = syscall.Errno( 0x7f) ++ ERFKILL = syscall.Errno( 0x8a) ++ EROFS = syscall.Errno( 0x1e) ++ ESHUTDOWN = syscall.Errno( 0x3a) ++ ESOCKTNOSUPPORT = syscall.Errno( 0x2c) ++ ESPIPE = syscall.Errno( 0x1d) ++ ESRCH = syscall.Errno( 0x3) ++ ESRMNT = syscall.Errno( 0x6c) ++ ESTALE = syscall.Errno( 0x46) ++ ESTRPIPE = syscall.Errno( 0x80) ++ ETIME = syscall.Errno( 0x53) ++ ETIMEDOUT = syscall.Errno( 0x3c) ++ ETOOMANYREFS = syscall.Errno( 0x3b) ++ ETXTBSY = syscall.Errno( 0x1a) ++ EUCLEAN = syscall.Errno( 0x75) ++ EUNATCH = syscall.Errno( 0x5e) ++ EUSERS = syscall.Errno( 0x44) ++ EWOULDBLOCK = syscall.Errno( 0x23) ++ EXDEV = syscall.Errno( 0x12) ++ EXFULL = syscall.Errno( 0x63) ++) ++ ++// Signals ++const ( ++ SIGABRT = syscall.Signal( 0x6) ++ SIGALRM = syscall.Signal( 0xe) ++ SIGBUS = syscall.Signal( 0xa) ++ SIGCHLD = syscall.Signal( 0x14) ++ SIGCLD = syscall.Signal( 0x14) ++ SIGCONT = syscall.Signal( 0x13) ++ SIGEMT = syscall.Signal( 0x7) ++ SIGFPE = syscall.Signal( 0x8) ++ SIGHUP = syscall.Signal( 0x1) ++ SIGILL = syscall.Signal( 0x4) ++ SIGINFO = syscall.Signal( 0x1d) ++ SIGINT = syscall.Signal( 0x2) ++ SIGIO = syscall.Signal( 0x17) ++ SIGIOT = syscall.Signal( 0x6) ++ SIGKILL = syscall.Signal( 0x9) ++ SIGPIPE = syscall.Signal( 0xd) ++ SIGPOLL = syscall.Signal( 0x17) ++ SIGPROF = syscall.Signal( 0x1b) ++ SIGPWR = syscall.Signal( 0x1d) ++ SIGQUIT = syscall.Signal( 0x3) ++ SIGSEGV = syscall.Signal( 0xb) ++ SIGSTOP = syscall.Signal( 0x11) ++ SIGSYS = syscall.Signal( 0xc) ++ SIGTERM = syscall.Signal( 0xf) ++ SIGTRAP = syscall.Signal( 0x5) ++ SIGTSTP = syscall.Signal( 0x12) ++ SIGTTIN = syscall.Signal( 0x15) ++ SIGTTOU = syscall.Signal( 0x16) ++ SIGURG = syscall.Signal( 0x10) ++ SIGUSR1 = syscall.Signal( 0x1e) ++ SIGUSR2 = syscall.Signal( 0x1f) ++ SIGVTALRM = syscall.Signal( 0x1a) ++ SIGWINCH = syscall.Signal( 0x1c) ++ SIGXCPU = syscall.Signal( 0x18) ++ SIGXFSZ = syscall.Signal( 0x19) ++) ++ ++ ++// Error table ++var errorList = [...]struct { ++ num syscall.Errno ++ name string ++ desc string ++} { ++ { 1, "EPERM", "operation not permitted" }, ++ { 2, "ENOENT", "no such file or directory" }, ++ { 3, "ESRCH", "no such process" }, ++ { 4, "EINTR", "interrupted system call" }, ++ { 5, "EIO", "input/output error" }, ++ { 6, "ENXIO", "no such device or address" }, ++ { 7, "E2BIG", "argument list too long" }, ++ { 8, "ENOEXEC", "exec format error" }, ++ { 9, "EBADF", "bad file descriptor" }, ++ { 10, "ECHILD", "no child processes" }, ++ { 11, "EDEADLK", "resource deadlock avoided" }, ++ { 12, "ENOMEM", "cannot allocate memory" }, ++ { 13, "EACCES", "permission denied" }, ++ { 14, "EFAULT", "bad address" }, ++ { 15, "ENOTBLK", "block device required" }, ++ { 16, "EBUSY", "device or resource busy" }, ++ { 17, "EEXIST", "file exists" }, ++ { 18, "EXDEV", "invalid cross-device link" }, ++ { 19, "ENODEV", "no such device" }, ++ { 20, "ENOTDIR", "not a directory" }, ++ { 21, "EISDIR", "is a directory" }, ++ { 22, "EINVAL", "invalid argument" }, ++ { 23, "ENFILE", "too many open files in system" }, ++ { 24, "EMFILE", "too many open files" }, ++ { 25, "ENOTTY", "inappropriate ioctl for device" }, ++ { 26, "ETXTBSY", "text file busy" }, ++ { 27, "EFBIG", "file too large" }, ++ { 28, "ENOSPC", "no space left on device" }, ++ { 29, "ESPIPE", "illegal seek" }, ++ { 30, "EROFS", "read-only file system" }, ++ { 31, "EMLINK", "too many links" }, ++ { 32, "EPIPE", "broken pipe" }, ++ { 33, "EDOM", "numerical argument out of domain" }, ++ { 34, "ERANGE", "numerical result out of range" }, ++ { 35, "EAGAIN", "resource temporarily unavailable" }, ++ { 36, "EINPROGRESS", "operation now in progress" }, ++ { 37, "EALREADY", "operation already in progress" }, ++ { 38, "ENOTSOCK", "socket operation on non-socket" }, ++ { 39, "EDESTADDRREQ", "destination address required" }, ++ { 40, "EMSGSIZE", "message too long" }, ++ { 41, "EPROTOTYPE", "protocol wrong type for socket" }, ++ { 42, "ENOPROTOOPT", "protocol not available" }, ++ { 43, "EPROTONOSUPPORT", "protocol not supported" }, ++ { 44, "ESOCKTNOSUPPORT", "socket type not supported" }, ++ { 45, "ENOTSUP", "operation not supported" }, ++ { 46, "EPFNOSUPPORT", "protocol family not supported" }, ++ { 47, "EAFNOSUPPORT", "address family not supported by protocol" }, ++ { 48, "EADDRINUSE", "address already in use" }, ++ { 49, "EADDRNOTAVAIL", "cannot assign requested address" }, ++ { 50, "ENETDOWN", "network is down" }, ++ { 51, "ENETUNREACH", "network is unreachable" }, ++ { 52, "ENETRESET", "network dropped connection on reset" }, ++ { 53, "ECONNABORTED", "software caused connection abort" }, ++ { 54, "ECONNRESET", "connection reset by peer" }, ++ { 55, "ENOBUFS", "no buffer space available" }, ++ { 56, "EISCONN", "transport endpoint is already connected" }, ++ { 57, "ENOTCONN", "transport endpoint is not connected" }, ++ { 58, "ESHUTDOWN", "cannot send after transport endpoint shutdown" }, ++ { 59, "ETOOMANYREFS", "too many references: cannot splice" }, ++ { 60, "ETIMEDOUT", "connection timed out" }, ++ { 61, "ECONNREFUSED", "connection refused" }, ++ { 62, "ELOOP", "too many levels of symbolic links" }, ++ { 63, "ENAMETOOLONG", "file name too long" }, ++ { 64, "EHOSTDOWN", "host is down" }, ++ { 65, "EHOSTUNREACH", "no route to host" }, ++ { 66, "ENOTEMPTY", "directory not empty" }, ++ { 68, "EUSERS", "too many users" }, ++ { 69, "EDQUOT", "disk quota exceeded" }, ++ { 70, "ESTALE", "stale file handle" }, ++ { 71, "EREMOTE", "object is remote" }, ++ { 77, "ENOLCK", "no locks available" }, ++ { 78, "ENOSYS", "function not implemented" }, ++ { 80, "ENOMSG", "no message of desired type" }, ++ { 81, "EIDRM", "identifier removed" }, ++ { 82, "ENOSR", "out of streams resources" }, ++ { 83, "ETIME", "timer expired" }, ++ { 84, "EBADMSG", "bad message" }, ++ { 85, "EPROTO", "protocol error" }, ++ { 86, "ENODATA", "no data available" }, ++ { 87, "ENOSTR", "device not a stream" }, ++ { 88, "ECHRNG", "channel number out of range" }, ++ { 89, "EL2NSYNC", "level 2 not synchronized" }, ++ { 90, "EL3HLT", "level 3 halted" }, ++ { 91, "EL3RST", "level 3 reset" }, ++ { 92, "ENOPKG", "package not installed" }, ++ { 93, "ELNRNG", "link number out of range" }, ++ { 94, "EUNATCH", "protocol driver not attached" }, ++ { 95, "ENOCSI", "no CSI structure available" }, ++ { 96, "EL2HLT", "level 2 halted" }, ++ { 97, "EBADE", "invalid exchange" }, ++ { 98, "EBADR", "invalid request descriptor" }, ++ { 99, "EXFULL", "exchange full" }, ++ { 100, "ENOANO", "no anode" }, ++ { 101, "EBADRQC", "invalid request code" }, ++ { 102, "EBADSLT", "invalid slot" }, ++ { 104, "EBFONT", "bad font file format" }, ++ { 105, "ENONET", "machine is not on the network" }, ++ { 106, "ENOLINK", "link has been severed" }, ++ { 107, "EADV", "advertise error" }, ++ { 108, "ESRMNT", "srmount error" }, ++ { 109, "ECOMM", "communication error on send" }, ++ { 110, "EMULTIHOP", "multihop attempted" }, ++ { 111, "EDOTDOT", "RFS specific error" }, ++ { 112, "EOVERFLOW", "value too large for defined data type" }, ++ { 113, "ENOTUNIQ", "name not unique on network" }, ++ { 114, "EBADFD", "file descriptor in bad state" }, ++ { 115, "EREMCHG", "remote address changed" }, ++ { 116, "EILSEQ", "invalid or incomplete multibyte or wide character" }, ++ { 117, "EUCLEAN", "structure needs cleaning" }, ++ { 118, "ENOTNAM", "not a XENIX named type file" }, ++ { 119, "ENAVAIL", "no XENIX semaphores available" }, ++ { 120, "EISNAM", "is a named type file" }, ++ { 121, "EREMOTEIO", "remote I/O error" }, ++ { 122, "ELIBACC", "can not access a needed shared library" }, ++ { 123, "ELIBBAD", "accessing a corrupted shared library" }, ++ { 124, "ELIBSCN", ".lib section in a.out corrupted" }, ++ { 125, "ELIBMAX", "attempting to link in too many shared libraries" }, ++ { 126, "ELIBEXEC", "cannot exec a shared library directly" }, ++ { 127, "ERESTART", "interrupted system call should be restarted" }, ++ { 128, "ESTRPIPE", "streams pipe error" }, ++ { 129, "ENOMEDIUM", "no medium found" }, ++ { 130, "EMEDIUMTYPE", "wrong medium type" }, ++ { 131, "ECANCELED", "operation canceled" }, ++ { 132, "ENOKEY", "required key not available" }, ++ { 133, "EKEYEXPIRED", "key has expired" }, ++ { 134, "EKEYREVOKED", "key has been revoked" }, ++ { 135, "EKEYREJECTED", "key was rejected by service" }, ++ { 136, "EOWNERDEAD", "owner died" }, ++ { 137, "ENOTRECOVERABLE", "state not recoverable" }, ++ { 138, "ERFKILL", "operation not possible due to RF-kill" }, ++ { 139, "EHWPOISON", "memory page has hardware error" }, ++} ++ ++ ++ ++// Signal table ++var signalList = [...]struct { ++ num syscall.Signal ++ name string ++ desc string ++} { ++ { 1, "SIGHUP", "hangup" }, ++ { 2, "SIGINT", "interrupt" }, ++ { 3, "SIGQUIT", "quit" }, ++ { 4, "SIGILL", "illegal instruction" }, ++ { 5, "SIGTRAP", "trace/breakpoint trap" }, ++ { 6, "SIGABRT", "aborted" }, ++ { 7, "SIGEMT", "EMT trap" }, ++ { 8, "SIGFPE", "floating point exception" }, ++ { 9, "SIGKILL", "killed" }, ++ { 10, "SIGBUS", "bus error" }, ++ { 11, "SIGSEGV", "segmentation fault" }, ++ { 12, "SIGSYS", "bad system call" }, ++ { 13, "SIGPIPE", "broken pipe" }, ++ { 14, "SIGALRM", "alarm clock" }, ++ { 15, "SIGTERM", "terminated" }, ++ { 16, "SIGURG", "urgent I/O condition" }, ++ { 17, "SIGSTOP", "stopped (signal)" }, ++ { 18, "SIGTSTP", "stopped" }, ++ { 19, "SIGCONT", "continued" }, ++ { 20, "SIGCHLD", "child exited" }, ++ { 21, "SIGTTIN", "stopped (tty input)" }, ++ { 22, "SIGTTOU", "stopped (tty output)" }, ++ { 23, "SIGIO", "I/O possible" }, ++ { 24, "SIGXCPU", "CPU time limit exceeded" }, ++ { 25, "SIGXFSZ", "file size limit exceeded" }, ++ { 26, "SIGVTALRM", "virtual timer expired" }, ++ { 27, "SIGPROF", "profiling timer expired" }, ++ { 28, "SIGWINCH", "window changed" }, ++ { 29, "SIGINFO", "power failure" }, ++ { 30, "SIGUSR1", "user defined signal 1" }, ++ { 31, "SIGUSR2", "user defined signal 2" }, ++} ++ +diff -urN containerd-1.5.9.org/vendor/golang.org/x/sys/unix/zsyscall_linux.go containerd-1.5.9.sw/vendor/golang.org/x/sys/unix/zsyscall_linux.go +--- containerd-1.5.9.org/vendor/golang.org/x/sys/unix/zsyscall_linux.go 2024-04-18 02:22:29.520948868 +0000 ++++ containerd-1.5.9.sw/vendor/golang.org/x/sys/unix/zsyscall_linux.go 2024-04-18 02:23:50.051027493 +0000 +@@ -1,7 +1,8 @@ + // Code generated by mkmerge.go; DO NOT EDIT. + +-//go:build linux ++//go:build linux && !sw64 + // +build linux ++// +build !sw64 + + package unix + +diff -urN containerd-1.5.9.org/vendor/golang.org/x/sys/unix/zsyscall_linux_sw64.go containerd-1.5.9.sw/vendor/golang.org/x/sys/unix/zsyscall_linux_sw64.go +--- containerd-1.5.9.org/vendor/golang.org/x/sys/unix/zsyscall_linux_sw64.go 1970-01-01 00:00:00.000000000 +0000 ++++ containerd-1.5.9.sw/vendor/golang.org/x/sys/unix/zsyscall_linux_sw64.go 2024-04-18 02:28:08.361279689 +0000 +@@ -0,0 +1,2814 @@ ++// go run mksyscall.go -tags linux,sw64 syscall_linux.go syscall_linux_sw64.go ++// Code generated by the command above; see README.md. DO NOT EDIT. ++ ++//go:build linux && sw64 ++// +build linux,sw64 ++ ++package unix ++ ++import ( ++ "syscall" ++ "unsafe" ++) ++ ++var _ syscall.Errno ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func FanotifyInit(flags uint, event_f_flags uint) (fd int, err error) { ++ r0, _, e1 := Syscall(SYS_FANOTIFY_INIT, uintptr(flags), uintptr(event_f_flags), 0) ++ fd = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func fanotifyMark(fd int, flags uint, mask uint64, dirFd int, pathname *byte) (err error) { ++ _, _, e1 := Syscall6(SYS_FANOTIFY_MARK, uintptr(fd), uintptr(flags), uintptr(mask), uintptr(dirFd), uintptr(unsafe.Pointer(pathname)), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func fchmodat(dirfd int, path string, mode uint32) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ _, _, e1 := Syscall(SYS_FCHMODAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode)) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func ioctl(fd int, req uint, arg uintptr) (err error) { ++ _, _, e1 := Syscall(SYS_IOCTL, uintptr(fd), uintptr(req), uintptr(arg)) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func ioctlPtr(fd int, req uint, arg unsafe.Pointer) (err error) { ++ _, _, e1 := Syscall(SYS_IOCTL, uintptr(fd), uintptr(req), uintptr(arg)) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Linkat(olddirfd int, oldpath string, newdirfd int, newpath string, flags int) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(oldpath) ++ if err != nil { ++ return ++ } ++ var _p1 *byte ++ _p1, err = BytePtrFromString(newpath) ++ if err != nil { ++ return ++ } ++ _, _, e1 := Syscall6(SYS_LINKAT, uintptr(olddirfd), uintptr(unsafe.Pointer(_p0)), uintptr(newdirfd), uintptr(unsafe.Pointer(_p1)), uintptr(flags), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func openat(dirfd int, path string, flags int, mode uint32) (fd int, err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ r0, _, e1 := Syscall6(SYS_OPENAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(flags), uintptr(mode), 0, 0) ++ fd = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func openat2(dirfd int, path string, open_how *OpenHow, size int) (fd int, err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ r0, _, e1 := Syscall6(SYS_OPENAT2, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(open_how)), uintptr(size), 0, 0) ++ fd = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func pipe2(p *[2]_C_int, flags int) (err error) { ++ _, _, e1 := RawSyscall(SYS_PIPE2, uintptr(unsafe.Pointer(p)), uintptr(flags), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func ppoll(fds *PollFd, nfds int, timeout *Timespec, sigmask *Sigset_t) (n int, err error) { ++ r0, _, e1 := Syscall6(SYS_PPOLL, uintptr(unsafe.Pointer(fds)), uintptr(nfds), uintptr(unsafe.Pointer(timeout)), uintptr(unsafe.Pointer(sigmask)), 0, 0) ++ n = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Readlinkat(dirfd int, path string, buf []byte) (n int, err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ var _p1 unsafe.Pointer ++ if len(buf) > 0 { ++ _p1 = unsafe.Pointer(&buf[0]) ++ } else { ++ _p1 = unsafe.Pointer(&_zero) ++ } ++ r0, _, e1 := Syscall6(SYS_READLINKAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf)), 0, 0) ++ n = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Symlinkat(oldpath string, newdirfd int, newpath string) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(oldpath) ++ if err != nil { ++ return ++ } ++ var _p1 *byte ++ _p1, err = BytePtrFromString(newpath) ++ if err != nil { ++ return ++ } ++ _, _, e1 := Syscall(SYS_SYMLINKAT, uintptr(unsafe.Pointer(_p0)), uintptr(newdirfd), uintptr(unsafe.Pointer(_p1))) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Unlinkat(dirfd int, path string, flags int) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ _, _, e1 := Syscall(SYS_UNLINKAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(flags)) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func utimensat(dirfd int, path string, times *[2]Timespec, flags int) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ _, _, e1 := Syscall6(SYS_UTIMENSAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(times)), uintptr(flags), 0, 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Getcwd(buf []byte) (n int, err error) { ++ var _p0 unsafe.Pointer ++ if len(buf) > 0 { ++ _p0 = unsafe.Pointer(&buf[0]) ++ } else { ++ _p0 = unsafe.Pointer(&_zero) ++ } ++ r0, _, e1 := Syscall(SYS_GETCWD, uintptr(_p0), uintptr(len(buf)), 0) ++ n = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func wait4(pid int, wstatus *_C_int, options int, rusage *Rusage) (wpid int, err error) { ++ r0, _, e1 := Syscall6(SYS_WAIT4, uintptr(pid), uintptr(unsafe.Pointer(wstatus)), uintptr(options), uintptr(unsafe.Pointer(rusage)), 0, 0) ++ wpid = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Waitid(idType int, id int, info *Siginfo, options int, rusage *Rusage) (err error) { ++ _, _, e1 := Syscall6(SYS_WAITID, uintptr(idType), uintptr(id), uintptr(unsafe.Pointer(info)), uintptr(options), uintptr(unsafe.Pointer(rusage)), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func KeyctlInt(cmd int, arg2 int, arg3 int, arg4 int, arg5 int) (ret int, err error) { ++ r0, _, e1 := Syscall6(SYS_KEYCTL, uintptr(cmd), uintptr(arg2), uintptr(arg3), uintptr(arg4), uintptr(arg5), 0) ++ ret = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func KeyctlBuffer(cmd int, arg2 int, buf []byte, arg5 int) (ret int, err error) { ++ var _p0 unsafe.Pointer ++ if len(buf) > 0 { ++ _p0 = unsafe.Pointer(&buf[0]) ++ } else { ++ _p0 = unsafe.Pointer(&_zero) ++ } ++ r0, _, e1 := Syscall6(SYS_KEYCTL, uintptr(cmd), uintptr(arg2), uintptr(_p0), uintptr(len(buf)), uintptr(arg5), 0) ++ ret = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func keyctlJoin(cmd int, arg2 string) (ret int, err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(arg2) ++ if err != nil { ++ return ++ } ++ r0, _, e1 := Syscall(SYS_KEYCTL, uintptr(cmd), uintptr(unsafe.Pointer(_p0)), 0) ++ ret = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func keyctlSearch(cmd int, arg2 int, arg3 string, arg4 string, arg5 int) (ret int, err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(arg3) ++ if err != nil { ++ return ++ } ++ var _p1 *byte ++ _p1, err = BytePtrFromString(arg4) ++ if err != nil { ++ return ++ } ++ r0, _, e1 := Syscall6(SYS_KEYCTL, uintptr(cmd), uintptr(arg2), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(arg5), 0) ++ ret = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func keyctlIOV(cmd int, arg2 int, payload []Iovec, arg5 int) (err error) { ++ var _p0 unsafe.Pointer ++ if len(payload) > 0 { ++ _p0 = unsafe.Pointer(&payload[0]) ++ } else { ++ _p0 = unsafe.Pointer(&_zero) ++ } ++ _, _, e1 := Syscall6(SYS_KEYCTL, uintptr(cmd), uintptr(arg2), uintptr(_p0), uintptr(len(payload)), uintptr(arg5), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func keyctlDH(cmd int, arg2 *KeyctlDHParams, buf []byte) (ret int, err error) { ++ var _p0 unsafe.Pointer ++ if len(buf) > 0 { ++ _p0 = unsafe.Pointer(&buf[0]) ++ } else { ++ _p0 = unsafe.Pointer(&_zero) ++ } ++ r0, _, e1 := Syscall6(SYS_KEYCTL, uintptr(cmd), uintptr(unsafe.Pointer(arg2)), uintptr(_p0), uintptr(len(buf)), 0, 0) ++ ret = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func keyctlRestrictKeyringByType(cmd int, arg2 int, keyType string, restriction string) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(keyType) ++ if err != nil { ++ return ++ } ++ var _p1 *byte ++ _p1, err = BytePtrFromString(restriction) ++ if err != nil { ++ return ++ } ++ _, _, e1 := Syscall6(SYS_KEYCTL, uintptr(cmd), uintptr(arg2), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0, 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func keyctlRestrictKeyring(cmd int, arg2 int) (err error) { ++ _, _, e1 := Syscall(SYS_KEYCTL, uintptr(cmd), uintptr(arg2), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func ptrace(request int, pid int, addr uintptr, data uintptr) (err error) { ++ _, _, e1 := Syscall6(SYS_PTRACE, uintptr(request), uintptr(pid), uintptr(addr), uintptr(data), 0, 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func reboot(magic1 uint, magic2 uint, cmd int, arg string) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(arg) ++ if err != nil { ++ return ++ } ++ _, _, e1 := Syscall6(SYS_REBOOT, uintptr(magic1), uintptr(magic2), uintptr(cmd), uintptr(unsafe.Pointer(_p0)), 0, 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func mount(source string, target string, fstype string, flags uintptr, data *byte) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(source) ++ if err != nil { ++ return ++ } ++ var _p1 *byte ++ _p1, err = BytePtrFromString(target) ++ if err != nil { ++ return ++ } ++ var _p2 *byte ++ _p2, err = BytePtrFromString(fstype) ++ if err != nil { ++ return ++ } ++ _, _, e1 := Syscall6(SYS_MOUNT, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(unsafe.Pointer(_p2)), uintptr(flags), uintptr(unsafe.Pointer(data)), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func mountSetattr(dirfd int, pathname string, flags uint, attr *MountAttr, size uintptr) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(pathname) ++ if err != nil { ++ return ++ } ++ _, _, e1 := Syscall6(SYS_MOUNT_SETATTR, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(flags), uintptr(unsafe.Pointer(attr)), uintptr(size), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Acct(path string) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ _, _, e1 := Syscall(SYS_ACCT, uintptr(unsafe.Pointer(_p0)), 0, 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func AddKey(keyType string, description string, payload []byte, ringid int) (id int, err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(keyType) ++ if err != nil { ++ return ++ } ++ var _p1 *byte ++ _p1, err = BytePtrFromString(description) ++ if err != nil { ++ return ++ } ++ var _p2 unsafe.Pointer ++ if len(payload) > 0 { ++ _p2 = unsafe.Pointer(&payload[0]) ++ } else { ++ _p2 = unsafe.Pointer(&_zero) ++ } ++ r0, _, e1 := Syscall6(SYS_ADD_KEY, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(_p2), uintptr(len(payload)), uintptr(ringid), 0) ++ id = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Adjtimex(buf *Timex) (state int, err error) { ++ r0, _, e1 := Syscall(SYS_ADJTIMEX, uintptr(unsafe.Pointer(buf)), 0, 0) ++ state = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Capget(hdr *CapUserHeader, data *CapUserData) (err error) { ++ _, _, e1 := RawSyscall(SYS_CAPGET, uintptr(unsafe.Pointer(hdr)), uintptr(unsafe.Pointer(data)), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Capset(hdr *CapUserHeader, data *CapUserData) (err error) { ++ _, _, e1 := RawSyscall(SYS_CAPSET, uintptr(unsafe.Pointer(hdr)), uintptr(unsafe.Pointer(data)), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Chdir(path string) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ _, _, e1 := Syscall(SYS_CHDIR, uintptr(unsafe.Pointer(_p0)), 0, 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Chroot(path string) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ _, _, e1 := Syscall(SYS_CHROOT, uintptr(unsafe.Pointer(_p0)), 0, 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func ClockGetres(clockid int32, res *Timespec) (err error) { ++ _, _, e1 := Syscall(SYS_CLOCK_GETRES, uintptr(clockid), uintptr(unsafe.Pointer(res)), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func ClockGettime(clockid int32, time *Timespec) (err error) { ++ _, _, e1 := Syscall(SYS_CLOCK_GETTIME, uintptr(clockid), uintptr(unsafe.Pointer(time)), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func ClockNanosleep(clockid int32, flags int, request *Timespec, remain *Timespec) (err error) { ++ _, _, e1 := Syscall6(SYS_CLOCK_NANOSLEEP, uintptr(clockid), uintptr(flags), uintptr(unsafe.Pointer(request)), uintptr(unsafe.Pointer(remain)), 0, 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Close(fd int) (err error) { ++ _, _, e1 := Syscall(SYS_CLOSE, uintptr(fd), 0, 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func CloseRange(first uint, last uint, flags uint) (err error) { ++ _, _, e1 := Syscall(SYS_CLOSE_RANGE, uintptr(first), uintptr(last), uintptr(flags)) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func CopyFileRange(rfd int, roff *int64, wfd int, woff *int64, len int, flags int) (n int, err error) { ++ r0, _, e1 := Syscall6(SYS_COPY_FILE_RANGE, uintptr(rfd), uintptr(unsafe.Pointer(roff)), uintptr(wfd), uintptr(unsafe.Pointer(woff)), uintptr(len), uintptr(flags)) ++ n = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func DeleteModule(name string, flags int) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(name) ++ if err != nil { ++ return ++ } ++ _, _, e1 := Syscall(SYS_DELETE_MODULE, uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Dup(oldfd int) (fd int, err error) { ++ r0, _, e1 := Syscall(SYS_DUP, uintptr(oldfd), 0, 0) ++ fd = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Dup3(oldfd int, newfd int, flags int) (err error) { ++ _, _, e1 := Syscall(SYS_DUP3, uintptr(oldfd), uintptr(newfd), uintptr(flags)) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func EpollCreate1(flag int) (fd int, err error) { ++ r0, _, e1 := RawSyscall(SYS_EPOLL_CREATE1, uintptr(flag), 0, 0) ++ fd = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func EpollCtl(epfd int, op int, fd int, event *EpollEvent) (err error) { ++ _, _, e1 := RawSyscall6(SYS_EPOLL_CTL, uintptr(epfd), uintptr(op), uintptr(fd), uintptr(unsafe.Pointer(event)), 0, 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Eventfd(initval uint, flags int) (fd int, err error) { ++ r0, _, e1 := Syscall(SYS_EVENTFD2, uintptr(initval), uintptr(flags), 0) ++ fd = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Exit(code int) { ++ SyscallNoError(SYS_EXIT_GROUP, uintptr(code), 0, 0) ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Fallocate(fd int, mode uint32, off int64, len int64) (err error) { ++ _, _, e1 := Syscall6(SYS_FALLOCATE, uintptr(fd), uintptr(mode), uintptr(off), uintptr(len), 0, 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Fchdir(fd int) (err error) { ++ _, _, e1 := Syscall(SYS_FCHDIR, uintptr(fd), 0, 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Fchmod(fd int, mode uint32) (err error) { ++ _, _, e1 := Syscall(SYS_FCHMOD, uintptr(fd), uintptr(mode), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Fchownat(dirfd int, path string, uid int, gid int, flags int) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ _, _, e1 := Syscall6(SYS_FCHOWNAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid), uintptr(flags), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Fdatasync(fd int) (err error) { ++ _, _, e1 := Syscall(SYS_FDATASYNC, uintptr(fd), 0, 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Fgetxattr(fd int, attr string, dest []byte) (sz int, err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(attr) ++ if err != nil { ++ return ++ } ++ var _p1 unsafe.Pointer ++ if len(dest) > 0 { ++ _p1 = unsafe.Pointer(&dest[0]) ++ } else { ++ _p1 = unsafe.Pointer(&_zero) ++ } ++ r0, _, e1 := Syscall6(SYS_FGETXATTR, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(dest)), 0, 0) ++ sz = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func FinitModule(fd int, params string, flags int) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(params) ++ if err != nil { ++ return ++ } ++ _, _, e1 := Syscall(SYS_FINIT_MODULE, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(flags)) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Flistxattr(fd int, dest []byte) (sz int, err error) { ++ var _p0 unsafe.Pointer ++ if len(dest) > 0 { ++ _p0 = unsafe.Pointer(&dest[0]) ++ } else { ++ _p0 = unsafe.Pointer(&_zero) ++ } ++ r0, _, e1 := Syscall(SYS_FLISTXATTR, uintptr(fd), uintptr(_p0), uintptr(len(dest))) ++ sz = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Flock(fd int, how int) (err error) { ++ _, _, e1 := Syscall(SYS_FLOCK, uintptr(fd), uintptr(how), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Fremovexattr(fd int, attr string) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(attr) ++ if err != nil { ++ return ++ } ++ _, _, e1 := Syscall(SYS_FREMOVEXATTR, uintptr(fd), uintptr(unsafe.Pointer(_p0)), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Fsetxattr(fd int, attr string, dest []byte, flags int) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(attr) ++ if err != nil { ++ return ++ } ++ var _p1 unsafe.Pointer ++ if len(dest) > 0 { ++ _p1 = unsafe.Pointer(&dest[0]) ++ } else { ++ _p1 = unsafe.Pointer(&_zero) ++ } ++ _, _, e1 := Syscall6(SYS_FSETXATTR, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(dest)), uintptr(flags), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Fsync(fd int) (err error) { ++ _, _, e1 := Syscall(SYS_FSYNC, uintptr(fd), 0, 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Fsmount(fd int, flags int, mountAttrs int) (fsfd int, err error) { ++ r0, _, e1 := Syscall(SYS_FSMOUNT, uintptr(fd), uintptr(flags), uintptr(mountAttrs)) ++ fsfd = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Fsopen(fsName string, flags int) (fd int, err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(fsName) ++ if err != nil { ++ return ++ } ++ r0, _, e1 := Syscall(SYS_FSOPEN, uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0) ++ fd = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Fspick(dirfd int, pathName string, flags int) (fd int, err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(pathName) ++ if err != nil { ++ return ++ } ++ r0, _, e1 := Syscall(SYS_FSPICK, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(flags)) ++ fd = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Getdents(fd int, buf []byte) (n int, err error) { ++ var _p0 unsafe.Pointer ++ if len(buf) > 0 { ++ _p0 = unsafe.Pointer(&buf[0]) ++ } else { ++ _p0 = unsafe.Pointer(&_zero) ++ } ++ r0, _, e1 := Syscall(SYS_GETDENTS64, uintptr(fd), uintptr(_p0), uintptr(len(buf))) ++ n = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Getpgid(pid int) (pgid int, err error) { ++ r0, _, e1 := RawSyscall(SYS_GETPGID, uintptr(pid), 0, 0) ++ pgid = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Getpriority(which int, who int) (prio int, err error) { ++ r0, _, e1 := Syscall(SYS_GETPRIORITY, uintptr(which), uintptr(who), 0) ++ prio = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Getrandom(buf []byte, flags int) (n int, err error) { ++ var _p0 unsafe.Pointer ++ if len(buf) > 0 { ++ _p0 = unsafe.Pointer(&buf[0]) ++ } else { ++ _p0 = unsafe.Pointer(&_zero) ++ } ++ r0, _, e1 := Syscall(SYS_GETRANDOM, uintptr(_p0), uintptr(len(buf)), uintptr(flags)) ++ n = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Getrusage(who int, rusage *Rusage) (err error) { ++ _, _, e1 := RawSyscall(SYS_GETRUSAGE, uintptr(who), uintptr(unsafe.Pointer(rusage)), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Getsid(pid int) (sid int, err error) { ++ r0, _, e1 := RawSyscall(SYS_GETSID, uintptr(pid), 0, 0) ++ sid = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Gettid() (tid int) { ++ r0, _ := RawSyscallNoError(SYS_GETTID, 0, 0, 0) ++ tid = int(r0) ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Getxattr(path string, attr string, dest []byte) (sz int, err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ var _p1 *byte ++ _p1, err = BytePtrFromString(attr) ++ if err != nil { ++ return ++ } ++ var _p2 unsafe.Pointer ++ if len(dest) > 0 { ++ _p2 = unsafe.Pointer(&dest[0]) ++ } else { ++ _p2 = unsafe.Pointer(&_zero) ++ } ++ r0, _, e1 := Syscall6(SYS_GETXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(_p2), uintptr(len(dest)), 0, 0) ++ sz = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func InitModule(moduleImage []byte, params string) (err error) { ++ var _p0 unsafe.Pointer ++ if len(moduleImage) > 0 { ++ _p0 = unsafe.Pointer(&moduleImage[0]) ++ } else { ++ _p0 = unsafe.Pointer(&_zero) ++ } ++ var _p1 *byte ++ _p1, err = BytePtrFromString(params) ++ if err != nil { ++ return ++ } ++ _, _, e1 := Syscall(SYS_INIT_MODULE, uintptr(_p0), uintptr(len(moduleImage)), uintptr(unsafe.Pointer(_p1))) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func InotifyAddWatch(fd int, pathname string, mask uint32) (watchdesc int, err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(pathname) ++ if err != nil { ++ return ++ } ++ r0, _, e1 := Syscall(SYS_INOTIFY_ADD_WATCH, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(mask)) ++ watchdesc = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func InotifyInit1(flags int) (fd int, err error) { ++ r0, _, e1 := RawSyscall(SYS_INOTIFY_INIT1, uintptr(flags), 0, 0) ++ fd = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func InotifyRmWatch(fd int, watchdesc uint32) (success int, err error) { ++ r0, _, e1 := RawSyscall(SYS_INOTIFY_RM_WATCH, uintptr(fd), uintptr(watchdesc), 0) ++ success = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Kill(pid int, sig syscall.Signal) (err error) { ++ _, _, e1 := RawSyscall(SYS_KILL, uintptr(pid), uintptr(sig), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Klogctl(typ int, buf []byte) (n int, err error) { ++ var _p0 unsafe.Pointer ++ if len(buf) > 0 { ++ _p0 = unsafe.Pointer(&buf[0]) ++ } else { ++ _p0 = unsafe.Pointer(&_zero) ++ } ++ r0, _, e1 := Syscall(SYS_SYSLOG, uintptr(typ), uintptr(_p0), uintptr(len(buf))) ++ n = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Lgetxattr(path string, attr string, dest []byte) (sz int, err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ var _p1 *byte ++ _p1, err = BytePtrFromString(attr) ++ if err != nil { ++ return ++ } ++ var _p2 unsafe.Pointer ++ if len(dest) > 0 { ++ _p2 = unsafe.Pointer(&dest[0]) ++ } else { ++ _p2 = unsafe.Pointer(&_zero) ++ } ++ r0, _, e1 := Syscall6(SYS_LGETXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(_p2), uintptr(len(dest)), 0, 0) ++ sz = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Listxattr(path string, dest []byte) (sz int, err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ var _p1 unsafe.Pointer ++ if len(dest) > 0 { ++ _p1 = unsafe.Pointer(&dest[0]) ++ } else { ++ _p1 = unsafe.Pointer(&_zero) ++ } ++ r0, _, e1 := Syscall(SYS_LISTXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(dest))) ++ sz = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Llistxattr(path string, dest []byte) (sz int, err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ var _p1 unsafe.Pointer ++ if len(dest) > 0 { ++ _p1 = unsafe.Pointer(&dest[0]) ++ } else { ++ _p1 = unsafe.Pointer(&_zero) ++ } ++ r0, _, e1 := Syscall(SYS_LLISTXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(dest))) ++ sz = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Lremovexattr(path string, attr string) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ var _p1 *byte ++ _p1, err = BytePtrFromString(attr) ++ if err != nil { ++ return ++ } ++ _, _, e1 := Syscall(SYS_LREMOVEXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Lsetxattr(path string, attr string, data []byte, flags int) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ var _p1 *byte ++ _p1, err = BytePtrFromString(attr) ++ if err != nil { ++ return ++ } ++ var _p2 unsafe.Pointer ++ if len(data) > 0 { ++ _p2 = unsafe.Pointer(&data[0]) ++ } else { ++ _p2 = unsafe.Pointer(&_zero) ++ } ++ _, _, e1 := Syscall6(SYS_LSETXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(_p2), uintptr(len(data)), uintptr(flags), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func MemfdCreate(name string, flags int) (fd int, err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(name) ++ if err != nil { ++ return ++ } ++ r0, _, e1 := Syscall(SYS_MEMFD_CREATE, uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0) ++ fd = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Mkdirat(dirfd int, path string, mode uint32) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ _, _, e1 := Syscall(SYS_MKDIRAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode)) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Mknodat(dirfd int, path string, mode uint32, dev int) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ _, _, e1 := Syscall6(SYS_MKNODAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(dev), 0, 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func MoveMount(fromDirfd int, fromPathName string, toDirfd int, toPathName string, flags int) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(fromPathName) ++ if err != nil { ++ return ++ } ++ var _p1 *byte ++ _p1, err = BytePtrFromString(toPathName) ++ if err != nil { ++ return ++ } ++ _, _, e1 := Syscall6(SYS_MOVE_MOUNT, uintptr(fromDirfd), uintptr(unsafe.Pointer(_p0)), uintptr(toDirfd), uintptr(unsafe.Pointer(_p1)), uintptr(flags), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Nanosleep(time *Timespec, leftover *Timespec) (err error) { ++ _, _, e1 := Syscall(SYS_NANOSLEEP, uintptr(unsafe.Pointer(time)), uintptr(unsafe.Pointer(leftover)), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func OpenTree(dfd int, fileName string, flags uint) (r int, err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(fileName) ++ if err != nil { ++ return ++ } ++ r0, _, e1 := Syscall(SYS_OPEN_TREE, uintptr(dfd), uintptr(unsafe.Pointer(_p0)), uintptr(flags)) ++ r = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func PerfEventOpen(attr *PerfEventAttr, pid int, cpu int, groupFd int, flags int) (fd int, err error) { ++ r0, _, e1 := Syscall6(SYS_PERF_EVENT_OPEN, uintptr(unsafe.Pointer(attr)), uintptr(pid), uintptr(cpu), uintptr(groupFd), uintptr(flags), 0) ++ fd = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func PivotRoot(newroot string, putold string) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(newroot) ++ if err != nil { ++ return ++ } ++ var _p1 *byte ++ _p1, err = BytePtrFromString(putold) ++ if err != nil { ++ return ++ } ++ _, _, e1 := Syscall(SYS_PIVOT_ROOT, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Prlimit(pid int, resource int, newlimit *Rlimit, old *Rlimit) (err error) { ++ _, _, e1 := RawSyscall6(SYS_PRLIMIT64, uintptr(pid), uintptr(resource), uintptr(unsafe.Pointer(newlimit)), uintptr(unsafe.Pointer(old)), 0, 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Prctl(option int, arg2 uintptr, arg3 uintptr, arg4 uintptr, arg5 uintptr) (err error) { ++ _, _, e1 := Syscall6(SYS_PRCTL, uintptr(option), uintptr(arg2), uintptr(arg3), uintptr(arg4), uintptr(arg5), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Pselect(nfd int, r *FdSet, w *FdSet, e *FdSet, timeout *Timespec, sigmask *Sigset_t) (n int, err error) { ++ r0, _, e1 := Syscall6(SYS_PSELECT6, uintptr(nfd), uintptr(unsafe.Pointer(r)), uintptr(unsafe.Pointer(w)), uintptr(unsafe.Pointer(e)), uintptr(unsafe.Pointer(timeout)), uintptr(unsafe.Pointer(sigmask))) ++ n = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func read(fd int, p []byte) (n int, err error) { ++ var _p0 unsafe.Pointer ++ if len(p) > 0 { ++ _p0 = unsafe.Pointer(&p[0]) ++ } else { ++ _p0 = unsafe.Pointer(&_zero) ++ } ++ r0, _, e1 := Syscall(SYS_READ, uintptr(fd), uintptr(_p0), uintptr(len(p))) ++ n = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Removexattr(path string, attr string) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ var _p1 *byte ++ _p1, err = BytePtrFromString(attr) ++ if err != nil { ++ return ++ } ++ _, _, e1 := Syscall(SYS_REMOVEXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Renameat2(olddirfd int, oldpath string, newdirfd int, newpath string, flags uint) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(oldpath) ++ if err != nil { ++ return ++ } ++ var _p1 *byte ++ _p1, err = BytePtrFromString(newpath) ++ if err != nil { ++ return ++ } ++ _, _, e1 := Syscall6(SYS_RENAMEAT2, uintptr(olddirfd), uintptr(unsafe.Pointer(_p0)), uintptr(newdirfd), uintptr(unsafe.Pointer(_p1)), uintptr(flags), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func RequestKey(keyType string, description string, callback string, destRingid int) (id int, err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(keyType) ++ if err != nil { ++ return ++ } ++ var _p1 *byte ++ _p1, err = BytePtrFromString(description) ++ if err != nil { ++ return ++ } ++ var _p2 *byte ++ _p2, err = BytePtrFromString(callback) ++ if err != nil { ++ return ++ } ++ r0, _, e1 := Syscall6(SYS_REQUEST_KEY, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(unsafe.Pointer(_p2)), uintptr(destRingid), 0, 0) ++ id = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Setdomainname(p []byte) (err error) { ++ var _p0 unsafe.Pointer ++ if len(p) > 0 { ++ _p0 = unsafe.Pointer(&p[0]) ++ } else { ++ _p0 = unsafe.Pointer(&_zero) ++ } ++ _, _, e1 := Syscall(SYS_SETDOMAINNAME, uintptr(_p0), uintptr(len(p)), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Sethostname(p []byte) (err error) { ++ var _p0 unsafe.Pointer ++ if len(p) > 0 { ++ _p0 = unsafe.Pointer(&p[0]) ++ } else { ++ _p0 = unsafe.Pointer(&_zero) ++ } ++ _, _, e1 := Syscall(SYS_SETHOSTNAME, uintptr(_p0), uintptr(len(p)), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Setpgid(pid int, pgid int) (err error) { ++ _, _, e1 := RawSyscall(SYS_SETPGID, uintptr(pid), uintptr(pgid), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Setsid() (pid int, err error) { ++ r0, _, e1 := RawSyscall(SYS_SETSID, 0, 0, 0) ++ pid = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Settimeofday(tv *Timeval) (err error) { ++ _, _, e1 := RawSyscall(SYS_SETTIMEOFDAY, uintptr(unsafe.Pointer(tv)), 0, 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Setns(fd int, nstype int) (err error) { ++ _, _, e1 := Syscall(SYS_SETNS, uintptr(fd), uintptr(nstype), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Setpriority(which int, who int, prio int) (err error) { ++ _, _, e1 := Syscall(SYS_SETPRIORITY, uintptr(which), uintptr(who), uintptr(prio)) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Setxattr(path string, attr string, data []byte, flags int) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ var _p1 *byte ++ _p1, err = BytePtrFromString(attr) ++ if err != nil { ++ return ++ } ++ var _p2 unsafe.Pointer ++ if len(data) > 0 { ++ _p2 = unsafe.Pointer(&data[0]) ++ } else { ++ _p2 = unsafe.Pointer(&_zero) ++ } ++ _, _, e1 := Syscall6(SYS_SETXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(_p2), uintptr(len(data)), uintptr(flags), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func signalfd(fd int, sigmask *Sigset_t, maskSize uintptr, flags int) (newfd int, err error) { ++ r0, _, e1 := Syscall6(SYS_SIGNALFD4, uintptr(fd), uintptr(unsafe.Pointer(sigmask)), uintptr(maskSize), uintptr(flags), 0, 0) ++ newfd = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Statx(dirfd int, path string, flags int, mask int, stat *Statx_t) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ _, _, e1 := Syscall6(SYS_STATX, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(flags), uintptr(mask), uintptr(unsafe.Pointer(stat)), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Sync() { ++ SyscallNoError(SYS_SYNC, 0, 0, 0) ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Syncfs(fd int) (err error) { ++ _, _, e1 := Syscall(SYS_SYNCFS, uintptr(fd), 0, 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Sysinfo(info *Sysinfo_t) (err error) { ++ _, _, e1 := RawSyscall(SYS_SYSINFO, uintptr(unsafe.Pointer(info)), 0, 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Tee(rfd int, wfd int, len int, flags int) (n int64, err error) { ++ r0, _, e1 := Syscall6(SYS_TEE, uintptr(rfd), uintptr(wfd), uintptr(len), uintptr(flags), 0, 0) ++ n = int64(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func TimerfdCreate(clockid int, flags int) (fd int, err error) { ++ r0, _, e1 := RawSyscall(SYS_TIMERFD_CREATE, uintptr(clockid), uintptr(flags), 0) ++ fd = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func TimerfdGettime(fd int, currValue *ItimerSpec) (err error) { ++ _, _, e1 := RawSyscall(SYS_TIMERFD_GETTIME, uintptr(fd), uintptr(unsafe.Pointer(currValue)), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func TimerfdSettime(fd int, flags int, newValue *ItimerSpec, oldValue *ItimerSpec) (err error) { ++ _, _, e1 := RawSyscall6(SYS_TIMERFD_SETTIME, uintptr(fd), uintptr(flags), uintptr(unsafe.Pointer(newValue)), uintptr(unsafe.Pointer(oldValue)), 0, 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Tgkill(tgid int, tid int, sig syscall.Signal) (err error) { ++ _, _, e1 := RawSyscall(SYS_TGKILL, uintptr(tgid), uintptr(tid), uintptr(sig)) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Times(tms *Tms) (ticks uintptr, err error) { ++ r0, _, e1 := RawSyscall(SYS_TIMES, uintptr(unsafe.Pointer(tms)), 0, 0) ++ ticks = uintptr(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Umask(mask int) (oldmask int) { ++ r0, _ := RawSyscallNoError(SYS_UMASK, uintptr(mask), 0, 0) ++ oldmask = int(r0) ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Uname(buf *Utsname) (err error) { ++ _, _, e1 := RawSyscall(SYS_UNAME, uintptr(unsafe.Pointer(buf)), 0, 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Unmount(target string, flags int) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(target) ++ if err != nil { ++ return ++ } ++ _, _, e1 := Syscall(SYS_UMOUNT2, uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Unshare(flags int) (err error) { ++ _, _, e1 := Syscall(SYS_UNSHARE, uintptr(flags), 0, 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func write(fd int, p []byte) (n int, err error) { ++ var _p0 unsafe.Pointer ++ if len(p) > 0 { ++ _p0 = unsafe.Pointer(&p[0]) ++ } else { ++ _p0 = unsafe.Pointer(&_zero) ++ } ++ r0, _, e1 := Syscall(SYS_WRITE, uintptr(fd), uintptr(_p0), uintptr(len(p))) ++ n = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func exitThread(code int) (err error) { ++ _, _, e1 := Syscall(SYS_EXIT, uintptr(code), 0, 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func readlen(fd int, p *byte, np int) (n int, err error) { ++ r0, _, e1 := Syscall(SYS_READ, uintptr(fd), uintptr(unsafe.Pointer(p)), uintptr(np)) ++ n = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func writelen(fd int, p *byte, np int) (n int, err error) { ++ r0, _, e1 := Syscall(SYS_WRITE, uintptr(fd), uintptr(unsafe.Pointer(p)), uintptr(np)) ++ n = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func readv(fd int, iovs []Iovec) (n int, err error) { ++ var _p0 unsafe.Pointer ++ if len(iovs) > 0 { ++ _p0 = unsafe.Pointer(&iovs[0]) ++ } else { ++ _p0 = unsafe.Pointer(&_zero) ++ } ++ r0, _, e1 := Syscall(SYS_READV, uintptr(fd), uintptr(_p0), uintptr(len(iovs))) ++ n = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func writev(fd int, iovs []Iovec) (n int, err error) { ++ var _p0 unsafe.Pointer ++ if len(iovs) > 0 { ++ _p0 = unsafe.Pointer(&iovs[0]) ++ } else { ++ _p0 = unsafe.Pointer(&_zero) ++ } ++ r0, _, e1 := Syscall(SYS_WRITEV, uintptr(fd), uintptr(_p0), uintptr(len(iovs))) ++ n = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func preadv(fd int, iovs []Iovec, offs_l uintptr, offs_h uintptr) (n int, err error) { ++ var _p0 unsafe.Pointer ++ if len(iovs) > 0 { ++ _p0 = unsafe.Pointer(&iovs[0]) ++ } else { ++ _p0 = unsafe.Pointer(&_zero) ++ } ++ r0, _, e1 := Syscall6(SYS_PREADV, uintptr(fd), uintptr(_p0), uintptr(len(iovs)), uintptr(offs_l), uintptr(offs_h), 0) ++ n = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func pwritev(fd int, iovs []Iovec, offs_l uintptr, offs_h uintptr) (n int, err error) { ++ var _p0 unsafe.Pointer ++ if len(iovs) > 0 { ++ _p0 = unsafe.Pointer(&iovs[0]) ++ } else { ++ _p0 = unsafe.Pointer(&_zero) ++ } ++ r0, _, e1 := Syscall6(SYS_PWRITEV, uintptr(fd), uintptr(_p0), uintptr(len(iovs)), uintptr(offs_l), uintptr(offs_h), 0) ++ n = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func preadv2(fd int, iovs []Iovec, offs_l uintptr, offs_h uintptr, flags int) (n int, err error) { ++ var _p0 unsafe.Pointer ++ if len(iovs) > 0 { ++ _p0 = unsafe.Pointer(&iovs[0]) ++ } else { ++ _p0 = unsafe.Pointer(&_zero) ++ } ++ r0, _, e1 := Syscall6(SYS_PREADV2, uintptr(fd), uintptr(_p0), uintptr(len(iovs)), uintptr(offs_l), uintptr(offs_h), uintptr(flags)) ++ n = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func pwritev2(fd int, iovs []Iovec, offs_l uintptr, offs_h uintptr, flags int) (n int, err error) { ++ var _p0 unsafe.Pointer ++ if len(iovs) > 0 { ++ _p0 = unsafe.Pointer(&iovs[0]) ++ } else { ++ _p0 = unsafe.Pointer(&_zero) ++ } ++ r0, _, e1 := Syscall6(SYS_PWRITEV2, uintptr(fd), uintptr(_p0), uintptr(len(iovs)), uintptr(offs_l), uintptr(offs_h), uintptr(flags)) ++ n = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func munmap(addr uintptr, length uintptr) (err error) { ++ _, _, e1 := Syscall(SYS_MUNMAP, uintptr(addr), uintptr(length), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Madvise(b []byte, advice int) (err error) { ++ var _p0 unsafe.Pointer ++ if len(b) > 0 { ++ _p0 = unsafe.Pointer(&b[0]) ++ } else { ++ _p0 = unsafe.Pointer(&_zero) ++ } ++ _, _, e1 := Syscall(SYS_MADVISE, uintptr(_p0), uintptr(len(b)), uintptr(advice)) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Mprotect(b []byte, prot int) (err error) { ++ var _p0 unsafe.Pointer ++ if len(b) > 0 { ++ _p0 = unsafe.Pointer(&b[0]) ++ } else { ++ _p0 = unsafe.Pointer(&_zero) ++ } ++ _, _, e1 := Syscall(SYS_MPROTECT, uintptr(_p0), uintptr(len(b)), uintptr(prot)) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Mlock(b []byte) (err error) { ++ var _p0 unsafe.Pointer ++ if len(b) > 0 { ++ _p0 = unsafe.Pointer(&b[0]) ++ } else { ++ _p0 = unsafe.Pointer(&_zero) ++ } ++ _, _, e1 := Syscall(SYS_MLOCK, uintptr(_p0), uintptr(len(b)), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Mlockall(flags int) (err error) { ++ _, _, e1 := Syscall(SYS_MLOCKALL, uintptr(flags), 0, 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Msync(b []byte, flags int) (err error) { ++ var _p0 unsafe.Pointer ++ if len(b) > 0 { ++ _p0 = unsafe.Pointer(&b[0]) ++ } else { ++ _p0 = unsafe.Pointer(&_zero) ++ } ++ _, _, e1 := Syscall(SYS_MSYNC, uintptr(_p0), uintptr(len(b)), uintptr(flags)) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Munlock(b []byte) (err error) { ++ var _p0 unsafe.Pointer ++ if len(b) > 0 { ++ _p0 = unsafe.Pointer(&b[0]) ++ } else { ++ _p0 = unsafe.Pointer(&_zero) ++ } ++ _, _, e1 := Syscall(SYS_MUNLOCK, uintptr(_p0), uintptr(len(b)), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Munlockall() (err error) { ++ _, _, e1 := Syscall(SYS_MUNLOCKALL, 0, 0, 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func faccessat(dirfd int, path string, mode uint32) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ _, _, e1 := Syscall(SYS_FACCESSAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode)) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Faccessat2(dirfd int, path string, mode uint32, flags int) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ _, _, e1 := Syscall6(SYS_FACCESSAT2, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(flags), 0, 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func nameToHandleAt(dirFD int, pathname string, fh *fileHandle, mountID *_C_int, flags int) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(pathname) ++ if err != nil { ++ return ++ } ++ _, _, e1 := Syscall6(SYS_NAME_TO_HANDLE_AT, uintptr(dirFD), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(fh)), uintptr(unsafe.Pointer(mountID)), uintptr(flags), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func openByHandleAt(mountFD int, fh *fileHandle, flags int) (fd int, err error) { ++ r0, _, e1 := Syscall(SYS_OPEN_BY_HANDLE_AT, uintptr(mountFD), uintptr(unsafe.Pointer(fh)), uintptr(flags)) ++ fd = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func ProcessVMReadv(pid int, localIov []Iovec, remoteIov []RemoteIovec, flags uint) (n int, err error) { ++ var _p0 unsafe.Pointer ++ if len(localIov) > 0 { ++ _p0 = unsafe.Pointer(&localIov[0]) ++ } else { ++ _p0 = unsafe.Pointer(&_zero) ++ } ++ var _p1 unsafe.Pointer ++ if len(remoteIov) > 0 { ++ _p1 = unsafe.Pointer(&remoteIov[0]) ++ } else { ++ _p1 = unsafe.Pointer(&_zero) ++ } ++ r0, _, e1 := Syscall6(SYS_PROCESS_VM_READV, uintptr(pid), uintptr(_p0), uintptr(len(localIov)), uintptr(_p1), uintptr(len(remoteIov)), uintptr(flags)) ++ n = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func ProcessVMWritev(pid int, localIov []Iovec, remoteIov []RemoteIovec, flags uint) (n int, err error) { ++ var _p0 unsafe.Pointer ++ if len(localIov) > 0 { ++ _p0 = unsafe.Pointer(&localIov[0]) ++ } else { ++ _p0 = unsafe.Pointer(&_zero) ++ } ++ var _p1 unsafe.Pointer ++ if len(remoteIov) > 0 { ++ _p1 = unsafe.Pointer(&remoteIov[0]) ++ } else { ++ _p1 = unsafe.Pointer(&_zero) ++ } ++ r0, _, e1 := Syscall6(SYS_PROCESS_VM_WRITEV, uintptr(pid), uintptr(_p0), uintptr(len(localIov)), uintptr(_p1), uintptr(len(remoteIov)), uintptr(flags)) ++ n = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func PidfdOpen(pid int, flags int) (fd int, err error) { ++ r0, _, e1 := Syscall(SYS_PIDFD_OPEN, uintptr(pid), uintptr(flags), 0) ++ fd = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func PidfdGetfd(pidfd int, targetfd int, flags int) (fd int, err error) { ++ r0, _, e1 := Syscall(SYS_PIDFD_GETFD, uintptr(pidfd), uintptr(targetfd), uintptr(flags)) ++ fd = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func PidfdSendSignal(pidfd int, sig Signal, info *Siginfo, flags int) (err error) { ++ _, _, e1 := Syscall6(SYS_PIDFD_SEND_SIGNAL, uintptr(pidfd), uintptr(sig), uintptr(unsafe.Pointer(info)), uintptr(flags), 0, 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func shmat(id int, addr uintptr, flag int) (ret uintptr, err error) { ++ r0, _, e1 := Syscall(SYS_SHMAT, uintptr(id), uintptr(addr), uintptr(flag)) ++ ret = uintptr(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func shmctl(id int, cmd int, buf *SysvShmDesc) (result int, err error) { ++ r0, _, e1 := Syscall(SYS_SHMCTL, uintptr(id), uintptr(cmd), uintptr(unsafe.Pointer(buf))) ++ result = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func shmdt(addr uintptr) (err error) { ++ _, _, e1 := Syscall(SYS_SHMDT, uintptr(addr), 0, 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func shmget(key int, size int, flag int) (id int, err error) { ++ r0, _, e1 := Syscall(SYS_SHMGET, uintptr(key), uintptr(size), uintptr(flag)) ++ id = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func getitimer(which int, currValue *Itimerval) (err error) { ++ _, _, e1 := Syscall(SYS_GETITIMER, uintptr(which), uintptr(unsafe.Pointer(currValue)), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func setitimer(which int, newValue *Itimerval, oldValue *Itimerval) (err error) { ++ _, _, e1 := Syscall(SYS_SETITIMER, uintptr(which), uintptr(unsafe.Pointer(newValue)), uintptr(unsafe.Pointer(oldValue))) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func rtSigprocmask(how int, set *Sigset_t, oldset *Sigset_t, sigsetsize uintptr) (err error) { ++ _, _, e1 := RawSyscall6(SYS_RT_SIGPROCMASK, uintptr(how), uintptr(unsafe.Pointer(set)), uintptr(unsafe.Pointer(oldset)), uintptr(sigsetsize), 0, 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func getxpid() (pid int, ppid int) { ++ r0, r1 := RawSyscallNoError(SYS_GETXPID, 0, 0, 0) ++ pid = int(r0) ++ ppid = int(r1) ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Fstat64(fd int, st *Stat_t) (err error) { ++ _, _, e1 := Syscall(SYS_FSTAT64, uintptr(fd), uintptr(unsafe.Pointer(st)), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Lstat64(path string, st *Stat_t) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ _, _, e1 := Syscall(SYS_LSTAT64, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(st)), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Stat64(path string, st *Stat_t) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ _, _, e1 := Syscall(SYS_STAT64, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(st)), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func getxuid() (uid int, euid int) { ++ r0, r1 := SyscallNoError(SYS_GETXUID, 0, 0, 0) ++ uid = int(r0) ++ euid = int(r1) ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func getxgid() (gid int, egid int) { ++ r0, r1 := SyscallNoError(SYS_GETXGID, 0, 0, 0) ++ gid = int(r0) ++ egid = int(r1) ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Statfs(path string, buf *Statfs_t) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ _, _, e1 := Syscall(SYS_STATFS, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(buf)), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Fstatfs(fd int, buf *Statfs_t) (err error) { ++ _, _, e1 := Syscall(SYS_FSTATFS, uintptr(fd), uintptr(unsafe.Pointer(buf)), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Fchown(fd int, uid int, gid int) (err error) { ++ _, _, e1 := Syscall(SYS_FCHOWN, uintptr(fd), uintptr(uid), uintptr(gid)) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Ftruncate(fd int, length int64) (err error) { ++ _, _, e1 := Syscall(SYS_FTRUNCATE, uintptr(fd), uintptr(length), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Getrlimit(resource int, rlim *Rlimit) (err error) { ++ _, _, e1 := RawSyscall(SYS_GETRLIMIT, uintptr(resource), uintptr(unsafe.Pointer(rlim)), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Lchown(path string, uid int, gid int) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ _, _, e1 := Syscall(SYS_LCHOWN, uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid)) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Listen(s int, n int) (err error) { ++ _, _, e1 := Syscall(SYS_LISTEN, uintptr(s), uintptr(n), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Pread(fd int, p []byte, offset int64) (n int, err error) { ++ var _p0 unsafe.Pointer ++ if len(p) > 0 { ++ _p0 = unsafe.Pointer(&p[0]) ++ } else { ++ _p0 = unsafe.Pointer(&_zero) ++ } ++ r0, _, e1 := Syscall6(SYS_PREAD64, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), 0, 0) ++ n = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Pwrite(fd int, p []byte, offset int64) (n int, err error) { ++ var _p0 unsafe.Pointer ++ if len(p) > 0 { ++ _p0 = unsafe.Pointer(&p[0]) ++ } else { ++ _p0 = unsafe.Pointer(&_zero) ++ } ++ r0, _, e1 := Syscall6(SYS_PWRITE64, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), 0, 0) ++ n = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Seek(fd int, offset int64, whence int) (off int64, err error) { ++ r0, _, e1 := Syscall(SYS_LSEEK, uintptr(fd), uintptr(offset), uintptr(whence)) ++ off = int64(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) { ++ r0, _, e1 := Syscall6(SYS_SENDFILE, uintptr(outfd), uintptr(infd), uintptr(unsafe.Pointer(offset)), uintptr(count), 0, 0) ++ written = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func setfsgid(gid int) (prev int, err error) { ++ r0, _, e1 := Syscall(SYS_SETFSGID, uintptr(gid), 0, 0) ++ prev = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func setfsuid(uid int) (prev int, err error) { ++ r0, _, e1 := Syscall(SYS_SETFSUID, uintptr(uid), 0, 0) ++ prev = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Setrlimit(resource int, rlim *Rlimit) (err error) { ++ _, _, e1 := RawSyscall(SYS_SETRLIMIT, uintptr(resource), uintptr(unsafe.Pointer(rlim)), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Shutdown(fd int, how int) (err error) { ++ _, _, e1 := Syscall(SYS_SHUTDOWN, uintptr(fd), uintptr(how), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Splice(rfd int, roff *int64, wfd int, woff *int64, len int, flags int) (n int64, err error) { ++ r0, _, e1 := Syscall6(SYS_SPLICE, uintptr(rfd), uintptr(unsafe.Pointer(roff)), uintptr(wfd), uintptr(unsafe.Pointer(woff)), uintptr(len), uintptr(flags)) ++ n = int64(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func SyncFileRange(fd int, off int64, n int64, flags int) (err error) { ++ _, _, e1 := Syscall6(SYS_SYNC_FILE_RANGE, uintptr(fd), uintptr(off), uintptr(n), uintptr(flags), 0, 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Truncate(path string, length int64) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ _, _, e1 := Syscall(SYS_TRUNCATE, uintptr(unsafe.Pointer(_p0)), uintptr(length), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func accept(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (fd int, err error) { ++ r0, _, e1 := Syscall(SYS_ACCEPT, uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen))) ++ fd = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func accept4(s int, rsa *RawSockaddrAny, addrlen *_Socklen, flags int) (fd int, err error) { ++ r0, _, e1 := Syscall6(SYS_ACCEPT4, uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)), uintptr(flags), 0, 0) ++ fd = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) { ++ _, _, e1 := Syscall(SYS_BIND, uintptr(s), uintptr(addr), uintptr(addrlen)) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) { ++ _, _, e1 := Syscall(SYS_CONNECT, uintptr(s), uintptr(addr), uintptr(addrlen)) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func getgroups(n int, list *_Gid_t) (nn int, err error) { ++ r0, _, e1 := RawSyscall(SYS_GETGROUPS, uintptr(n), uintptr(unsafe.Pointer(list)), 0) ++ nn = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func setgroups(n int, list *_Gid_t) (err error) { ++ _, _, e1 := RawSyscall(SYS_SETGROUPS, uintptr(n), uintptr(unsafe.Pointer(list)), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error) { ++ _, _, e1 := Syscall6(SYS_GETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(unsafe.Pointer(vallen)), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error) { ++ _, _, e1 := Syscall6(SYS_SETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(vallen), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func socket(domain int, typ int, proto int) (fd int, err error) { ++ r0, _, e1 := RawSyscall(SYS_SOCKET, uintptr(domain), uintptr(typ), uintptr(proto)) ++ fd = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func socketpair(domain int, typ int, proto int, fd *[2]int32) (err error) { ++ _, _, e1 := RawSyscall6(SYS_SOCKETPAIR, uintptr(domain), uintptr(typ), uintptr(proto), uintptr(unsafe.Pointer(fd)), 0, 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func getpeername(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) { ++ _, _, e1 := RawSyscall(SYS_GETPEERNAME, uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen))) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func getsockname(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) { ++ _, _, e1 := RawSyscall(SYS_GETSOCKNAME, uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen))) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Socklen) (n int, err error) { ++ var _p0 unsafe.Pointer ++ if len(p) > 0 { ++ _p0 = unsafe.Pointer(&p[0]) ++ } else { ++ _p0 = unsafe.Pointer(&_zero) ++ } ++ r0, _, e1 := Syscall6(SYS_RECVFROM, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(flags), uintptr(unsafe.Pointer(from)), uintptr(unsafe.Pointer(fromlen))) ++ n = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (err error) { ++ var _p0 unsafe.Pointer ++ if len(buf) > 0 { ++ _p0 = unsafe.Pointer(&buf[0]) ++ } else { ++ _p0 = unsafe.Pointer(&_zero) ++ } ++ _, _, e1 := Syscall6(SYS_SENDTO, uintptr(s), uintptr(_p0), uintptr(len(buf)), uintptr(flags), uintptr(to), uintptr(addrlen)) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func recvmsg(s int, msg *Msghdr, flags int) (n int, err error) { ++ r0, _, e1 := Syscall(SYS_RECVMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags)) ++ n = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func sendmsg(s int, msg *Msghdr, flags int) (n int, err error) { ++ r0, _, e1 := Syscall(SYS_SENDMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags)) ++ n = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func mmap(addr uintptr, length uintptr, prot int, flags int, fd int, offset int64) (xaddr uintptr, err error) { ++ r0, _, e1 := Syscall6(SYS_MMAP, uintptr(addr), uintptr(length), uintptr(prot), uintptr(flags), uintptr(fd), uintptr(offset)) ++ xaddr = uintptr(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Gettimeofday(tv *Timeval) (err error) { ++ _, _, e1 := RawSyscall(SYS_GETTIMEOFDAY, uintptr(unsafe.Pointer(tv)), 0, 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func EpollWait(epfd int, events []EpollEvent, msec int) (n int, err error) { ++ var _p0 unsafe.Pointer ++ if len(events) > 0 { ++ _p0 = unsafe.Pointer(&events[0]) ++ } else { ++ _p0 = unsafe.Pointer(&_zero) ++ } ++ r0, _, e1 := Syscall6(SYS_EPOLL_WAIT, uintptr(epfd), uintptr(_p0), uintptr(len(events)), uintptr(msec), 0, 0) ++ n = int(r0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Fadvise(fd int, offset int64, length int64, advice int) (err error) { ++ _, _, e1 := Syscall6(SYS_FADVISE64, uintptr(fd), uintptr(offset), uintptr(length), uintptr(advice), 0, 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Fstatat(dirfd int, path string, stat *Stat_t, flags int) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ _, _, e1 := Syscall6(SYS_NEWFSTATAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), uintptr(flags), 0, 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Ustat(dev int, ubuf *Ustat_t) (err error) { ++ _, _, e1 := Syscall(SYS_USTAT, uintptr(dev), uintptr(unsafe.Pointer(ubuf)), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func futimesat(dirfd int, path string, times *[2]Timeval) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ _, _, e1 := Syscall(SYS_FUTIMESAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(times))) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func utimes(path string, times *[2]Timeval) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(path) ++ if err != nil { ++ return ++ } ++ _, _, e1 := Syscall(SYS_UTIMES, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(times)), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Renameat(olddirfd int, oldpath string, newdirfd int, newpath string) (err error) { ++ var _p0 *byte ++ _p0, err = BytePtrFromString(oldpath) ++ if err != nil { ++ return ++ } ++ var _p1 *byte ++ _p1, err = BytePtrFromString(newpath) ++ if err != nil { ++ return ++ } ++ _, _, e1 := Syscall6(SYS_RENAMEAT, uintptr(olddirfd), uintptr(unsafe.Pointer(_p0)), uintptr(newdirfd), uintptr(unsafe.Pointer(_p1)), 0, 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func dup2(oldfd int, newfd int) (err error) { ++ _, _, e1 := Syscall(SYS_DUP2, uintptr(oldfd), uintptr(newfd), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Setregid(rgid int, egid int) (err error) { ++ _, _, e1 := RawSyscall(SYS_SETREGID, uintptr(rgid), uintptr(egid), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Setresgid(rgid int, egid int, sgid int) (err error) { ++ _, _, e1 := RawSyscall(SYS_SETRESGID, uintptr(rgid), uintptr(egid), uintptr(sgid)) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Setresuid(ruid int, euid int, suid int) (err error) { ++ _, _, e1 := RawSyscall(SYS_SETRESUID, uintptr(ruid), uintptr(euid), uintptr(suid)) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} ++ ++// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT ++ ++func Setreuid(ruid int, euid int) (err error) { ++ _, _, e1 := RawSyscall(SYS_SETREUID, uintptr(ruid), uintptr(euid), 0) ++ if e1 != 0 { ++ err = errnoErr(e1) ++ } ++ return ++} +diff -urN containerd-1.5.9.org/vendor/golang.org/x/sys/unix/zsysnum_linux_sw64.go containerd-1.5.9.sw/vendor/golang.org/x/sys/unix/zsysnum_linux_sw64.go +--- containerd-1.5.9.org/vendor/golang.org/x/sys/unix/zsysnum_linux_sw64.go 1970-01-01 00:00:00.000000000 +0000 ++++ containerd-1.5.9.sw/vendor/golang.org/x/sys/unix/zsysnum_linux_sw64.go 2024-04-18 02:28:08.301279631 +0000 +@@ -0,0 +1,373 @@ ++// go run linux/mksysnum.go -Wall -Werror -static -I/tmp/include /tmp/include/asm/unistd.h ++// Code generated by the command above; see README.md. DO NOT EDIT. ++ ++//go:build sw64 && linux ++// +build sw64,linux ++ ++package unix ++ ++const ( ++ SYS_EXIT = 1 ++ SYS_FORK = 2 ++ SYS_READ = 3 ++ SYS_WRITE = 4 ++ SYS_CLOSE = 6 ++ SYS_LINK = 9 ++ SYS_UNLINK = 10 ++ SYS_CHDIR = 12 ++ SYS_FCHDIR = 13 ++ SYS_MKNOD = 14 ++ SYS_CHMOD = 15 ++ SYS_CHOWN = 16 ++ SYS_BRK = 17 ++ SYS_LSEEK = 19 ++ SYS_GETXPID = 20 ++ SYS_UMOUNT2 = 22 ++ SYS_SETUID = 23 ++ SYS_GETXUID = 24 ++ SYS_PTRACE = 26 ++ SYS_ACCESS = 33 ++ SYS_SYNC = 36 ++ SYS_KILL = 37 ++ SYS_SETPGID = 39 ++ SYS_DUP = 41 ++ SYS_PIPE = 42 ++ SYS_OPEN = 45 ++ SYS_GETXGID = 47 ++ SYS_ODD_SIGPROCMASK = 48 ++ SYS_ACCT = 51 ++ SYS_SIGPENDING = 52 ++ SYS_IOCTL = 54 ++ SYS_SYMLINK = 57 ++ SYS_READLINK = 58 ++ SYS_EXECVE = 59 ++ SYS_UMASK = 60 ++ SYS_CHROOT = 61 ++ SYS_GETPGRP = 63 ++ SYS_VFORK = 66 ++ SYS_STAT = 67 ++ SYS_LSTAT = 68 ++ SYS_MMAP = 71 ++ SYS_MUNMAP = 73 ++ SYS_MPROTECT = 74 ++ SYS_MADVISE = 75 ++ SYS_VHANGUP = 76 ++ SYS_GETGROUPS = 79 ++ SYS_SETGROUPS = 80 ++ SYS_SETPGRP = 82 ++ SYS_GETHOSTNAME = 87 ++ SYS_SETHOSTNAME = 88 ++ SYS_DUP2 = 90 ++ SYS_FSTAT = 91 ++ SYS_FCNTL = 92 ++ SYS_POLL = 94 ++ SYS_FSYNC = 95 ++ SYS_SETPRIORITY = 96 ++ SYS_SOCKET = 97 ++ SYS_CONNECT = 98 ++ SYS_ACCEPT = 99 ++ SYS_ODD_GETPRIORITY = 100 ++ SYS_SEND = 101 ++ SYS_RECV = 102 ++ SYS_SIGRETURN = 103 ++ SYS_BIND = 104 ++ SYS_SETSOCKOPT = 105 ++ SYS_LISTEN = 106 ++ SYS_SIGSUSPEND = 111 ++ SYS_RECVMSG = 113 ++ SYS_SENDMSG = 114 ++ SYS_GETSOCKOPT = 118 ++ SYS_SOCKETCALL = 119 ++ SYS_READV = 120 ++ SYS_WRITEV = 121 ++ SYS_FCHOWN = 123 ++ SYS_FCHMOD = 124 ++ SYS_RECVFROM = 125 ++ SYS_SETREUID = 126 ++ SYS_SETREGID = 127 ++ SYS_RENAME = 128 ++ SYS_TRUNCATE = 129 ++ SYS_FTRUNCATE = 130 ++ SYS_FLOCK = 131 ++ SYS_SETGID = 132 ++ SYS_SENDTO = 133 ++ SYS_SHUTDOWN = 134 ++ SYS_SOCKETPAIR = 135 ++ SYS_MKDIR = 136 ++ SYS_RMDIR = 137 ++ SYS_GETPEERNAME = 141 ++ SYS_GETRLIMIT = 144 ++ SYS_SETRLIMIT = 145 ++ SYS_SETSID = 147 ++ SYS_QUOTACTL = 148 ++ SYS_GETSOCKNAME = 150 ++ SYS_SIGACTION = 156 ++ SYS_SETDOMAINNAME = 166 ++ SYS_BPF = 170 ++ SYS_USERFAULTFD = 171 ++ SYS_MEMBARRIER = 172 ++ SYS_MLOCK2 = 173 ++ SYS_GETPID = 174 ++ SYS_GETPPID = 175 ++ SYS_GETUID = 176 ++ SYS_GETEUID = 177 ++ SYS_GETGID = 178 ++ SYS_GETEGID = 179 ++ SYS_MSGCTL = 200 ++ SYS_MSGGET = 201 ++ SYS_MSGRCV = 202 ++ SYS_MSGSND = 203 ++ SYS_SEMCTL = 204 ++ SYS_SEMGET = 205 ++ SYS_SEMOP = 206 ++ SYS_LCHOWN = 208 ++ SYS_SHMAT = 209 ++ SYS_SHMCTL = 210 ++ SYS_SHMDT = 211 ++ SYS_SHMGET = 212 ++ SYS_MSYNC = 217 ++ SYS_STATFS64 = 229 ++ SYS_FSTATFS64 = 230 ++ SYS_GETPGID = 233 ++ SYS_GETSID = 234 ++ SYS_SIGALTSTACK = 235 ++ SYS_SYSFS = 254 ++ SYS_GETSYSINFO = 256 ++ SYS_SETSYSINFO = 257 ++ SYS_PIDFD_SEND_SIGNAL = 271 ++ SYS_IO_URING_SETUP = 272 ++ SYS_IO_URING_ENTER = 273 ++ SYS_IO_URING_REGISTER = 274 ++ SYS_OPEN_TREE = 275 ++ SYS_MOVE_MOUNT = 276 ++ SYS_FSOPEN = 277 ++ SYS_FSCONFIG = 278 ++ SYS_FSMOUNT = 279 ++ SYS_FSPICK = 280 ++ SYS_PIDFD_OPEN = 281 ++ SYS_CLONE3 = 282 ++ SYS_CLOSE_RANGE = 283 ++ SYS_OPENAT2 = 284 ++ SYS_PIDFD_GETFD = 285 ++ SYS_FACCESSAT2 = 286 ++ SYS_PROCESS_MADVISE = 287 ++ SYS_PKEY_MPROTECT = 288 ++ SYS_PKEY_ALLOC = 289 ++ SYS_PKEY_FREE = 290 ++ SYS_GETPRIORITY = 298 ++ SYS_SIGPROCMASK = 299 ++ SYS_BDFLUSH = 300 ++ SYS_MOUNT = 302 ++ SYS_SWAPOFF = 304 ++ SYS_GETDENTS = 305 ++ SYS_CREATE_MODULE = 306 ++ SYS_INIT_MODULE = 307 ++ SYS_DELETE_MODULE = 308 ++ SYS_GET_KERNEL_SYMS = 309 ++ SYS_SYSLOG = 310 ++ SYS_REBOOT = 311 ++ SYS_CLONE = 312 ++ SYS_USELIB = 313 ++ SYS_MLOCK = 314 ++ SYS_MUNLOCK = 315 ++ SYS_MLOCKALL = 316 ++ SYS_MUNLOCKALL = 317 ++ SYS_SYSINFO = 318 ++ SYS_OLDUMOUNT = 321 ++ SYS_SWAPON = 322 ++ SYS_TIMES = 323 ++ SYS_PERSONALITY = 324 ++ SYS_SETFSUID = 325 ++ SYS_SETFSGID = 326 ++ SYS_USTAT = 327 ++ SYS_STATFS = 328 ++ SYS_FSTATFS = 329 ++ SYS_SCHED_SETPARAM = 330 ++ SYS_SCHED_GETPARAM = 331 ++ SYS_SCHED_SETSCHEDULER = 332 ++ SYS_SCHED_GETSCHEDULER = 333 ++ SYS_SCHED_YIELD = 334 ++ SYS_SCHED_GET_PRIORITY_MAX = 335 ++ SYS_SCHED_GET_PRIORITY_MIN = 336 ++ SYS_SCHED_RR_GET_INTERVAL = 337 ++ SYS_AFS_SYSCALL = 338 ++ SYS_UNAME = 339 ++ SYS_NANOSLEEP = 340 ++ SYS_MREMAP = 341 ++ SYS_NFSSERVCTL = 342 ++ SYS_SETRESUID = 343 ++ SYS_GETRESUID = 344 ++ SYS_PCICONFIG_READ = 345 ++ SYS_PCICONFIG_WRITE = 346 ++ SYS_QUERY_MODULE = 347 ++ SYS_PRCTL = 348 ++ SYS_PREAD64 = 349 ++ SYS_PWRITE64 = 350 ++ SYS_RT_SIGRETURN = 351 ++ SYS_RT_SIGACTION = 352 ++ SYS_RT_SIGPROCMASK = 353 ++ SYS_RT_SIGPENDING = 354 ++ SYS_RT_SIGTIMEDWAIT = 355 ++ SYS_RT_SIGQUEUEINFO = 356 ++ SYS_RT_SIGSUSPEND = 357 ++ SYS_SELECT = 358 ++ SYS_GETTIMEOFDAY = 359 ++ SYS_SETTIMEOFDAY = 360 ++ SYS_GETITIMER = 361 ++ SYS_SETITIMER = 362 ++ SYS_UTIMES = 363 ++ SYS_GETRUSAGE = 364 ++ SYS_WAIT4 = 365 ++ SYS_ADJTIMEX = 366 ++ SYS_GETCWD = 367 ++ SYS_CAPGET = 368 ++ SYS_CAPSET = 369 ++ SYS_SENDFILE = 370 ++ SYS_SETRESGID = 371 ++ SYS_GETRESGID = 372 ++ SYS_DIPC = 373 ++ SYS_PIVOT_ROOT = 374 ++ SYS_MINCORE = 375 ++ SYS_PCICONFIG_IOBASE = 376 ++ SYS_GETDENTS64 = 377 ++ SYS_GETTID = 378 ++ SYS_READAHEAD = 379 ++ SYS_TKILL = 381 ++ SYS_SETXATTR = 382 ++ SYS_LSETXATTR = 383 ++ SYS_FSETXATTR = 384 ++ SYS_GETXATTR = 385 ++ SYS_LGETXATTR = 386 ++ SYS_FGETXATTR = 387 ++ SYS_LISTXATTR = 388 ++ SYS_LLISTXATTR = 389 ++ SYS_FLISTXATTR = 390 ++ SYS_REMOVEXATTR = 391 ++ SYS_LREMOVEXATTR = 392 ++ SYS_FREMOVEXATTR = 393 ++ SYS_FUTEX = 394 ++ SYS_SCHED_SETAFFINITY = 395 ++ SYS_SCHED_GETAFFINITY = 396 ++ SYS_TUXCALL = 397 ++ SYS_IO_SETUP = 398 ++ SYS_IO_DESTROY = 399 ++ SYS_IO_GETEVENTS = 400 ++ SYS_IO_SUBMIT = 401 ++ SYS_IO_CANCEL = 402 ++ SYS_IO_PGETEVENTS = 403 ++ SYS_RSEQ = 404 ++ SYS_EXIT_GROUP = 405 ++ SYS_LOOKUP_DCOOKIE = 406 ++ SYS_EPOLL_CREATE = 407 ++ SYS_EPOLL_CTL = 408 ++ SYS_EPOLL_WAIT = 409 ++ SYS_REMAP_FILE_PAGES = 410 ++ SYS_SET_TID_ADDRESS = 411 ++ SYS_RESTART_SYSCALL = 412 ++ SYS_FADVISE64 = 413 ++ SYS_TIMER_CREATE = 414 ++ SYS_TIMER_SETTIME = 415 ++ SYS_TIMER_GETTIME = 416 ++ SYS_TIMER_GETOVERRUN = 417 ++ SYS_TIMER_DELETE = 418 ++ SYS_CLOCK_SETTIME = 419 ++ SYS_CLOCK_GETTIME = 420 ++ SYS_CLOCK_GETRES = 421 ++ SYS_CLOCK_NANOSLEEP = 422 ++ SYS_SEMTIMEDOP = 423 ++ SYS_TGKILL = 424 ++ SYS_STAT64 = 425 ++ SYS_LSTAT64 = 426 ++ SYS_FSTAT64 = 427 ++ SYS_VSERVER = 428 ++ SYS_MBIND = 429 ++ SYS_GET_MEMPOLICY = 430 ++ SYS_SET_MEMPOLICY = 431 ++ SYS_MQ_OPEN = 432 ++ SYS_MQ_UNLINK = 433 ++ SYS_MQ_TIMEDSEND = 434 ++ SYS_MQ_TIMEDRECEIVE = 435 ++ SYS_MQ_NOTIFY = 436 ++ SYS_MQ_GETSETATTR = 437 ++ SYS_WAITID = 438 ++ SYS_ADD_KEY = 439 ++ SYS_REQUEST_KEY = 440 ++ SYS_KEYCTL = 441 ++ SYS_IOPRIO_SET = 442 ++ SYS_IOPRIO_GET = 443 ++ SYS_INOTIFY_INIT = 444 ++ SYS_INOTIFY_ADD_WATCH = 445 ++ SYS_INOTIFY_RM_WATCH = 446 ++ SYS_FDATASYNC = 447 ++ SYS_KEXEC_LOAD = 448 ++ SYS_MIGRATE_PAGES = 449 ++ SYS_OPENAT = 450 ++ SYS_MKDIRAT = 451 ++ SYS_MKNODAT = 452 ++ SYS_FCHOWNAT = 453 ++ SYS_FUTIMESAT = 454 ++ SYS_FSTATAT64 = 455 ++ SYS_UNLINKAT = 456 ++ SYS_RENAMEAT = 457 ++ SYS_LINKAT = 458 ++ SYS_SYMLINKAT = 459 ++ SYS_READLINKAT = 460 ++ SYS_FCHMODAT = 461 ++ SYS_FACCESSAT = 462 ++ SYS_PSELECT6 = 463 ++ SYS_PPOLL = 464 ++ SYS_UNSHARE = 465 ++ SYS_SET_ROBUST_LIST = 466 ++ SYS_GET_ROBUST_LIST = 467 ++ SYS_SPLICE = 468 ++ SYS_SYNC_FILE_RANGE = 469 ++ SYS_TEE = 470 ++ SYS_VMSPLICE = 471 ++ SYS_MOVE_PAGES = 472 ++ SYS_GETCPU = 473 ++ SYS_EPOLL_PWAIT = 474 ++ SYS_UTIMENSAT = 475 ++ SYS_SIGNALFD = 476 ++ SYS_TIMERFD = 477 ++ SYS_EVENTFD = 478 ++ SYS_RECVMMSG = 479 ++ SYS_FALLOCATE = 480 ++ SYS_TIMERFD_CREATE = 481 ++ SYS_TIMERFD_SETTIME = 482 ++ SYS_TIMERFD_GETTIME = 483 ++ SYS_SIGNALFD4 = 484 ++ SYS_EVENTFD2 = 485 ++ SYS_EPOLL_CREATE1 = 486 ++ SYS_DUP3 = 487 ++ SYS_PIPE2 = 488 ++ SYS_INOTIFY_INIT1 = 489 ++ SYS_PREADV = 490 ++ SYS_PWRITEV = 491 ++ SYS_RT_TGSIGQUEUEINFO = 492 ++ SYS_PERF_EVENT_OPEN = 493 ++ SYS_FANOTIFY_INIT = 494 ++ SYS_FANOTIFY_MARK = 495 ++ SYS_PRLIMIT64 = 496 ++ SYS_NAME_TO_HANDLE_AT = 497 ++ SYS_OPEN_BY_HANDLE_AT = 498 ++ SYS_CLOCK_ADJTIME = 499 ++ SYS_SYNCFS = 500 ++ SYS_SETNS = 501 ++ SYS_ACCEPT4 = 502 ++ SYS_SENDMMSG = 503 ++ SYS_PROCESS_VM_READV = 504 ++ SYS_PROCESS_VM_WRITEV = 505 ++ SYS_KCMP = 506 ++ SYS_FINIT_MODULE = 507 ++ SYS_SCHED_SETATTR = 508 ++ SYS_SCHED_GETATTR = 509 ++ SYS_RENAMEAT2 = 510 ++ SYS_GETRANDOM = 511 ++ SYS_MEMFD_CREATE = 512 ++ SYS_EXECVEAT = 513 ++ SYS_SECCOMP = 514 ++ SYS_COPY_FILE_RANGE = 515 ++ SYS_PREADV2 = 516 ++ SYS_PWRITEV2 = 517 ++ SYS_STATX = 518 ++) +diff -urN containerd-1.5.9.org/vendor/golang.org/x/sys/unix/ztypes_linux.go containerd-1.5.9.sw/vendor/golang.org/x/sys/unix/ztypes_linux.go +--- containerd-1.5.9.org/vendor/golang.org/x/sys/unix/ztypes_linux.go 2024-04-18 02:22:29.540948888 +0000 ++++ containerd-1.5.9.sw/vendor/golang.org/x/sys/unix/ztypes_linux.go 2024-04-18 02:23:50.021027463 +0000 +@@ -1,7 +1,8 @@ + // Code generated by mkmerge.go; DO NOT EDIT. + +-//go:build linux ++//go:build linux && !sw64 + // +build linux ++// +build !sw64 + + package unix + +diff -urN containerd-1.5.9.org/vendor/golang.org/x/sys/unix/ztypes_linux_sw64.go containerd-1.5.9.sw/vendor/golang.org/x/sys/unix/ztypes_linux_sw64.go +--- containerd-1.5.9.org/vendor/golang.org/x/sys/unix/ztypes_linux_sw64.go 1970-01-01 00:00:00.000000000 +0000 ++++ containerd-1.5.9.sw/vendor/golang.org/x/sys/unix/ztypes_linux_sw64.go 2024-04-18 02:28:08.301279631 +0000 +@@ -0,0 +1,6220 @@ ++// cgo -godefs -objdir=/tmp/sw64/cgo -- -Wall -Werror -static -I/tmp/sw64/include linux/types.go | go run mkpost.go ++// Code generated by the command above; see README.md. DO NOT EDIT. ++ ++//go:build sw64 && linux ++// +build sw64,linux ++ ++package unix ++ ++const ( ++ SizeofPtr = 0x8 ++ SizeofShort = 0x2 ++ SizeofInt = 0x4 ++ SizeofLong = 0x8 ++ SizeofLongLong = 0x8 ++ PathMax = 0x1000 ++) ++ ++type ( ++ _C_short int16 ++ _C_int int32 ++ _C_long int64 ++ _C_long_long int64 ++) ++ ++type Timespec struct { ++ Sec int64 ++ Nsec int64 ++} ++ ++type Timeval struct { ++ Sec int64 ++ Usec int64 ++} ++ ++type Timex struct { ++ Modes uint32 ++ Offset int64 ++ Freq int64 ++ Maxerror int64 ++ Esterror int64 ++ Status int32 ++ Constant int64 ++ Precision int64 ++ Tolerance int64 ++ Time Timeval ++ Tick int64 ++ Ppsfreq int64 ++ Jitter int64 ++ Shift int32 ++ Stabil int64 ++ Jitcnt int64 ++ Calcnt int64 ++ Errcnt int64 ++ Stbcnt int64 ++ Tai int32 ++ _ [44]byte ++} ++ ++type ItimerSpec struct { ++ Interval Timespec ++ Value Timespec ++} ++ ++type Itimerval struct { ++ Interval Timeval ++ Value Timeval ++} ++ ++const ( ++ TIME_OK = 0x0 ++ TIME_INS = 0x1 ++ TIME_DEL = 0x2 ++ TIME_OOP = 0x3 ++ TIME_WAIT = 0x4 ++ TIME_ERROR = 0x5 ++ TIME_BAD = 0x5 ++) ++ ++type Time_t int64 ++ ++type Tms struct { ++ Utime int64 ++ Stime int64 ++ Cutime int64 ++ Cstime int64 ++} ++ ++type Utimbuf struct { ++ Actime int64 ++ Modtime int64 ++} ++ ++type Rusage struct { ++ Utime Timeval ++ Stime Timeval ++ Maxrss int64 ++ Ixrss int64 ++ Idrss int64 ++ Isrss int64 ++ Minflt int64 ++ Majflt int64 ++ Nswap int64 ++ Inblock int64 ++ Oublock int64 ++ Msgsnd int64 ++ Msgrcv int64 ++ Nsignals int64 ++ Nvcsw int64 ++ Nivcsw int64 ++} ++ ++type Rlimit struct { ++ Cur uint64 ++ Max uint64 ++} ++ ++type _Gid_t uint32 ++ ++type Stat_t struct { ++ Dev uint64 ++ Ino uint64 ++ Rdev uint64 ++ Size int64 ++ Blocks uint64 ++ Mode uint32 ++ Uid uint32 ++ Gid uint32 ++ Blksize uint32 ++ Nlink uint32 ++ _ int32 ++ Atim Timespec ++ Mtim Timespec ++ Ctim Timespec ++ _ [3]int64 ++} ++ ++type StatxTimestamp struct { ++ Sec int64 ++ Nsec uint32 ++ _ int32 ++} ++ ++type Statx_t struct { ++ Mask uint32 ++ Blksize uint32 ++ Attributes uint64 ++ Nlink uint32 ++ Uid uint32 ++ Gid uint32 ++ Mode uint16 ++ _ [1]uint16 ++ Ino uint64 ++ Size uint64 ++ Blocks uint64 ++ Attributes_mask uint64 ++ Atime StatxTimestamp ++ Btime StatxTimestamp ++ Ctime StatxTimestamp ++ Mtime StatxTimestamp ++ Rdev_major uint32 ++ Rdev_minor uint32 ++ Dev_major uint32 ++ Dev_minor uint32 ++ Mnt_id uint64 ++ _ uint64 ++ _ [12]uint64 ++} ++ ++type Dirent struct { ++ Ino uint64 ++ Off int64 ++ Reclen uint16 ++ Type uint8 ++ Name [256]int8 ++ _ [5]byte ++} ++ ++type Fsid struct { ++ Val [2]int32 ++} ++ ++type Flock_t struct { ++ Type int16 ++ Whence int16 ++ Start int64 ++ Len int64 ++ Pid int32 ++ _ [4]byte ++} ++ ++type FileCloneRange struct { ++ Src_fd int64 ++ Src_offset uint64 ++ Src_length uint64 ++ Dest_offset uint64 ++} ++ ++type RawFileDedupeRange struct { ++ Src_offset uint64 ++ Src_length uint64 ++ Dest_count uint16 ++ Reserved1 uint16 ++ Reserved2 uint32 ++} ++ ++type RawFileDedupeRangeInfo struct { ++ Dest_fd int64 ++ Dest_offset uint64 ++ Bytes_deduped uint64 ++ Status int32 ++ Reserved uint32 ++} ++ ++const ( ++ SizeofRawFileDedupeRange = 0x18 ++ SizeofRawFileDedupeRangeInfo = 0x20 ++ FILE_DEDUPE_RANGE_SAME = 0x0 ++ FILE_DEDUPE_RANGE_DIFFERS = 0x1 ++) ++ ++type FscryptPolicy struct { ++ Version uint8 ++ Contents_encryption_mode uint8 ++ Filenames_encryption_mode uint8 ++ Flags uint8 ++ Master_key_descriptor [8]uint8 ++} ++ ++type FscryptKey struct { ++ Mode uint32 ++ Raw [64]uint8 ++ Size uint32 ++} ++ ++type FscryptPolicyV1 struct { ++ Version uint8 ++ Contents_encryption_mode uint8 ++ Filenames_encryption_mode uint8 ++ Flags uint8 ++ Master_key_descriptor [8]uint8 ++} ++ ++type FscryptPolicyV2 struct { ++ Version uint8 ++ Contents_encryption_mode uint8 ++ Filenames_encryption_mode uint8 ++ Flags uint8 ++ _ [4]uint8 ++ Master_key_identifier [16]uint8 ++} ++ ++type FscryptGetPolicyExArg struct { ++ Size uint64 ++ Policy [24]byte ++} ++ ++type FscryptKeySpecifier struct { ++ Type uint32 ++ _ uint32 ++ U [32]byte ++} ++ ++type FscryptAddKeyArg struct { ++ Key_spec FscryptKeySpecifier ++ Raw_size uint32 ++ Key_id uint32 ++ _ [8]uint32 ++} ++ ++type FscryptRemoveKeyArg struct { ++ Key_spec FscryptKeySpecifier ++ Removal_status_flags uint32 ++ _ [5]uint32 ++} ++ ++type FscryptGetKeyStatusArg struct { ++ Key_spec FscryptKeySpecifier ++ _ [6]uint32 ++ Status uint32 ++ Status_flags uint32 ++ User_count uint32 ++ _ [13]uint32 ++} ++ ++type DmIoctl struct { ++ Version [3]uint32 ++ Data_size uint32 ++ Data_start uint32 ++ Target_count uint32 ++ Open_count int32 ++ Flags uint32 ++ Event_nr uint32 ++ _ uint32 ++ Dev uint64 ++ Name [128]byte ++ Uuid [129]byte ++ Data [7]byte ++} ++ ++type DmTargetSpec struct { ++ Sector_start uint64 ++ Length uint64 ++ Status int32 ++ Next uint32 ++ Target_type [16]byte ++} ++ ++type DmTargetDeps struct { ++ Count uint32 ++ _ uint32 ++} ++ ++type DmNameList struct { ++ Dev uint64 ++ Next uint32 ++ Name [0]byte ++ _ [4]byte ++} ++ ++type DmTargetVersions struct { ++ Next uint32 ++ Version [3]uint32 ++} ++ ++type DmTargetMsg struct { ++ Sector uint64 ++} ++ ++const ( ++ SizeofDmIoctl = 0x138 ++ SizeofDmTargetSpec = 0x28 ++) ++ ++type KeyctlDHParams struct { ++ Private int32 ++ Prime int32 ++ Base int32 ++} ++ ++const ( ++ FADV_NORMAL = 0x0 ++ FADV_RANDOM = 0x1 ++ FADV_SEQUENTIAL = 0x2 ++ FADV_WILLNEED = 0x3 ++ FADV_DONTNEED = 0x4 ++ FADV_NOREUSE = 0x5 ++) ++ ++type RawSockaddrInet4 struct { ++ Family uint16 ++ Port uint16 ++ Addr [4]byte /* in_addr */ ++ Zero [8]uint8 ++} ++ ++type RawSockaddrInet6 struct { ++ Family uint16 ++ Port uint16 ++ Flowinfo uint32 ++ Addr [16]byte /* in6_addr */ ++ Scope_id uint32 ++} ++ ++type RawSockaddrUnix struct { ++ Family uint16 ++ Path [108]int8 ++} ++ ++type RawSockaddrLinklayer struct { ++ Family uint16 ++ Protocol uint16 ++ Ifindex int32 ++ Hatype uint16 ++ Pkttype uint8 ++ Halen uint8 ++ Addr [8]uint8 ++} ++ ++type RawSockaddrNetlink struct { ++ Family uint16 ++ Pad uint16 ++ Pid uint32 ++ Groups uint32 ++} ++ ++type RawSockaddrHCI struct { ++ Family uint16 ++ Dev uint16 ++ Channel uint16 ++} ++ ++type RawSockaddrL2 struct { ++ Family uint16 ++ Psm uint16 ++ Bdaddr [6]uint8 ++ Cid uint16 ++ Bdaddr_type uint8 ++ _ [1]byte ++} ++ ++type RawSockaddrRFCOMM struct { ++ Family uint16 ++ Bdaddr [6]uint8 ++ Channel uint8 ++ _ [1]byte ++} ++ ++type RawSockaddrCAN struct { ++ Family uint16 ++ Ifindex int32 ++ Addr [16]byte ++} ++ ++type RawSockaddrALG struct { ++ Family uint16 ++ Type [14]uint8 ++ Feat uint32 ++ Mask uint32 ++ Name [64]uint8 ++} ++ ++// TODO: 5.10 kernel doesn't support Flags feild ++// just for compiler pass ++type RawSockaddrVM struct { ++ Family uint16 ++ Reserved1 uint16 ++ Port uint32 ++ Cid uint32 ++ Flags uint8 ++ Zero [4]uint8 ++} ++ ++type RawSockaddrXDP struct { ++ Family uint16 ++ Flags uint16 ++ Ifindex uint32 ++ Queue_id uint32 ++ Shared_umem_fd uint32 ++} ++ ++type RawSockaddrPPPoX [0x1e]byte ++ ++type RawSockaddrTIPC struct { ++ Family uint16 ++ Addrtype uint8 ++ Scope int8 ++ Addr [12]byte ++} ++ ++type RawSockaddrL2TPIP struct { ++ Family uint16 ++ Unused uint16 ++ Addr [4]byte /* in_addr */ ++ Conn_id uint32 ++ _ [4]uint8 ++} ++ ++type RawSockaddrL2TPIP6 struct { ++ Family uint16 ++ Unused uint16 ++ Flowinfo uint32 ++ Addr [16]byte /* in6_addr */ ++ Scope_id uint32 ++ Conn_id uint32 ++} ++ ++type RawSockaddrIUCV struct { ++ Family uint16 ++ Port uint16 ++ Addr uint32 ++ Nodeid [8]int8 ++ User_id [8]int8 ++ Name [8]int8 ++} ++ ++type RawSockaddrNFC struct { ++ Sa_family uint16 ++ Dev_idx uint32 ++ Target_idx uint32 ++ Nfc_protocol uint32 ++} ++ ++type RawSockaddrNFCLLCP struct { ++ Sa_family uint16 ++ Dev_idx uint32 ++ Target_idx uint32 ++ Nfc_protocol uint32 ++ Dsap uint8 ++ Ssap uint8 ++ Service_name [63]uint8 ++ Service_name_len uint64 ++} ++ ++type RawSockaddr struct { ++ Family uint16 ++ Data [14]int8 ++} ++ ++type RawSockaddrAny struct { ++ Addr RawSockaddr ++ Pad [96]int8 ++} ++ ++type _Socklen uint32 ++ ++type Linger struct { ++ Onoff int32 ++ Linger int32 ++} ++ ++type Iovec struct { ++ Base *byte ++ Len uint64 ++} ++ ++type IPMreq struct { ++ Multiaddr [4]byte /* in_addr */ ++ Interface [4]byte /* in_addr */ ++} ++ ++type IPMreqn struct { ++ Multiaddr [4]byte /* in_addr */ ++ Address [4]byte /* in_addr */ ++ Ifindex int32 ++} ++ ++type IPv6Mreq struct { ++ Multiaddr [16]byte /* in6_addr */ ++ Interface uint32 ++} ++ ++type PacketMreq struct { ++ Ifindex int32 ++ Type uint16 ++ Alen uint16 ++ Address [8]uint8 ++} ++ ++type Msghdr struct { ++ Name *byte ++ Namelen uint32 ++ Iov *Iovec ++ Iovlen uint64 ++ Control *byte ++ Controllen uint64 ++ Flags int32 ++ _ [4]byte ++} ++ ++type Cmsghdr struct { ++ Len uint64 ++ Level int32 ++ Type int32 ++} ++ ++type Inet4Pktinfo struct { ++ Ifindex int32 ++ Spec_dst [4]byte /* in_addr */ ++ Addr [4]byte /* in_addr */ ++} ++ ++type Inet6Pktinfo struct { ++ Addr [16]byte /* in6_addr */ ++ Ifindex uint32 ++} ++ ++type IPv6MTUInfo struct { ++ Addr RawSockaddrInet6 ++ Mtu uint32 ++} ++ ++type ICMPv6Filter struct { ++ Data [8]uint32 ++} ++ ++type Ucred struct { ++ Pid int32 ++ Uid uint32 ++ Gid uint32 ++} ++ ++type TCPInfo struct { ++ State uint8 ++ Ca_state uint8 ++ Retransmits uint8 ++ Probes uint8 ++ Backoff uint8 ++ Options uint8 ++ Rto uint32 ++ Ato uint32 ++ Snd_mss uint32 ++ Rcv_mss uint32 ++ Unacked uint32 ++ Sacked uint32 ++ Lost uint32 ++ Retrans uint32 ++ Fackets uint32 ++ Last_data_sent uint32 ++ Last_ack_sent uint32 ++ Last_data_recv uint32 ++ Last_ack_recv uint32 ++ Pmtu uint32 ++ Rcv_ssthresh uint32 ++ Rtt uint32 ++ Rttvar uint32 ++ Snd_ssthresh uint32 ++ Snd_cwnd uint32 ++ Advmss uint32 ++ Reordering uint32 ++ Rcv_rtt uint32 ++ Rcv_space uint32 ++ Total_retrans uint32 ++} ++ ++type CanFilter struct { ++ Id uint32 ++ Mask uint32 ++} ++ ++type ifreq struct { ++ Ifrn [16]byte ++ Ifru [24]byte ++} ++ ++type TCPRepairOpt struct { ++ Code uint32 ++ Val uint32 ++} ++ ++const ( ++ SizeofSockaddrInet4 = 0x10 ++ SizeofSockaddrInet6 = 0x1c ++ SizeofSockaddrAny = 0x70 ++ SizeofSockaddrUnix = 0x6e ++ SizeofSockaddrLinklayer = 0x14 ++ SizeofSockaddrNetlink = 0xc ++ SizeofSockaddrHCI = 0x6 ++ SizeofSockaddrL2 = 0xe ++ SizeofSockaddrRFCOMM = 0xa ++ SizeofSockaddrCAN = 0x18 ++ SizeofSockaddrALG = 0x58 ++ SizeofSockaddrVM = 0x10 ++ SizeofSockaddrXDP = 0x10 ++ SizeofSockaddrPPPoX = 0x1e ++ SizeofSockaddrTIPC = 0x10 ++ SizeofSockaddrL2TPIP = 0x10 ++ SizeofSockaddrL2TPIP6 = 0x20 ++ SizeofSockaddrIUCV = 0x20 ++ SizeofSockaddrNFC = 0x10 ++ SizeofSockaddrNFCLLCP = 0x60 ++ SizeofLinger = 0x8 ++ SizeofIovec = 0x10 ++ SizeofIPMreq = 0x8 ++ SizeofIPMreqn = 0xc ++ SizeofIPv6Mreq = 0x14 ++ SizeofPacketMreq = 0x10 ++ SizeofMsghdr = 0x38 ++ SizeofCmsghdr = 0x10 ++ SizeofInet4Pktinfo = 0xc ++ SizeofInet6Pktinfo = 0x14 ++ SizeofIPv6MTUInfo = 0x20 ++ SizeofICMPv6Filter = 0x20 ++ SizeofUcred = 0xc ++ SizeofTCPInfo = 0x68 ++ SizeofCanFilter = 0x8 ++ SizeofTCPRepairOpt = 0x8 ++) ++ ++const ( ++ NDA_UNSPEC = 0x0 ++ NDA_DST = 0x1 ++ NDA_LLADDR = 0x2 ++ NDA_CACHEINFO = 0x3 ++ NDA_PROBES = 0x4 ++ NDA_VLAN = 0x5 ++ NDA_PORT = 0x6 ++ NDA_VNI = 0x7 ++ NDA_IFINDEX = 0x8 ++ NDA_MASTER = 0x9 ++ NDA_LINK_NETNSID = 0xa ++ NDA_SRC_VNI = 0xb ++ NTF_USE = 0x1 ++ NTF_SELF = 0x2 ++ NTF_MASTER = 0x4 ++ NTF_PROXY = 0x8 ++ NTF_EXT_LEARNED = 0x10 ++ NTF_OFFLOADED = 0x20 ++ NTF_ROUTER = 0x80 ++ NUD_INCOMPLETE = 0x1 ++ NUD_REACHABLE = 0x2 ++ NUD_STALE = 0x4 ++ NUD_DELAY = 0x8 ++ NUD_PROBE = 0x10 ++ NUD_FAILED = 0x20 ++ NUD_NOARP = 0x40 ++ NUD_PERMANENT = 0x80 ++ NUD_NONE = 0x0 ++ IFA_UNSPEC = 0x0 ++ IFA_ADDRESS = 0x1 ++ IFA_LOCAL = 0x2 ++ IFA_LABEL = 0x3 ++ IFA_BROADCAST = 0x4 ++ IFA_ANYCAST = 0x5 ++ IFA_CACHEINFO = 0x6 ++ IFA_MULTICAST = 0x7 ++ IFA_FLAGS = 0x8 ++ IFA_RT_PRIORITY = 0x9 ++ IFA_TARGET_NETNSID = 0xa ++ RT_SCOPE_UNIVERSE = 0x0 ++ RT_SCOPE_SITE = 0xc8 ++ RT_SCOPE_LINK = 0xfd ++ RT_SCOPE_HOST = 0xfe ++ RT_SCOPE_NOWHERE = 0xff ++ RT_TABLE_UNSPEC = 0x0 ++ RT_TABLE_COMPAT = 0xfc ++ RT_TABLE_DEFAULT = 0xfd ++ RT_TABLE_MAIN = 0xfe ++ RT_TABLE_LOCAL = 0xff ++ RT_TABLE_MAX = 0xffffffff ++ RTA_UNSPEC = 0x0 ++ RTA_DST = 0x1 ++ RTA_SRC = 0x2 ++ RTA_IIF = 0x3 ++ RTA_OIF = 0x4 ++ RTA_GATEWAY = 0x5 ++ RTA_PRIORITY = 0x6 ++ RTA_PREFSRC = 0x7 ++ RTA_METRICS = 0x8 ++ RTA_MULTIPATH = 0x9 ++ RTA_FLOW = 0xb ++ RTA_CACHEINFO = 0xc ++ RTA_TABLE = 0xf ++ RTA_MARK = 0x10 ++ RTA_MFC_STATS = 0x11 ++ RTA_VIA = 0x12 ++ RTA_NEWDST = 0x13 ++ RTA_PREF = 0x14 ++ RTA_ENCAP_TYPE = 0x15 ++ RTA_ENCAP = 0x16 ++ RTA_EXPIRES = 0x17 ++ RTA_PAD = 0x18 ++ RTA_UID = 0x19 ++ RTA_TTL_PROPAGATE = 0x1a ++ RTA_IP_PROTO = 0x1b ++ RTA_SPORT = 0x1c ++ RTA_DPORT = 0x1d ++ RTN_UNSPEC = 0x0 ++ RTN_UNICAST = 0x1 ++ RTN_LOCAL = 0x2 ++ RTN_BROADCAST = 0x3 ++ RTN_ANYCAST = 0x4 ++ RTN_MULTICAST = 0x5 ++ RTN_BLACKHOLE = 0x6 ++ RTN_UNREACHABLE = 0x7 ++ RTN_PROHIBIT = 0x8 ++ RTN_THROW = 0x9 ++ RTN_NAT = 0xa ++ RTN_XRESOLVE = 0xb ++ SizeofNlMsghdr = 0x10 ++ SizeofNlMsgerr = 0x14 ++ SizeofRtGenmsg = 0x1 ++ SizeofNlAttr = 0x4 ++ SizeofRtAttr = 0x4 ++ SizeofIfInfomsg = 0x10 ++ SizeofIfAddrmsg = 0x8 ++ SizeofIfaCacheinfo = 0x10 ++ SizeofRtMsg = 0xc ++ SizeofRtNexthop = 0x8 ++ SizeofNdUseroptmsg = 0x10 ++ SizeofNdMsg = 0xc ++) ++ ++type NlMsghdr struct { ++ Len uint32 ++ Type uint16 ++ Flags uint16 ++ Seq uint32 ++ Pid uint32 ++} ++ ++type NlMsgerr struct { ++ Error int32 ++ Msg NlMsghdr ++} ++ ++type RtGenmsg struct { ++ Family uint8 ++} ++ ++type NlAttr struct { ++ Len uint16 ++ Type uint16 ++} ++ ++type RtAttr struct { ++ Len uint16 ++ Type uint16 ++} ++ ++type IfInfomsg struct { ++ Family uint8 ++ _ uint8 ++ Type uint16 ++ Index int32 ++ Flags uint32 ++ Change uint32 ++} ++ ++type IfAddrmsg struct { ++ Family uint8 ++ Prefixlen uint8 ++ Flags uint8 ++ Scope uint8 ++ Index uint32 ++} ++ ++type IfaCacheinfo struct { ++ Prefered uint32 ++ Valid uint32 ++ Cstamp uint32 ++ Tstamp uint32 ++} ++ ++type RtMsg struct { ++ Family uint8 ++ Dst_len uint8 ++ Src_len uint8 ++ Tos uint8 ++ Table uint8 ++ Protocol uint8 ++ Scope uint8 ++ Type uint8 ++ Flags uint32 ++} ++ ++type RtNexthop struct { ++ Len uint16 ++ Flags uint8 ++ Hops uint8 ++ Ifindex int32 ++} ++ ++type NdUseroptmsg struct { ++ Family uint8 ++ Pad1 uint8 ++ Opts_len uint16 ++ Ifindex int32 ++ Icmp_type uint8 ++ Icmp_code uint8 ++ Pad2 uint16 ++ Pad3 uint32 ++} ++ ++type NdMsg struct { ++ Family uint8 ++ Pad1 uint8 ++ Pad2 uint16 ++ Ifindex int32 ++ State uint16 ++ Flags uint8 ++ Type uint8 ++} ++ ++const ( ++ ICMP_FILTER = 0x1 ++ ++ ICMPV6_FILTER = 0x1 ++ ICMPV6_FILTER_BLOCK = 0x1 ++ ICMPV6_FILTER_BLOCKOTHERS = 0x3 ++ ICMPV6_FILTER_PASS = 0x2 ++ ICMPV6_FILTER_PASSONLY = 0x4 ++) ++ ++const ( ++ SizeofSockFilter = 0x8 ++ SizeofSockFprog = 0x10 ++) ++ ++type SockFilter struct { ++ Code uint16 ++ Jt uint8 ++ Jf uint8 ++ K uint32 ++} ++ ++type SockFprog struct { ++ Len uint16 ++ Filter *SockFilter ++} ++ ++type InotifyEvent struct { ++ Wd int32 ++ Mask uint32 ++ Cookie uint32 ++ Len uint32 ++} ++ ++const SizeofInotifyEvent = 0x10 ++ ++type PtraceRegs struct{} ++ ++type FdSet struct { ++ Bits [16]int64 ++} ++ ++type Sysinfo_t struct { ++ Uptime int64 ++ Loads [3]uint64 ++ Totalram uint64 ++ Freeram uint64 ++ Sharedram uint64 ++ Bufferram uint64 ++ Totalswap uint64 ++ Freeswap uint64 ++ Procs uint16 ++ Pad uint16 ++ Totalhigh uint64 ++ Freehigh uint64 ++ Unit uint32 ++ _ [0]int8 ++ _ [4]byte ++} ++ ++const SI_LOAD_SHIFT = 0x10 ++ ++type Utsname struct { ++ Sysname [65]byte ++ Nodename [65]byte ++ Release [65]byte ++ Version [65]byte ++ Machine [65]byte ++ Domainname [65]byte ++} ++ ++type Ustat_t struct { ++ Tfree int32 ++ Tinode uint64 ++ Fname [6]int8 ++ Fpack [6]int8 ++ _ [4]byte ++} ++ ++type EpollEvent struct { ++ Events uint32 ++ _ int32 ++ Fd int32 ++ Pad int32 ++} ++ ++const ( ++ AT_EMPTY_PATH = 0x1000 ++ AT_FDCWD = -0x64 ++ AT_NO_AUTOMOUNT = 0x800 ++ AT_REMOVEDIR = 0x200 ++ ++ AT_STATX_SYNC_AS_STAT = 0x0 ++ AT_STATX_FORCE_SYNC = 0x2000 ++ AT_STATX_DONT_SYNC = 0x4000 ++ ++ AT_RECURSIVE = 0x8000 ++ ++ AT_SYMLINK_FOLLOW = 0x400 ++ AT_SYMLINK_NOFOLLOW = 0x100 ++ ++ AT_EACCESS = 0x200 ++ ++ OPEN_TREE_CLONE = 0x1 ++ OPEN_TREE_CLOEXEC = 0x200000 ++ ++ MOVE_MOUNT_F_SYMLINKS = 0x1 ++ MOVE_MOUNT_F_AUTOMOUNTS = 0x2 ++ MOVE_MOUNT_F_EMPTY_PATH = 0x4 ++ MOVE_MOUNT_T_SYMLINKS = 0x10 ++ MOVE_MOUNT_T_AUTOMOUNTS = 0x20 ++ MOVE_MOUNT_T_EMPTY_PATH = 0x40 ++ ++ FSOPEN_CLOEXEC = 0x1 ++ ++ FSPICK_CLOEXEC = 0x1 ++ FSPICK_SYMLINK_NOFOLLOW = 0x2 ++ FSPICK_NO_AUTOMOUNT = 0x4 ++ FSPICK_EMPTY_PATH = 0x8 ++ ++ FSMOUNT_CLOEXEC = 0x1 ++ ++ FSCONFIG_SET_FLAG = 0x0 ++ FSCONFIG_SET_STRING = 0x1 ++ FSCONFIG_SET_BINARY = 0x2 ++ FSCONFIG_SET_PATH = 0x3 ++ FSCONFIG_SET_PATH_EMPTY = 0x4 ++ FSCONFIG_SET_FD = 0x5 ++ FSCONFIG_CMD_CREATE = 0x6 ++ FSCONFIG_CMD_RECONFIGURE = 0x7 ++) ++ ++type OpenHow struct { ++ Flags uint64 ++ Mode uint64 ++ Resolve uint64 ++} ++ ++const SizeofOpenHow = 0x18 ++ ++const ( ++ RESOLVE_BENEATH = 0x8 ++ RESOLVE_IN_ROOT = 0x10 ++ RESOLVE_NO_MAGICLINKS = 0x2 ++ RESOLVE_NO_SYMLINKS = 0x4 ++ RESOLVE_NO_XDEV = 0x1 ++) ++ ++type PollFd struct { ++ Fd int32 ++ Events int16 ++ Revents int16 ++} ++ ++const ( ++ POLLIN = 0x1 ++ POLLPRI = 0x2 ++ POLLOUT = 0x4 ++ POLLRDHUP = 0x2000 ++ POLLERR = 0x8 ++ POLLHUP = 0x10 ++ POLLNVAL = 0x20 ++) ++ ++type Sigset_t struct { ++ Val [16]uint64 ++} ++ ++const _C__NSIG = 0x41 ++ ++const ( ++ SIG_BLOCK = 0x1 ++ SIG_UNBLOCK = 0x2 ++ SIG_SETMASK = 0x3 ++) ++ ++type SignalfdSiginfo struct { ++ Signo uint32 ++ Errno int32 ++ Code int32 ++ Pid uint32 ++ Uid uint32 ++ Fd int32 ++ Tid uint32 ++ Band uint32 ++ Overrun uint32 ++ Trapno uint32 ++ Status int32 ++ Int int32 ++ Ptr uint64 ++ Utime uint64 ++ Stime uint64 ++ Addr uint64 ++ Addr_lsb uint16 ++ _ uint16 ++ Syscall int32 ++ Call_addr uint64 ++ Arch uint32 ++ _ [28]uint8 ++} ++ ++type Siginfo struct { ++ Signo int32 ++ Errno int32 ++ Code int32 ++ _ int32 ++ _ [112]byte ++} ++ ++type Termios struct { ++ Iflag uint32 ++ Oflag uint32 ++ Cflag uint32 ++ Lflag uint32 ++ Cc [19]uint8 ++ Line uint8 ++ Ispeed uint32 ++ Ospeed uint32 ++} ++ ++type Winsize struct { ++ Row uint16 ++ Col uint16 ++ Xpixel uint16 ++ Ypixel uint16 ++} ++ ++type Taskstats struct { ++ Version uint16 ++ Ac_exitcode uint32 ++ Ac_flag uint8 ++ Ac_nice uint8 ++ Cpu_count uint64 ++ Cpu_delay_total uint64 ++ Blkio_count uint64 ++ Blkio_delay_total uint64 ++ Swapin_count uint64 ++ Swapin_delay_total uint64 ++ Cpu_run_real_total uint64 ++ Cpu_run_virtual_total uint64 ++ Ac_comm [32]int8 ++ Ac_sched uint8 ++ Ac_pad [3]uint8 ++ _ [4]byte ++ Ac_uid uint32 ++ Ac_gid uint32 ++ Ac_pid uint32 ++ Ac_ppid uint32 ++ Ac_btime uint32 ++ Ac_etime uint64 ++ Ac_utime uint64 ++ Ac_stime uint64 ++ Ac_minflt uint64 ++ Ac_majflt uint64 ++ Coremem uint64 ++ Virtmem uint64 ++ Hiwater_rss uint64 ++ Hiwater_vm uint64 ++ Read_char uint64 ++ Write_char uint64 ++ Read_syscalls uint64 ++ Write_syscalls uint64 ++ Read_bytes uint64 ++ Write_bytes uint64 ++ Cancelled_write_bytes uint64 ++ Nvcsw uint64 ++ Nivcsw uint64 ++ Ac_utimescaled uint64 ++ Ac_stimescaled uint64 ++ Cpu_scaled_run_real_total uint64 ++ Freepages_count uint64 ++ Freepages_delay_total uint64 ++ Thrashing_count uint64 ++ Thrashing_delay_total uint64 ++ Ac_btime64 uint64 ++} ++ ++const ( ++ TASKSTATS_CMD_UNSPEC = 0x0 ++ TASKSTATS_CMD_GET = 0x1 ++ TASKSTATS_CMD_NEW = 0x2 ++ TASKSTATS_TYPE_UNSPEC = 0x0 ++ TASKSTATS_TYPE_PID = 0x1 ++ TASKSTATS_TYPE_TGID = 0x2 ++ TASKSTATS_TYPE_STATS = 0x3 ++ TASKSTATS_TYPE_AGGR_PID = 0x4 ++ TASKSTATS_TYPE_AGGR_TGID = 0x5 ++ TASKSTATS_TYPE_NULL = 0x6 ++ TASKSTATS_CMD_ATTR_UNSPEC = 0x0 ++ TASKSTATS_CMD_ATTR_PID = 0x1 ++ TASKSTATS_CMD_ATTR_TGID = 0x2 ++ TASKSTATS_CMD_ATTR_REGISTER_CPUMASK = 0x3 ++ TASKSTATS_CMD_ATTR_DEREGISTER_CPUMASK = 0x4 ++) ++ ++type CGroupStats struct { ++ Sleeping uint64 ++ Running uint64 ++ Stopped uint64 ++ Uninterruptible uint64 ++ Io_wait uint64 ++} ++ ++const ( ++ CGROUPSTATS_CMD_UNSPEC = 0x3 ++ CGROUPSTATS_CMD_GET = 0x4 ++ CGROUPSTATS_CMD_NEW = 0x5 ++ CGROUPSTATS_TYPE_UNSPEC = 0x0 ++ CGROUPSTATS_TYPE_CGROUP_STATS = 0x1 ++ CGROUPSTATS_CMD_ATTR_UNSPEC = 0x0 ++ CGROUPSTATS_CMD_ATTR_FD = 0x1 ++) ++ ++type Genlmsghdr struct { ++ Cmd uint8 ++ Version uint8 ++ Reserved uint16 ++} ++ ++const ( ++ CTRL_CMD_UNSPEC = 0x0 ++ CTRL_CMD_NEWFAMILY = 0x1 ++ CTRL_CMD_DELFAMILY = 0x2 ++ CTRL_CMD_GETFAMILY = 0x3 ++ CTRL_CMD_NEWOPS = 0x4 ++ CTRL_CMD_DELOPS = 0x5 ++ CTRL_CMD_GETOPS = 0x6 ++ CTRL_CMD_NEWMCAST_GRP = 0x7 ++ CTRL_CMD_DELMCAST_GRP = 0x8 ++ CTRL_CMD_GETMCAST_GRP = 0x9 ++ CTRL_CMD_GETPOLICY = 0xa ++ CTRL_ATTR_UNSPEC = 0x0 ++ CTRL_ATTR_FAMILY_ID = 0x1 ++ CTRL_ATTR_FAMILY_NAME = 0x2 ++ CTRL_ATTR_VERSION = 0x3 ++ CTRL_ATTR_HDRSIZE = 0x4 ++ CTRL_ATTR_MAXATTR = 0x5 ++ CTRL_ATTR_OPS = 0x6 ++ CTRL_ATTR_MCAST_GROUPS = 0x7 ++ CTRL_ATTR_POLICY = 0x8 ++ CTRL_ATTR_OP_POLICY = 0x9 ++ CTRL_ATTR_OP = 0xa ++ CTRL_ATTR_OP_UNSPEC = 0x0 ++ CTRL_ATTR_OP_ID = 0x1 ++ CTRL_ATTR_OP_FLAGS = 0x2 ++ CTRL_ATTR_MCAST_GRP_UNSPEC = 0x0 ++ CTRL_ATTR_MCAST_GRP_NAME = 0x1 ++ CTRL_ATTR_MCAST_GRP_ID = 0x2 ++ CTRL_ATTR_POLICY_UNSPEC = 0x0 ++ CTRL_ATTR_POLICY_DO = 0x1 ++ CTRL_ATTR_POLICY_DUMP = 0x2 ++ CTRL_ATTR_POLICY_DUMP_MAX = 0x2 ++) ++ ++type cpuMask uint64 ++ ++const ( ++ _CPU_SETSIZE = 0x400 ++ _NCPUBITS = 0x40 ++) ++ ++const ( ++ BDADDR_BREDR = 0x0 ++ BDADDR_LE_PUBLIC = 0x1 ++ BDADDR_LE_RANDOM = 0x2 ++) ++ ++type PerfEventAttr struct { ++ Type uint32 ++ Size uint32 ++ Config uint64 ++ Sample uint64 ++ Sample_type uint64 ++ Read_format uint64 ++ Bits uint64 ++ Wakeup uint32 ++ Bp_type uint32 ++ Ext1 uint64 ++ Ext2 uint64 ++ Branch_sample_type uint64 ++ Sample_regs_user uint64 ++ Sample_stack_user uint32 ++ Clockid int32 ++ Sample_regs_intr uint64 ++ Aux_watermark uint32 ++ Sample_max_stack uint16 ++ _ uint16 ++ Aux_sample_size uint32 ++ _ uint32 ++ Sig_data uint64 ++} ++ ++type PerfEventMmapPage struct { ++ Version uint32 ++ Compat_version uint32 ++ Lock uint32 ++ Index uint32 ++ Offset int64 ++ Time_enabled uint64 ++ Time_running uint64 ++ Capabilities uint64 ++ Pmc_width uint16 ++ Time_shift uint16 ++ Time_mult uint32 ++ Time_offset uint64 ++ Time_zero uint64 ++ Size uint32 ++ _ uint32 ++ Time_cycles uint64 ++ Time_mask uint64 ++ _ [928]uint8 ++ Data_head uint64 ++ Data_tail uint64 ++ Data_offset uint64 ++ Data_size uint64 ++ Aux_head uint64 ++ Aux_tail uint64 ++ Aux_offset uint64 ++ Aux_size uint64 ++} ++ ++const ( ++ PerfBitDisabled uint64 = CBitFieldMaskBit0 ++ PerfBitInherit = CBitFieldMaskBit1 ++ PerfBitPinned = CBitFieldMaskBit2 ++ PerfBitExclusive = CBitFieldMaskBit3 ++ PerfBitExcludeUser = CBitFieldMaskBit4 ++ PerfBitExcludeKernel = CBitFieldMaskBit5 ++ PerfBitExcludeHv = CBitFieldMaskBit6 ++ PerfBitExcludeIdle = CBitFieldMaskBit7 ++ PerfBitMmap = CBitFieldMaskBit8 ++ PerfBitComm = CBitFieldMaskBit9 ++ PerfBitFreq = CBitFieldMaskBit10 ++ PerfBitInheritStat = CBitFieldMaskBit11 ++ PerfBitEnableOnExec = CBitFieldMaskBit12 ++ PerfBitTask = CBitFieldMaskBit13 ++ PerfBitWatermark = CBitFieldMaskBit14 ++ PerfBitPreciseIPBit1 = CBitFieldMaskBit15 ++ PerfBitPreciseIPBit2 = CBitFieldMaskBit16 ++ PerfBitMmapData = CBitFieldMaskBit17 ++ PerfBitSampleIDAll = CBitFieldMaskBit18 ++ PerfBitExcludeHost = CBitFieldMaskBit19 ++ PerfBitExcludeGuest = CBitFieldMaskBit20 ++ PerfBitExcludeCallchainKernel = CBitFieldMaskBit21 ++ PerfBitExcludeCallchainUser = CBitFieldMaskBit22 ++ PerfBitMmap2 = CBitFieldMaskBit23 ++ PerfBitCommExec = CBitFieldMaskBit24 ++ PerfBitUseClockID = CBitFieldMaskBit25 ++ PerfBitContextSwitch = CBitFieldMaskBit26 ++) ++ ++const ( ++ PERF_TYPE_HARDWARE = 0x0 ++ PERF_TYPE_SOFTWARE = 0x1 ++ PERF_TYPE_TRACEPOINT = 0x2 ++ PERF_TYPE_HW_CACHE = 0x3 ++ PERF_TYPE_RAW = 0x4 ++ PERF_TYPE_BREAKPOINT = 0x5 ++ PERF_TYPE_MAX = 0x6 ++ PERF_COUNT_HW_CPU_CYCLES = 0x0 ++ PERF_COUNT_HW_INSTRUCTIONS = 0x1 ++ PERF_COUNT_HW_CACHE_REFERENCES = 0x2 ++ PERF_COUNT_HW_CACHE_MISSES = 0x3 ++ PERF_COUNT_HW_BRANCH_INSTRUCTIONS = 0x4 ++ PERF_COUNT_HW_BRANCH_MISSES = 0x5 ++ PERF_COUNT_HW_BUS_CYCLES = 0x6 ++ PERF_COUNT_HW_STALLED_CYCLES_FRONTEND = 0x7 ++ PERF_COUNT_HW_STALLED_CYCLES_BACKEND = 0x8 ++ PERF_COUNT_HW_REF_CPU_CYCLES = 0x9 ++ PERF_COUNT_HW_MAX = 0xa ++ PERF_COUNT_HW_CACHE_L1D = 0x0 ++ PERF_COUNT_HW_CACHE_L1I = 0x1 ++ PERF_COUNT_HW_CACHE_LL = 0x2 ++ PERF_COUNT_HW_CACHE_DTLB = 0x3 ++ PERF_COUNT_HW_CACHE_ITLB = 0x4 ++ PERF_COUNT_HW_CACHE_BPU = 0x5 ++ PERF_COUNT_HW_CACHE_NODE = 0x6 ++ PERF_COUNT_HW_CACHE_MAX = 0x7 ++ PERF_COUNT_HW_CACHE_OP_READ = 0x0 ++ PERF_COUNT_HW_CACHE_OP_WRITE = 0x1 ++ PERF_COUNT_HW_CACHE_OP_PREFETCH = 0x2 ++ PERF_COUNT_HW_CACHE_OP_MAX = 0x3 ++ PERF_COUNT_HW_CACHE_RESULT_ACCESS = 0x0 ++ PERF_COUNT_HW_CACHE_RESULT_MISS = 0x1 ++ PERF_COUNT_HW_CACHE_RESULT_MAX = 0x2 ++ PERF_COUNT_SW_CPU_CLOCK = 0x0 ++ PERF_COUNT_SW_TASK_CLOCK = 0x1 ++ PERF_COUNT_SW_PAGE_FAULTS = 0x2 ++ PERF_COUNT_SW_CONTEXT_SWITCHES = 0x3 ++ PERF_COUNT_SW_CPU_MIGRATIONS = 0x4 ++ PERF_COUNT_SW_PAGE_FAULTS_MIN = 0x5 ++ PERF_COUNT_SW_PAGE_FAULTS_MAJ = 0x6 ++ PERF_COUNT_SW_ALIGNMENT_FAULTS = 0x7 ++ PERF_COUNT_SW_EMULATION_FAULTS = 0x8 ++ PERF_COUNT_SW_DUMMY = 0x9 ++ PERF_COUNT_SW_BPF_OUTPUT = 0xa ++ PERF_COUNT_SW_MAX = 0xb ++ PERF_SAMPLE_IP = 0x1 ++ PERF_SAMPLE_TID = 0x2 ++ PERF_SAMPLE_TIME = 0x4 ++ PERF_SAMPLE_ADDR = 0x8 ++ PERF_SAMPLE_READ = 0x10 ++ PERF_SAMPLE_CALLCHAIN = 0x20 ++ PERF_SAMPLE_ID = 0x40 ++ PERF_SAMPLE_CPU = 0x80 ++ PERF_SAMPLE_PERIOD = 0x100 ++ PERF_SAMPLE_STREAM_ID = 0x200 ++ PERF_SAMPLE_RAW = 0x400 ++ PERF_SAMPLE_BRANCH_STACK = 0x800 ++ PERF_SAMPLE_REGS_USER = 0x1000 ++ PERF_SAMPLE_STACK_USER = 0x2000 ++ PERF_SAMPLE_WEIGHT = 0x4000 ++ PERF_SAMPLE_DATA_SRC = 0x8000 ++ PERF_SAMPLE_IDENTIFIER = 0x10000 ++ PERF_SAMPLE_TRANSACTION = 0x20000 ++ PERF_SAMPLE_REGS_INTR = 0x40000 ++ PERF_SAMPLE_PHYS_ADDR = 0x80000 ++ PERF_SAMPLE_AUX = 0x100000 ++ PERF_SAMPLE_CGROUP = 0x200000 ++ ++ PERF_SAMPLE_MAX = 0x400000 ++ PERF_SAMPLE_BRANCH_USER_SHIFT = 0x0 ++ PERF_SAMPLE_BRANCH_KERNEL_SHIFT = 0x1 ++ PERF_SAMPLE_BRANCH_HV_SHIFT = 0x2 ++ PERF_SAMPLE_BRANCH_ANY_SHIFT = 0x3 ++ PERF_SAMPLE_BRANCH_ANY_CALL_SHIFT = 0x4 ++ PERF_SAMPLE_BRANCH_ANY_RETURN_SHIFT = 0x5 ++ PERF_SAMPLE_BRANCH_IND_CALL_SHIFT = 0x6 ++ PERF_SAMPLE_BRANCH_ABORT_TX_SHIFT = 0x7 ++ PERF_SAMPLE_BRANCH_IN_TX_SHIFT = 0x8 ++ PERF_SAMPLE_BRANCH_NO_TX_SHIFT = 0x9 ++ PERF_SAMPLE_BRANCH_COND_SHIFT = 0xa ++ PERF_SAMPLE_BRANCH_CALL_STACK_SHIFT = 0xb ++ PERF_SAMPLE_BRANCH_IND_JUMP_SHIFT = 0xc ++ PERF_SAMPLE_BRANCH_CALL_SHIFT = 0xd ++ PERF_SAMPLE_BRANCH_NO_FLAGS_SHIFT = 0xe ++ PERF_SAMPLE_BRANCH_NO_CYCLES_SHIFT = 0xf ++ PERF_SAMPLE_BRANCH_TYPE_SAVE_SHIFT = 0x10 ++ PERF_SAMPLE_BRANCH_HW_INDEX_SHIFT = 0x11 ++ PERF_SAMPLE_BRANCH_MAX_SHIFT = 0x12 ++ PERF_SAMPLE_BRANCH_USER = 0x1 ++ PERF_SAMPLE_BRANCH_KERNEL = 0x2 ++ PERF_SAMPLE_BRANCH_HV = 0x4 ++ PERF_SAMPLE_BRANCH_ANY = 0x8 ++ PERF_SAMPLE_BRANCH_ANY_CALL = 0x10 ++ PERF_SAMPLE_BRANCH_ANY_RETURN = 0x20 ++ PERF_SAMPLE_BRANCH_IND_CALL = 0x40 ++ PERF_SAMPLE_BRANCH_ABORT_TX = 0x80 ++ PERF_SAMPLE_BRANCH_IN_TX = 0x100 ++ PERF_SAMPLE_BRANCH_NO_TX = 0x200 ++ PERF_SAMPLE_BRANCH_COND = 0x400 ++ PERF_SAMPLE_BRANCH_CALL_STACK = 0x800 ++ PERF_SAMPLE_BRANCH_IND_JUMP = 0x1000 ++ PERF_SAMPLE_BRANCH_CALL = 0x2000 ++ PERF_SAMPLE_BRANCH_NO_FLAGS = 0x4000 ++ PERF_SAMPLE_BRANCH_NO_CYCLES = 0x8000 ++ PERF_SAMPLE_BRANCH_TYPE_SAVE = 0x10000 ++ PERF_SAMPLE_BRANCH_HW_INDEX = 0x20000 ++ PERF_SAMPLE_BRANCH_MAX = 0x40000 ++ PERF_BR_UNKNOWN = 0x0 ++ PERF_BR_COND = 0x1 ++ PERF_BR_UNCOND = 0x2 ++ PERF_BR_IND = 0x3 ++ PERF_BR_CALL = 0x4 ++ PERF_BR_IND_CALL = 0x5 ++ PERF_BR_RET = 0x6 ++ PERF_BR_SYSCALL = 0x7 ++ PERF_BR_SYSRET = 0x8 ++ PERF_BR_COND_CALL = 0x9 ++ PERF_BR_COND_RET = 0xa ++ ++ PERF_BR_MAX = 0xb ++ PERF_SAMPLE_REGS_ABI_NONE = 0x0 ++ PERF_SAMPLE_REGS_ABI_32 = 0x1 ++ PERF_SAMPLE_REGS_ABI_64 = 0x2 ++ PERF_TXN_ELISION = 0x1 ++ PERF_TXN_TRANSACTION = 0x2 ++ PERF_TXN_SYNC = 0x4 ++ PERF_TXN_ASYNC = 0x8 ++ PERF_TXN_RETRY = 0x10 ++ PERF_TXN_CONFLICT = 0x20 ++ PERF_TXN_CAPACITY_WRITE = 0x40 ++ PERF_TXN_CAPACITY_READ = 0x80 ++ PERF_TXN_MAX = 0x100 ++ PERF_TXN_ABORT_MASK = -0x100000000 ++ PERF_TXN_ABORT_SHIFT = 0x20 ++ PERF_FORMAT_TOTAL_TIME_ENABLED = 0x1 ++ PERF_FORMAT_TOTAL_TIME_RUNNING = 0x2 ++ PERF_FORMAT_ID = 0x4 ++ PERF_FORMAT_GROUP = 0x8 ++ PERF_FORMAT_MAX = 0x10 ++ PERF_IOC_FLAG_GROUP = 0x1 ++ PERF_RECORD_MMAP = 0x1 ++ PERF_RECORD_LOST = 0x2 ++ PERF_RECORD_COMM = 0x3 ++ PERF_RECORD_EXIT = 0x4 ++ PERF_RECORD_THROTTLE = 0x5 ++ PERF_RECORD_UNTHROTTLE = 0x6 ++ PERF_RECORD_FORK = 0x7 ++ PERF_RECORD_READ = 0x8 ++ PERF_RECORD_SAMPLE = 0x9 ++ PERF_RECORD_MMAP2 = 0xa ++ PERF_RECORD_AUX = 0xb ++ PERF_RECORD_ITRACE_START = 0xc ++ PERF_RECORD_LOST_SAMPLES = 0xd ++ PERF_RECORD_SWITCH = 0xe ++ PERF_RECORD_SWITCH_CPU_WIDE = 0xf ++ PERF_RECORD_NAMESPACES = 0x10 ++ PERF_RECORD_KSYMBOL = 0x11 ++ PERF_RECORD_BPF_EVENT = 0x12 ++ PERF_RECORD_CGROUP = 0x13 ++ PERF_RECORD_TEXT_POKE = 0x14 ++ PERF_RECORD_AUX_OUTPUT_HW_ID = 0x15 ++ ++ PERF_RECORD_MAX = 0x16 ++ PERF_RECORD_KSYMBOL_TYPE_UNKNOWN = 0x0 ++ PERF_RECORD_KSYMBOL_TYPE_BPF = 0x1 ++ PERF_RECORD_KSYMBOL_TYPE_OOL = 0x2 ++ PERF_RECORD_KSYMBOL_TYPE_MAX = 0x3 ++ PERF_BPF_EVENT_UNKNOWN = 0x0 ++ PERF_BPF_EVENT_PROG_LOAD = 0x1 ++ PERF_BPF_EVENT_PROG_UNLOAD = 0x2 ++ PERF_BPF_EVENT_MAX = 0x3 ++ PERF_CONTEXT_HV = -0x20 ++ PERF_CONTEXT_KERNEL = -0x80 ++ PERF_CONTEXT_USER = -0x200 ++ PERF_CONTEXT_GUEST = -0x800 ++ PERF_CONTEXT_GUEST_KERNEL = -0x880 ++ PERF_CONTEXT_GUEST_USER = -0xa00 ++ PERF_CONTEXT_MAX = -0xfff ++) ++ ++const ( ++ CBitFieldMaskBit0 = 0x1 ++ CBitFieldMaskBit1 = 0x2 ++ CBitFieldMaskBit2 = 0x4 ++ CBitFieldMaskBit3 = 0x8 ++ CBitFieldMaskBit4 = 0x10 ++ CBitFieldMaskBit5 = 0x20 ++ CBitFieldMaskBit6 = 0x40 ++ CBitFieldMaskBit7 = 0x80 ++ CBitFieldMaskBit8 = 0x100 ++ CBitFieldMaskBit9 = 0x200 ++ CBitFieldMaskBit10 = 0x400 ++ CBitFieldMaskBit11 = 0x800 ++ CBitFieldMaskBit12 = 0x1000 ++ CBitFieldMaskBit13 = 0x2000 ++ CBitFieldMaskBit14 = 0x4000 ++ CBitFieldMaskBit15 = 0x8000 ++ CBitFieldMaskBit16 = 0x10000 ++ CBitFieldMaskBit17 = 0x20000 ++ CBitFieldMaskBit18 = 0x40000 ++ CBitFieldMaskBit19 = 0x80000 ++ CBitFieldMaskBit20 = 0x100000 ++ CBitFieldMaskBit21 = 0x200000 ++ CBitFieldMaskBit22 = 0x400000 ++ CBitFieldMaskBit23 = 0x800000 ++ CBitFieldMaskBit24 = 0x1000000 ++ CBitFieldMaskBit25 = 0x2000000 ++ CBitFieldMaskBit26 = 0x4000000 ++ CBitFieldMaskBit27 = 0x8000000 ++ CBitFieldMaskBit28 = 0x10000000 ++ CBitFieldMaskBit29 = 0x20000000 ++ CBitFieldMaskBit30 = 0x40000000 ++ CBitFieldMaskBit31 = 0x80000000 ++ CBitFieldMaskBit32 = 0x100000000 ++ CBitFieldMaskBit33 = 0x200000000 ++ CBitFieldMaskBit34 = 0x400000000 ++ CBitFieldMaskBit35 = 0x800000000 ++ CBitFieldMaskBit36 = 0x1000000000 ++ CBitFieldMaskBit37 = 0x2000000000 ++ CBitFieldMaskBit38 = 0x4000000000 ++ CBitFieldMaskBit39 = 0x8000000000 ++ CBitFieldMaskBit40 = 0x10000000000 ++ CBitFieldMaskBit41 = 0x20000000000 ++ CBitFieldMaskBit42 = 0x40000000000 ++ CBitFieldMaskBit43 = 0x80000000000 ++ CBitFieldMaskBit44 = 0x100000000000 ++ CBitFieldMaskBit45 = 0x200000000000 ++ CBitFieldMaskBit46 = 0x400000000000 ++ CBitFieldMaskBit47 = 0x800000000000 ++ CBitFieldMaskBit48 = 0x1000000000000 ++ CBitFieldMaskBit49 = 0x2000000000000 ++ CBitFieldMaskBit50 = 0x4000000000000 ++ CBitFieldMaskBit51 = 0x8000000000000 ++ CBitFieldMaskBit52 = 0x10000000000000 ++ CBitFieldMaskBit53 = 0x20000000000000 ++ CBitFieldMaskBit54 = 0x40000000000000 ++ CBitFieldMaskBit55 = 0x80000000000000 ++ CBitFieldMaskBit56 = 0x100000000000000 ++ CBitFieldMaskBit57 = 0x200000000000000 ++ CBitFieldMaskBit58 = 0x400000000000000 ++ CBitFieldMaskBit59 = 0x800000000000000 ++ CBitFieldMaskBit60 = 0x1000000000000000 ++ CBitFieldMaskBit61 = 0x2000000000000000 ++ CBitFieldMaskBit62 = 0x4000000000000000 ++ CBitFieldMaskBit63 = 0x8000000000000000 ++) ++ ++type SockaddrStorage struct { ++ Family uint16 ++ _ [118]int8 ++ _ uint64 ++} ++ ++type TCPMD5Sig struct { ++ Addr SockaddrStorage ++ Flags uint8 ++ Prefixlen uint8 ++ Keylen uint16 ++ _ uint32 ++ Key [80]uint8 ++} ++ ++type HDDriveCmdHdr struct { ++ Command uint8 ++ Number uint8 ++ Feature uint8 ++ Count uint8 ++} ++ ++type HDGeometry struct { ++ Heads uint8 ++ Sectors uint8 ++ Cylinders uint16 ++ Start uint64 ++} ++ ++type HDDriveID struct { ++ Config uint16 ++ Cyls uint16 ++ Reserved2 uint16 ++ Heads uint16 ++ Track_bytes uint16 ++ Sector_bytes uint16 ++ Sectors uint16 ++ Vendor0 uint16 ++ Vendor1 uint16 ++ Vendor2 uint16 ++ Serial_no [20]uint8 ++ Buf_type uint16 ++ Buf_size uint16 ++ Ecc_bytes uint16 ++ Fw_rev [8]uint8 ++ Model [40]uint8 ++ Max_multsect uint8 ++ Vendor3 uint8 ++ Dword_io uint16 ++ Vendor4 uint8 ++ Capability uint8 ++ Reserved50 uint16 ++ Vendor5 uint8 ++ TPIO uint8 ++ Vendor6 uint8 ++ TDMA uint8 ++ Field_valid uint16 ++ Cur_cyls uint16 ++ Cur_heads uint16 ++ Cur_sectors uint16 ++ Cur_capacity0 uint16 ++ Cur_capacity1 uint16 ++ Multsect uint8 ++ Multsect_valid uint8 ++ Lba_capacity uint32 ++ Dma_1word uint16 ++ Dma_mword uint16 ++ Eide_pio_modes uint16 ++ Eide_dma_min uint16 ++ Eide_dma_time uint16 ++ Eide_pio uint16 ++ Eide_pio_iordy uint16 ++ Words69_70 [2]uint16 ++ Words71_74 [4]uint16 ++ Queue_depth uint16 ++ Words76_79 [4]uint16 ++ Major_rev_num uint16 ++ Minor_rev_num uint16 ++ Command_set_1 uint16 ++ Command_set_2 uint16 ++ Cfsse uint16 ++ Cfs_enable_1 uint16 ++ Cfs_enable_2 uint16 ++ Csf_default uint16 ++ Dma_ultra uint16 ++ Trseuc uint16 ++ TrsEuc uint16 ++ CurAPMvalues uint16 ++ Mprc uint16 ++ Hw_config uint16 ++ Acoustic uint16 ++ Msrqs uint16 ++ Sxfert uint16 ++ Sal uint16 ++ Spg uint32 ++ Lba_capacity_2 uint64 ++ Words104_125 [22]uint16 ++ Last_lun uint16 ++ Word127 uint16 ++ Dlf uint16 ++ Csfo uint16 ++ Words130_155 [26]uint16 ++ Word156 uint16 ++ Words157_159 [3]uint16 ++ Cfa_power uint16 ++ Words161_175 [15]uint16 ++ Words176_205 [30]uint16 ++ Words206_254 [49]uint16 ++ Integrity_word uint16 ++} ++ ++type Statfs_t struct { ++ Type int64 ++ Bsize int64 ++ Blocks int64 ++ Bfree int64 ++ Bavail int64 ++ Files int64 ++ Ffree int64 ++ Fsid Fsid ++ Namelen int64 ++ Frsize int64 ++ Flags int64 ++ Spare [4]int64 ++} ++ ++const ( ++ ST_MANDLOCK = 0x40 ++ ST_NOATIME = 0x400 ++ ST_NODEV = 0x4 ++ ST_NODIRATIME = 0x800 ++ ST_NOEXEC = 0x8 ++ ST_NOSUID = 0x2 ++ ST_RDONLY = 0x1 ++ ST_RELATIME = 0x1000 ++ ST_SYNCHRONOUS = 0x10 ++) ++ ++type TpacketHdr struct { ++ Status uint64 ++ Len uint32 ++ Snaplen uint32 ++ Mac uint16 ++ Net uint16 ++ Sec uint32 ++ Usec uint32 ++ _ [4]byte ++} ++ ++type Tpacket2Hdr struct { ++ Status uint32 ++ Len uint32 ++ Snaplen uint32 ++ Mac uint16 ++ Net uint16 ++ Sec uint32 ++ Nsec uint32 ++ Vlan_tci uint16 ++ Vlan_tpid uint16 ++ _ [4]uint8 ++} ++ ++type Tpacket3Hdr struct { ++ Next_offset uint32 ++ Sec uint32 ++ Nsec uint32 ++ Snaplen uint32 ++ Len uint32 ++ Status uint32 ++ Mac uint16 ++ Net uint16 ++ Hv1 TpacketHdrVariant1 ++ _ [8]uint8 ++} ++ ++type TpacketHdrVariant1 struct { ++ Rxhash uint32 ++ Vlan_tci uint32 ++ Vlan_tpid uint16 ++ _ uint16 ++} ++ ++type TpacketBlockDesc struct { ++ Version uint32 ++ To_priv uint32 ++ Hdr [40]byte ++} ++ ++type TpacketBDTS struct { ++ Sec uint32 ++ Usec uint32 ++} ++ ++type TpacketHdrV1 struct { ++ Block_status uint32 ++ Num_pkts uint32 ++ Offset_to_first_pkt uint32 ++ Blk_len uint32 ++ Seq_num uint64 ++ Ts_first_pkt TpacketBDTS ++ Ts_last_pkt TpacketBDTS ++} ++ ++type TpacketReq struct { ++ Block_size uint32 ++ Block_nr uint32 ++ Frame_size uint32 ++ Frame_nr uint32 ++} ++ ++type TpacketReq3 struct { ++ Block_size uint32 ++ Block_nr uint32 ++ Frame_size uint32 ++ Frame_nr uint32 ++ Retire_blk_tov uint32 ++ Sizeof_priv uint32 ++ Feature_req_word uint32 ++} ++ ++type TpacketStats struct { ++ Packets uint32 ++ Drops uint32 ++} ++ ++type TpacketStatsV3 struct { ++ Packets uint32 ++ Drops uint32 ++ Freeze_q_cnt uint32 ++} ++ ++type TpacketAuxdata struct { ++ Status uint32 ++ Len uint32 ++ Snaplen uint32 ++ Mac uint16 ++ Net uint16 ++ Vlan_tci uint16 ++ Vlan_tpid uint16 ++} ++ ++const ( ++ TPACKET_V1 = 0x0 ++ TPACKET_V2 = 0x1 ++ TPACKET_V3 = 0x2 ++) ++ ++const ( ++ SizeofTpacketHdr = 0x20 ++ SizeofTpacket2Hdr = 0x20 ++ SizeofTpacket3Hdr = 0x30 ++ ++ SizeofTpacketStats = 0x8 ++ SizeofTpacketStatsV3 = 0xc ++) ++ ++const ( ++ IFLA_UNSPEC = 0x0 ++ IFLA_ADDRESS = 0x1 ++ IFLA_BROADCAST = 0x2 ++ IFLA_IFNAME = 0x3 ++ IFLA_MTU = 0x4 ++ IFLA_LINK = 0x5 ++ IFLA_QDISC = 0x6 ++ IFLA_STATS = 0x7 ++ IFLA_COST = 0x8 ++ IFLA_PRIORITY = 0x9 ++ IFLA_MASTER = 0xa ++ IFLA_WIRELESS = 0xb ++ IFLA_PROTINFO = 0xc ++ IFLA_TXQLEN = 0xd ++ IFLA_MAP = 0xe ++ IFLA_WEIGHT = 0xf ++ IFLA_OPERSTATE = 0x10 ++ IFLA_LINKMODE = 0x11 ++ IFLA_LINKINFO = 0x12 ++ IFLA_NET_NS_PID = 0x13 ++ IFLA_IFALIAS = 0x14 ++ IFLA_NUM_VF = 0x15 ++ IFLA_VFINFO_LIST = 0x16 ++ IFLA_STATS64 = 0x17 ++ IFLA_VF_PORTS = 0x18 ++ IFLA_PORT_SELF = 0x19 ++ IFLA_AF_SPEC = 0x1a ++ IFLA_GROUP = 0x1b ++ IFLA_NET_NS_FD = 0x1c ++ IFLA_EXT_MASK = 0x1d ++ IFLA_PROMISCUITY = 0x1e ++ IFLA_NUM_TX_QUEUES = 0x1f ++ IFLA_NUM_RX_QUEUES = 0x20 ++ IFLA_CARRIER = 0x21 ++ IFLA_PHYS_PORT_ID = 0x22 ++ IFLA_CARRIER_CHANGES = 0x23 ++ IFLA_PHYS_SWITCH_ID = 0x24 ++ IFLA_LINK_NETNSID = 0x25 ++ IFLA_PHYS_PORT_NAME = 0x26 ++ IFLA_PROTO_DOWN = 0x27 ++ IFLA_GSO_MAX_SEGS = 0x28 ++ IFLA_GSO_MAX_SIZE = 0x29 ++ IFLA_PAD = 0x2a ++ IFLA_XDP = 0x2b ++ IFLA_EVENT = 0x2c ++ IFLA_NEW_NETNSID = 0x2d ++ IFLA_IF_NETNSID = 0x2e ++ IFLA_TARGET_NETNSID = 0x2e ++ IFLA_CARRIER_UP_COUNT = 0x2f ++ IFLA_CARRIER_DOWN_COUNT = 0x30 ++ IFLA_NEW_IFINDEX = 0x31 ++ IFLA_MIN_MTU = 0x32 ++ IFLA_MAX_MTU = 0x33 ++ IFLA_PROP_LIST = 0x34 ++ IFLA_ALT_IFNAME = 0x35 ++ IFLA_PERM_ADDRESS = 0x36 ++ IFLA_PROTO_DOWN_REASON = 0x37 ++ ++ IFLA_PROTO_DOWN_REASON_UNSPEC = 0x0 ++ IFLA_PROTO_DOWN_REASON_MASK = 0x1 ++ IFLA_PROTO_DOWN_REASON_VALUE = 0x2 ++ IFLA_PROTO_DOWN_REASON_MAX = 0x2 ++ IFLA_INET_UNSPEC = 0x0 ++ IFLA_INET_CONF = 0x1 ++ IFLA_INET6_UNSPEC = 0x0 ++ IFLA_INET6_FLAGS = 0x1 ++ IFLA_INET6_CONF = 0x2 ++ IFLA_INET6_STATS = 0x3 ++ IFLA_INET6_MCAST = 0x4 ++ IFLA_INET6_CACHEINFO = 0x5 ++ IFLA_INET6_ICMP6STATS = 0x6 ++ IFLA_INET6_TOKEN = 0x7 ++ IFLA_INET6_ADDR_GEN_MODE = 0x8 ++ IFLA_BR_UNSPEC = 0x0 ++ IFLA_BR_FORWARD_DELAY = 0x1 ++ IFLA_BR_HELLO_TIME = 0x2 ++ IFLA_BR_MAX_AGE = 0x3 ++ IFLA_BR_AGEING_TIME = 0x4 ++ IFLA_BR_STP_STATE = 0x5 ++ IFLA_BR_PRIORITY = 0x6 ++ IFLA_BR_VLAN_FILTERING = 0x7 ++ IFLA_BR_VLAN_PROTOCOL = 0x8 ++ IFLA_BR_GROUP_FWD_MASK = 0x9 ++ IFLA_BR_ROOT_ID = 0xa ++ IFLA_BR_BRIDGE_ID = 0xb ++ IFLA_BR_ROOT_PORT = 0xc ++ IFLA_BR_ROOT_PATH_COST = 0xd ++ IFLA_BR_TOPOLOGY_CHANGE = 0xe ++ IFLA_BR_TOPOLOGY_CHANGE_DETECTED = 0xf ++ IFLA_BR_HELLO_TIMER = 0x10 ++ IFLA_BR_TCN_TIMER = 0x11 ++ IFLA_BR_TOPOLOGY_CHANGE_TIMER = 0x12 ++ IFLA_BR_GC_TIMER = 0x13 ++ IFLA_BR_GROUP_ADDR = 0x14 ++ IFLA_BR_FDB_FLUSH = 0x15 ++ IFLA_BR_MCAST_ROUTER = 0x16 ++ IFLA_BR_MCAST_SNOOPING = 0x17 ++ IFLA_BR_MCAST_QUERY_USE_IFADDR = 0x18 ++ IFLA_BR_MCAST_QUERIER = 0x19 ++ IFLA_BR_MCAST_HASH_ELASTICITY = 0x1a ++ IFLA_BR_MCAST_HASH_MAX = 0x1b ++ IFLA_BR_MCAST_LAST_MEMBER_CNT = 0x1c ++ IFLA_BR_MCAST_STARTUP_QUERY_CNT = 0x1d ++ IFLA_BR_MCAST_LAST_MEMBER_INTVL = 0x1e ++ IFLA_BR_MCAST_MEMBERSHIP_INTVL = 0x1f ++ IFLA_BR_MCAST_QUERIER_INTVL = 0x20 ++ IFLA_BR_MCAST_QUERY_INTVL = 0x21 ++ IFLA_BR_MCAST_QUERY_RESPONSE_INTVL = 0x22 ++ IFLA_BR_MCAST_STARTUP_QUERY_INTVL = 0x23 ++ IFLA_BR_NF_CALL_IPTABLES = 0x24 ++ IFLA_BR_NF_CALL_IP6TABLES = 0x25 ++ IFLA_BR_NF_CALL_ARPTABLES = 0x26 ++ IFLA_BR_VLAN_DEFAULT_PVID = 0x27 ++ IFLA_BR_PAD = 0x28 ++ IFLA_BR_VLAN_STATS_ENABLED = 0x29 ++ IFLA_BR_MCAST_STATS_ENABLED = 0x2a ++ IFLA_BR_MCAST_IGMP_VERSION = 0x2b ++ IFLA_BR_MCAST_MLD_VERSION = 0x2c ++ IFLA_BR_VLAN_STATS_PER_PORT = 0x2d ++ IFLA_BR_MULTI_BOOLOPT = 0x2e ++ IFLA_BRPORT_UNSPEC = 0x0 ++ IFLA_BRPORT_STATE = 0x1 ++ IFLA_BRPORT_PRIORITY = 0x2 ++ IFLA_BRPORT_COST = 0x3 ++ IFLA_BRPORT_MODE = 0x4 ++ IFLA_BRPORT_GUARD = 0x5 ++ IFLA_BRPORT_PROTECT = 0x6 ++ IFLA_BRPORT_FAST_LEAVE = 0x7 ++ IFLA_BRPORT_LEARNING = 0x8 ++ IFLA_BRPORT_UNICAST_FLOOD = 0x9 ++ IFLA_BRPORT_PROXYARP = 0xa ++ IFLA_BRPORT_LEARNING_SYNC = 0xb ++ IFLA_BRPORT_PROXYARP_WIFI = 0xc ++ IFLA_BRPORT_ROOT_ID = 0xd ++ IFLA_BRPORT_BRIDGE_ID = 0xe ++ IFLA_BRPORT_DESIGNATED_PORT = 0xf ++ IFLA_BRPORT_DESIGNATED_COST = 0x10 ++ IFLA_BRPORT_ID = 0x11 ++ IFLA_BRPORT_NO = 0x12 ++ IFLA_BRPORT_TOPOLOGY_CHANGE_ACK = 0x13 ++ IFLA_BRPORT_CONFIG_PENDING = 0x14 ++ IFLA_BRPORT_MESSAGE_AGE_TIMER = 0x15 ++ IFLA_BRPORT_FORWARD_DELAY_TIMER = 0x16 ++ IFLA_BRPORT_HOLD_TIMER = 0x17 ++ IFLA_BRPORT_FLUSH = 0x18 ++ IFLA_BRPORT_MULTICAST_ROUTER = 0x19 ++ IFLA_BRPORT_PAD = 0x1a ++ IFLA_BRPORT_MCAST_FLOOD = 0x1b ++ IFLA_BRPORT_MCAST_TO_UCAST = 0x1c ++ IFLA_BRPORT_VLAN_TUNNEL = 0x1d ++ IFLA_BRPORT_BCAST_FLOOD = 0x1e ++ IFLA_BRPORT_GROUP_FWD_MASK = 0x1f ++ IFLA_BRPORT_NEIGH_SUPPRESS = 0x20 ++ IFLA_BRPORT_ISOLATED = 0x21 ++ IFLA_BRPORT_BACKUP_PORT = 0x22 ++ IFLA_BRPORT_MRP_RING_OPEN = 0x23 ++ IFLA_BRPORT_MRP_IN_OPEN = 0x24 ++ IFLA_INFO_UNSPEC = 0x0 ++ IFLA_INFO_KIND = 0x1 ++ IFLA_INFO_DATA = 0x2 ++ IFLA_INFO_XSTATS = 0x3 ++ IFLA_INFO_SLAVE_KIND = 0x4 ++ IFLA_INFO_SLAVE_DATA = 0x5 ++ IFLA_VLAN_UNSPEC = 0x0 ++ IFLA_VLAN_ID = 0x1 ++ IFLA_VLAN_FLAGS = 0x2 ++ IFLA_VLAN_EGRESS_QOS = 0x3 ++ IFLA_VLAN_INGRESS_QOS = 0x4 ++ IFLA_VLAN_PROTOCOL = 0x5 ++ IFLA_VLAN_QOS_UNSPEC = 0x0 ++ IFLA_VLAN_QOS_MAPPING = 0x1 ++ IFLA_MACVLAN_UNSPEC = 0x0 ++ IFLA_MACVLAN_MODE = 0x1 ++ IFLA_MACVLAN_FLAGS = 0x2 ++ IFLA_MACVLAN_MACADDR_MODE = 0x3 ++ IFLA_MACVLAN_MACADDR = 0x4 ++ IFLA_MACVLAN_MACADDR_DATA = 0x5 ++ IFLA_MACVLAN_MACADDR_COUNT = 0x6 ++ IFLA_VRF_UNSPEC = 0x0 ++ IFLA_VRF_TABLE = 0x1 ++ IFLA_VRF_PORT_UNSPEC = 0x0 ++ IFLA_VRF_PORT_TABLE = 0x1 ++ IFLA_MACSEC_UNSPEC = 0x0 ++ IFLA_MACSEC_SCI = 0x1 ++ IFLA_MACSEC_PORT = 0x2 ++ IFLA_MACSEC_ICV_LEN = 0x3 ++ IFLA_MACSEC_CIPHER_SUITE = 0x4 ++ IFLA_MACSEC_WINDOW = 0x5 ++ IFLA_MACSEC_ENCODING_SA = 0x6 ++ IFLA_MACSEC_ENCRYPT = 0x7 ++ IFLA_MACSEC_PROTECT = 0x8 ++ IFLA_MACSEC_INC_SCI = 0x9 ++ IFLA_MACSEC_ES = 0xa ++ IFLA_MACSEC_SCB = 0xb ++ IFLA_MACSEC_REPLAY_PROTECT = 0xc ++ IFLA_MACSEC_VALIDATION = 0xd ++ IFLA_MACSEC_PAD = 0xe ++ IFLA_MACSEC_OFFLOAD = 0xf ++ IFLA_XFRM_UNSPEC = 0x0 ++ IFLA_XFRM_LINK = 0x1 ++ IFLA_XFRM_IF_ID = 0x2 ++ IFLA_IPVLAN_UNSPEC = 0x0 ++ IFLA_IPVLAN_MODE = 0x1 ++ IFLA_IPVLAN_FLAGS = 0x2 ++ IFLA_VXLAN_UNSPEC = 0x0 ++ IFLA_VXLAN_ID = 0x1 ++ IFLA_VXLAN_GROUP = 0x2 ++ IFLA_VXLAN_LINK = 0x3 ++ IFLA_VXLAN_LOCAL = 0x4 ++ IFLA_VXLAN_TTL = 0x5 ++ IFLA_VXLAN_TOS = 0x6 ++ IFLA_VXLAN_LEARNING = 0x7 ++ IFLA_VXLAN_AGEING = 0x8 ++ IFLA_VXLAN_LIMIT = 0x9 ++ IFLA_VXLAN_PORT_RANGE = 0xa ++ IFLA_VXLAN_PROXY = 0xb ++ IFLA_VXLAN_RSC = 0xc ++ IFLA_VXLAN_L2MISS = 0xd ++ IFLA_VXLAN_L3MISS = 0xe ++ IFLA_VXLAN_PORT = 0xf ++ IFLA_VXLAN_GROUP6 = 0x10 ++ IFLA_VXLAN_LOCAL6 = 0x11 ++ IFLA_VXLAN_UDP_CSUM = 0x12 ++ IFLA_VXLAN_UDP_ZERO_CSUM6_TX = 0x13 ++ IFLA_VXLAN_UDP_ZERO_CSUM6_RX = 0x14 ++ IFLA_VXLAN_REMCSUM_TX = 0x15 ++ IFLA_VXLAN_REMCSUM_RX = 0x16 ++ IFLA_VXLAN_GBP = 0x17 ++ IFLA_VXLAN_REMCSUM_NOPARTIAL = 0x18 ++ IFLA_VXLAN_COLLECT_METADATA = 0x19 ++ IFLA_VXLAN_LABEL = 0x1a ++ IFLA_VXLAN_GPE = 0x1b ++ IFLA_VXLAN_TTL_INHERIT = 0x1c ++ IFLA_VXLAN_DF = 0x1d ++ IFLA_GENEVE_UNSPEC = 0x0 ++ IFLA_GENEVE_ID = 0x1 ++ IFLA_GENEVE_REMOTE = 0x2 ++ IFLA_GENEVE_TTL = 0x3 ++ IFLA_GENEVE_TOS = 0x4 ++ IFLA_GENEVE_PORT = 0x5 ++ IFLA_GENEVE_COLLECT_METADATA = 0x6 ++ IFLA_GENEVE_REMOTE6 = 0x7 ++ IFLA_GENEVE_UDP_CSUM = 0x8 ++ IFLA_GENEVE_UDP_ZERO_CSUM6_TX = 0x9 ++ IFLA_GENEVE_UDP_ZERO_CSUM6_RX = 0xa ++ IFLA_GENEVE_LABEL = 0xb ++ IFLA_GENEVE_TTL_INHERIT = 0xc ++ IFLA_GENEVE_DF = 0xd ++ IFLA_BAREUDP_UNSPEC = 0x0 ++ IFLA_BAREUDP_PORT = 0x1 ++ IFLA_BAREUDP_ETHERTYPE = 0x2 ++ IFLA_BAREUDP_SRCPORT_MIN = 0x3 ++ IFLA_BAREUDP_MULTIPROTO_MODE = 0x4 ++ IFLA_PPP_UNSPEC = 0x0 ++ IFLA_PPP_DEV_FD = 0x1 ++ IFLA_GTP_UNSPEC = 0x0 ++ IFLA_GTP_FD0 = 0x1 ++ IFLA_GTP_FD1 = 0x2 ++ IFLA_GTP_PDP_HASHSIZE = 0x3 ++ IFLA_GTP_ROLE = 0x4 ++ IFLA_BOND_UNSPEC = 0x0 ++ IFLA_BOND_MODE = 0x1 ++ IFLA_BOND_ACTIVE_SLAVE = 0x2 ++ IFLA_BOND_MIIMON = 0x3 ++ IFLA_BOND_UPDELAY = 0x4 ++ IFLA_BOND_DOWNDELAY = 0x5 ++ IFLA_BOND_USE_CARRIER = 0x6 ++ IFLA_BOND_ARP_INTERVAL = 0x7 ++ IFLA_BOND_ARP_IP_TARGET = 0x8 ++ IFLA_BOND_ARP_VALIDATE = 0x9 ++ IFLA_BOND_ARP_ALL_TARGETS = 0xa ++ IFLA_BOND_PRIMARY = 0xb ++ IFLA_BOND_PRIMARY_RESELECT = 0xc ++ IFLA_BOND_FAIL_OVER_MAC = 0xd ++ IFLA_BOND_XMIT_HASH_POLICY = 0xe ++ IFLA_BOND_RESEND_IGMP = 0xf ++ IFLA_BOND_NUM_PEER_NOTIF = 0x10 ++ IFLA_BOND_ALL_SLAVES_ACTIVE = 0x11 ++ IFLA_BOND_MIN_LINKS = 0x12 ++ IFLA_BOND_LP_INTERVAL = 0x13 ++ IFLA_BOND_PACKETS_PER_SLAVE = 0x14 ++ IFLA_BOND_AD_LACP_RATE = 0x15 ++ IFLA_BOND_AD_SELECT = 0x16 ++ IFLA_BOND_AD_INFO = 0x17 ++ IFLA_BOND_AD_ACTOR_SYS_PRIO = 0x18 ++ IFLA_BOND_AD_USER_PORT_KEY = 0x19 ++ IFLA_BOND_AD_ACTOR_SYSTEM = 0x1a ++ IFLA_BOND_TLB_DYNAMIC_LB = 0x1b ++ IFLA_BOND_PEER_NOTIF_DELAY = 0x1c ++ IFLA_BOND_AD_INFO_UNSPEC = 0x0 ++ IFLA_BOND_AD_INFO_AGGREGATOR = 0x1 ++ IFLA_BOND_AD_INFO_NUM_PORTS = 0x2 ++ IFLA_BOND_AD_INFO_ACTOR_KEY = 0x3 ++ IFLA_BOND_AD_INFO_PARTNER_KEY = 0x4 ++ IFLA_BOND_AD_INFO_PARTNER_MAC = 0x5 ++ IFLA_BOND_SLAVE_UNSPEC = 0x0 ++ IFLA_BOND_SLAVE_STATE = 0x1 ++ IFLA_BOND_SLAVE_MII_STATUS = 0x2 ++ IFLA_BOND_SLAVE_LINK_FAILURE_COUNT = 0x3 ++ IFLA_BOND_SLAVE_PERM_HWADDR = 0x4 ++ IFLA_BOND_SLAVE_QUEUE_ID = 0x5 ++ IFLA_BOND_SLAVE_AD_AGGREGATOR_ID = 0x6 ++ IFLA_BOND_SLAVE_AD_ACTOR_OPER_PORT_STATE = 0x7 ++ IFLA_BOND_SLAVE_AD_PARTNER_OPER_PORT_STATE = 0x8 ++ IFLA_VF_INFO_UNSPEC = 0x0 ++ IFLA_VF_INFO = 0x1 ++ IFLA_VF_UNSPEC = 0x0 ++ IFLA_VF_MAC = 0x1 ++ IFLA_VF_VLAN = 0x2 ++ IFLA_VF_TX_RATE = 0x3 ++ IFLA_VF_SPOOFCHK = 0x4 ++ IFLA_VF_LINK_STATE = 0x5 ++ IFLA_VF_RATE = 0x6 ++ IFLA_VF_RSS_QUERY_EN = 0x7 ++ IFLA_VF_STATS = 0x8 ++ IFLA_VF_TRUST = 0x9 ++ IFLA_VF_IB_NODE_GUID = 0xa ++ IFLA_VF_IB_PORT_GUID = 0xb ++ IFLA_VF_VLAN_LIST = 0xc ++ IFLA_VF_BROADCAST = 0xd ++ IFLA_VF_VLAN_INFO_UNSPEC = 0x0 ++ IFLA_VF_VLAN_INFO = 0x1 ++ IFLA_VF_LINK_STATE_AUTO = 0x0 ++ IFLA_VF_LINK_STATE_ENABLE = 0x1 ++ IFLA_VF_LINK_STATE_DISABLE = 0x2 ++ IFLA_VF_STATS_RX_PACKETS = 0x0 ++ IFLA_VF_STATS_TX_PACKETS = 0x1 ++ IFLA_VF_STATS_RX_BYTES = 0x2 ++ IFLA_VF_STATS_TX_BYTES = 0x3 ++ IFLA_VF_STATS_BROADCAST = 0x4 ++ IFLA_VF_STATS_MULTICAST = 0x5 ++ IFLA_VF_STATS_PAD = 0x6 ++ IFLA_VF_STATS_RX_DROPPED = 0x7 ++ IFLA_VF_STATS_TX_DROPPED = 0x8 ++ IFLA_VF_PORT_UNSPEC = 0x0 ++ IFLA_VF_PORT = 0x1 ++ IFLA_PORT_UNSPEC = 0x0 ++ IFLA_PORT_VF = 0x1 ++ IFLA_PORT_PROFILE = 0x2 ++ IFLA_PORT_VSI_TYPE = 0x3 ++ IFLA_PORT_INSTANCE_UUID = 0x4 ++ IFLA_PORT_HOST_UUID = 0x5 ++ IFLA_PORT_REQUEST = 0x6 ++ IFLA_PORT_RESPONSE = 0x7 ++ IFLA_IPOIB_UNSPEC = 0x0 ++ IFLA_IPOIB_PKEY = 0x1 ++ IFLA_IPOIB_MODE = 0x2 ++ IFLA_IPOIB_UMCAST = 0x3 ++ IFLA_HSR_UNSPEC = 0x0 ++ IFLA_HSR_SLAVE1 = 0x1 ++ IFLA_HSR_SLAVE2 = 0x2 ++ IFLA_HSR_MULTICAST_SPEC = 0x3 ++ IFLA_HSR_SUPERVISION_ADDR = 0x4 ++ IFLA_HSR_SEQ_NR = 0x5 ++ IFLA_HSR_VERSION = 0x6 ++ IFLA_HSR_PROTOCOL = 0x7 ++ IFLA_STATS_UNSPEC = 0x0 ++ IFLA_STATS_LINK_64 = 0x1 ++ IFLA_STATS_LINK_XSTATS = 0x2 ++ IFLA_STATS_LINK_XSTATS_SLAVE = 0x3 ++ IFLA_STATS_LINK_OFFLOAD_XSTATS = 0x4 ++ IFLA_STATS_AF_SPEC = 0x5 ++ IFLA_OFFLOAD_XSTATS_UNSPEC = 0x0 ++ IFLA_OFFLOAD_XSTATS_CPU_HIT = 0x1 ++ IFLA_XDP_UNSPEC = 0x0 ++ IFLA_XDP_FD = 0x1 ++ IFLA_XDP_ATTACHED = 0x2 ++ IFLA_XDP_FLAGS = 0x3 ++ IFLA_XDP_PROG_ID = 0x4 ++ IFLA_XDP_DRV_PROG_ID = 0x5 ++ IFLA_XDP_SKB_PROG_ID = 0x6 ++ IFLA_XDP_HW_PROG_ID = 0x7 ++ IFLA_XDP_EXPECTED_FD = 0x8 ++ IFLA_EVENT_NONE = 0x0 ++ IFLA_EVENT_REBOOT = 0x1 ++ IFLA_EVENT_FEATURES = 0x2 ++ IFLA_EVENT_BONDING_FAILOVER = 0x3 ++ IFLA_EVENT_NOTIFY_PEERS = 0x4 ++ IFLA_EVENT_IGMP_RESEND = 0x5 ++ IFLA_EVENT_BONDING_OPTIONS = 0x6 ++ IFLA_TUN_UNSPEC = 0x0 ++ IFLA_TUN_OWNER = 0x1 ++ IFLA_TUN_GROUP = 0x2 ++ IFLA_TUN_TYPE = 0x3 ++ IFLA_TUN_PI = 0x4 ++ IFLA_TUN_VNET_HDR = 0x5 ++ IFLA_TUN_PERSIST = 0x6 ++ IFLA_TUN_MULTI_QUEUE = 0x7 ++ IFLA_TUN_NUM_QUEUES = 0x8 ++ IFLA_TUN_NUM_DISABLED_QUEUES = 0x9 ++ IFLA_RMNET_UNSPEC = 0x0 ++ IFLA_RMNET_MUX_ID = 0x1 ++ IFLA_RMNET_FLAGS = 0x2 ++) ++ ++const ( ++ NF_INET_PRE_ROUTING = 0x0 ++ NF_INET_LOCAL_IN = 0x1 ++ NF_INET_FORWARD = 0x2 ++ NF_INET_LOCAL_OUT = 0x3 ++ NF_INET_POST_ROUTING = 0x4 ++ NF_INET_NUMHOOKS = 0x5 ++) ++ ++const ( ++ NF_NETDEV_INGRESS = 0x0 ++ NF_NETDEV_EGRESS = 0x1 ++ ++ NF_NETDEV_NUMHOOKS = 0x2 ++) ++ ++const ( ++ NFPROTO_UNSPEC = 0x0 ++ NFPROTO_INET = 0x1 ++ NFPROTO_IPV4 = 0x2 ++ NFPROTO_ARP = 0x3 ++ NFPROTO_NETDEV = 0x5 ++ NFPROTO_BRIDGE = 0x7 ++ NFPROTO_IPV6 = 0xa ++ NFPROTO_DECNET = 0xc ++ NFPROTO_NUMPROTO = 0xd ++) ++ ++const SO_ORIGINAL_DST = 0x50 ++ ++type Nfgenmsg struct { ++ Nfgen_family uint8 ++ Version uint8 ++ Res_id uint16 ++} ++ ++const ( ++ NFNL_BATCH_UNSPEC = 0x0 ++ NFNL_BATCH_GENID = 0x1 ++) ++ ++const ( ++ NFT_REG_VERDICT = 0x0 ++ NFT_REG_1 = 0x1 ++ NFT_REG_2 = 0x2 ++ NFT_REG_3 = 0x3 ++ NFT_REG_4 = 0x4 ++ NFT_REG32_00 = 0x8 ++ NFT_REG32_01 = 0x9 ++ NFT_REG32_02 = 0xa ++ NFT_REG32_03 = 0xb ++ NFT_REG32_04 = 0xc ++ NFT_REG32_05 = 0xd ++ NFT_REG32_06 = 0xe ++ NFT_REG32_07 = 0xf ++ NFT_REG32_08 = 0x10 ++ NFT_REG32_09 = 0x11 ++ NFT_REG32_10 = 0x12 ++ NFT_REG32_11 = 0x13 ++ NFT_REG32_12 = 0x14 ++ NFT_REG32_13 = 0x15 ++ NFT_REG32_14 = 0x16 ++ NFT_REG32_15 = 0x17 ++ NFT_CONTINUE = -0x1 ++ NFT_BREAK = -0x2 ++ NFT_JUMP = -0x3 ++ NFT_GOTO = -0x4 ++ NFT_RETURN = -0x5 ++ NFT_MSG_NEWTABLE = 0x0 ++ NFT_MSG_GETTABLE = 0x1 ++ NFT_MSG_DELTABLE = 0x2 ++ NFT_MSG_NEWCHAIN = 0x3 ++ NFT_MSG_GETCHAIN = 0x4 ++ NFT_MSG_DELCHAIN = 0x5 ++ NFT_MSG_NEWRULE = 0x6 ++ NFT_MSG_GETRULE = 0x7 ++ NFT_MSG_DELRULE = 0x8 ++ NFT_MSG_NEWSET = 0x9 ++ NFT_MSG_GETSET = 0xa ++ NFT_MSG_DELSET = 0xb ++ NFT_MSG_NEWSETELEM = 0xc ++ NFT_MSG_GETSETELEM = 0xd ++ NFT_MSG_DELSETELEM = 0xe ++ NFT_MSG_NEWGEN = 0xf ++ NFT_MSG_GETGEN = 0x10 ++ NFT_MSG_TRACE = 0x11 ++ NFT_MSG_NEWOBJ = 0x12 ++ NFT_MSG_GETOBJ = 0x13 ++ NFT_MSG_DELOBJ = 0x14 ++ NFT_MSG_GETOBJ_RESET = 0x15 ++ NFT_MSG_MAX = 0x19 ++ NFTA_LIST_UNSPEC = 0x0 ++ NFTA_LIST_ELEM = 0x1 ++ NFTA_HOOK_UNSPEC = 0x0 ++ NFTA_HOOK_HOOKNUM = 0x1 ++ NFTA_HOOK_PRIORITY = 0x2 ++ NFTA_HOOK_DEV = 0x3 ++ NFT_TABLE_F_DORMANT = 0x1 ++ NFTA_TABLE_UNSPEC = 0x0 ++ NFTA_TABLE_NAME = 0x1 ++ NFTA_TABLE_FLAGS = 0x2 ++ NFTA_TABLE_USE = 0x3 ++ NFTA_CHAIN_UNSPEC = 0x0 ++ NFTA_CHAIN_TABLE = 0x1 ++ NFTA_CHAIN_HANDLE = 0x2 ++ NFTA_CHAIN_NAME = 0x3 ++ NFTA_CHAIN_HOOK = 0x4 ++ NFTA_CHAIN_POLICY = 0x5 ++ NFTA_CHAIN_USE = 0x6 ++ NFTA_CHAIN_TYPE = 0x7 ++ NFTA_CHAIN_COUNTERS = 0x8 ++ NFTA_CHAIN_PAD = 0x9 ++ NFTA_RULE_UNSPEC = 0x0 ++ NFTA_RULE_TABLE = 0x1 ++ NFTA_RULE_CHAIN = 0x2 ++ NFTA_RULE_HANDLE = 0x3 ++ NFTA_RULE_EXPRESSIONS = 0x4 ++ NFTA_RULE_COMPAT = 0x5 ++ NFTA_RULE_POSITION = 0x6 ++ NFTA_RULE_USERDATA = 0x7 ++ NFTA_RULE_PAD = 0x8 ++ NFTA_RULE_ID = 0x9 ++ NFT_RULE_COMPAT_F_INV = 0x2 ++ NFT_RULE_COMPAT_F_MASK = 0x2 ++ NFTA_RULE_COMPAT_UNSPEC = 0x0 ++ NFTA_RULE_COMPAT_PROTO = 0x1 ++ NFTA_RULE_COMPAT_FLAGS = 0x2 ++ NFT_SET_ANONYMOUS = 0x1 ++ NFT_SET_CONSTANT = 0x2 ++ NFT_SET_INTERVAL = 0x4 ++ NFT_SET_MAP = 0x8 ++ NFT_SET_TIMEOUT = 0x10 ++ NFT_SET_EVAL = 0x20 ++ NFT_SET_OBJECT = 0x40 ++ NFT_SET_POL_PERFORMANCE = 0x0 ++ NFT_SET_POL_MEMORY = 0x1 ++ NFTA_SET_DESC_UNSPEC = 0x0 ++ NFTA_SET_DESC_SIZE = 0x1 ++ NFTA_SET_UNSPEC = 0x0 ++ NFTA_SET_TABLE = 0x1 ++ NFTA_SET_NAME = 0x2 ++ NFTA_SET_FLAGS = 0x3 ++ NFTA_SET_KEY_TYPE = 0x4 ++ NFTA_SET_KEY_LEN = 0x5 ++ NFTA_SET_DATA_TYPE = 0x6 ++ NFTA_SET_DATA_LEN = 0x7 ++ NFTA_SET_POLICY = 0x8 ++ NFTA_SET_DESC = 0x9 ++ NFTA_SET_ID = 0xa ++ NFTA_SET_TIMEOUT = 0xb ++ NFTA_SET_GC_INTERVAL = 0xc ++ NFTA_SET_USERDATA = 0xd ++ NFTA_SET_PAD = 0xe ++ NFTA_SET_OBJ_TYPE = 0xf ++ NFT_SET_ELEM_INTERVAL_END = 0x1 ++ NFTA_SET_ELEM_UNSPEC = 0x0 ++ NFTA_SET_ELEM_KEY = 0x1 ++ NFTA_SET_ELEM_DATA = 0x2 ++ NFTA_SET_ELEM_FLAGS = 0x3 ++ NFTA_SET_ELEM_TIMEOUT = 0x4 ++ NFTA_SET_ELEM_EXPIRATION = 0x5 ++ NFTA_SET_ELEM_USERDATA = 0x6 ++ NFTA_SET_ELEM_EXPR = 0x7 ++ NFTA_SET_ELEM_PAD = 0x8 ++ NFTA_SET_ELEM_OBJREF = 0x9 ++ NFTA_SET_ELEM_LIST_UNSPEC = 0x0 ++ NFTA_SET_ELEM_LIST_TABLE = 0x1 ++ NFTA_SET_ELEM_LIST_SET = 0x2 ++ NFTA_SET_ELEM_LIST_ELEMENTS = 0x3 ++ NFTA_SET_ELEM_LIST_SET_ID = 0x4 ++ NFT_DATA_VALUE = 0x0 ++ NFT_DATA_VERDICT = 0xffffff00 ++ NFTA_DATA_UNSPEC = 0x0 ++ NFTA_DATA_VALUE = 0x1 ++ NFTA_DATA_VERDICT = 0x2 ++ NFTA_VERDICT_UNSPEC = 0x0 ++ NFTA_VERDICT_CODE = 0x1 ++ NFTA_VERDICT_CHAIN = 0x2 ++ NFTA_EXPR_UNSPEC = 0x0 ++ NFTA_EXPR_NAME = 0x1 ++ NFTA_EXPR_DATA = 0x2 ++ NFTA_IMMEDIATE_UNSPEC = 0x0 ++ NFTA_IMMEDIATE_DREG = 0x1 ++ NFTA_IMMEDIATE_DATA = 0x2 ++ NFTA_BITWISE_UNSPEC = 0x0 ++ NFTA_BITWISE_SREG = 0x1 ++ NFTA_BITWISE_DREG = 0x2 ++ NFTA_BITWISE_LEN = 0x3 ++ NFTA_BITWISE_MASK = 0x4 ++ NFTA_BITWISE_XOR = 0x5 ++ NFT_BYTEORDER_NTOH = 0x0 ++ NFT_BYTEORDER_HTON = 0x1 ++ NFTA_BYTEORDER_UNSPEC = 0x0 ++ NFTA_BYTEORDER_SREG = 0x1 ++ NFTA_BYTEORDER_DREG = 0x2 ++ NFTA_BYTEORDER_OP = 0x3 ++ NFTA_BYTEORDER_LEN = 0x4 ++ NFTA_BYTEORDER_SIZE = 0x5 ++ NFT_CMP_EQ = 0x0 ++ NFT_CMP_NEQ = 0x1 ++ NFT_CMP_LT = 0x2 ++ NFT_CMP_LTE = 0x3 ++ NFT_CMP_GT = 0x4 ++ NFT_CMP_GTE = 0x5 ++ NFTA_CMP_UNSPEC = 0x0 ++ NFTA_CMP_SREG = 0x1 ++ NFTA_CMP_OP = 0x2 ++ NFTA_CMP_DATA = 0x3 ++ NFT_RANGE_EQ = 0x0 ++ NFT_RANGE_NEQ = 0x1 ++ NFTA_RANGE_UNSPEC = 0x0 ++ NFTA_RANGE_SREG = 0x1 ++ NFTA_RANGE_OP = 0x2 ++ NFTA_RANGE_FROM_DATA = 0x3 ++ NFTA_RANGE_TO_DATA = 0x4 ++ NFT_LOOKUP_F_INV = 0x1 ++ NFTA_LOOKUP_UNSPEC = 0x0 ++ NFTA_LOOKUP_SET = 0x1 ++ NFTA_LOOKUP_SREG = 0x2 ++ NFTA_LOOKUP_DREG = 0x3 ++ NFTA_LOOKUP_SET_ID = 0x4 ++ NFTA_LOOKUP_FLAGS = 0x5 ++ NFT_DYNSET_OP_ADD = 0x0 ++ NFT_DYNSET_OP_UPDATE = 0x1 ++ NFT_DYNSET_F_INV = 0x1 ++ NFTA_DYNSET_UNSPEC = 0x0 ++ NFTA_DYNSET_SET_NAME = 0x1 ++ NFTA_DYNSET_SET_ID = 0x2 ++ NFTA_DYNSET_OP = 0x3 ++ NFTA_DYNSET_SREG_KEY = 0x4 ++ NFTA_DYNSET_SREG_DATA = 0x5 ++ NFTA_DYNSET_TIMEOUT = 0x6 ++ NFTA_DYNSET_EXPR = 0x7 ++ NFTA_DYNSET_PAD = 0x8 ++ NFTA_DYNSET_FLAGS = 0x9 ++ NFT_PAYLOAD_LL_HEADER = 0x0 ++ NFT_PAYLOAD_NETWORK_HEADER = 0x1 ++ NFT_PAYLOAD_TRANSPORT_HEADER = 0x2 ++ NFT_PAYLOAD_CSUM_NONE = 0x0 ++ NFT_PAYLOAD_CSUM_INET = 0x1 ++ NFT_PAYLOAD_L4CSUM_PSEUDOHDR = 0x1 ++ NFTA_PAYLOAD_UNSPEC = 0x0 ++ NFTA_PAYLOAD_DREG = 0x1 ++ NFTA_PAYLOAD_BASE = 0x2 ++ NFTA_PAYLOAD_OFFSET = 0x3 ++ NFTA_PAYLOAD_LEN = 0x4 ++ NFTA_PAYLOAD_SREG = 0x5 ++ NFTA_PAYLOAD_CSUM_TYPE = 0x6 ++ NFTA_PAYLOAD_CSUM_OFFSET = 0x7 ++ NFTA_PAYLOAD_CSUM_FLAGS = 0x8 ++ NFT_EXTHDR_F_PRESENT = 0x1 ++ NFT_EXTHDR_OP_IPV6 = 0x0 ++ NFT_EXTHDR_OP_TCPOPT = 0x1 ++ NFTA_EXTHDR_UNSPEC = 0x0 ++ NFTA_EXTHDR_DREG = 0x1 ++ NFTA_EXTHDR_TYPE = 0x2 ++ NFTA_EXTHDR_OFFSET = 0x3 ++ NFTA_EXTHDR_LEN = 0x4 ++ NFTA_EXTHDR_FLAGS = 0x5 ++ NFTA_EXTHDR_OP = 0x6 ++ NFTA_EXTHDR_SREG = 0x7 ++ NFT_META_LEN = 0x0 ++ NFT_META_PROTOCOL = 0x1 ++ NFT_META_PRIORITY = 0x2 ++ NFT_META_MARK = 0x3 ++ NFT_META_IIF = 0x4 ++ NFT_META_OIF = 0x5 ++ NFT_META_IIFNAME = 0x6 ++ NFT_META_OIFNAME = 0x7 ++ NFT_META_IIFTYPE = 0x8 ++ NFT_META_OIFTYPE = 0x9 ++ NFT_META_SKUID = 0xa ++ NFT_META_SKGID = 0xb ++ NFT_META_NFTRACE = 0xc ++ NFT_META_RTCLASSID = 0xd ++ NFT_META_SECMARK = 0xe ++ NFT_META_NFPROTO = 0xf ++ NFT_META_L4PROTO = 0x10 ++ NFT_META_BRI_IIFNAME = 0x11 ++ NFT_META_BRI_OIFNAME = 0x12 ++ NFT_META_PKTTYPE = 0x13 ++ NFT_META_CPU = 0x14 ++ NFT_META_IIFGROUP = 0x15 ++ NFT_META_OIFGROUP = 0x16 ++ NFT_META_CGROUP = 0x17 ++ NFT_META_PRANDOM = 0x18 ++ NFT_RT_CLASSID = 0x0 ++ NFT_RT_NEXTHOP4 = 0x1 ++ NFT_RT_NEXTHOP6 = 0x2 ++ NFT_RT_TCPMSS = 0x3 ++ NFT_HASH_JENKINS = 0x0 ++ NFT_HASH_SYM = 0x1 ++ NFTA_HASH_UNSPEC = 0x0 ++ NFTA_HASH_SREG = 0x1 ++ NFTA_HASH_DREG = 0x2 ++ NFTA_HASH_LEN = 0x3 ++ NFTA_HASH_MODULUS = 0x4 ++ NFTA_HASH_SEED = 0x5 ++ NFTA_HASH_OFFSET = 0x6 ++ NFTA_HASH_TYPE = 0x7 ++ NFTA_META_UNSPEC = 0x0 ++ NFTA_META_DREG = 0x1 ++ NFTA_META_KEY = 0x2 ++ NFTA_META_SREG = 0x3 ++ NFTA_RT_UNSPEC = 0x0 ++ NFTA_RT_DREG = 0x1 ++ NFTA_RT_KEY = 0x2 ++ NFT_CT_STATE = 0x0 ++ NFT_CT_DIRECTION = 0x1 ++ NFT_CT_STATUS = 0x2 ++ NFT_CT_MARK = 0x3 ++ NFT_CT_SECMARK = 0x4 ++ NFT_CT_EXPIRATION = 0x5 ++ NFT_CT_HELPER = 0x6 ++ NFT_CT_L3PROTOCOL = 0x7 ++ NFT_CT_SRC = 0x8 ++ NFT_CT_DST = 0x9 ++ NFT_CT_PROTOCOL = 0xa ++ NFT_CT_PROTO_SRC = 0xb ++ NFT_CT_PROTO_DST = 0xc ++ NFT_CT_LABELS = 0xd ++ NFT_CT_PKTS = 0xe ++ NFT_CT_BYTES = 0xf ++ NFT_CT_AVGPKT = 0x10 ++ NFT_CT_ZONE = 0x11 ++ NFT_CT_EVENTMASK = 0x12 ++ NFTA_CT_UNSPEC = 0x0 ++ NFTA_CT_DREG = 0x1 ++ NFTA_CT_KEY = 0x2 ++ NFTA_CT_DIRECTION = 0x3 ++ NFTA_CT_SREG = 0x4 ++ NFT_LIMIT_PKTS = 0x0 ++ NFT_LIMIT_PKT_BYTES = 0x1 ++ NFT_LIMIT_F_INV = 0x1 ++ NFTA_LIMIT_UNSPEC = 0x0 ++ NFTA_LIMIT_RATE = 0x1 ++ NFTA_LIMIT_UNIT = 0x2 ++ NFTA_LIMIT_BURST = 0x3 ++ NFTA_LIMIT_TYPE = 0x4 ++ NFTA_LIMIT_FLAGS = 0x5 ++ NFTA_LIMIT_PAD = 0x6 ++ NFTA_COUNTER_UNSPEC = 0x0 ++ NFTA_COUNTER_BYTES = 0x1 ++ NFTA_COUNTER_PACKETS = 0x2 ++ NFTA_COUNTER_PAD = 0x3 ++ NFTA_LOG_UNSPEC = 0x0 ++ NFTA_LOG_GROUP = 0x1 ++ NFTA_LOG_PREFIX = 0x2 ++ NFTA_LOG_SNAPLEN = 0x3 ++ NFTA_LOG_QTHRESHOLD = 0x4 ++ NFTA_LOG_LEVEL = 0x5 ++ NFTA_LOG_FLAGS = 0x6 ++ NFTA_QUEUE_UNSPEC = 0x0 ++ NFTA_QUEUE_NUM = 0x1 ++ NFTA_QUEUE_TOTAL = 0x2 ++ NFTA_QUEUE_FLAGS = 0x3 ++ NFTA_QUEUE_SREG_QNUM = 0x4 ++ NFT_QUOTA_F_INV = 0x1 ++ NFT_QUOTA_F_DEPLETED = 0x2 ++ NFTA_QUOTA_UNSPEC = 0x0 ++ NFTA_QUOTA_BYTES = 0x1 ++ NFTA_QUOTA_FLAGS = 0x2 ++ NFTA_QUOTA_PAD = 0x3 ++ NFTA_QUOTA_CONSUMED = 0x4 ++ NFT_REJECT_ICMP_UNREACH = 0x0 ++ NFT_REJECT_TCP_RST = 0x1 ++ NFT_REJECT_ICMPX_UNREACH = 0x2 ++ NFT_REJECT_ICMPX_NO_ROUTE = 0x0 ++ NFT_REJECT_ICMPX_PORT_UNREACH = 0x1 ++ NFT_REJECT_ICMPX_HOST_UNREACH = 0x2 ++ NFT_REJECT_ICMPX_ADMIN_PROHIBITED = 0x3 ++ NFTA_REJECT_UNSPEC = 0x0 ++ NFTA_REJECT_TYPE = 0x1 ++ NFTA_REJECT_ICMP_CODE = 0x2 ++ NFT_NAT_SNAT = 0x0 ++ NFT_NAT_DNAT = 0x1 ++ NFTA_NAT_UNSPEC = 0x0 ++ NFTA_NAT_TYPE = 0x1 ++ NFTA_NAT_FAMILY = 0x2 ++ NFTA_NAT_REG_ADDR_MIN = 0x3 ++ NFTA_NAT_REG_ADDR_MAX = 0x4 ++ NFTA_NAT_REG_PROTO_MIN = 0x5 ++ NFTA_NAT_REG_PROTO_MAX = 0x6 ++ NFTA_NAT_FLAGS = 0x7 ++ NFTA_MASQ_UNSPEC = 0x0 ++ NFTA_MASQ_FLAGS = 0x1 ++ NFTA_MASQ_REG_PROTO_MIN = 0x2 ++ NFTA_MASQ_REG_PROTO_MAX = 0x3 ++ NFTA_REDIR_UNSPEC = 0x0 ++ NFTA_REDIR_REG_PROTO_MIN = 0x1 ++ NFTA_REDIR_REG_PROTO_MAX = 0x2 ++ NFTA_REDIR_FLAGS = 0x3 ++ NFTA_DUP_UNSPEC = 0x0 ++ NFTA_DUP_SREG_ADDR = 0x1 ++ NFTA_DUP_SREG_DEV = 0x2 ++ NFTA_FWD_UNSPEC = 0x0 ++ NFTA_FWD_SREG_DEV = 0x1 ++ NFTA_OBJREF_UNSPEC = 0x0 ++ NFTA_OBJREF_IMM_TYPE = 0x1 ++ NFTA_OBJREF_IMM_NAME = 0x2 ++ NFTA_OBJREF_SET_SREG = 0x3 ++ NFTA_OBJREF_SET_NAME = 0x4 ++ NFTA_OBJREF_SET_ID = 0x5 ++ NFTA_GEN_UNSPEC = 0x0 ++ NFTA_GEN_ID = 0x1 ++ NFTA_GEN_PROC_PID = 0x2 ++ NFTA_GEN_PROC_NAME = 0x3 ++ NFTA_FIB_UNSPEC = 0x0 ++ NFTA_FIB_DREG = 0x1 ++ NFTA_FIB_RESULT = 0x2 ++ NFTA_FIB_FLAGS = 0x3 ++ NFT_FIB_RESULT_UNSPEC = 0x0 ++ NFT_FIB_RESULT_OIF = 0x1 ++ NFT_FIB_RESULT_OIFNAME = 0x2 ++ NFT_FIB_RESULT_ADDRTYPE = 0x3 ++ NFTA_FIB_F_SADDR = 0x1 ++ NFTA_FIB_F_DADDR = 0x2 ++ NFTA_FIB_F_MARK = 0x4 ++ NFTA_FIB_F_IIF = 0x8 ++ NFTA_FIB_F_OIF = 0x10 ++ NFTA_FIB_F_PRESENT = 0x20 ++ NFTA_CT_HELPER_UNSPEC = 0x0 ++ NFTA_CT_HELPER_NAME = 0x1 ++ NFTA_CT_HELPER_L3PROTO = 0x2 ++ NFTA_CT_HELPER_L4PROTO = 0x3 ++ NFTA_OBJ_UNSPEC = 0x0 ++ NFTA_OBJ_TABLE = 0x1 ++ NFTA_OBJ_NAME = 0x2 ++ NFTA_OBJ_TYPE = 0x3 ++ NFTA_OBJ_DATA = 0x4 ++ NFTA_OBJ_USE = 0x5 ++ NFTA_TRACE_UNSPEC = 0x0 ++ NFTA_TRACE_TABLE = 0x1 ++ NFTA_TRACE_CHAIN = 0x2 ++ NFTA_TRACE_RULE_HANDLE = 0x3 ++ NFTA_TRACE_TYPE = 0x4 ++ NFTA_TRACE_VERDICT = 0x5 ++ NFTA_TRACE_ID = 0x6 ++ NFTA_TRACE_LL_HEADER = 0x7 ++ NFTA_TRACE_NETWORK_HEADER = 0x8 ++ NFTA_TRACE_TRANSPORT_HEADER = 0x9 ++ NFTA_TRACE_IIF = 0xa ++ NFTA_TRACE_IIFTYPE = 0xb ++ NFTA_TRACE_OIF = 0xc ++ NFTA_TRACE_OIFTYPE = 0xd ++ NFTA_TRACE_MARK = 0xe ++ NFTA_TRACE_NFPROTO = 0xf ++ NFTA_TRACE_POLICY = 0x10 ++ NFTA_TRACE_PAD = 0x11 ++ NFT_TRACETYPE_UNSPEC = 0x0 ++ NFT_TRACETYPE_POLICY = 0x1 ++ NFT_TRACETYPE_RETURN = 0x2 ++ NFT_TRACETYPE_RULE = 0x3 ++ NFTA_NG_UNSPEC = 0x0 ++ NFTA_NG_DREG = 0x1 ++ NFTA_NG_MODULUS = 0x2 ++ NFTA_NG_TYPE = 0x3 ++ NFTA_NG_OFFSET = 0x4 ++ NFT_NG_INCREMENTAL = 0x0 ++ NFT_NG_RANDOM = 0x1 ++) ++ ++const ( ++ NFTA_TARGET_UNSPEC = 0x0 ++ NFTA_TARGET_NAME = 0x1 ++ NFTA_TARGET_REV = 0x2 ++ NFTA_TARGET_INFO = 0x3 ++ NFTA_MATCH_UNSPEC = 0x0 ++ NFTA_MATCH_NAME = 0x1 ++ NFTA_MATCH_REV = 0x2 ++ NFTA_MATCH_INFO = 0x3 ++ NFTA_COMPAT_UNSPEC = 0x0 ++ NFTA_COMPAT_NAME = 0x1 ++ NFTA_COMPAT_REV = 0x2 ++ NFTA_COMPAT_TYPE = 0x3 ++) ++ ++type RTCTime struct { ++ Sec int32 ++ Min int32 ++ Hour int32 ++ Mday int32 ++ Mon int32 ++ Year int32 ++ Wday int32 ++ Yday int32 ++ Isdst int32 ++} ++ ++type RTCWkAlrm struct { ++ Enabled uint8 ++ Pending uint8 ++ Time RTCTime ++} ++ ++type RTCPLLInfo struct { ++ Ctrl int32 ++ Value int32 ++ Max int32 ++ Min int32 ++ Posmult int32 ++ Negmult int32 ++ Clock int64 ++} ++ ++type BlkpgIoctlArg struct { ++ Op int32 ++ Flags int32 ++ Datalen int32 ++ Data *byte ++} ++ ++type BlkpgPartition struct { ++ Start int64 ++ Length int64 ++ Pno int32 ++ Devname [64]uint8 ++ Volname [64]uint8 ++ _ [4]byte ++} ++ ++const ( ++ BLKPG = 0x20001269 ++ BLKPG_ADD_PARTITION = 0x1 ++ BLKPG_DEL_PARTITION = 0x2 ++ BLKPG_RESIZE_PARTITION = 0x3 ++) ++ ++const ( ++ NETNSA_NONE = 0x0 ++ NETNSA_NSID = 0x1 ++ NETNSA_PID = 0x2 ++ NETNSA_FD = 0x3 ++ NETNSA_TARGET_NSID = 0x4 ++ NETNSA_CURRENT_NSID = 0x5 ++) ++ ++type XDPRingOffset struct { ++ Producer uint64 ++ Consumer uint64 ++ Desc uint64 ++ Flags uint64 ++} ++ ++type XDPMmapOffsets struct { ++ Rx XDPRingOffset ++ Tx XDPRingOffset ++ Fr XDPRingOffset ++ Cr XDPRingOffset ++} ++ ++type XDPUmemReg struct { ++ Addr uint64 ++ Len uint64 ++ Size uint32 ++ Headroom uint32 ++ Flags uint32 ++ _ [4]byte ++} ++ ++type XDPStatistics struct { ++ Rx_dropped uint64 ++ Rx_invalid_descs uint64 ++ Tx_invalid_descs uint64 ++ Rx_ring_full uint64 ++ Rx_fill_ring_empty_descs uint64 ++ Tx_ring_empty_descs uint64 ++} ++ ++type XDPDesc struct { ++ Addr uint64 ++ Len uint32 ++ Options uint32 ++} ++ ++const ( ++ NCSI_CMD_UNSPEC = 0x0 ++ NCSI_CMD_PKG_INFO = 0x1 ++ NCSI_CMD_SET_INTERFACE = 0x2 ++ NCSI_CMD_CLEAR_INTERFACE = 0x3 ++ NCSI_ATTR_UNSPEC = 0x0 ++ NCSI_ATTR_IFINDEX = 0x1 ++ NCSI_ATTR_PACKAGE_LIST = 0x2 ++ NCSI_ATTR_PACKAGE_ID = 0x3 ++ NCSI_ATTR_CHANNEL_ID = 0x4 ++ NCSI_PKG_ATTR_UNSPEC = 0x0 ++ NCSI_PKG_ATTR = 0x1 ++ NCSI_PKG_ATTR_ID = 0x2 ++ NCSI_PKG_ATTR_FORCED = 0x3 ++ NCSI_PKG_ATTR_CHANNEL_LIST = 0x4 ++ NCSI_CHANNEL_ATTR_UNSPEC = 0x0 ++ NCSI_CHANNEL_ATTR = 0x1 ++ NCSI_CHANNEL_ATTR_ID = 0x2 ++ NCSI_CHANNEL_ATTR_VERSION_MAJOR = 0x3 ++ NCSI_CHANNEL_ATTR_VERSION_MINOR = 0x4 ++ NCSI_CHANNEL_ATTR_VERSION_STR = 0x5 ++ NCSI_CHANNEL_ATTR_LINK_STATE = 0x6 ++ NCSI_CHANNEL_ATTR_ACTIVE = 0x7 ++ NCSI_CHANNEL_ATTR_FORCED = 0x8 ++ NCSI_CHANNEL_ATTR_VLAN_LIST = 0x9 ++ NCSI_CHANNEL_ATTR_VLAN_ID = 0xa ++) ++ ++type ScmTimestamping struct { ++ Ts [3]Timespec ++} ++ ++const ( ++ SOF_TIMESTAMPING_TX_HARDWARE = 0x1 ++ SOF_TIMESTAMPING_TX_SOFTWARE = 0x2 ++ SOF_TIMESTAMPING_RX_HARDWARE = 0x4 ++ SOF_TIMESTAMPING_RX_SOFTWARE = 0x8 ++ SOF_TIMESTAMPING_SOFTWARE = 0x10 ++ SOF_TIMESTAMPING_SYS_HARDWARE = 0x20 ++ SOF_TIMESTAMPING_RAW_HARDWARE = 0x40 ++ SOF_TIMESTAMPING_OPT_ID = 0x80 ++ SOF_TIMESTAMPING_TX_SCHED = 0x100 ++ SOF_TIMESTAMPING_TX_ACK = 0x200 ++ SOF_TIMESTAMPING_OPT_CMSG = 0x400 ++ SOF_TIMESTAMPING_OPT_TSONLY = 0x800 ++ SOF_TIMESTAMPING_OPT_STATS = 0x1000 ++ SOF_TIMESTAMPING_OPT_PKTINFO = 0x2000 ++ SOF_TIMESTAMPING_OPT_TX_SWHW = 0x4000 ++ ++ SOF_TIMESTAMPING_LAST = 0x4000 ++ SOF_TIMESTAMPING_MASK = 0x7fff ++ ++ SCM_TSTAMP_SND = 0x0 ++ SCM_TSTAMP_SCHED = 0x1 ++ SCM_TSTAMP_ACK = 0x2 ++) ++ ++type SockExtendedErr struct { ++ Errno uint32 ++ Origin uint8 ++ Type uint8 ++ Code uint8 ++ Pad uint8 ++ Info uint32 ++ Data uint32 ++} ++ ++type FanotifyEventMetadata struct { ++ Event_len uint32 ++ Vers uint8 ++ Reserved uint8 ++ Metadata_len uint16 ++ Mask uint64 ++ Fd int32 ++ Pid int32 ++} ++ ++type FanotifyResponse struct { ++ Fd int32 ++ Response uint32 ++} ++ ++const ( ++ CRYPTO_MSG_BASE = 0x10 ++ CRYPTO_MSG_NEWALG = 0x10 ++ CRYPTO_MSG_DELALG = 0x11 ++ CRYPTO_MSG_UPDATEALG = 0x12 ++ CRYPTO_MSG_GETALG = 0x13 ++ CRYPTO_MSG_DELRNG = 0x14 ++ CRYPTO_MSG_GETSTAT = 0x15 ++) ++ ++const ( ++ CRYPTOCFGA_UNSPEC = 0x0 ++ CRYPTOCFGA_PRIORITY_VAL = 0x1 ++ CRYPTOCFGA_REPORT_LARVAL = 0x2 ++ CRYPTOCFGA_REPORT_HASH = 0x3 ++ CRYPTOCFGA_REPORT_BLKCIPHER = 0x4 ++ CRYPTOCFGA_REPORT_AEAD = 0x5 ++ CRYPTOCFGA_REPORT_COMPRESS = 0x6 ++ CRYPTOCFGA_REPORT_RNG = 0x7 ++ CRYPTOCFGA_REPORT_CIPHER = 0x8 ++ CRYPTOCFGA_REPORT_AKCIPHER = 0x9 ++ CRYPTOCFGA_REPORT_KPP = 0xa ++ CRYPTOCFGA_REPORT_ACOMP = 0xb ++ CRYPTOCFGA_STAT_LARVAL = 0xc ++ CRYPTOCFGA_STAT_HASH = 0xd ++ CRYPTOCFGA_STAT_BLKCIPHER = 0xe ++ CRYPTOCFGA_STAT_AEAD = 0xf ++ CRYPTOCFGA_STAT_COMPRESS = 0x10 ++ CRYPTOCFGA_STAT_RNG = 0x11 ++ CRYPTOCFGA_STAT_CIPHER = 0x12 ++ CRYPTOCFGA_STAT_AKCIPHER = 0x13 ++ CRYPTOCFGA_STAT_KPP = 0x14 ++ CRYPTOCFGA_STAT_ACOMP = 0x15 ++) ++ ++type CryptoUserAlg struct { ++ Name [64]int8 ++ Driver_name [64]int8 ++ Module_name [64]int8 ++ Type uint32 ++ Mask uint32 ++ Refcnt uint32 ++ Flags uint32 ++} ++ ++type CryptoStatAEAD struct { ++ Type [64]int8 ++ Encrypt_cnt uint64 ++ Encrypt_tlen uint64 ++ Decrypt_cnt uint64 ++ Decrypt_tlen uint64 ++ Err_cnt uint64 ++} ++ ++type CryptoStatAKCipher struct { ++ Type [64]int8 ++ Encrypt_cnt uint64 ++ Encrypt_tlen uint64 ++ Decrypt_cnt uint64 ++ Decrypt_tlen uint64 ++ Verify_cnt uint64 ++ Sign_cnt uint64 ++ Err_cnt uint64 ++} ++ ++type CryptoStatCipher struct { ++ Type [64]int8 ++ Encrypt_cnt uint64 ++ Encrypt_tlen uint64 ++ Decrypt_cnt uint64 ++ Decrypt_tlen uint64 ++ Err_cnt uint64 ++} ++ ++type CryptoStatCompress struct { ++ Type [64]int8 ++ Compress_cnt uint64 ++ Compress_tlen uint64 ++ Decompress_cnt uint64 ++ Decompress_tlen uint64 ++ Err_cnt uint64 ++} ++ ++type CryptoStatHash struct { ++ Type [64]int8 ++ Hash_cnt uint64 ++ Hash_tlen uint64 ++ Err_cnt uint64 ++} ++ ++type CryptoStatKPP struct { ++ Type [64]int8 ++ Setsecret_cnt uint64 ++ Generate_public_key_cnt uint64 ++ Compute_shared_secret_cnt uint64 ++ Err_cnt uint64 ++} ++ ++type CryptoStatRNG struct { ++ Type [64]int8 ++ Generate_cnt uint64 ++ Generate_tlen uint64 ++ Seed_cnt uint64 ++ Err_cnt uint64 ++} ++ ++type CryptoStatLarval struct { ++ Type [64]int8 ++} ++ ++type CryptoReportLarval struct { ++ Type [64]int8 ++} ++ ++type CryptoReportHash struct { ++ Type [64]int8 ++ Blocksize uint32 ++ Digestsize uint32 ++} ++ ++type CryptoReportCipher struct { ++ Type [64]int8 ++ Blocksize uint32 ++ Min_keysize uint32 ++ Max_keysize uint32 ++} ++ ++type CryptoReportBlkCipher struct { ++ Type [64]int8 ++ Geniv [64]int8 ++ Blocksize uint32 ++ Min_keysize uint32 ++ Max_keysize uint32 ++ Ivsize uint32 ++} ++ ++type CryptoReportAEAD struct { ++ Type [64]int8 ++ Geniv [64]int8 ++ Blocksize uint32 ++ Maxauthsize uint32 ++ Ivsize uint32 ++} ++ ++type CryptoReportComp struct { ++ Type [64]int8 ++} ++ ++type CryptoReportRNG struct { ++ Type [64]int8 ++ Seedsize uint32 ++} ++ ++type CryptoReportAKCipher struct { ++ Type [64]int8 ++} ++ ++type CryptoReportKPP struct { ++ Type [64]int8 ++} ++ ++type CryptoReportAcomp struct { ++ Type [64]int8 ++} ++ ++const ( ++ BPF_REG_0 = 0x0 ++ BPF_REG_1 = 0x1 ++ BPF_REG_2 = 0x2 ++ BPF_REG_3 = 0x3 ++ BPF_REG_4 = 0x4 ++ BPF_REG_5 = 0x5 ++ BPF_REG_6 = 0x6 ++ BPF_REG_7 = 0x7 ++ BPF_REG_8 = 0x8 ++ BPF_REG_9 = 0x9 ++ BPF_REG_10 = 0xa ++ BPF_MAP_CREATE = 0x0 ++ BPF_MAP_LOOKUP_ELEM = 0x1 ++ BPF_MAP_UPDATE_ELEM = 0x2 ++ BPF_MAP_DELETE_ELEM = 0x3 ++ BPF_MAP_GET_NEXT_KEY = 0x4 ++ BPF_PROG_LOAD = 0x5 ++ BPF_OBJ_PIN = 0x6 ++ BPF_OBJ_GET = 0x7 ++ BPF_PROG_ATTACH = 0x8 ++ BPF_PROG_DETACH = 0x9 ++ BPF_PROG_TEST_RUN = 0xa ++ BPF_PROG_GET_NEXT_ID = 0xb ++ BPF_MAP_GET_NEXT_ID = 0xc ++ BPF_PROG_GET_FD_BY_ID = 0xd ++ BPF_MAP_GET_FD_BY_ID = 0xe ++ BPF_OBJ_GET_INFO_BY_FD = 0xf ++ BPF_PROG_QUERY = 0x10 ++ BPF_RAW_TRACEPOINT_OPEN = 0x11 ++ BPF_BTF_LOAD = 0x12 ++ BPF_BTF_GET_FD_BY_ID = 0x13 ++ BPF_TASK_FD_QUERY = 0x14 ++ BPF_MAP_LOOKUP_AND_DELETE_ELEM = 0x15 ++ BPF_MAP_FREEZE = 0x16 ++ BPF_BTF_GET_NEXT_ID = 0x17 ++ BPF_MAP_LOOKUP_BATCH = 0x18 ++ BPF_MAP_LOOKUP_AND_DELETE_BATCH = 0x19 ++ BPF_MAP_UPDATE_BATCH = 0x1a ++ BPF_MAP_DELETE_BATCH = 0x1b ++ BPF_LINK_CREATE = 0x1c ++ BPF_LINK_UPDATE = 0x1d ++ BPF_LINK_GET_FD_BY_ID = 0x1e ++ BPF_LINK_GET_NEXT_ID = 0x1f ++ BPF_ENABLE_STATS = 0x20 ++ BPF_ITER_CREATE = 0x21 ++ BPF_LINK_DETACH = 0x22 ++ BPF_PROG_BIND_MAP = 0x23 ++ BPF_MAP_TYPE_UNSPEC = 0x0 ++ BPF_MAP_TYPE_HASH = 0x1 ++ BPF_MAP_TYPE_ARRAY = 0x2 ++ BPF_MAP_TYPE_PROG_ARRAY = 0x3 ++ BPF_MAP_TYPE_PERF_EVENT_ARRAY = 0x4 ++ BPF_MAP_TYPE_PERCPU_HASH = 0x5 ++ BPF_MAP_TYPE_PERCPU_ARRAY = 0x6 ++ BPF_MAP_TYPE_STACK_TRACE = 0x7 ++ BPF_MAP_TYPE_CGROUP_ARRAY = 0x8 ++ BPF_MAP_TYPE_LRU_HASH = 0x9 ++ BPF_MAP_TYPE_LRU_PERCPU_HASH = 0xa ++ BPF_MAP_TYPE_LPM_TRIE = 0xb ++ BPF_MAP_TYPE_ARRAY_OF_MAPS = 0xc ++ BPF_MAP_TYPE_HASH_OF_MAPS = 0xd ++ BPF_MAP_TYPE_DEVMAP = 0xe ++ BPF_MAP_TYPE_SOCKMAP = 0xf ++ BPF_MAP_TYPE_CPUMAP = 0x10 ++ BPF_MAP_TYPE_XSKMAP = 0x11 ++ BPF_MAP_TYPE_SOCKHASH = 0x12 ++ BPF_MAP_TYPE_CGROUP_STORAGE = 0x13 ++ BPF_MAP_TYPE_REUSEPORT_SOCKARRAY = 0x14 ++ BPF_MAP_TYPE_PERCPU_CGROUP_STORAGE = 0x15 ++ BPF_MAP_TYPE_QUEUE = 0x16 ++ BPF_MAP_TYPE_STACK = 0x17 ++ BPF_MAP_TYPE_SK_STORAGE = 0x18 ++ BPF_MAP_TYPE_DEVMAP_HASH = 0x19 ++ BPF_MAP_TYPE_STRUCT_OPS = 0x1a ++ BPF_MAP_TYPE_RINGBUF = 0x1b ++ BPF_MAP_TYPE_INODE_STORAGE = 0x1c ++ BPF_PROG_TYPE_UNSPEC = 0x0 ++ BPF_PROG_TYPE_SOCKET_FILTER = 0x1 ++ BPF_PROG_TYPE_KPROBE = 0x2 ++ BPF_PROG_TYPE_SCHED_CLS = 0x3 ++ BPF_PROG_TYPE_SCHED_ACT = 0x4 ++ BPF_PROG_TYPE_TRACEPOINT = 0x5 ++ BPF_PROG_TYPE_XDP = 0x6 ++ BPF_PROG_TYPE_PERF_EVENT = 0x7 ++ BPF_PROG_TYPE_CGROUP_SKB = 0x8 ++ BPF_PROG_TYPE_CGROUP_SOCK = 0x9 ++ BPF_PROG_TYPE_LWT_IN = 0xa ++ BPF_PROG_TYPE_LWT_OUT = 0xb ++ BPF_PROG_TYPE_LWT_XMIT = 0xc ++ BPF_PROG_TYPE_SOCK_OPS = 0xd ++ BPF_PROG_TYPE_SK_SKB = 0xe ++ BPF_PROG_TYPE_CGROUP_DEVICE = 0xf ++ BPF_PROG_TYPE_SK_MSG = 0x10 ++ BPF_PROG_TYPE_RAW_TRACEPOINT = 0x11 ++ BPF_PROG_TYPE_CGROUP_SOCK_ADDR = 0x12 ++ BPF_PROG_TYPE_LWT_SEG6LOCAL = 0x13 ++ BPF_PROG_TYPE_LIRC_MODE2 = 0x14 ++ BPF_PROG_TYPE_SK_REUSEPORT = 0x15 ++ BPF_PROG_TYPE_FLOW_DISSECTOR = 0x16 ++ BPF_PROG_TYPE_CGROUP_SYSCTL = 0x17 ++ BPF_PROG_TYPE_RAW_TRACEPOINT_WRITABLE = 0x18 ++ BPF_PROG_TYPE_CGROUP_SOCKOPT = 0x19 ++ BPF_PROG_TYPE_TRACING = 0x1a ++ BPF_PROG_TYPE_STRUCT_OPS = 0x1b ++ BPF_PROG_TYPE_EXT = 0x1c ++ BPF_PROG_TYPE_LSM = 0x1d ++ BPF_PROG_TYPE_SK_LOOKUP = 0x1e ++ BPF_CGROUP_INET_INGRESS = 0x0 ++ BPF_CGROUP_INET_EGRESS = 0x1 ++ BPF_CGROUP_INET_SOCK_CREATE = 0x2 ++ BPF_CGROUP_SOCK_OPS = 0x3 ++ BPF_SK_SKB_STREAM_PARSER = 0x4 ++ BPF_SK_SKB_STREAM_VERDICT = 0x5 ++ BPF_CGROUP_DEVICE = 0x6 ++ BPF_SK_MSG_VERDICT = 0x7 ++ BPF_CGROUP_INET4_BIND = 0x8 ++ BPF_CGROUP_INET6_BIND = 0x9 ++ BPF_CGROUP_INET4_CONNECT = 0xa ++ BPF_CGROUP_INET6_CONNECT = 0xb ++ BPF_CGROUP_INET4_POST_BIND = 0xc ++ BPF_CGROUP_INET6_POST_BIND = 0xd ++ BPF_CGROUP_UDP4_SENDMSG = 0xe ++ BPF_CGROUP_UDP6_SENDMSG = 0xf ++ BPF_LIRC_MODE2 = 0x10 ++ BPF_FLOW_DISSECTOR = 0x11 ++ BPF_CGROUP_SYSCTL = 0x12 ++ BPF_CGROUP_UDP4_RECVMSG = 0x13 ++ BPF_CGROUP_UDP6_RECVMSG = 0x14 ++ BPF_CGROUP_GETSOCKOPT = 0x15 ++ BPF_CGROUP_SETSOCKOPT = 0x16 ++ BPF_TRACE_RAW_TP = 0x17 ++ BPF_TRACE_FENTRY = 0x18 ++ BPF_TRACE_FEXIT = 0x19 ++ BPF_MODIFY_RETURN = 0x1a ++ BPF_LSM_MAC = 0x1b ++ BPF_TRACE_ITER = 0x1c ++ BPF_CGROUP_INET4_GETPEERNAME = 0x1d ++ BPF_CGROUP_INET6_GETPEERNAME = 0x1e ++ BPF_CGROUP_INET4_GETSOCKNAME = 0x1f ++ BPF_CGROUP_INET6_GETSOCKNAME = 0x20 ++ BPF_XDP_DEVMAP = 0x21 ++ BPF_CGROUP_INET_SOCK_RELEASE = 0x22 ++ BPF_XDP_CPUMAP = 0x23 ++ BPF_SK_LOOKUP = 0x24 ++ BPF_XDP = 0x25 ++ BPF_LINK_TYPE_UNSPEC = 0x0 ++ BPF_LINK_TYPE_RAW_TRACEPOINT = 0x1 ++ BPF_LINK_TYPE_TRACING = 0x2 ++ BPF_LINK_TYPE_CGROUP = 0x3 ++ BPF_LINK_TYPE_ITER = 0x4 ++ BPF_LINK_TYPE_NETNS = 0x5 ++ BPF_LINK_TYPE_XDP = 0x6 ++ BPF_ANY = 0x0 ++ BPF_NOEXIST = 0x1 ++ BPF_EXIST = 0x2 ++ BPF_F_LOCK = 0x4 ++ BPF_F_NO_PREALLOC = 0x1 ++ BPF_F_NO_COMMON_LRU = 0x2 ++ BPF_F_NUMA_NODE = 0x4 ++ BPF_F_RDONLY = 0x8 ++ BPF_F_WRONLY = 0x10 ++ BPF_F_STACK_BUILD_ID = 0x20 ++ BPF_F_ZERO_SEED = 0x40 ++ BPF_F_RDONLY_PROG = 0x80 ++ BPF_F_WRONLY_PROG = 0x100 ++ BPF_F_CLONE = 0x200 ++ BPF_F_MMAPABLE = 0x400 ++ BPF_F_PRESERVE_ELEMS = 0x800 ++ BPF_F_INNER_MAP = 0x1000 ++ BPF_STATS_RUN_TIME = 0x0 ++ BPF_STACK_BUILD_ID_EMPTY = 0x0 ++ BPF_STACK_BUILD_ID_VALID = 0x1 ++ BPF_STACK_BUILD_ID_IP = 0x2 ++ BPF_F_RECOMPUTE_CSUM = 0x1 ++ BPF_F_INVALIDATE_HASH = 0x2 ++ BPF_F_HDR_FIELD_MASK = 0xf ++ BPF_F_PSEUDO_HDR = 0x10 ++ BPF_F_MARK_MANGLED_0 = 0x20 ++ BPF_F_MARK_ENFORCE = 0x40 ++ BPF_F_INGRESS = 0x1 ++ BPF_F_TUNINFO_IPV6 = 0x1 ++ BPF_F_SKIP_FIELD_MASK = 0xff ++ BPF_F_USER_STACK = 0x100 ++ BPF_F_FAST_STACK_CMP = 0x200 ++ BPF_F_REUSE_STACKID = 0x400 ++ BPF_F_USER_BUILD_ID = 0x800 ++ BPF_F_ZERO_CSUM_TX = 0x2 ++ BPF_F_DONT_FRAGMENT = 0x4 ++ BPF_F_SEQ_NUMBER = 0x8 ++ BPF_F_INDEX_MASK = 0xffffffff ++ BPF_F_CURRENT_CPU = 0xffffffff ++ BPF_F_CTXLEN_MASK = 0xfffff00000000 ++ BPF_F_CURRENT_NETNS = -0x1 ++ BPF_CSUM_LEVEL_QUERY = 0x0 ++ BPF_CSUM_LEVEL_INC = 0x1 ++ BPF_CSUM_LEVEL_DEC = 0x2 ++ BPF_CSUM_LEVEL_RESET = 0x3 ++ BPF_F_ADJ_ROOM_FIXED_GSO = 0x1 ++ BPF_F_ADJ_ROOM_ENCAP_L3_IPV4 = 0x2 ++ BPF_F_ADJ_ROOM_ENCAP_L3_IPV6 = 0x4 ++ BPF_F_ADJ_ROOM_ENCAP_L4_GRE = 0x8 ++ BPF_F_ADJ_ROOM_ENCAP_L4_UDP = 0x10 ++ BPF_F_ADJ_ROOM_NO_CSUM_RESET = 0x20 ++ BPF_ADJ_ROOM_ENCAP_L2_MASK = 0xff ++ BPF_ADJ_ROOM_ENCAP_L2_SHIFT = 0x38 ++ BPF_F_SYSCTL_BASE_NAME = 0x1 ++ BPF_LOCAL_STORAGE_GET_F_CREATE = 0x1 ++ BPF_SK_STORAGE_GET_F_CREATE = 0x1 ++ BPF_F_GET_BRANCH_RECORDS_SIZE = 0x1 ++ BPF_RB_NO_WAKEUP = 0x1 ++ BPF_RB_FORCE_WAKEUP = 0x2 ++ BPF_RB_AVAIL_DATA = 0x0 ++ BPF_RB_RING_SIZE = 0x1 ++ BPF_RB_CONS_POS = 0x2 ++ BPF_RB_PROD_POS = 0x3 ++ BPF_RINGBUF_BUSY_BIT = 0x80000000 ++ BPF_RINGBUF_DISCARD_BIT = 0x40000000 ++ BPF_RINGBUF_HDR_SZ = 0x8 ++ BPF_SK_LOOKUP_F_REPLACE = 0x1 ++ BPF_SK_LOOKUP_F_NO_REUSEPORT = 0x2 ++ BPF_ADJ_ROOM_NET = 0x0 ++ BPF_ADJ_ROOM_MAC = 0x1 ++ BPF_HDR_START_MAC = 0x0 ++ BPF_HDR_START_NET = 0x1 ++ BPF_LWT_ENCAP_SEG6 = 0x0 ++ BPF_LWT_ENCAP_SEG6_INLINE = 0x1 ++ BPF_LWT_ENCAP_IP = 0x2 ++ BPF_OK = 0x0 ++ BPF_DROP = 0x2 ++ BPF_REDIRECT = 0x7 ++ BPF_LWT_REROUTE = 0x80 ++ BPF_SOCK_OPS_RTO_CB_FLAG = 0x1 ++ BPF_SOCK_OPS_RETRANS_CB_FLAG = 0x2 ++ BPF_SOCK_OPS_STATE_CB_FLAG = 0x4 ++ BPF_SOCK_OPS_RTT_CB_FLAG = 0x8 ++ BPF_SOCK_OPS_PARSE_ALL_HDR_OPT_CB_FLAG = 0x10 ++ BPF_SOCK_OPS_PARSE_UNKNOWN_HDR_OPT_CB_FLAG = 0x20 ++ BPF_SOCK_OPS_WRITE_HDR_OPT_CB_FLAG = 0x40 ++ BPF_SOCK_OPS_ALL_CB_FLAGS = 0x7f ++ BPF_SOCK_OPS_VOID = 0x0 ++ BPF_SOCK_OPS_TIMEOUT_INIT = 0x1 ++ BPF_SOCK_OPS_RWND_INIT = 0x2 ++ BPF_SOCK_OPS_TCP_CONNECT_CB = 0x3 ++ BPF_SOCK_OPS_ACTIVE_ESTABLISHED_CB = 0x4 ++ BPF_SOCK_OPS_PASSIVE_ESTABLISHED_CB = 0x5 ++ BPF_SOCK_OPS_NEEDS_ECN = 0x6 ++ BPF_SOCK_OPS_BASE_RTT = 0x7 ++ BPF_SOCK_OPS_RTO_CB = 0x8 ++ BPF_SOCK_OPS_RETRANS_CB = 0x9 ++ BPF_SOCK_OPS_STATE_CB = 0xa ++ BPF_SOCK_OPS_TCP_LISTEN_CB = 0xb ++ BPF_SOCK_OPS_RTT_CB = 0xc ++ BPF_SOCK_OPS_PARSE_HDR_OPT_CB = 0xd ++ BPF_SOCK_OPS_HDR_OPT_LEN_CB = 0xe ++ BPF_SOCK_OPS_WRITE_HDR_OPT_CB = 0xf ++ BPF_TCP_ESTABLISHED = 0x1 ++ BPF_TCP_SYN_SENT = 0x2 ++ BPF_TCP_SYN_RECV = 0x3 ++ BPF_TCP_FIN_WAIT1 = 0x4 ++ BPF_TCP_FIN_WAIT2 = 0x5 ++ BPF_TCP_TIME_WAIT = 0x6 ++ BPF_TCP_CLOSE = 0x7 ++ BPF_TCP_CLOSE_WAIT = 0x8 ++ BPF_TCP_LAST_ACK = 0x9 ++ BPF_TCP_LISTEN = 0xa ++ BPF_TCP_CLOSING = 0xb ++ BPF_TCP_NEW_SYN_RECV = 0xc ++ BPF_TCP_MAX_STATES = 0xd ++ TCP_BPF_IW = 0x3e9 ++ TCP_BPF_SNDCWND_CLAMP = 0x3ea ++ TCP_BPF_DELACK_MAX = 0x3eb ++ TCP_BPF_RTO_MIN = 0x3ec ++ TCP_BPF_SYN = 0x3ed ++ TCP_BPF_SYN_IP = 0x3ee ++ TCP_BPF_SYN_MAC = 0x3ef ++ BPF_LOAD_HDR_OPT_TCP_SYN = 0x1 ++ BPF_WRITE_HDR_TCP_CURRENT_MSS = 0x1 ++ BPF_WRITE_HDR_TCP_SYNACK_COOKIE = 0x2 ++ BPF_DEVCG_ACC_MKNOD = 0x1 ++ BPF_DEVCG_ACC_READ = 0x2 ++ BPF_DEVCG_ACC_WRITE = 0x4 ++ BPF_DEVCG_DEV_BLOCK = 0x1 ++ BPF_DEVCG_DEV_CHAR = 0x2 ++ BPF_FIB_LOOKUP_DIRECT = 0x1 ++ BPF_FIB_LOOKUP_OUTPUT = 0x2 ++ BPF_FIB_LKUP_RET_SUCCESS = 0x0 ++ BPF_FIB_LKUP_RET_BLACKHOLE = 0x1 ++ BPF_FIB_LKUP_RET_UNREACHABLE = 0x2 ++ BPF_FIB_LKUP_RET_PROHIBIT = 0x3 ++ BPF_FIB_LKUP_RET_NOT_FWDED = 0x4 ++ BPF_FIB_LKUP_RET_FWD_DISABLED = 0x5 ++ BPF_FIB_LKUP_RET_UNSUPP_LWT = 0x6 ++ BPF_FIB_LKUP_RET_NO_NEIGH = 0x7 ++ BPF_FIB_LKUP_RET_FRAG_NEEDED = 0x8 ++ BPF_FD_TYPE_RAW_TRACEPOINT = 0x0 ++ BPF_FD_TYPE_TRACEPOINT = 0x1 ++ BPF_FD_TYPE_KPROBE = 0x2 ++ BPF_FD_TYPE_KRETPROBE = 0x3 ++ BPF_FD_TYPE_UPROBE = 0x4 ++ BPF_FD_TYPE_URETPROBE = 0x5 ++ BPF_FLOW_DISSECTOR_F_PARSE_1ST_FRAG = 0x1 ++ BPF_FLOW_DISSECTOR_F_STOP_AT_FLOW_LABEL = 0x2 ++ BPF_FLOW_DISSECTOR_F_STOP_AT_ENCAP = 0x4 ++) ++ ++const ( ++ RTNLGRP_NONE = 0x0 ++ RTNLGRP_LINK = 0x1 ++ RTNLGRP_NOTIFY = 0x2 ++ RTNLGRP_NEIGH = 0x3 ++ RTNLGRP_TC = 0x4 ++ RTNLGRP_IPV4_IFADDR = 0x5 ++ RTNLGRP_IPV4_MROUTE = 0x6 ++ RTNLGRP_IPV4_ROUTE = 0x7 ++ RTNLGRP_IPV4_RULE = 0x8 ++ RTNLGRP_IPV6_IFADDR = 0x9 ++ RTNLGRP_IPV6_MROUTE = 0xa ++ RTNLGRP_IPV6_ROUTE = 0xb ++ RTNLGRP_IPV6_IFINFO = 0xc ++ RTNLGRP_DECnet_IFADDR = 0xd ++ RTNLGRP_NOP2 = 0xe ++ RTNLGRP_DECnet_ROUTE = 0xf ++ RTNLGRP_DECnet_RULE = 0x10 ++ RTNLGRP_NOP4 = 0x11 ++ RTNLGRP_IPV6_PREFIX = 0x12 ++ RTNLGRP_IPV6_RULE = 0x13 ++ RTNLGRP_ND_USEROPT = 0x14 ++ RTNLGRP_PHONET_IFADDR = 0x15 ++ RTNLGRP_PHONET_ROUTE = 0x16 ++ RTNLGRP_DCB = 0x17 ++ RTNLGRP_IPV4_NETCONF = 0x18 ++ RTNLGRP_IPV6_NETCONF = 0x19 ++ RTNLGRP_MDB = 0x1a ++ RTNLGRP_MPLS_ROUTE = 0x1b ++ RTNLGRP_NSID = 0x1c ++ RTNLGRP_MPLS_NETCONF = 0x1d ++ RTNLGRP_IPV4_MROUTE_R = 0x1e ++ RTNLGRP_IPV6_MROUTE_R = 0x1f ++ RTNLGRP_NEXTHOP = 0x20 ++ RTNLGRP_BRVLAN = 0x21 ++) ++ ++type CapUserHeader struct { ++ Version uint32 ++ Pid int32 ++} ++ ++type CapUserData struct { ++ Effective uint32 ++ Permitted uint32 ++ Inheritable uint32 ++} ++ ++const ( ++ LINUX_CAPABILITY_VERSION_1 = 0x19980330 ++ LINUX_CAPABILITY_VERSION_2 = 0x20071026 ++ LINUX_CAPABILITY_VERSION_3 = 0x20080522 ++) ++ ++const ( ++ LO_FLAGS_READ_ONLY = 0x1 ++ LO_FLAGS_AUTOCLEAR = 0x4 ++ LO_FLAGS_PARTSCAN = 0x8 ++ LO_FLAGS_DIRECT_IO = 0x10 ++) ++ ++type LoopInfo struct { ++ Number int32 ++ Device uint32 ++ Inode uint64 ++ Rdevice uint32 ++ Offset int32 ++ Encrypt_type int32 ++ Encrypt_key_size int32 ++ Flags int32 ++ Name [64]int8 ++ Encrypt_key [32]uint8 ++ Init [2]uint64 ++ Reserved [4]int8 ++ _ [4]byte ++} ++type LoopInfo64 struct { ++ Device uint64 ++ Inode uint64 ++ Rdevice uint64 ++ Offset uint64 ++ Sizelimit uint64 ++ Number uint32 ++ Encrypt_type uint32 ++ Encrypt_key_size uint32 ++ Flags uint32 ++ File_name [64]uint8 ++ Crypt_name [64]uint8 ++ Encrypt_key [32]uint8 ++ Init [2]uint64 ++} ++ ++type TIPCSocketAddr struct { ++ Ref uint32 ++ Node uint32 ++} ++ ++type TIPCServiceRange struct { ++ Type uint32 ++ Lower uint32 ++ Upper uint32 ++} ++ ++type TIPCServiceName struct { ++ Type uint32 ++ Instance uint32 ++ Domain uint32 ++} ++ ++type TIPCSubscr struct { ++ Seq TIPCServiceRange ++ Timeout uint32 ++ Filter uint32 ++ Handle [8]int8 ++} ++ ++type TIPCEvent struct { ++ Event uint32 ++ Lower uint32 ++ Upper uint32 ++ Port TIPCSocketAddr ++ S TIPCSubscr ++} ++ ++type TIPCGroupReq struct { ++ Type uint32 ++ Instance uint32 ++ Scope uint32 ++ Flags uint32 ++} ++ ++type TIPCSIOCLNReq struct { ++ Peer uint32 ++ Id uint32 ++ Linkname [68]int8 ++} ++ ++type TIPCSIOCNodeIDReq struct { ++ Peer uint32 ++ Id [16]int8 ++} ++ ++const ( ++ TIPC_CLUSTER_SCOPE = 0x2 ++ TIPC_NODE_SCOPE = 0x3 ++) ++ ++const ( ++ SYSLOG_ACTION_CLOSE = 0 ++ SYSLOG_ACTION_OPEN = 1 ++ SYSLOG_ACTION_READ = 2 ++ SYSLOG_ACTION_READ_ALL = 3 ++ SYSLOG_ACTION_READ_CLEAR = 4 ++ SYSLOG_ACTION_CLEAR = 5 ++ SYSLOG_ACTION_CONSOLE_OFF = 6 ++ SYSLOG_ACTION_CONSOLE_ON = 7 ++ SYSLOG_ACTION_CONSOLE_LEVEL = 8 ++ SYSLOG_ACTION_SIZE_UNREAD = 9 ++ SYSLOG_ACTION_SIZE_BUFFER = 10 ++) ++ ++const ( ++ DEVLINK_CMD_UNSPEC = 0x0 ++ DEVLINK_CMD_GET = 0x1 ++ DEVLINK_CMD_SET = 0x2 ++ DEVLINK_CMD_NEW = 0x3 ++ DEVLINK_CMD_DEL = 0x4 ++ DEVLINK_CMD_PORT_GET = 0x5 ++ DEVLINK_CMD_PORT_SET = 0x6 ++ DEVLINK_CMD_PORT_NEW = 0x7 ++ DEVLINK_CMD_PORT_DEL = 0x8 ++ DEVLINK_CMD_PORT_SPLIT = 0x9 ++ DEVLINK_CMD_PORT_UNSPLIT = 0xa ++ DEVLINK_CMD_SB_GET = 0xb ++ DEVLINK_CMD_SB_SET = 0xc ++ DEVLINK_CMD_SB_NEW = 0xd ++ DEVLINK_CMD_SB_DEL = 0xe ++ DEVLINK_CMD_SB_POOL_GET = 0xf ++ DEVLINK_CMD_SB_POOL_SET = 0x10 ++ DEVLINK_CMD_SB_POOL_NEW = 0x11 ++ DEVLINK_CMD_SB_POOL_DEL = 0x12 ++ DEVLINK_CMD_SB_PORT_POOL_GET = 0x13 ++ DEVLINK_CMD_SB_PORT_POOL_SET = 0x14 ++ DEVLINK_CMD_SB_PORT_POOL_NEW = 0x15 ++ DEVLINK_CMD_SB_PORT_POOL_DEL = 0x16 ++ DEVLINK_CMD_SB_TC_POOL_BIND_GET = 0x17 ++ DEVLINK_CMD_SB_TC_POOL_BIND_SET = 0x18 ++ DEVLINK_CMD_SB_TC_POOL_BIND_NEW = 0x19 ++ DEVLINK_CMD_SB_TC_POOL_BIND_DEL = 0x1a ++ DEVLINK_CMD_SB_OCC_SNAPSHOT = 0x1b ++ DEVLINK_CMD_SB_OCC_MAX_CLEAR = 0x1c ++ DEVLINK_CMD_ESWITCH_GET = 0x1d ++ DEVLINK_CMD_ESWITCH_SET = 0x1e ++ DEVLINK_CMD_DPIPE_TABLE_GET = 0x1f ++ DEVLINK_CMD_DPIPE_ENTRIES_GET = 0x20 ++ DEVLINK_CMD_DPIPE_HEADERS_GET = 0x21 ++ DEVLINK_CMD_DPIPE_TABLE_COUNTERS_SET = 0x22 ++ DEVLINK_CMD_RESOURCE_SET = 0x23 ++ DEVLINK_CMD_RESOURCE_DUMP = 0x24 ++ DEVLINK_CMD_RELOAD = 0x25 ++ DEVLINK_CMD_PARAM_GET = 0x26 ++ DEVLINK_CMD_PARAM_SET = 0x27 ++ DEVLINK_CMD_PARAM_NEW = 0x28 ++ DEVLINK_CMD_PARAM_DEL = 0x29 ++ DEVLINK_CMD_REGION_GET = 0x2a ++ DEVLINK_CMD_REGION_SET = 0x2b ++ DEVLINK_CMD_REGION_NEW = 0x2c ++ DEVLINK_CMD_REGION_DEL = 0x2d ++ DEVLINK_CMD_REGION_READ = 0x2e ++ DEVLINK_CMD_PORT_PARAM_GET = 0x2f ++ DEVLINK_CMD_PORT_PARAM_SET = 0x30 ++ DEVLINK_CMD_PORT_PARAM_NEW = 0x31 ++ DEVLINK_CMD_PORT_PARAM_DEL = 0x32 ++ DEVLINK_CMD_INFO_GET = 0x33 ++ DEVLINK_CMD_HEALTH_REPORTER_GET = 0x34 ++ DEVLINK_CMD_HEALTH_REPORTER_SET = 0x35 ++ DEVLINK_CMD_HEALTH_REPORTER_RECOVER = 0x36 ++ DEVLINK_CMD_HEALTH_REPORTER_DIAGNOSE = 0x37 ++ DEVLINK_CMD_HEALTH_REPORTER_DUMP_GET = 0x38 ++ DEVLINK_CMD_HEALTH_REPORTER_DUMP_CLEAR = 0x39 ++ DEVLINK_CMD_FLASH_UPDATE = 0x3a ++ DEVLINK_CMD_FLASH_UPDATE_END = 0x3b ++ DEVLINK_CMD_FLASH_UPDATE_STATUS = 0x3c ++ DEVLINK_CMD_TRAP_GET = 0x3d ++ DEVLINK_CMD_TRAP_SET = 0x3e ++ DEVLINK_CMD_TRAP_NEW = 0x3f ++ DEVLINK_CMD_TRAP_DEL = 0x40 ++ DEVLINK_CMD_TRAP_GROUP_GET = 0x41 ++ DEVLINK_CMD_TRAP_GROUP_SET = 0x42 ++ DEVLINK_CMD_TRAP_GROUP_NEW = 0x43 ++ DEVLINK_CMD_TRAP_GROUP_DEL = 0x44 ++ DEVLINK_CMD_TRAP_POLICER_GET = 0x45 ++ DEVLINK_CMD_TRAP_POLICER_SET = 0x46 ++ DEVLINK_CMD_TRAP_POLICER_NEW = 0x47 ++ DEVLINK_CMD_TRAP_POLICER_DEL = 0x48 ++ DEVLINK_CMD_HEALTH_REPORTER_TEST = 0x49 ++ DEVLINK_CMD_MAX = 0x49 ++ DEVLINK_PORT_TYPE_NOTSET = 0x0 ++ DEVLINK_PORT_TYPE_AUTO = 0x1 ++ DEVLINK_PORT_TYPE_ETH = 0x2 ++ DEVLINK_PORT_TYPE_IB = 0x3 ++ DEVLINK_SB_POOL_TYPE_INGRESS = 0x0 ++ DEVLINK_SB_POOL_TYPE_EGRESS = 0x1 ++ DEVLINK_SB_THRESHOLD_TYPE_STATIC = 0x0 ++ DEVLINK_SB_THRESHOLD_TYPE_DYNAMIC = 0x1 ++ DEVLINK_ESWITCH_MODE_LEGACY = 0x0 ++ DEVLINK_ESWITCH_MODE_SWITCHDEV = 0x1 ++ DEVLINK_ESWITCH_INLINE_MODE_NONE = 0x0 ++ DEVLINK_ESWITCH_INLINE_MODE_LINK = 0x1 ++ DEVLINK_ESWITCH_INLINE_MODE_NETWORK = 0x2 ++ DEVLINK_ESWITCH_INLINE_MODE_TRANSPORT = 0x3 ++ DEVLINK_ESWITCH_ENCAP_MODE_NONE = 0x0 ++ DEVLINK_ESWITCH_ENCAP_MODE_BASIC = 0x1 ++ DEVLINK_PORT_FLAVOUR_PHYSICAL = 0x0 ++ DEVLINK_PORT_FLAVOUR_CPU = 0x1 ++ DEVLINK_PORT_FLAVOUR_DSA = 0x2 ++ DEVLINK_PORT_FLAVOUR_PCI_PF = 0x3 ++ DEVLINK_PORT_FLAVOUR_PCI_VF = 0x4 ++ DEVLINK_PORT_FLAVOUR_VIRTUAL = 0x5 ++ DEVLINK_PORT_FLAVOUR_UNUSED = 0x6 ++ DEVLINK_PARAM_CMODE_RUNTIME = 0x0 ++ DEVLINK_PARAM_CMODE_DRIVERINIT = 0x1 ++ DEVLINK_PARAM_CMODE_PERMANENT = 0x2 ++ DEVLINK_PARAM_CMODE_MAX = 0x2 ++ DEVLINK_PARAM_FW_LOAD_POLICY_VALUE_DRIVER = 0x0 ++ DEVLINK_PARAM_FW_LOAD_POLICY_VALUE_FLASH = 0x1 ++ DEVLINK_PARAM_FW_LOAD_POLICY_VALUE_DISK = 0x2 ++ DEVLINK_PARAM_FW_LOAD_POLICY_VALUE_UNKNOWN = 0x3 ++ DEVLINK_PARAM_RESET_DEV_ON_DRV_PROBE_VALUE_UNKNOWN = 0x0 ++ DEVLINK_PARAM_RESET_DEV_ON_DRV_PROBE_VALUE_ALWAYS = 0x1 ++ DEVLINK_PARAM_RESET_DEV_ON_DRV_PROBE_VALUE_NEVER = 0x2 ++ DEVLINK_PARAM_RESET_DEV_ON_DRV_PROBE_VALUE_DISK = 0x3 ++ DEVLINK_ATTR_STATS_RX_PACKETS = 0x0 ++ DEVLINK_ATTR_STATS_RX_BYTES = 0x1 ++ DEVLINK_ATTR_STATS_RX_DROPPED = 0x2 ++ DEVLINK_ATTR_STATS_MAX = 0x2 ++ DEVLINK_FLASH_OVERWRITE_SETTINGS_BIT = 0x0 ++ DEVLINK_FLASH_OVERWRITE_IDENTIFIERS_BIT = 0x1 ++ DEVLINK_FLASH_OVERWRITE_MAX_BIT = 0x1 ++ DEVLINK_TRAP_ACTION_DROP = 0x0 ++ DEVLINK_TRAP_ACTION_TRAP = 0x1 ++ DEVLINK_TRAP_ACTION_MIRROR = 0x2 ++ DEVLINK_TRAP_TYPE_DROP = 0x0 ++ DEVLINK_TRAP_TYPE_EXCEPTION = 0x1 ++ DEVLINK_TRAP_TYPE_CONTROL = 0x2 ++ DEVLINK_ATTR_TRAP_METADATA_TYPE_IN_PORT = 0x0 ++ DEVLINK_ATTR_TRAP_METADATA_TYPE_FA_COOKIE = 0x1 ++ DEVLINK_RELOAD_ACTION_UNSPEC = 0x0 ++ DEVLINK_RELOAD_ACTION_DRIVER_REINIT = 0x1 ++ DEVLINK_RELOAD_ACTION_FW_ACTIVATE = 0x2 ++ DEVLINK_RELOAD_ACTION_MAX = 0x2 ++ DEVLINK_RELOAD_LIMIT_UNSPEC = 0x0 ++ DEVLINK_RELOAD_LIMIT_NO_RESET = 0x1 ++ DEVLINK_RELOAD_LIMIT_MAX = 0x1 ++ DEVLINK_ATTR_UNSPEC = 0x0 ++ DEVLINK_ATTR_BUS_NAME = 0x1 ++ DEVLINK_ATTR_DEV_NAME = 0x2 ++ DEVLINK_ATTR_PORT_INDEX = 0x3 ++ DEVLINK_ATTR_PORT_TYPE = 0x4 ++ DEVLINK_ATTR_PORT_DESIRED_TYPE = 0x5 ++ DEVLINK_ATTR_PORT_NETDEV_IFINDEX = 0x6 ++ DEVLINK_ATTR_PORT_NETDEV_NAME = 0x7 ++ DEVLINK_ATTR_PORT_IBDEV_NAME = 0x8 ++ DEVLINK_ATTR_PORT_SPLIT_COUNT = 0x9 ++ DEVLINK_ATTR_PORT_SPLIT_GROUP = 0xa ++ DEVLINK_ATTR_SB_INDEX = 0xb ++ DEVLINK_ATTR_SB_SIZE = 0xc ++ DEVLINK_ATTR_SB_INGRESS_POOL_COUNT = 0xd ++ DEVLINK_ATTR_SB_EGRESS_POOL_COUNT = 0xe ++ DEVLINK_ATTR_SB_INGRESS_TC_COUNT = 0xf ++ DEVLINK_ATTR_SB_EGRESS_TC_COUNT = 0x10 ++ DEVLINK_ATTR_SB_POOL_INDEX = 0x11 ++ DEVLINK_ATTR_SB_POOL_TYPE = 0x12 ++ DEVLINK_ATTR_SB_POOL_SIZE = 0x13 ++ DEVLINK_ATTR_SB_POOL_THRESHOLD_TYPE = 0x14 ++ DEVLINK_ATTR_SB_THRESHOLD = 0x15 ++ DEVLINK_ATTR_SB_TC_INDEX = 0x16 ++ DEVLINK_ATTR_SB_OCC_CUR = 0x17 ++ DEVLINK_ATTR_SB_OCC_MAX = 0x18 ++ DEVLINK_ATTR_ESWITCH_MODE = 0x19 ++ DEVLINK_ATTR_ESWITCH_INLINE_MODE = 0x1a ++ DEVLINK_ATTR_DPIPE_TABLES = 0x1b ++ DEVLINK_ATTR_DPIPE_TABLE = 0x1c ++ DEVLINK_ATTR_DPIPE_TABLE_NAME = 0x1d ++ DEVLINK_ATTR_DPIPE_TABLE_SIZE = 0x1e ++ DEVLINK_ATTR_DPIPE_TABLE_MATCHES = 0x1f ++ DEVLINK_ATTR_DPIPE_TABLE_ACTIONS = 0x20 ++ DEVLINK_ATTR_DPIPE_TABLE_COUNTERS_ENABLED = 0x21 ++ DEVLINK_ATTR_DPIPE_ENTRIES = 0x22 ++ DEVLINK_ATTR_DPIPE_ENTRY = 0x23 ++ DEVLINK_ATTR_DPIPE_ENTRY_INDEX = 0x24 ++ DEVLINK_ATTR_DPIPE_ENTRY_MATCH_VALUES = 0x25 ++ DEVLINK_ATTR_DPIPE_ENTRY_ACTION_VALUES = 0x26 ++ DEVLINK_ATTR_DPIPE_ENTRY_COUNTER = 0x27 ++ DEVLINK_ATTR_DPIPE_MATCH = 0x28 ++ DEVLINK_ATTR_DPIPE_MATCH_VALUE = 0x29 ++ DEVLINK_ATTR_DPIPE_MATCH_TYPE = 0x2a ++ DEVLINK_ATTR_DPIPE_ACTION = 0x2b ++ DEVLINK_ATTR_DPIPE_ACTION_VALUE = 0x2c ++ DEVLINK_ATTR_DPIPE_ACTION_TYPE = 0x2d ++ DEVLINK_ATTR_DPIPE_VALUE = 0x2e ++ DEVLINK_ATTR_DPIPE_VALUE_MASK = 0x2f ++ DEVLINK_ATTR_DPIPE_VALUE_MAPPING = 0x30 ++ DEVLINK_ATTR_DPIPE_HEADERS = 0x31 ++ DEVLINK_ATTR_DPIPE_HEADER = 0x32 ++ DEVLINK_ATTR_DPIPE_HEADER_NAME = 0x33 ++ DEVLINK_ATTR_DPIPE_HEADER_ID = 0x34 ++ DEVLINK_ATTR_DPIPE_HEADER_FIELDS = 0x35 ++ DEVLINK_ATTR_DPIPE_HEADER_GLOBAL = 0x36 ++ DEVLINK_ATTR_DPIPE_HEADER_INDEX = 0x37 ++ DEVLINK_ATTR_DPIPE_FIELD = 0x38 ++ DEVLINK_ATTR_DPIPE_FIELD_NAME = 0x39 ++ DEVLINK_ATTR_DPIPE_FIELD_ID = 0x3a ++ DEVLINK_ATTR_DPIPE_FIELD_BITWIDTH = 0x3b ++ DEVLINK_ATTR_DPIPE_FIELD_MAPPING_TYPE = 0x3c ++ DEVLINK_ATTR_PAD = 0x3d ++ DEVLINK_ATTR_ESWITCH_ENCAP_MODE = 0x3e ++ DEVLINK_ATTR_RESOURCE_LIST = 0x3f ++ DEVLINK_ATTR_RESOURCE = 0x40 ++ DEVLINK_ATTR_RESOURCE_NAME = 0x41 ++ DEVLINK_ATTR_RESOURCE_ID = 0x42 ++ DEVLINK_ATTR_RESOURCE_SIZE = 0x43 ++ DEVLINK_ATTR_RESOURCE_SIZE_NEW = 0x44 ++ DEVLINK_ATTR_RESOURCE_SIZE_VALID = 0x45 ++ DEVLINK_ATTR_RESOURCE_SIZE_MIN = 0x46 ++ DEVLINK_ATTR_RESOURCE_SIZE_MAX = 0x47 ++ DEVLINK_ATTR_RESOURCE_SIZE_GRAN = 0x48 ++ DEVLINK_ATTR_RESOURCE_UNIT = 0x49 ++ DEVLINK_ATTR_RESOURCE_OCC = 0x4a ++ DEVLINK_ATTR_DPIPE_TABLE_RESOURCE_ID = 0x4b ++ DEVLINK_ATTR_DPIPE_TABLE_RESOURCE_UNITS = 0x4c ++ DEVLINK_ATTR_PORT_FLAVOUR = 0x4d ++ DEVLINK_ATTR_PORT_NUMBER = 0x4e ++ DEVLINK_ATTR_PORT_SPLIT_SUBPORT_NUMBER = 0x4f ++ DEVLINK_ATTR_PARAM = 0x50 ++ DEVLINK_ATTR_PARAM_NAME = 0x51 ++ DEVLINK_ATTR_PARAM_GENERIC = 0x52 ++ DEVLINK_ATTR_PARAM_TYPE = 0x53 ++ DEVLINK_ATTR_PARAM_VALUES_LIST = 0x54 ++ DEVLINK_ATTR_PARAM_VALUE = 0x55 ++ DEVLINK_ATTR_PARAM_VALUE_DATA = 0x56 ++ DEVLINK_ATTR_PARAM_VALUE_CMODE = 0x57 ++ DEVLINK_ATTR_REGION_NAME = 0x58 ++ DEVLINK_ATTR_REGION_SIZE = 0x59 ++ DEVLINK_ATTR_REGION_SNAPSHOTS = 0x5a ++ DEVLINK_ATTR_REGION_SNAPSHOT = 0x5b ++ DEVLINK_ATTR_REGION_SNAPSHOT_ID = 0x5c ++ DEVLINK_ATTR_REGION_CHUNKS = 0x5d ++ DEVLINK_ATTR_REGION_CHUNK = 0x5e ++ DEVLINK_ATTR_REGION_CHUNK_DATA = 0x5f ++ DEVLINK_ATTR_REGION_CHUNK_ADDR = 0x60 ++ DEVLINK_ATTR_REGION_CHUNK_LEN = 0x61 ++ DEVLINK_ATTR_INFO_DRIVER_NAME = 0x62 ++ DEVLINK_ATTR_INFO_SERIAL_NUMBER = 0x63 ++ DEVLINK_ATTR_INFO_VERSION_FIXED = 0x64 ++ DEVLINK_ATTR_INFO_VERSION_RUNNING = 0x65 ++ DEVLINK_ATTR_INFO_VERSION_STORED = 0x66 ++ DEVLINK_ATTR_INFO_VERSION_NAME = 0x67 ++ DEVLINK_ATTR_INFO_VERSION_VALUE = 0x68 ++ DEVLINK_ATTR_SB_POOL_CELL_SIZE = 0x69 ++ DEVLINK_ATTR_FMSG = 0x6a ++ DEVLINK_ATTR_FMSG_OBJ_NEST_START = 0x6b ++ DEVLINK_ATTR_FMSG_PAIR_NEST_START = 0x6c ++ DEVLINK_ATTR_FMSG_ARR_NEST_START = 0x6d ++ DEVLINK_ATTR_FMSG_NEST_END = 0x6e ++ DEVLINK_ATTR_FMSG_OBJ_NAME = 0x6f ++ DEVLINK_ATTR_FMSG_OBJ_VALUE_TYPE = 0x70 ++ DEVLINK_ATTR_FMSG_OBJ_VALUE_DATA = 0x71 ++ DEVLINK_ATTR_HEALTH_REPORTER = 0x72 ++ DEVLINK_ATTR_HEALTH_REPORTER_NAME = 0x73 ++ DEVLINK_ATTR_HEALTH_REPORTER_STATE = 0x74 ++ DEVLINK_ATTR_HEALTH_REPORTER_ERR_COUNT = 0x75 ++ DEVLINK_ATTR_HEALTH_REPORTER_RECOVER_COUNT = 0x76 ++ DEVLINK_ATTR_HEALTH_REPORTER_DUMP_TS = 0x77 ++ DEVLINK_ATTR_HEALTH_REPORTER_GRACEFUL_PERIOD = 0x78 ++ DEVLINK_ATTR_HEALTH_REPORTER_AUTO_RECOVER = 0x79 ++ DEVLINK_ATTR_FLASH_UPDATE_FILE_NAME = 0x7a ++ DEVLINK_ATTR_FLASH_UPDATE_COMPONENT = 0x7b ++ DEVLINK_ATTR_FLASH_UPDATE_STATUS_MSG = 0x7c ++ DEVLINK_ATTR_FLASH_UPDATE_STATUS_DONE = 0x7d ++ DEVLINK_ATTR_FLASH_UPDATE_STATUS_TOTAL = 0x7e ++ DEVLINK_ATTR_PORT_PCI_PF_NUMBER = 0x7f ++ DEVLINK_ATTR_PORT_PCI_VF_NUMBER = 0x80 ++ DEVLINK_ATTR_STATS = 0x81 ++ DEVLINK_ATTR_TRAP_NAME = 0x82 ++ DEVLINK_ATTR_TRAP_ACTION = 0x83 ++ DEVLINK_ATTR_TRAP_TYPE = 0x84 ++ DEVLINK_ATTR_TRAP_GENERIC = 0x85 ++ DEVLINK_ATTR_TRAP_METADATA = 0x86 ++ DEVLINK_ATTR_TRAP_GROUP_NAME = 0x87 ++ DEVLINK_ATTR_RELOAD_FAILED = 0x88 ++ DEVLINK_ATTR_HEALTH_REPORTER_DUMP_TS_NS = 0x89 ++ DEVLINK_ATTR_NETNS_FD = 0x8a ++ DEVLINK_ATTR_NETNS_PID = 0x8b ++ DEVLINK_ATTR_NETNS_ID = 0x8c ++ DEVLINK_ATTR_HEALTH_REPORTER_AUTO_DUMP = 0x8d ++ DEVLINK_ATTR_TRAP_POLICER_ID = 0x8e ++ DEVLINK_ATTR_TRAP_POLICER_RATE = 0x8f ++ DEVLINK_ATTR_TRAP_POLICER_BURST = 0x90 ++ DEVLINK_ATTR_PORT_FUNCTION = 0x91 ++ DEVLINK_ATTR_INFO_BOARD_SERIAL_NUMBER = 0x92 ++ DEVLINK_ATTR_PORT_LANES = 0x93 ++ DEVLINK_ATTR_PORT_SPLITTABLE = 0x94 ++ DEVLINK_ATTR_PORT_EXTERNAL = 0x95 ++ DEVLINK_ATTR_PORT_CONTROLLER_NUMBER = 0x96 ++ DEVLINK_ATTR_FLASH_UPDATE_STATUS_TIMEOUT = 0x97 ++ DEVLINK_ATTR_FLASH_UPDATE_OVERWRITE_MASK = 0x98 ++ DEVLINK_ATTR_RELOAD_ACTION = 0x99 ++ DEVLINK_ATTR_RELOAD_ACTIONS_PERFORMED = 0x9a ++ DEVLINK_ATTR_RELOAD_LIMITS = 0x9b ++ DEVLINK_ATTR_DEV_STATS = 0x9c ++ DEVLINK_ATTR_RELOAD_STATS = 0x9d ++ DEVLINK_ATTR_RELOAD_STATS_ENTRY = 0x9e ++ DEVLINK_ATTR_RELOAD_STATS_LIMIT = 0x9f ++ DEVLINK_ATTR_RELOAD_STATS_VALUE = 0xa0 ++ DEVLINK_ATTR_REMOTE_RELOAD_STATS = 0xa1 ++ DEVLINK_ATTR_RELOAD_ACTION_INFO = 0xa2 ++ DEVLINK_ATTR_RELOAD_ACTION_STATS = 0xa3 ++ DEVLINK_ATTR_PORT_PCI_SF_NUMBER = 0xa4 ++ DEVLINK_ATTR_RATE_TYPE = 0xa5 ++ DEVLINK_ATTR_RATE_TX_SHARE = 0xa6 ++ DEVLINK_ATTR_RATE_TX_MAX = 0xa7 ++ DEVLINK_ATTR_RATE_NODE_NAME = 0xa8 ++ DEVLINK_ATTR_RATE_PARENT_NODE_NAME = 0xa9 ++ DEVLINK_ATTR_REGION_MAX_SNAPSHOTS = 0xaa ++ ++ DEVLINK_ATTR_MAX = 0xaa ++ DEVLINK_DPIPE_FIELD_MAPPING_TYPE_NONE = 0x0 ++ DEVLINK_DPIPE_FIELD_MAPPING_TYPE_IFINDEX = 0x1 ++ DEVLINK_DPIPE_MATCH_TYPE_FIELD_EXACT = 0x0 ++ DEVLINK_DPIPE_ACTION_TYPE_FIELD_MODIFY = 0x0 ++ DEVLINK_DPIPE_FIELD_ETHERNET_DST_MAC = 0x0 ++ DEVLINK_DPIPE_FIELD_IPV4_DST_IP = 0x0 ++ DEVLINK_DPIPE_FIELD_IPV6_DST_IP = 0x0 ++ DEVLINK_DPIPE_HEADER_ETHERNET = 0x0 ++ DEVLINK_DPIPE_HEADER_IPV4 = 0x1 ++ DEVLINK_DPIPE_HEADER_IPV6 = 0x2 ++ DEVLINK_RESOURCE_UNIT_ENTRY = 0x0 ++ DEVLINK_PORT_FUNCTION_ATTR_UNSPEC = 0x0 ++ DEVLINK_PORT_FUNCTION_ATTR_HW_ADDR = 0x1 ++ ++ DEVLINK_PORT_FUNCTION_ATTR_MAX = 0x1 ++) ++ ++type FsverityDigest struct { ++ Algorithm uint16 ++ Size uint16 ++} ++ ++type FsverityEnableArg struct { ++ Version uint32 ++ Hash_algorithm uint32 ++ Block_size uint32 ++ Salt_size uint32 ++ Salt_ptr uint64 ++ Sig_size uint32 ++ _ uint32 ++ Sig_ptr uint64 ++ _ [11]uint64 ++} ++ ++type Nhmsg struct { ++ Family uint8 ++ Scope uint8 ++ Protocol uint8 ++ Resvd uint8 ++ Flags uint32 ++} ++ ++type NexthopGrp struct { ++ Id uint32 ++ Weight uint8 ++ Resvd1 uint8 ++ Resvd2 uint16 ++} ++ ++const ( ++ NHA_UNSPEC = 0x0 ++ NHA_ID = 0x1 ++ NHA_GROUP = 0x2 ++ NHA_GROUP_TYPE = 0x3 ++ NHA_BLACKHOLE = 0x4 ++ NHA_OIF = 0x5 ++ NHA_GATEWAY = 0x6 ++ NHA_ENCAP_TYPE = 0x7 ++ NHA_ENCAP = 0x8 ++ NHA_GROUPS = 0x9 ++ NHA_MASTER = 0xa ++) ++ ++const ( ++ CAN_RAW_FILTER = 0x1 ++ CAN_RAW_ERR_FILTER = 0x2 ++ CAN_RAW_LOOPBACK = 0x3 ++ CAN_RAW_RECV_OWN_MSGS = 0x4 ++ CAN_RAW_FD_FRAMES = 0x5 ++ CAN_RAW_JOIN_FILTERS = 0x6 ++) ++ ++type WatchdogInfo struct { ++ Options uint32 ++ Version uint32 ++ Identity [32]uint8 ++} ++ ++type PPSFData struct { ++ Info PPSKInfo ++ Timeout PPSKTime ++} ++ ++type PPSKParams struct { ++ Api_version int32 ++ Mode int32 ++ Assert_off_tu PPSKTime ++ Clear_off_tu PPSKTime ++} ++ ++type PPSKInfo struct { ++ Assert_sequence uint32 ++ Clear_sequence uint32 ++ Assert_tu PPSKTime ++ Clear_tu PPSKTime ++ Current_mode int32 ++ _ [4]byte ++} ++ ++type PPSKTime struct { ++ Sec int64 ++ Nsec int32 ++ Flags uint32 ++} ++ ++const ( ++ PPS_GETPARAMS = 0x400870a1 ++ PPS_SETPARAMS = 0x800870a2 ++ PPS_GETCAP = 0x400870a3 ++ PPS_FETCH = 0xc00870a4 ++) ++ ++const ( ++ LWTUNNEL_ENCAP_NONE = 0x0 ++ LWTUNNEL_ENCAP_MPLS = 0x1 ++ LWTUNNEL_ENCAP_IP = 0x2 ++ LWTUNNEL_ENCAP_ILA = 0x3 ++ LWTUNNEL_ENCAP_IP6 = 0x4 ++ LWTUNNEL_ENCAP_SEG6 = 0x5 ++ LWTUNNEL_ENCAP_BPF = 0x6 ++ LWTUNNEL_ENCAP_SEG6_LOCAL = 0x7 ++ LWTUNNEL_ENCAP_RPL = 0x8 ++ ++ LWTUNNEL_ENCAP_MAX = 0x8 ++ ++ MPLS_IPTUNNEL_UNSPEC = 0x0 ++ MPLS_IPTUNNEL_DST = 0x1 ++ MPLS_IPTUNNEL_TTL = 0x2 ++ MPLS_IPTUNNEL_MAX = 0x2 ++) ++ ++const ( ++ ETHTOOL_ID_UNSPEC = 0x0 ++ ETHTOOL_RX_COPYBREAK = 0x1 ++ ETHTOOL_TX_COPYBREAK = 0x2 ++ ETHTOOL_PFC_PREVENTION_TOUT = 0x3 ++ ETHTOOL_TUNABLE_UNSPEC = 0x0 ++ ETHTOOL_TUNABLE_U8 = 0x1 ++ ETHTOOL_TUNABLE_U16 = 0x2 ++ ETHTOOL_TUNABLE_U32 = 0x3 ++ ETHTOOL_TUNABLE_U64 = 0x4 ++ ETHTOOL_TUNABLE_STRING = 0x5 ++ ETHTOOL_TUNABLE_S8 = 0x6 ++ ETHTOOL_TUNABLE_S16 = 0x7 ++ ETHTOOL_TUNABLE_S32 = 0x8 ++ ETHTOOL_TUNABLE_S64 = 0x9 ++ ETHTOOL_PHY_ID_UNSPEC = 0x0 ++ ETHTOOL_PHY_DOWNSHIFT = 0x1 ++ ETHTOOL_PHY_FAST_LINK_DOWN = 0x2 ++ ETHTOOL_PHY_EDPD = 0x3 ++ ETHTOOL_LINK_EXT_STATE_AUTONEG = 0x0 ++ ETHTOOL_LINK_EXT_STATE_LINK_TRAINING_FAILURE = 0x1 ++ ETHTOOL_LINK_EXT_STATE_LINK_LOGICAL_MISMATCH = 0x2 ++ ETHTOOL_LINK_EXT_STATE_BAD_SIGNAL_INTEGRITY = 0x3 ++ ETHTOOL_LINK_EXT_STATE_NO_CABLE = 0x4 ++ ETHTOOL_LINK_EXT_STATE_CABLE_ISSUE = 0x5 ++ ETHTOOL_LINK_EXT_STATE_EEPROM_ISSUE = 0x6 ++ ETHTOOL_LINK_EXT_STATE_CALIBRATION_FAILURE = 0x7 ++ ETHTOOL_LINK_EXT_STATE_POWER_BUDGET_EXCEEDED = 0x8 ++ ETHTOOL_LINK_EXT_STATE_OVERHEAT = 0x9 ++ ETHTOOL_LINK_EXT_SUBSTATE_AN_NO_PARTNER_DETECTED = 0x1 ++ ETHTOOL_LINK_EXT_SUBSTATE_AN_ACK_NOT_RECEIVED = 0x2 ++ ETHTOOL_LINK_EXT_SUBSTATE_AN_NEXT_PAGE_EXCHANGE_FAILED = 0x3 ++ ETHTOOL_LINK_EXT_SUBSTATE_AN_NO_PARTNER_DETECTED_FORCE_MODE = 0x4 ++ ETHTOOL_LINK_EXT_SUBSTATE_AN_FEC_MISMATCH_DURING_OVERRIDE = 0x5 ++ ETHTOOL_LINK_EXT_SUBSTATE_AN_NO_HCD = 0x6 ++ ETHTOOL_LINK_EXT_SUBSTATE_LT_KR_FRAME_LOCK_NOT_ACQUIRED = 0x1 ++ ETHTOOL_LINK_EXT_SUBSTATE_LT_KR_LINK_INHIBIT_TIMEOUT = 0x2 ++ ETHTOOL_LINK_EXT_SUBSTATE_LT_KR_LINK_PARTNER_DID_NOT_SET_RECEIVER_READY = 0x3 ++ ETHTOOL_LINK_EXT_SUBSTATE_LT_REMOTE_FAULT = 0x4 ++ ETHTOOL_LINK_EXT_SUBSTATE_LLM_PCS_DID_NOT_ACQUIRE_BLOCK_LOCK = 0x1 ++ ETHTOOL_LINK_EXT_SUBSTATE_LLM_PCS_DID_NOT_ACQUIRE_AM_LOCK = 0x2 ++ ETHTOOL_LINK_EXT_SUBSTATE_LLM_PCS_DID_NOT_GET_ALIGN_STATUS = 0x3 ++ ETHTOOL_LINK_EXT_SUBSTATE_LLM_FC_FEC_IS_NOT_LOCKED = 0x4 ++ ETHTOOL_LINK_EXT_SUBSTATE_LLM_RS_FEC_IS_NOT_LOCKED = 0x5 ++ ETHTOOL_LINK_EXT_SUBSTATE_BSI_LARGE_NUMBER_OF_PHYSICAL_ERRORS = 0x1 ++ ETHTOOL_LINK_EXT_SUBSTATE_BSI_UNSUPPORTED_RATE = 0x2 ++ ETHTOOL_LINK_EXT_SUBSTATE_CI_UNSUPPORTED_CABLE = 0x1 ++ ETHTOOL_LINK_EXT_SUBSTATE_CI_CABLE_TEST_FAILURE = 0x2 ++ ETHTOOL_FLASH_ALL_REGIONS = 0x0 ++ ETHTOOL_F_UNSUPPORTED__BIT = 0x0 ++ ETHTOOL_F_WISH__BIT = 0x1 ++ ETHTOOL_F_COMPAT__BIT = 0x2 ++ ETHTOOL_FEC_NONE_BIT = 0x0 ++ ETHTOOL_FEC_AUTO_BIT = 0x1 ++ ETHTOOL_FEC_OFF_BIT = 0x2 ++ ETHTOOL_FEC_RS_BIT = 0x3 ++ ETHTOOL_FEC_BASER_BIT = 0x4 ++ ETHTOOL_FEC_LLRS_BIT = 0x5 ++ ETHTOOL_LINK_MODE_10baseT_Half_BIT = 0x0 ++ ETHTOOL_LINK_MODE_10baseT_Full_BIT = 0x1 ++ ETHTOOL_LINK_MODE_100baseT_Half_BIT = 0x2 ++ ETHTOOL_LINK_MODE_100baseT_Full_BIT = 0x3 ++ ETHTOOL_LINK_MODE_1000baseT_Half_BIT = 0x4 ++ ETHTOOL_LINK_MODE_1000baseT_Full_BIT = 0x5 ++ ETHTOOL_LINK_MODE_Autoneg_BIT = 0x6 ++ ETHTOOL_LINK_MODE_TP_BIT = 0x7 ++ ETHTOOL_LINK_MODE_AUI_BIT = 0x8 ++ ETHTOOL_LINK_MODE_MII_BIT = 0x9 ++ ETHTOOL_LINK_MODE_FIBRE_BIT = 0xa ++ ETHTOOL_LINK_MODE_BNC_BIT = 0xb ++ ETHTOOL_LINK_MODE_10000baseT_Full_BIT = 0xc ++ ETHTOOL_LINK_MODE_Pause_BIT = 0xd ++ ETHTOOL_LINK_MODE_Asym_Pause_BIT = 0xe ++ ETHTOOL_LINK_MODE_2500baseX_Full_BIT = 0xf ++ ETHTOOL_LINK_MODE_Backplane_BIT = 0x10 ++ ETHTOOL_LINK_MODE_1000baseKX_Full_BIT = 0x11 ++ ETHTOOL_LINK_MODE_10000baseKX4_Full_BIT = 0x12 ++ ETHTOOL_LINK_MODE_10000baseKR_Full_BIT = 0x13 ++ ETHTOOL_LINK_MODE_10000baseR_FEC_BIT = 0x14 ++ ETHTOOL_LINK_MODE_20000baseMLD2_Full_BIT = 0x15 ++ ETHTOOL_LINK_MODE_20000baseKR2_Full_BIT = 0x16 ++ ETHTOOL_LINK_MODE_40000baseKR4_Full_BIT = 0x17 ++ ETHTOOL_LINK_MODE_40000baseCR4_Full_BIT = 0x18 ++ ETHTOOL_LINK_MODE_40000baseSR4_Full_BIT = 0x19 ++ ETHTOOL_LINK_MODE_40000baseLR4_Full_BIT = 0x1a ++ ETHTOOL_LINK_MODE_56000baseKR4_Full_BIT = 0x1b ++ ETHTOOL_LINK_MODE_56000baseCR4_Full_BIT = 0x1c ++ ETHTOOL_LINK_MODE_56000baseSR4_Full_BIT = 0x1d ++ ETHTOOL_LINK_MODE_56000baseLR4_Full_BIT = 0x1e ++ ETHTOOL_LINK_MODE_25000baseCR_Full_BIT = 0x1f ++ ETHTOOL_LINK_MODE_25000baseKR_Full_BIT = 0x20 ++ ETHTOOL_LINK_MODE_25000baseSR_Full_BIT = 0x21 ++ ETHTOOL_LINK_MODE_50000baseCR2_Full_BIT = 0x22 ++ ETHTOOL_LINK_MODE_50000baseKR2_Full_BIT = 0x23 ++ ETHTOOL_LINK_MODE_100000baseKR4_Full_BIT = 0x24 ++ ETHTOOL_LINK_MODE_100000baseSR4_Full_BIT = 0x25 ++ ETHTOOL_LINK_MODE_100000baseCR4_Full_BIT = 0x26 ++ ETHTOOL_LINK_MODE_100000baseLR4_ER4_Full_BIT = 0x27 ++ ETHTOOL_LINK_MODE_50000baseSR2_Full_BIT = 0x28 ++ ETHTOOL_LINK_MODE_1000baseX_Full_BIT = 0x29 ++ ETHTOOL_LINK_MODE_10000baseCR_Full_BIT = 0x2a ++ ETHTOOL_LINK_MODE_10000baseSR_Full_BIT = 0x2b ++ ETHTOOL_LINK_MODE_10000baseLR_Full_BIT = 0x2c ++ ETHTOOL_LINK_MODE_10000baseLRM_Full_BIT = 0x2d ++ ETHTOOL_LINK_MODE_10000baseER_Full_BIT = 0x2e ++ ETHTOOL_LINK_MODE_2500baseT_Full_BIT = 0x2f ++ ETHTOOL_LINK_MODE_5000baseT_Full_BIT = 0x30 ++ ETHTOOL_LINK_MODE_FEC_NONE_BIT = 0x31 ++ ETHTOOL_LINK_MODE_FEC_RS_BIT = 0x32 ++ ETHTOOL_LINK_MODE_FEC_BASER_BIT = 0x33 ++ ETHTOOL_LINK_MODE_50000baseKR_Full_BIT = 0x34 ++ ETHTOOL_LINK_MODE_50000baseSR_Full_BIT = 0x35 ++ ETHTOOL_LINK_MODE_50000baseCR_Full_BIT = 0x36 ++ ETHTOOL_LINK_MODE_50000baseLR_ER_FR_Full_BIT = 0x37 ++ ETHTOOL_LINK_MODE_50000baseDR_Full_BIT = 0x38 ++ ETHTOOL_LINK_MODE_100000baseKR2_Full_BIT = 0x39 ++ ETHTOOL_LINK_MODE_100000baseSR2_Full_BIT = 0x3a ++ ETHTOOL_LINK_MODE_100000baseCR2_Full_BIT = 0x3b ++ ETHTOOL_LINK_MODE_100000baseLR2_ER2_FR2_Full_BIT = 0x3c ++ ETHTOOL_LINK_MODE_100000baseDR2_Full_BIT = 0x3d ++ ETHTOOL_LINK_MODE_200000baseKR4_Full_BIT = 0x3e ++ ETHTOOL_LINK_MODE_200000baseSR4_Full_BIT = 0x3f ++ ETHTOOL_LINK_MODE_200000baseLR4_ER4_FR4_Full_BIT = 0x40 ++ ETHTOOL_LINK_MODE_200000baseDR4_Full_BIT = 0x41 ++ ETHTOOL_LINK_MODE_200000baseCR4_Full_BIT = 0x42 ++ ETHTOOL_LINK_MODE_100baseT1_Full_BIT = 0x43 ++ ETHTOOL_LINK_MODE_1000baseT1_Full_BIT = 0x44 ++ ETHTOOL_LINK_MODE_400000baseKR8_Full_BIT = 0x45 ++ ETHTOOL_LINK_MODE_400000baseSR8_Full_BIT = 0x46 ++ ETHTOOL_LINK_MODE_400000baseLR8_ER8_FR8_Full_BIT = 0x47 ++ ETHTOOL_LINK_MODE_400000baseDR8_Full_BIT = 0x48 ++ ETHTOOL_LINK_MODE_400000baseCR8_Full_BIT = 0x49 ++ ETHTOOL_LINK_MODE_FEC_LLRS_BIT = 0x4a ++ ETHTOOL_LINK_MODE_100000baseKR_Full_BIT = 0x4b ++ ETHTOOL_LINK_MODE_100000baseSR_Full_BIT = 0x4c ++ ETHTOOL_LINK_MODE_100000baseLR_ER_FR_Full_BIT = 0x4d ++ ETHTOOL_LINK_MODE_100000baseCR_Full_BIT = 0x4e ++ ETHTOOL_LINK_MODE_100000baseDR_Full_BIT = 0x4f ++ ETHTOOL_LINK_MODE_200000baseKR2_Full_BIT = 0x50 ++ ETHTOOL_LINK_MODE_200000baseSR2_Full_BIT = 0x51 ++ ETHTOOL_LINK_MODE_200000baseLR2_ER2_FR2_Full_BIT = 0x52 ++ ETHTOOL_LINK_MODE_200000baseDR2_Full_BIT = 0x53 ++ ETHTOOL_LINK_MODE_200000baseCR2_Full_BIT = 0x54 ++ ETHTOOL_LINK_MODE_400000baseKR4_Full_BIT = 0x55 ++ ETHTOOL_LINK_MODE_400000baseSR4_Full_BIT = 0x56 ++ ETHTOOL_LINK_MODE_400000baseLR4_ER4_FR4_Full_BIT = 0x57 ++ ETHTOOL_LINK_MODE_400000baseDR4_Full_BIT = 0x58 ++ ETHTOOL_LINK_MODE_400000baseCR4_Full_BIT = 0x59 ++ ETHTOOL_LINK_MODE_100baseFX_Half_BIT = 0x5a ++ ETHTOOL_LINK_MODE_100baseFX_Full_BIT = 0x5b ++ ++ ETHTOOL_MSG_USER_NONE = 0x0 ++ ETHTOOL_MSG_STRSET_GET = 0x1 ++ ETHTOOL_MSG_LINKINFO_GET = 0x2 ++ ETHTOOL_MSG_LINKINFO_SET = 0x3 ++ ETHTOOL_MSG_LINKMODES_GET = 0x4 ++ ETHTOOL_MSG_LINKMODES_SET = 0x5 ++ ETHTOOL_MSG_LINKSTATE_GET = 0x6 ++ ETHTOOL_MSG_DEBUG_GET = 0x7 ++ ETHTOOL_MSG_DEBUG_SET = 0x8 ++ ETHTOOL_MSG_WOL_GET = 0x9 ++ ETHTOOL_MSG_WOL_SET = 0xa ++ ETHTOOL_MSG_FEATURES_GET = 0xb ++ ETHTOOL_MSG_FEATURES_SET = 0xc ++ ETHTOOL_MSG_PRIVFLAGS_GET = 0xd ++ ETHTOOL_MSG_PRIVFLAGS_SET = 0xe ++ ETHTOOL_MSG_RINGS_GET = 0xf ++ ETHTOOL_MSG_RINGS_SET = 0x10 ++ ETHTOOL_MSG_CHANNELS_GET = 0x11 ++ ETHTOOL_MSG_CHANNELS_SET = 0x12 ++ ETHTOOL_MSG_COALESCE_GET = 0x13 ++ ETHTOOL_MSG_COALESCE_SET = 0x14 ++ ETHTOOL_MSG_PAUSE_GET = 0x15 ++ ETHTOOL_MSG_PAUSE_SET = 0x16 ++ ETHTOOL_MSG_EEE_GET = 0x17 ++ ETHTOOL_MSG_EEE_SET = 0x18 ++ ETHTOOL_MSG_TSINFO_GET = 0x19 ++ ETHTOOL_MSG_CABLE_TEST_ACT = 0x1a ++ ETHTOOL_MSG_CABLE_TEST_TDR_ACT = 0x1b ++ ETHTOOL_MSG_TUNNEL_INFO_GET = 0x1c ++ ETHTOOL_MSG_FEC_GET = 0x1d ++ ETHTOOL_MSG_FEC_SET = 0x1e ++ ETHTOOL_MSG_MODULE_EEPROM_GET = 0x1f ++ ETHTOOL_MSG_STATS_GET = 0x20 ++ ETHTOOL_MSG_PHC_VCLOCKS_GET = 0x21 ++ ETHTOOL_MSG_MODULE_GET = 0x22 ++ ETHTOOL_MSG_MODULE_SET = 0x23 ++ ETHTOOL_MSG_USER_MAX = 0x23 ++ ETHTOOL_MSG_KERNEL_NONE = 0x0 ++ ETHTOOL_MSG_STRSET_GET_REPLY = 0x1 ++ ETHTOOL_MSG_LINKINFO_GET_REPLY = 0x2 ++ ETHTOOL_MSG_LINKINFO_NTF = 0x3 ++ ETHTOOL_MSG_LINKMODES_GET_REPLY = 0x4 ++ ETHTOOL_MSG_LINKMODES_NTF = 0x5 ++ ETHTOOL_MSG_LINKSTATE_GET_REPLY = 0x6 ++ ETHTOOL_MSG_DEBUG_GET_REPLY = 0x7 ++ ETHTOOL_MSG_DEBUG_NTF = 0x8 ++ ETHTOOL_MSG_WOL_GET_REPLY = 0x9 ++ ETHTOOL_MSG_WOL_NTF = 0xa ++ ETHTOOL_MSG_FEATURES_GET_REPLY = 0xb ++ ETHTOOL_MSG_FEATURES_SET_REPLY = 0xc ++ ETHTOOL_MSG_FEATURES_NTF = 0xd ++ ETHTOOL_MSG_PRIVFLAGS_GET_REPLY = 0xe ++ ETHTOOL_MSG_PRIVFLAGS_NTF = 0xf ++ ETHTOOL_MSG_RINGS_GET_REPLY = 0x10 ++ ETHTOOL_MSG_RINGS_NTF = 0x11 ++ ETHTOOL_MSG_CHANNELS_GET_REPLY = 0x12 ++ ETHTOOL_MSG_CHANNELS_NTF = 0x13 ++ ETHTOOL_MSG_COALESCE_GET_REPLY = 0x14 ++ ETHTOOL_MSG_COALESCE_NTF = 0x15 ++ ETHTOOL_MSG_PAUSE_GET_REPLY = 0x16 ++ ETHTOOL_MSG_PAUSE_NTF = 0x17 ++ ETHTOOL_MSG_EEE_GET_REPLY = 0x18 ++ ETHTOOL_MSG_EEE_NTF = 0x19 ++ ETHTOOL_MSG_TSINFO_GET_REPLY = 0x1a ++ ETHTOOL_MSG_CABLE_TEST_NTF = 0x1b ++ ETHTOOL_MSG_CABLE_TEST_TDR_NTF = 0x1c ++ ETHTOOL_MSG_TUNNEL_INFO_GET_REPLY = 0x1d ++ ETHTOOL_MSG_FEC_GET_REPLY = 0x1e ++ ETHTOOL_MSG_FEC_NTF = 0x1f ++ ETHTOOL_MSG_MODULE_EEPROM_GET_REPLY = 0x20 ++ ETHTOOL_MSG_STATS_GET_REPLY = 0x21 ++ ETHTOOL_MSG_PHC_VCLOCKS_GET_REPLY = 0x22 ++ ETHTOOL_MSG_MODULE_GET_REPLY = 0x23 ++ ETHTOOL_MSG_MODULE_NTF = 0x24 ++ ETHTOOL_MSG_KERNEL_MAX = 0x24 ++ ETHTOOL_A_HEADER_UNSPEC = 0x0 ++ ETHTOOL_A_HEADER_DEV_INDEX = 0x1 ++ ETHTOOL_A_HEADER_DEV_NAME = 0x2 ++ ETHTOOL_A_HEADER_FLAGS = 0x3 ++ ETHTOOL_A_HEADER_MAX = 0x3 ++ ETHTOOL_A_BITSET_BIT_UNSPEC = 0x0 ++ ETHTOOL_A_BITSET_BIT_INDEX = 0x1 ++ ETHTOOL_A_BITSET_BIT_NAME = 0x2 ++ ETHTOOL_A_BITSET_BIT_VALUE = 0x3 ++ ETHTOOL_A_BITSET_BIT_MAX = 0x3 ++ ETHTOOL_A_BITSET_BITS_UNSPEC = 0x0 ++ ETHTOOL_A_BITSET_BITS_BIT = 0x1 ++ ETHTOOL_A_BITSET_BITS_MAX = 0x1 ++ ETHTOOL_A_BITSET_UNSPEC = 0x0 ++ ETHTOOL_A_BITSET_NOMASK = 0x1 ++ ETHTOOL_A_BITSET_SIZE = 0x2 ++ ETHTOOL_A_BITSET_BITS = 0x3 ++ ETHTOOL_A_BITSET_VALUE = 0x4 ++ ETHTOOL_A_BITSET_MASK = 0x5 ++ ETHTOOL_A_BITSET_MAX = 0x5 ++ ETHTOOL_A_STRING_UNSPEC = 0x0 ++ ETHTOOL_A_STRING_INDEX = 0x1 ++ ETHTOOL_A_STRING_VALUE = 0x2 ++ ETHTOOL_A_STRING_MAX = 0x2 ++ ETHTOOL_A_STRINGS_UNSPEC = 0x0 ++ ETHTOOL_A_STRINGS_STRING = 0x1 ++ ETHTOOL_A_STRINGS_MAX = 0x1 ++ ETHTOOL_A_STRINGSET_UNSPEC = 0x0 ++ ETHTOOL_A_STRINGSET_ID = 0x1 ++ ETHTOOL_A_STRINGSET_COUNT = 0x2 ++ ETHTOOL_A_STRINGSET_STRINGS = 0x3 ++ ETHTOOL_A_STRINGSET_MAX = 0x3 ++ ETHTOOL_A_STRINGSETS_UNSPEC = 0x0 ++ ETHTOOL_A_STRINGSETS_STRINGSET = 0x1 ++ ETHTOOL_A_STRINGSETS_MAX = 0x1 ++ ETHTOOL_A_STRSET_UNSPEC = 0x0 ++ ETHTOOL_A_STRSET_HEADER = 0x1 ++ ETHTOOL_A_STRSET_STRINGSETS = 0x2 ++ ETHTOOL_A_STRSET_COUNTS_ONLY = 0x3 ++ ETHTOOL_A_STRSET_MAX = 0x3 ++ ETHTOOL_A_LINKINFO_UNSPEC = 0x0 ++ ETHTOOL_A_LINKINFO_HEADER = 0x1 ++ ETHTOOL_A_LINKINFO_PORT = 0x2 ++ ETHTOOL_A_LINKINFO_PHYADDR = 0x3 ++ ETHTOOL_A_LINKINFO_TP_MDIX = 0x4 ++ ETHTOOL_A_LINKINFO_TP_MDIX_CTRL = 0x5 ++ ETHTOOL_A_LINKINFO_TRANSCEIVER = 0x6 ++ ETHTOOL_A_LINKINFO_MAX = 0x6 ++ ETHTOOL_A_LINKMODES_UNSPEC = 0x0 ++ ETHTOOL_A_LINKMODES_HEADER = 0x1 ++ ETHTOOL_A_LINKMODES_AUTONEG = 0x2 ++ ETHTOOL_A_LINKMODES_OURS = 0x3 ++ ETHTOOL_A_LINKMODES_PEER = 0x4 ++ ETHTOOL_A_LINKMODES_SPEED = 0x5 ++ ETHTOOL_A_LINKMODES_DUPLEX = 0x6 ++ ETHTOOL_A_LINKMODES_MASTER_SLAVE_CFG = 0x7 ++ ETHTOOL_A_LINKMODES_MASTER_SLAVE_STATE = 0x8 ++ ++ ETHTOOL_A_LINKMODES_MAX = 0x8 ++ ETHTOOL_A_LINKSTATE_UNSPEC = 0x0 ++ ETHTOOL_A_LINKSTATE_HEADER = 0x1 ++ ETHTOOL_A_LINKSTATE_LINK = 0x2 ++ ETHTOOL_A_LINKSTATE_SQI = 0x3 ++ ETHTOOL_A_LINKSTATE_SQI_MAX = 0x4 ++ ETHTOOL_A_LINKSTATE_EXT_STATE = 0x5 ++ ETHTOOL_A_LINKSTATE_EXT_SUBSTATE = 0x6 ++ ETHTOOL_A_LINKSTATE_MAX = 0x6 ++ ETHTOOL_A_DEBUG_UNSPEC = 0x0 ++ ETHTOOL_A_DEBUG_HEADER = 0x1 ++ ETHTOOL_A_DEBUG_MSGMASK = 0x2 ++ ETHTOOL_A_DEBUG_MAX = 0x2 ++ ETHTOOL_A_WOL_UNSPEC = 0x0 ++ ETHTOOL_A_WOL_HEADER = 0x1 ++ ETHTOOL_A_WOL_MODES = 0x2 ++ ETHTOOL_A_WOL_SOPASS = 0x3 ++ ETHTOOL_A_WOL_MAX = 0x3 ++ ETHTOOL_A_FEATURES_UNSPEC = 0x0 ++ ETHTOOL_A_FEATURES_HEADER = 0x1 ++ ETHTOOL_A_FEATURES_HW = 0x2 ++ ETHTOOL_A_FEATURES_WANTED = 0x3 ++ ETHTOOL_A_FEATURES_ACTIVE = 0x4 ++ ETHTOOL_A_FEATURES_NOCHANGE = 0x5 ++ ETHTOOL_A_FEATURES_MAX = 0x5 ++ ETHTOOL_A_PRIVFLAGS_UNSPEC = 0x0 ++ ETHTOOL_A_PRIVFLAGS_HEADER = 0x1 ++ ETHTOOL_A_PRIVFLAGS_FLAGS = 0x2 ++ ETHTOOL_A_PRIVFLAGS_MAX = 0x2 ++ ETHTOOL_A_RINGS_UNSPEC = 0x0 ++ ETHTOOL_A_RINGS_HEADER = 0x1 ++ ETHTOOL_A_RINGS_RX_MAX = 0x2 ++ ETHTOOL_A_RINGS_RX_MINI_MAX = 0x3 ++ ETHTOOL_A_RINGS_RX_JUMBO_MAX = 0x4 ++ ETHTOOL_A_RINGS_TX_MAX = 0x5 ++ ETHTOOL_A_RINGS_RX = 0x6 ++ ETHTOOL_A_RINGS_RX_MINI = 0x7 ++ ETHTOOL_A_RINGS_RX_JUMBO = 0x8 ++ ETHTOOL_A_RINGS_TX = 0x9 ++ ++ ETHTOOL_A_RINGS_MAX = 0x9 ++ ETHTOOL_A_CHANNELS_UNSPEC = 0x0 ++ ETHTOOL_A_CHANNELS_HEADER = 0x1 ++ ETHTOOL_A_CHANNELS_RX_MAX = 0x2 ++ ETHTOOL_A_CHANNELS_TX_MAX = 0x3 ++ ETHTOOL_A_CHANNELS_OTHER_MAX = 0x4 ++ ETHTOOL_A_CHANNELS_COMBINED_MAX = 0x5 ++ ETHTOOL_A_CHANNELS_RX_COUNT = 0x6 ++ ETHTOOL_A_CHANNELS_TX_COUNT = 0x7 ++ ETHTOOL_A_CHANNELS_OTHER_COUNT = 0x8 ++ ETHTOOL_A_CHANNELS_COMBINED_COUNT = 0x9 ++ ETHTOOL_A_CHANNELS_MAX = 0x9 ++ ETHTOOL_A_COALESCE_UNSPEC = 0x0 ++ ETHTOOL_A_COALESCE_HEADER = 0x1 ++ ETHTOOL_A_COALESCE_RX_USECS = 0x2 ++ ETHTOOL_A_COALESCE_RX_MAX_FRAMES = 0x3 ++ ETHTOOL_A_COALESCE_RX_USECS_IRQ = 0x4 ++ ETHTOOL_A_COALESCE_RX_MAX_FRAMES_IRQ = 0x5 ++ ETHTOOL_A_COALESCE_TX_USECS = 0x6 ++ ETHTOOL_A_COALESCE_TX_MAX_FRAMES = 0x7 ++ ETHTOOL_A_COALESCE_TX_USECS_IRQ = 0x8 ++ ETHTOOL_A_COALESCE_TX_MAX_FRAMES_IRQ = 0x9 ++ ETHTOOL_A_COALESCE_STATS_BLOCK_USECS = 0xa ++ ETHTOOL_A_COALESCE_USE_ADAPTIVE_RX = 0xb ++ ETHTOOL_A_COALESCE_USE_ADAPTIVE_TX = 0xc ++ ETHTOOL_A_COALESCE_PKT_RATE_LOW = 0xd ++ ETHTOOL_A_COALESCE_RX_USECS_LOW = 0xe ++ ETHTOOL_A_COALESCE_RX_MAX_FRAMES_LOW = 0xf ++ ETHTOOL_A_COALESCE_TX_USECS_LOW = 0x10 ++ ETHTOOL_A_COALESCE_TX_MAX_FRAMES_LOW = 0x11 ++ ETHTOOL_A_COALESCE_PKT_RATE_HIGH = 0x12 ++ ETHTOOL_A_COALESCE_RX_USECS_HIGH = 0x13 ++ ETHTOOL_A_COALESCE_RX_MAX_FRAMES_HIGH = 0x14 ++ ETHTOOL_A_COALESCE_TX_USECS_HIGH = 0x15 ++ ETHTOOL_A_COALESCE_TX_MAX_FRAMES_HIGH = 0x16 ++ ETHTOOL_A_COALESCE_RATE_SAMPLE_INTERVAL = 0x17 ++ ++ ETHTOOL_A_COALESCE_MAX = 0x17 ++ ETHTOOL_A_PAUSE_UNSPEC = 0x0 ++ ETHTOOL_A_PAUSE_HEADER = 0x1 ++ ETHTOOL_A_PAUSE_AUTONEG = 0x2 ++ ETHTOOL_A_PAUSE_RX = 0x3 ++ ETHTOOL_A_PAUSE_TX = 0x4 ++ ETHTOOL_A_PAUSE_STATS = 0x5 ++ ETHTOOL_A_PAUSE_MAX = 0x5 ++ ETHTOOL_A_PAUSE_STAT_UNSPEC = 0x0 ++ ETHTOOL_A_PAUSE_STAT_PAD = 0x1 ++ ETHTOOL_A_PAUSE_STAT_TX_FRAMES = 0x2 ++ ETHTOOL_A_PAUSE_STAT_RX_FRAMES = 0x3 ++ ETHTOOL_A_PAUSE_STAT_MAX = 0x3 ++ ETHTOOL_A_EEE_UNSPEC = 0x0 ++ ETHTOOL_A_EEE_HEADER = 0x1 ++ ETHTOOL_A_EEE_MODES_OURS = 0x2 ++ ETHTOOL_A_EEE_MODES_PEER = 0x3 ++ ETHTOOL_A_EEE_ACTIVE = 0x4 ++ ETHTOOL_A_EEE_ENABLED = 0x5 ++ ETHTOOL_A_EEE_TX_LPI_ENABLED = 0x6 ++ ETHTOOL_A_EEE_TX_LPI_TIMER = 0x7 ++ ETHTOOL_A_EEE_MAX = 0x7 ++ ETHTOOL_A_TSINFO_UNSPEC = 0x0 ++ ETHTOOL_A_TSINFO_HEADER = 0x1 ++ ETHTOOL_A_TSINFO_TIMESTAMPING = 0x2 ++ ETHTOOL_A_TSINFO_TX_TYPES = 0x3 ++ ETHTOOL_A_TSINFO_RX_FILTERS = 0x4 ++ ETHTOOL_A_TSINFO_PHC_INDEX = 0x5 ++ ETHTOOL_A_TSINFO_MAX = 0x5 ++ ETHTOOL_A_CABLE_TEST_UNSPEC = 0x0 ++ ETHTOOL_A_CABLE_TEST_HEADER = 0x1 ++ ETHTOOL_A_CABLE_TEST_MAX = 0x1 ++ ETHTOOL_A_CABLE_RESULT_CODE_UNSPEC = 0x0 ++ ETHTOOL_A_CABLE_RESULT_CODE_OK = 0x1 ++ ETHTOOL_A_CABLE_RESULT_CODE_OPEN = 0x2 ++ ETHTOOL_A_CABLE_RESULT_CODE_SAME_SHORT = 0x3 ++ ETHTOOL_A_CABLE_RESULT_CODE_CROSS_SHORT = 0x4 ++ ETHTOOL_A_CABLE_PAIR_A = 0x0 ++ ETHTOOL_A_CABLE_PAIR_B = 0x1 ++ ETHTOOL_A_CABLE_PAIR_C = 0x2 ++ ETHTOOL_A_CABLE_PAIR_D = 0x3 ++ ETHTOOL_A_CABLE_RESULT_UNSPEC = 0x0 ++ ETHTOOL_A_CABLE_RESULT_PAIR = 0x1 ++ ETHTOOL_A_CABLE_RESULT_CODE = 0x2 ++ ETHTOOL_A_CABLE_RESULT_MAX = 0x2 ++ ETHTOOL_A_CABLE_FAULT_LENGTH_UNSPEC = 0x0 ++ ETHTOOL_A_CABLE_FAULT_LENGTH_PAIR = 0x1 ++ ETHTOOL_A_CABLE_FAULT_LENGTH_CM = 0x2 ++ ETHTOOL_A_CABLE_FAULT_LENGTH_MAX = 0x2 ++ ETHTOOL_A_CABLE_TEST_NTF_STATUS_UNSPEC = 0x0 ++ ETHTOOL_A_CABLE_TEST_NTF_STATUS_STARTED = 0x1 ++ ETHTOOL_A_CABLE_TEST_NTF_STATUS_COMPLETED = 0x2 ++ ETHTOOL_A_CABLE_NEST_UNSPEC = 0x0 ++ ETHTOOL_A_CABLE_NEST_RESULT = 0x1 ++ ETHTOOL_A_CABLE_NEST_FAULT_LENGTH = 0x2 ++ ETHTOOL_A_CABLE_NEST_MAX = 0x2 ++ ETHTOOL_A_CABLE_TEST_NTF_UNSPEC = 0x0 ++ ETHTOOL_A_CABLE_TEST_NTF_HEADER = 0x1 ++ ETHTOOL_A_CABLE_TEST_NTF_STATUS = 0x2 ++ ETHTOOL_A_CABLE_TEST_NTF_NEST = 0x3 ++ ETHTOOL_A_CABLE_TEST_NTF_MAX = 0x3 ++ ETHTOOL_A_CABLE_TEST_TDR_CFG_UNSPEC = 0x0 ++ ETHTOOL_A_CABLE_TEST_TDR_CFG_FIRST = 0x1 ++ ETHTOOL_A_CABLE_TEST_TDR_CFG_LAST = 0x2 ++ ETHTOOL_A_CABLE_TEST_TDR_CFG_STEP = 0x3 ++ ETHTOOL_A_CABLE_TEST_TDR_CFG_PAIR = 0x4 ++ ETHTOOL_A_CABLE_TEST_TDR_CFG_MAX = 0x4 ++ ETHTOOL_A_CABLE_TEST_TDR_UNSPEC = 0x0 ++ ETHTOOL_A_CABLE_TEST_TDR_HEADER = 0x1 ++ ETHTOOL_A_CABLE_TEST_TDR_CFG = 0x2 ++ ETHTOOL_A_CABLE_TEST_TDR_MAX = 0x2 ++ ETHTOOL_A_CABLE_AMPLITUDE_UNSPEC = 0x0 ++ ETHTOOL_A_CABLE_AMPLITUDE_PAIR = 0x1 ++ ETHTOOL_A_CABLE_AMPLITUDE_mV = 0x2 ++ ETHTOOL_A_CABLE_AMPLITUDE_MAX = 0x2 ++ ETHTOOL_A_CABLE_PULSE_UNSPEC = 0x0 ++ ETHTOOL_A_CABLE_PULSE_mV = 0x1 ++ ETHTOOL_A_CABLE_PULSE_MAX = 0x1 ++ ETHTOOL_A_CABLE_STEP_UNSPEC = 0x0 ++ ETHTOOL_A_CABLE_STEP_FIRST_DISTANCE = 0x1 ++ ETHTOOL_A_CABLE_STEP_LAST_DISTANCE = 0x2 ++ ETHTOOL_A_CABLE_STEP_STEP_DISTANCE = 0x3 ++ ETHTOOL_A_CABLE_STEP_MAX = 0x3 ++ ETHTOOL_A_CABLE_TDR_NEST_UNSPEC = 0x0 ++ ETHTOOL_A_CABLE_TDR_NEST_STEP = 0x1 ++ ETHTOOL_A_CABLE_TDR_NEST_AMPLITUDE = 0x2 ++ ETHTOOL_A_CABLE_TDR_NEST_PULSE = 0x3 ++ ETHTOOL_A_CABLE_TDR_NEST_MAX = 0x3 ++ ETHTOOL_A_CABLE_TEST_TDR_NTF_UNSPEC = 0x0 ++ ETHTOOL_A_CABLE_TEST_TDR_NTF_HEADER = 0x1 ++ ETHTOOL_A_CABLE_TEST_TDR_NTF_STATUS = 0x2 ++ ETHTOOL_A_CABLE_TEST_TDR_NTF_NEST = 0x3 ++ ETHTOOL_A_CABLE_TEST_TDR_NTF_MAX = 0x3 ++ ETHTOOL_UDP_TUNNEL_TYPE_VXLAN = 0x0 ++ ETHTOOL_UDP_TUNNEL_TYPE_GENEVE = 0x1 ++ ETHTOOL_UDP_TUNNEL_TYPE_VXLAN_GPE = 0x2 ++ ETHTOOL_A_TUNNEL_UDP_ENTRY_UNSPEC = 0x0 ++ ETHTOOL_A_TUNNEL_UDP_ENTRY_PORT = 0x1 ++ ETHTOOL_A_TUNNEL_UDP_ENTRY_TYPE = 0x2 ++ ETHTOOL_A_TUNNEL_UDP_ENTRY_MAX = 0x2 ++ ETHTOOL_A_TUNNEL_UDP_TABLE_UNSPEC = 0x0 ++ ETHTOOL_A_TUNNEL_UDP_TABLE_SIZE = 0x1 ++ ETHTOOL_A_TUNNEL_UDP_TABLE_TYPES = 0x2 ++ ETHTOOL_A_TUNNEL_UDP_TABLE_ENTRY = 0x3 ++ ETHTOOL_A_TUNNEL_UDP_TABLE_MAX = 0x3 ++ ETHTOOL_A_TUNNEL_UDP_UNSPEC = 0x0 ++ ETHTOOL_A_TUNNEL_UDP_TABLE = 0x1 ++ ETHTOOL_A_TUNNEL_UDP_MAX = 0x1 ++ ETHTOOL_A_TUNNEL_INFO_UNSPEC = 0x0 ++ ETHTOOL_A_TUNNEL_INFO_HEADER = 0x1 ++ ETHTOOL_A_TUNNEL_INFO_UDP_PORTS = 0x2 ++ ETHTOOL_A_TUNNEL_INFO_MAX = 0x2 ++) ++ ++const SPEED_UNKNOWN = -0x1 ++ ++type EthtoolDrvinfo struct { ++ Cmd uint32 ++ Driver [32]byte ++ Version [32]byte ++ Fw_version [32]byte ++ Bus_info [32]byte ++ Erom_version [32]byte ++ Reserved2 [12]byte ++ N_priv_flags uint32 ++ N_stats uint32 ++ Testinfo_len uint32 ++ Eedump_len uint32 ++ Regdump_len uint32 ++} ++ ++type ( ++ HIDRawReportDescriptor struct { ++ Size uint32 ++ Value [4096]uint8 ++ } ++ HIDRawDevInfo struct { ++ Bustype uint32 ++ Vendor int16 ++ Product int16 ++ } ++) ++ ++const ( ++ CLOSE_RANGE_UNSHARE = 0x2 ++ CLOSE_RANGE_CLOEXEC = 0x4 ++) ++ ++const ( ++ NLMSGERR_ATTR_MSG = 0x1 ++ NLMSGERR_ATTR_OFFS = 0x2 ++ NLMSGERR_ATTR_COOKIE = 0x3 ++) ++ ++type ( ++ EraseInfo struct { ++ Start uint32 ++ Length uint32 ++ } ++ EraseInfo64 struct { ++ Start uint64 ++ Length uint64 ++ } ++ MtdOobBuf struct { ++ Start uint32 ++ Length uint32 ++ Ptr *uint8 ++ } ++ MtdOobBuf64 struct { ++ Start uint64 ++ Pad uint32 ++ Length uint32 ++ Ptr uint64 ++ } ++ MtdWriteReq struct { ++ Start uint64 ++ Len uint64 ++ Ooblen uint64 ++ Data uint64 ++ Oob uint64 ++ Mode uint8 ++ _ [7]uint8 ++ } ++ MtdInfo struct { ++ Type uint8 ++ Flags uint32 ++ Size uint32 ++ Erasesize uint32 ++ Writesize uint32 ++ Oobsize uint32 ++ _ uint64 ++ } ++ RegionInfo struct { ++ Offset uint32 ++ Erasesize uint32 ++ Numblocks uint32 ++ Regionindex uint32 ++ } ++ OtpInfo struct { ++ Start uint32 ++ Length uint32 ++ Locked uint32 ++ } ++ NandOobinfo struct { ++ Useecc uint32 ++ Eccbytes uint32 ++ Oobfree [8][2]uint32 ++ Eccpos [32]uint32 ++ } ++ NandOobfree struct { ++ Offset uint32 ++ Length uint32 ++ } ++ NandEcclayout struct { ++ Eccbytes uint32 ++ Eccpos [64]uint32 ++ Oobavail uint32 ++ Oobfree [8]NandOobfree ++ } ++ MtdEccStats struct { ++ Corrected uint32 ++ Failed uint32 ++ Badblocks uint32 ++ Bbtblocks uint32 ++ } ++) ++ ++const ( ++ MTD_OPS_PLACE_OOB = 0x0 ++ MTD_OPS_AUTO_OOB = 0x1 ++ MTD_OPS_RAW = 0x2 ++) ++ ++const ( ++ MTD_FILE_MODE_NORMAL = 0x0 ++ MTD_FILE_MODE_OTP_FACTORY = 0x1 ++ MTD_FILE_MODE_OTP_USER = 0x2 ++ MTD_FILE_MODE_RAW = 0x3 ++) ++ ++const ( ++ NFC_CMD_UNSPEC = 0x0 ++ NFC_CMD_GET_DEVICE = 0x1 ++ NFC_CMD_DEV_UP = 0x2 ++ NFC_CMD_DEV_DOWN = 0x3 ++ NFC_CMD_DEP_LINK_UP = 0x4 ++ NFC_CMD_DEP_LINK_DOWN = 0x5 ++ NFC_CMD_START_POLL = 0x6 ++ NFC_CMD_STOP_POLL = 0x7 ++ NFC_CMD_GET_TARGET = 0x8 ++ NFC_EVENT_TARGETS_FOUND = 0x9 ++ NFC_EVENT_DEVICE_ADDED = 0xa ++ NFC_EVENT_DEVICE_REMOVED = 0xb ++ NFC_EVENT_TARGET_LOST = 0xc ++ NFC_EVENT_TM_ACTIVATED = 0xd ++ NFC_EVENT_TM_DEACTIVATED = 0xe ++ NFC_CMD_LLC_GET_PARAMS = 0xf ++ NFC_CMD_LLC_SET_PARAMS = 0x10 ++ NFC_CMD_ENABLE_SE = 0x11 ++ NFC_CMD_DISABLE_SE = 0x12 ++ NFC_CMD_LLC_SDREQ = 0x13 ++ NFC_EVENT_LLC_SDRES = 0x14 ++ NFC_CMD_FW_DOWNLOAD = 0x15 ++ NFC_EVENT_SE_ADDED = 0x16 ++ NFC_EVENT_SE_REMOVED = 0x17 ++ NFC_EVENT_SE_CONNECTIVITY = 0x18 ++ NFC_EVENT_SE_TRANSACTION = 0x19 ++ NFC_CMD_GET_SE = 0x1a ++ NFC_CMD_SE_IO = 0x1b ++ NFC_CMD_ACTIVATE_TARGET = 0x1c ++ NFC_CMD_VENDOR = 0x1d ++ NFC_CMD_DEACTIVATE_TARGET = 0x1e ++ NFC_ATTR_UNSPEC = 0x0 ++ NFC_ATTR_DEVICE_INDEX = 0x1 ++ NFC_ATTR_DEVICE_NAME = 0x2 ++ NFC_ATTR_PROTOCOLS = 0x3 ++ NFC_ATTR_TARGET_INDEX = 0x4 ++ NFC_ATTR_TARGET_SENS_RES = 0x5 ++ NFC_ATTR_TARGET_SEL_RES = 0x6 ++ NFC_ATTR_TARGET_NFCID1 = 0x7 ++ NFC_ATTR_TARGET_SENSB_RES = 0x8 ++ NFC_ATTR_TARGET_SENSF_RES = 0x9 ++ NFC_ATTR_COMM_MODE = 0xa ++ NFC_ATTR_RF_MODE = 0xb ++ NFC_ATTR_DEVICE_POWERED = 0xc ++ NFC_ATTR_IM_PROTOCOLS = 0xd ++ NFC_ATTR_TM_PROTOCOLS = 0xe ++ NFC_ATTR_LLC_PARAM_LTO = 0xf ++ NFC_ATTR_LLC_PARAM_RW = 0x10 ++ NFC_ATTR_LLC_PARAM_MIUX = 0x11 ++ NFC_ATTR_SE = 0x12 ++ NFC_ATTR_LLC_SDP = 0x13 ++ NFC_ATTR_FIRMWARE_NAME = 0x14 ++ NFC_ATTR_SE_INDEX = 0x15 ++ NFC_ATTR_SE_TYPE = 0x16 ++ NFC_ATTR_SE_AID = 0x17 ++ NFC_ATTR_FIRMWARE_DOWNLOAD_STATUS = 0x18 ++ NFC_ATTR_SE_APDU = 0x19 ++ NFC_ATTR_TARGET_ISO15693_DSFID = 0x1a ++ NFC_ATTR_TARGET_ISO15693_UID = 0x1b ++ NFC_ATTR_SE_PARAMS = 0x1c ++ NFC_ATTR_VENDOR_ID = 0x1d ++ NFC_ATTR_VENDOR_SUBCMD = 0x1e ++ NFC_ATTR_VENDOR_DATA = 0x1f ++ NFC_SDP_ATTR_UNSPEC = 0x0 ++ NFC_SDP_ATTR_URI = 0x1 ++ NFC_SDP_ATTR_SAP = 0x2 ++) ++ ++type LandlockRulesetAttr struct{} ++ ++type LandlockPathBeneathAttr struct{} ++ ++const ( ++ PIDFD_NONBLOCK = 0x4 ++) ++ ++type SysvIpcPerm struct { ++ Key int32 ++ Uid uint32 ++ Gid uint32 ++ Cuid uint32 ++ Cgid uint32 ++ Mode uint32 ++ _ [0]uint8 ++ Seq uint16 ++ _ uint16 ++ _ uint64 ++ _ uint64 ++} ++type SysvShmDesc struct { ++ Perm SysvIpcPerm ++ Segsz uint64 ++ Atime int64 ++ Dtime int64 ++ Ctime int64 ++ Cpid int32 ++ Lpid int32 ++ Nattch uint64 ++ _ uint64 ++ _ uint64 ++} ++ ++const ( ++ IPC_CREAT = 0x200 ++ IPC_EXCL = 0x400 ++ IPC_NOWAIT = 0x800 ++ IPC_PRIVATE = 0x0 ++ ++ ipc_64 = 0x100 ++) ++ ++const ( ++ IPC_RMID = 0x0 ++ IPC_SET = 0x1 ++ IPC_STAT = 0x2 ++) ++ ++const ( ++ SHM_RDONLY = 0x1000 ++ SHM_RND = 0x2000 ++) ++ ++type MountAttr struct{} ++ ++const ( ++ WG_CMD_GET_DEVICE = 0x0 ++ WG_CMD_SET_DEVICE = 0x1 ++ WGDEVICE_F_REPLACE_PEERS = 0x1 ++ WGDEVICE_A_UNSPEC = 0x0 ++ WGDEVICE_A_IFINDEX = 0x1 ++ WGDEVICE_A_IFNAME = 0x2 ++ WGDEVICE_A_PRIVATE_KEY = 0x3 ++ WGDEVICE_A_PUBLIC_KEY = 0x4 ++ WGDEVICE_A_FLAGS = 0x5 ++ WGDEVICE_A_LISTEN_PORT = 0x6 ++ WGDEVICE_A_FWMARK = 0x7 ++ WGDEVICE_A_PEERS = 0x8 ++ WGPEER_F_REMOVE_ME = 0x1 ++ WGPEER_F_REPLACE_ALLOWEDIPS = 0x2 ++ WGPEER_F_UPDATE_ONLY = 0x4 ++ WGPEER_A_UNSPEC = 0x0 ++ WGPEER_A_PUBLIC_KEY = 0x1 ++ WGPEER_A_PRESHARED_KEY = 0x2 ++ WGPEER_A_FLAGS = 0x3 ++ WGPEER_A_ENDPOINT = 0x4 ++ WGPEER_A_PERSISTENT_KEEPALIVE_INTERVAL = 0x5 ++ WGPEER_A_LAST_HANDSHAKE_TIME = 0x6 ++ WGPEER_A_RX_BYTES = 0x7 ++ WGPEER_A_TX_BYTES = 0x8 ++ WGPEER_A_ALLOWEDIPS = 0x9 ++ WGPEER_A_PROTOCOL_VERSION = 0xa ++ WGALLOWEDIP_A_UNSPEC = 0x0 ++ WGALLOWEDIP_A_FAMILY = 0x1 ++ WGALLOWEDIP_A_IPADDR = 0x2 ++ WGALLOWEDIP_A_CIDR_MASK = 0x3 ++) ++ ++const ( ++ NL_ATTR_TYPE_INVALID = 0x0 ++ NL_ATTR_TYPE_FLAG = 0x1 ++ NL_ATTR_TYPE_U8 = 0x2 ++ NL_ATTR_TYPE_U16 = 0x3 ++ NL_ATTR_TYPE_U32 = 0x4 ++ NL_ATTR_TYPE_U64 = 0x5 ++ NL_ATTR_TYPE_S8 = 0x6 ++ NL_ATTR_TYPE_S16 = 0x7 ++ NL_ATTR_TYPE_S32 = 0x8 ++ NL_ATTR_TYPE_S64 = 0x9 ++ NL_ATTR_TYPE_BINARY = 0xa ++ NL_ATTR_TYPE_STRING = 0xb ++ NL_ATTR_TYPE_NUL_STRING = 0xc ++ NL_ATTR_TYPE_NESTED = 0xd ++ NL_ATTR_TYPE_NESTED_ARRAY = 0xe ++ NL_ATTR_TYPE_BITFIELD32 = 0xf ++ ++ NL_POLICY_TYPE_ATTR_UNSPEC = 0x0 ++ NL_POLICY_TYPE_ATTR_TYPE = 0x1 ++ NL_POLICY_TYPE_ATTR_MIN_VALUE_S = 0x2 ++ NL_POLICY_TYPE_ATTR_MAX_VALUE_S = 0x3 ++ NL_POLICY_TYPE_ATTR_MIN_VALUE_U = 0x4 ++ NL_POLICY_TYPE_ATTR_MAX_VALUE_U = 0x5 ++ NL_POLICY_TYPE_ATTR_MIN_LENGTH = 0x6 ++ NL_POLICY_TYPE_ATTR_MAX_LENGTH = 0x7 ++ NL_POLICY_TYPE_ATTR_POLICY_IDX = 0x8 ++ NL_POLICY_TYPE_ATTR_POLICY_MAXTYPE = 0x9 ++ NL_POLICY_TYPE_ATTR_BITFIELD32_MASK = 0xa ++ NL_POLICY_TYPE_ATTR_PAD = 0xb ++ NL_POLICY_TYPE_ATTR_MASK = 0xc ++ NL_POLICY_TYPE_ATTR_MAX = 0xc ++) ++ ++type CANBitTiming struct { ++ Bitrate uint32 ++ Sample_point uint32 ++ Tq uint32 ++ Prop_seg uint32 ++ Phase_seg1 uint32 ++ Phase_seg2 uint32 ++ Sjw uint32 ++ Brp uint32 ++} ++ ++type CANBitTimingConst struct { ++ Name [16]uint8 ++ Tseg1_min uint32 ++ Tseg1_max uint32 ++ Tseg2_min uint32 ++ Tseg2_max uint32 ++ Sjw_max uint32 ++ Brp_min uint32 ++ Brp_max uint32 ++ Brp_inc uint32 ++} ++ ++type CANClock struct { ++ Freq uint32 ++} ++ ++type CANBusErrorCounters struct { ++ Txerr uint16 ++ Rxerr uint16 ++} ++ ++type CANCtrlMode struct { ++ Mask uint32 ++ Flags uint32 ++} ++ ++type CANDeviceStats struct { ++ Bus_error uint32 ++ Error_warning uint32 ++ Error_passive uint32 ++ Bus_off uint32 ++ Arbitration_lost uint32 ++ Restarts uint32 ++} ++ ++const ( ++ CAN_STATE_ERROR_ACTIVE = 0x0 ++ CAN_STATE_ERROR_WARNING = 0x1 ++ CAN_STATE_ERROR_PASSIVE = 0x2 ++ CAN_STATE_BUS_OFF = 0x3 ++ CAN_STATE_STOPPED = 0x4 ++ CAN_STATE_SLEEPING = 0x5 ++ CAN_STATE_MAX = 0x6 ++) ++ ++const ( ++ IFLA_CAN_UNSPEC = 0x0 ++ IFLA_CAN_BITTIMING = 0x1 ++ IFLA_CAN_BITTIMING_CONST = 0x2 ++ IFLA_CAN_CLOCK = 0x3 ++ IFLA_CAN_STATE = 0x4 ++ IFLA_CAN_CTRLMODE = 0x5 ++ IFLA_CAN_RESTART_MS = 0x6 ++ IFLA_CAN_RESTART = 0x7 ++ IFLA_CAN_BERR_COUNTER = 0x8 ++ IFLA_CAN_DATA_BITTIMING = 0x9 ++ IFLA_CAN_DATA_BITTIMING_CONST = 0xa ++ IFLA_CAN_TERMINATION = 0xb ++ IFLA_CAN_TERMINATION_CONST = 0xc ++ IFLA_CAN_BITRATE_CONST = 0xd ++ IFLA_CAN_DATA_BITRATE_CONST = 0xe ++ IFLA_CAN_BITRATE_MAX = 0xf ++) ++ ++type KCMAttach struct { ++ Fd int32 ++ Bpf_fd int32 ++} ++ ++type KCMUnattach struct { ++ Fd int32 ++} ++ ++type KCMClone struct { ++ Fd int32 ++} ++ ++const ( ++ NL80211_AC_BE = 0x2 ++ NL80211_AC_BK = 0x3 ++ NL80211_ACL_POLICY_ACCEPT_UNLESS_LISTED = 0x0 ++ NL80211_ACL_POLICY_DENY_UNLESS_LISTED = 0x1 ++ NL80211_AC_VI = 0x1 ++ NL80211_AC_VO = 0x0 ++ NL80211_ATTR_4ADDR = 0x53 ++ NL80211_ATTR_ACK = 0x5c ++ NL80211_ATTR_ACK_SIGNAL = 0x107 ++ NL80211_ATTR_ACL_POLICY = 0xa5 ++ NL80211_ATTR_ADMITTED_TIME = 0xd4 ++ NL80211_ATTR_AIRTIME_WEIGHT = 0x112 ++ NL80211_ATTR_AKM_SUITES = 0x4c ++ NL80211_ATTR_AP_ISOLATE = 0x60 ++ NL80211_ATTR_AUTH_DATA = 0x9c ++ NL80211_ATTR_AUTH_TYPE = 0x35 ++ NL80211_ATTR_BANDS = 0xef ++ NL80211_ATTR_BEACON_HEAD = 0xe ++ NL80211_ATTR_BEACON_INTERVAL = 0xc ++ NL80211_ATTR_BEACON_TAIL = 0xf ++ NL80211_ATTR_BG_SCAN_PERIOD = 0x98 ++ NL80211_ATTR_BSS_BASIC_RATES = 0x24 ++ NL80211_ATTR_BSS = 0x2f ++ NL80211_ATTR_BSS_CTS_PROT = 0x1c ++ NL80211_ATTR_BSS_HT_OPMODE = 0x6d ++ NL80211_ATTR_BSSID = 0xf5 ++ NL80211_ATTR_BSS_SELECT = 0xe3 ++ NL80211_ATTR_BSS_SHORT_PREAMBLE = 0x1d ++ NL80211_ATTR_BSS_SHORT_SLOT_TIME = 0x1e ++ NL80211_ATTR_CENTER_FREQ1 = 0xa0 ++ NL80211_ATTR_CENTER_FREQ1_OFFSET = 0x123 ++ NL80211_ATTR_CENTER_FREQ2 = 0xa1 ++ NL80211_ATTR_CHANNEL_WIDTH = 0x9f ++ NL80211_ATTR_CH_SWITCH_BLOCK_TX = 0xb8 ++ NL80211_ATTR_CH_SWITCH_COUNT = 0xb7 ++ NL80211_ATTR_CIPHER_SUITE_GROUP = 0x4a ++ NL80211_ATTR_CIPHER_SUITES = 0x39 ++ NL80211_ATTR_CIPHER_SUITES_PAIRWISE = 0x49 ++ NL80211_ATTR_CNTDWN_OFFS_BEACON = 0xba ++ NL80211_ATTR_CNTDWN_OFFS_PRESP = 0xbb ++ NL80211_ATTR_COALESCE_RULE = 0xb6 ++ NL80211_ATTR_COALESCE_RULE_CONDITION = 0x2 ++ NL80211_ATTR_COALESCE_RULE_DELAY = 0x1 ++ NL80211_ATTR_COALESCE_RULE_MAX = 0x3 ++ NL80211_ATTR_COALESCE_RULE_PKT_PATTERN = 0x3 ++ NL80211_ATTR_CONN_FAILED_REASON = 0x9b ++ NL80211_ATTR_CONTROL_PORT = 0x44 ++ NL80211_ATTR_CONTROL_PORT_ETHERTYPE = 0x66 ++ NL80211_ATTR_CONTROL_PORT_NO_ENCRYPT = 0x67 ++ NL80211_ATTR_CONTROL_PORT_NO_PREAUTH = 0x11e ++ NL80211_ATTR_CONTROL_PORT_OVER_NL80211 = 0x108 ++ NL80211_ATTR_COOKIE = 0x58 ++ NL80211_ATTR_CQM_BEACON_LOSS_EVENT = 0x8 ++ NL80211_ATTR_CQM = 0x5e ++ NL80211_ATTR_CQM_MAX = 0x9 ++ NL80211_ATTR_CQM_PKT_LOSS_EVENT = 0x4 ++ NL80211_ATTR_CQM_RSSI_HYST = 0x2 ++ NL80211_ATTR_CQM_RSSI_LEVEL = 0x9 ++ NL80211_ATTR_CQM_RSSI_THOLD = 0x1 ++ NL80211_ATTR_CQM_RSSI_THRESHOLD_EVENT = 0x3 ++ NL80211_ATTR_CQM_TXE_INTVL = 0x7 ++ NL80211_ATTR_CQM_TXE_PKTS = 0x6 ++ NL80211_ATTR_CQM_TXE_RATE = 0x5 ++ NL80211_ATTR_CRIT_PROT_ID = 0xb3 ++ NL80211_ATTR_CSA_C_OFF_BEACON = 0xba ++ NL80211_ATTR_CSA_C_OFF_PRESP = 0xbb ++ NL80211_ATTR_CSA_C_OFFSETS_TX = 0xcd ++ NL80211_ATTR_CSA_IES = 0xb9 ++ NL80211_ATTR_DEVICE_AP_SME = 0x8d ++ NL80211_ATTR_DFS_CAC_TIME = 0x7 ++ NL80211_ATTR_DFS_REGION = 0x92 ++ ++ NL80211_ATTR_DISABLE_HT = 0x93 ++ NL80211_ATTR_DISABLE_VHT = 0xaf ++ NL80211_ATTR_DISCONNECTED_BY_AP = 0x47 ++ NL80211_ATTR_DONT_WAIT_FOR_ACK = 0x8e ++ NL80211_ATTR_DTIM_PERIOD = 0xd ++ NL80211_ATTR_DURATION = 0x57 ++ NL80211_ATTR_EXT_CAPA = 0xa9 ++ NL80211_ATTR_EXT_CAPA_MASK = 0xaa ++ NL80211_ATTR_EXTERNAL_AUTH_ACTION = 0x104 ++ NL80211_ATTR_EXTERNAL_AUTH_SUPPORT = 0x105 ++ NL80211_ATTR_EXT_FEATURES = 0xd9 ++ NL80211_ATTR_FEATURE_FLAGS = 0x8f ++ NL80211_ATTR_FILS_CACHE_ID = 0xfd ++ NL80211_ATTR_FILS_DISCOVERY = 0x126 ++ NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM = 0xfb ++ NL80211_ATTR_FILS_ERP_REALM = 0xfa ++ NL80211_ATTR_FILS_ERP_RRK = 0xfc ++ NL80211_ATTR_FILS_ERP_USERNAME = 0xf9 ++ NL80211_ATTR_FILS_KEK = 0xf2 ++ NL80211_ATTR_FILS_NONCES = 0xf3 ++ NL80211_ATTR_FRAME = 0x33 ++ NL80211_ATTR_FRAME_MATCH = 0x5b ++ NL80211_ATTR_FRAME_TYPE = 0x65 ++ NL80211_ATTR_FREQ_AFTER = 0x3b ++ NL80211_ATTR_FREQ_BEFORE = 0x3a ++ NL80211_ATTR_FREQ_FIXED = 0x3c ++ NL80211_ATTR_FREQ_RANGE_END = 0x3 ++ NL80211_ATTR_FREQ_RANGE_MAX_BW = 0x4 ++ NL80211_ATTR_FREQ_RANGE_START = 0x2 ++ NL80211_ATTR_FTM_RESPONDER = 0x10e ++ NL80211_ATTR_FTM_RESPONDER_STATS = 0x10f ++ NL80211_ATTR_GENERATION = 0x2e ++ NL80211_ATTR_HANDLE_DFS = 0xbf ++ NL80211_ATTR_HE_6GHZ_CAPABILITY = 0x125 ++ NL80211_ATTR_HE_BSS_COLOR = 0x11b ++ NL80211_ATTR_HE_CAPABILITY = 0x10d ++ NL80211_ATTR_HE_OBSS_PD = 0x117 ++ NL80211_ATTR_HIDDEN_SSID = 0x7e ++ NL80211_ATTR_HT_CAPABILITY = 0x1f ++ NL80211_ATTR_HT_CAPABILITY_MASK = 0x94 ++ NL80211_ATTR_IE_ASSOC_RESP = 0x80 ++ NL80211_ATTR_IE = 0x2a ++ NL80211_ATTR_IE_PROBE_RESP = 0x7f ++ NL80211_ATTR_IE_RIC = 0xb2 ++ NL80211_ATTR_IFACE_SOCKET_OWNER = 0xcc ++ NL80211_ATTR_IFINDEX = 0x3 ++ NL80211_ATTR_IFNAME = 0x4 ++ NL80211_ATTR_IFTYPE_AKM_SUITES = 0x11c ++ NL80211_ATTR_IFTYPE = 0x5 ++ NL80211_ATTR_IFTYPE_EXT_CAPA = 0xe6 ++ NL80211_ATTR_INACTIVITY_TIMEOUT = 0x96 ++ NL80211_ATTR_INTERFACE_COMBINATIONS = 0x78 ++ NL80211_ATTR_KEY_CIPHER = 0x9 ++ NL80211_ATTR_KEY = 0x50 ++ NL80211_ATTR_KEY_DATA = 0x7 ++ NL80211_ATTR_KEY_DEFAULT = 0xb ++ NL80211_ATTR_KEY_DEFAULT_MGMT = 0x28 ++ NL80211_ATTR_KEY_DEFAULT_TYPES = 0x6e ++ NL80211_ATTR_KEY_IDX = 0x8 ++ NL80211_ATTR_KEYS = 0x51 ++ NL80211_ATTR_KEY_SEQ = 0xa ++ NL80211_ATTR_KEY_TYPE = 0x37 ++ NL80211_ATTR_LOCAL_MESH_POWER_MODE = 0xa4 ++ NL80211_ATTR_LOCAL_STATE_CHANGE = 0x5f ++ NL80211_ATTR_MAC_ACL_MAX = 0xa7 ++ NL80211_ATTR_MAC_ADDRS = 0xa6 ++ NL80211_ATTR_MAC = 0x6 ++ NL80211_ATTR_MAC_HINT = 0xc8 ++ NL80211_ATTR_MAC_MASK = 0xd7 ++ NL80211_ATTR_MAX_AP_ASSOC_STA = 0xca ++ NL80211_ATTR_MAX = 0x129 ++ NL80211_ATTR_MAX_CRIT_PROT_DURATION = 0xb4 ++ NL80211_ATTR_MAX_CSA_COUNTERS = 0xce ++ NL80211_ATTR_MAX_MATCH_SETS = 0x85 ++ NL80211_ATTR_MAX_NUM_PMKIDS = 0x56 ++ NL80211_ATTR_MAX_NUM_SCAN_SSIDS = 0x2b ++ NL80211_ATTR_MAX_NUM_SCHED_SCAN_PLANS = 0xde ++ NL80211_ATTR_MAX_NUM_SCHED_SCAN_SSIDS = 0x7b ++ NL80211_ATTR_MAX_REMAIN_ON_CHANNEL_DURATION = 0x6f ++ NL80211_ATTR_MAX_SCAN_IE_LEN = 0x38 ++ NL80211_ATTR_MAX_SCAN_PLAN_INTERVAL = 0xdf ++ NL80211_ATTR_MAX_SCAN_PLAN_ITERATIONS = 0xe0 ++ NL80211_ATTR_MAX_SCHED_SCAN_IE_LEN = 0x7c ++ NL80211_ATTR_MCAST_RATE = 0x6b ++ NL80211_ATTR_MDID = 0xb1 ++ NL80211_ATTR_MEASUREMENT_DURATION = 0xeb ++ NL80211_ATTR_MEASUREMENT_DURATION_MANDATORY = 0xec ++ NL80211_ATTR_MESH_CONFIG = 0x23 ++ NL80211_ATTR_MESH_ID = 0x18 ++ NL80211_ATTR_MESH_PEER_AID = 0xed ++ NL80211_ATTR_MESH_SETUP = 0x70 ++ NL80211_ATTR_MGMT_SUBTYPE = 0x29 ++ NL80211_ATTR_MNTR_FLAGS = 0x17 ++ NL80211_ATTR_MPATH_INFO = 0x1b ++ NL80211_ATTR_MPATH_NEXT_HOP = 0x1a ++ NL80211_ATTR_MULTICAST_TO_UNICAST_ENABLED = 0xf4 ++ NL80211_ATTR_MU_MIMO_FOLLOW_MAC_ADDR = 0xe8 ++ NL80211_ATTR_MU_MIMO_GROUP_DATA = 0xe7 ++ NL80211_ATTR_NAN_FUNC = 0xf0 ++ NL80211_ATTR_NAN_MASTER_PREF = 0xee ++ NL80211_ATTR_NAN_MATCH = 0xf1 ++ NL80211_ATTR_NETNS_FD = 0xdb ++ NL80211_ATTR_NOACK_MAP = 0x95 ++ NL80211_ATTR_NSS = 0x106 ++ NL80211_ATTR_OFFCHANNEL_TX_OK = 0x6c ++ NL80211_ATTR_OPER_CLASS = 0xd6 ++ NL80211_ATTR_OPMODE_NOTIF = 0xc2 ++ NL80211_ATTR_P2P_CTWINDOW = 0xa2 ++ NL80211_ATTR_P2P_OPPPS = 0xa3 ++ NL80211_ATTR_PAD = 0xe5 ++ NL80211_ATTR_PBSS = 0xe2 ++ NL80211_ATTR_PEER_AID = 0xb5 ++ NL80211_ATTR_PEER_MEASUREMENTS = 0x111 ++ NL80211_ATTR_PID = 0x52 ++ NL80211_ATTR_PMK = 0xfe ++ NL80211_ATTR_PMKID = 0x55 ++ NL80211_ATTR_PMK_LIFETIME = 0x11f ++ NL80211_ATTR_PMKR0_NAME = 0x102 ++ NL80211_ATTR_PMK_REAUTH_THRESHOLD = 0x120 ++ NL80211_ATTR_PMKSA_CANDIDATE = 0x86 ++ NL80211_ATTR_PORT_AUTHORIZED = 0x103 ++ NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN = 0x5 ++ NL80211_ATTR_POWER_RULE_MAX_EIRP = 0x6 ++ NL80211_ATTR_PREV_BSSID = 0x4f ++ NL80211_ATTR_PRIVACY = 0x46 ++ NL80211_ATTR_PROBE_RESP = 0x91 ++ NL80211_ATTR_PROBE_RESP_OFFLOAD = 0x90 ++ NL80211_ATTR_PROTOCOL_FEATURES = 0xad ++ NL80211_ATTR_PS_STATE = 0x5d ++ NL80211_ATTR_QOS_MAP = 0xc7 ++ NL80211_ATTR_RADAR_EVENT = 0xa8 ++ NL80211_ATTR_REASON_CODE = 0x36 ++ NL80211_ATTR_RECEIVE_MULTICAST = 0x121 ++ ++ NL80211_ATTR_REG_ALPHA2 = 0x21 ++ NL80211_ATTR_REG_INDOOR = 0xdd ++ NL80211_ATTR_REG_INITIATOR = 0x30 ++ NL80211_ATTR_REG_RULE_FLAGS = 0x1 ++ NL80211_ATTR_REG_RULES = 0x22 ++ NL80211_ATTR_REG_TYPE = 0x31 ++ NL80211_ATTR_REKEY_DATA = 0x7a ++ NL80211_ATTR_REQ_IE = 0x4d ++ NL80211_ATTR_RESP_IE = 0x4e ++ NL80211_ATTR_ROAM_SUPPORT = 0x83 ++ NL80211_ATTR_RX_FRAME_TYPES = 0x64 ++ NL80211_ATTR_RXMGMT_FLAGS = 0xbc ++ NL80211_ATTR_RX_SIGNAL_DBM = 0x97 ++ NL80211_ATTR_S1G_CAPABILITY = 0x128 ++ NL80211_ATTR_S1G_CAPABILITY_MASK = 0x129 ++ NL80211_ATTR_SAE_DATA = 0x9c ++ NL80211_ATTR_SAE_PASSWORD = 0x115 ++ ++ NL80211_ATTR_SCAN_FLAGS = 0x9e ++ NL80211_ATTR_SCAN_FREQ_KHZ = 0x124 ++ NL80211_ATTR_SCAN_FREQUENCIES = 0x2c ++ NL80211_ATTR_SCAN_GENERATION = 0x2e ++ NL80211_ATTR_SCAN_SSIDS = 0x2d ++ NL80211_ATTR_SCAN_START_TIME_TSF_BSSID = 0xea ++ NL80211_ATTR_SCAN_START_TIME_TSF = 0xe9 ++ NL80211_ATTR_SCAN_SUPP_RATES = 0x7d ++ NL80211_ATTR_SCHED_SCAN_DELAY = 0xdc ++ NL80211_ATTR_SCHED_SCAN_INTERVAL = 0x77 ++ NL80211_ATTR_SCHED_SCAN_MATCH = 0x84 ++ NL80211_ATTR_SCHED_SCAN_MATCH_SSID = 0x1 ++ NL80211_ATTR_SCHED_SCAN_MAX_REQS = 0x100 ++ NL80211_ATTR_SCHED_SCAN_MULTI = 0xff ++ NL80211_ATTR_SCHED_SCAN_PLANS = 0xe1 ++ NL80211_ATTR_SCHED_SCAN_RELATIVE_RSSI = 0xf6 ++ NL80211_ATTR_SCHED_SCAN_RSSI_ADJUST = 0xf7 ++ NL80211_ATTR_SMPS_MODE = 0xd5 ++ NL80211_ATTR_SOCKET_OWNER = 0xcc ++ NL80211_ATTR_SOFTWARE_IFTYPES = 0x79 ++ NL80211_ATTR_SPLIT_WIPHY_DUMP = 0xae ++ NL80211_ATTR_SSID = 0x34 ++ NL80211_ATTR_STA_AID = 0x10 ++ NL80211_ATTR_STA_CAPABILITY = 0xab ++ NL80211_ATTR_STA_EXT_CAPABILITY = 0xac ++ NL80211_ATTR_STA_FLAGS2 = 0x43 ++ NL80211_ATTR_STA_FLAGS = 0x11 ++ NL80211_ATTR_STA_INFO = 0x15 ++ NL80211_ATTR_STA_LISTEN_INTERVAL = 0x12 ++ NL80211_ATTR_STA_PLINK_ACTION = 0x19 ++ NL80211_ATTR_STA_PLINK_STATE = 0x74 ++ NL80211_ATTR_STA_SUPPORTED_CHANNELS = 0xbd ++ NL80211_ATTR_STA_SUPPORTED_OPER_CLASSES = 0xbe ++ NL80211_ATTR_STA_SUPPORTED_RATES = 0x13 ++ NL80211_ATTR_STA_SUPPORT_P2P_PS = 0xe4 ++ NL80211_ATTR_STATUS_CODE = 0x48 ++ NL80211_ATTR_STA_TX_POWER = 0x114 ++ NL80211_ATTR_STA_TX_POWER_SETTING = 0x113 ++ NL80211_ATTR_STA_VLAN = 0x14 ++ NL80211_ATTR_STA_WME = 0x81 ++ NL80211_ATTR_SUPPORT_10_MHZ = 0xc1 ++ NL80211_ATTR_SUPPORT_5_MHZ = 0xc0 ++ NL80211_ATTR_SUPPORT_AP_UAPSD = 0x82 ++ NL80211_ATTR_SUPPORTED_COMMANDS = 0x32 ++ NL80211_ATTR_SUPPORTED_IFTYPES = 0x20 ++ NL80211_ATTR_SUPPORT_IBSS_RSN = 0x68 ++ NL80211_ATTR_SUPPORT_MESH_AUTH = 0x73 ++ NL80211_ATTR_SURVEY_INFO = 0x54 ++ NL80211_ATTR_SURVEY_RADIO_STATS = 0xda ++ NL80211_ATTR_TDLS_ACTION = 0x88 ++ NL80211_ATTR_TDLS_DIALOG_TOKEN = 0x89 ++ NL80211_ATTR_TDLS_EXTERNAL_SETUP = 0x8c ++ NL80211_ATTR_TDLS_INITIATOR = 0xcf ++ NL80211_ATTR_TDLS_OPERATION = 0x8a ++ NL80211_ATTR_TDLS_PEER_CAPABILITY = 0xcb ++ NL80211_ATTR_TDLS_SUPPORT = 0x8b ++ NL80211_ATTR_TESTDATA = 0x45 ++ NL80211_ATTR_TID_CONFIG = 0x11d ++ NL80211_ATTR_TIMED_OUT = 0x41 ++ NL80211_ATTR_TIMEOUT = 0x110 ++ NL80211_ATTR_TIMEOUT_REASON = 0xf8 ++ NL80211_ATTR_TSID = 0xd2 ++ NL80211_ATTR_TWT_RESPONDER = 0x116 ++ NL80211_ATTR_TX_FRAME_TYPES = 0x63 ++ NL80211_ATTR_TX_NO_CCK_RATE = 0x87 ++ NL80211_ATTR_TXQ_LIMIT = 0x10a ++ NL80211_ATTR_TXQ_MEMORY_LIMIT = 0x10b ++ NL80211_ATTR_TXQ_QUANTUM = 0x10c ++ NL80211_ATTR_TXQ_STATS = 0x109 ++ NL80211_ATTR_TX_RATES = 0x5a ++ NL80211_ATTR_UNSOL_BCAST_PROBE_RESP = 0x127 ++ NL80211_ATTR_UNSPEC = 0x0 ++ NL80211_ATTR_USE_MFP = 0x42 ++ NL80211_ATTR_USER_PRIO = 0xd3 ++ NL80211_ATTR_USER_REG_HINT_TYPE = 0x9a ++ NL80211_ATTR_USE_RRM = 0xd0 ++ NL80211_ATTR_VENDOR_DATA = 0xc5 ++ NL80211_ATTR_VENDOR_EVENTS = 0xc6 ++ NL80211_ATTR_VENDOR_ID = 0xc3 ++ NL80211_ATTR_VENDOR_SUBCMD = 0xc4 ++ NL80211_ATTR_VHT_CAPABILITY = 0x9d ++ NL80211_ATTR_VHT_CAPABILITY_MASK = 0xb0 ++ NL80211_ATTR_VLAN_ID = 0x11a ++ NL80211_ATTR_WANT_1X_4WAY_HS = 0x101 ++ NL80211_ATTR_WDEV = 0x99 ++ NL80211_ATTR_WIPHY_ANTENNA_AVAIL_RX = 0x72 ++ NL80211_ATTR_WIPHY_ANTENNA_AVAIL_TX = 0x71 ++ NL80211_ATTR_WIPHY_ANTENNA_RX = 0x6a ++ NL80211_ATTR_WIPHY_ANTENNA_TX = 0x69 ++ NL80211_ATTR_WIPHY_BANDS = 0x16 ++ NL80211_ATTR_WIPHY_CHANNEL_TYPE = 0x27 ++ NL80211_ATTR_WIPHY = 0x1 ++ NL80211_ATTR_WIPHY_COVERAGE_CLASS = 0x59 ++ NL80211_ATTR_WIPHY_DYN_ACK = 0xd1 ++ NL80211_ATTR_WIPHY_EDMG_BW_CONFIG = 0x119 ++ NL80211_ATTR_WIPHY_EDMG_CHANNELS = 0x118 ++ NL80211_ATTR_WIPHY_FRAG_THRESHOLD = 0x3f ++ NL80211_ATTR_WIPHY_FREQ = 0x26 ++ NL80211_ATTR_WIPHY_FREQ_HINT = 0xc9 ++ NL80211_ATTR_WIPHY_FREQ_OFFSET = 0x122 ++ NL80211_ATTR_WIPHY_NAME = 0x2 ++ NL80211_ATTR_WIPHY_RETRY_LONG = 0x3e ++ NL80211_ATTR_WIPHY_RETRY_SHORT = 0x3d ++ NL80211_ATTR_WIPHY_RTS_THRESHOLD = 0x40 ++ NL80211_ATTR_WIPHY_SELF_MANAGED_REG = 0xd8 ++ NL80211_ATTR_WIPHY_TX_POWER_LEVEL = 0x62 ++ NL80211_ATTR_WIPHY_TX_POWER_SETTING = 0x61 ++ NL80211_ATTR_WIPHY_TXQ_PARAMS = 0x25 ++ NL80211_ATTR_WOWLAN_TRIGGERS = 0x75 ++ NL80211_ATTR_WOWLAN_TRIGGERS_SUPPORTED = 0x76 ++ NL80211_ATTR_WPA_VERSIONS = 0x4b ++ NL80211_AUTHTYPE_AUTOMATIC = 0x8 ++ NL80211_AUTHTYPE_FILS_PK = 0x7 ++ NL80211_AUTHTYPE_FILS_SK = 0x5 ++ NL80211_AUTHTYPE_FILS_SK_PFS = 0x6 ++ NL80211_AUTHTYPE_FT = 0x2 ++ NL80211_AUTHTYPE_MAX = 0x7 ++ NL80211_AUTHTYPE_NETWORK_EAP = 0x3 ++ NL80211_AUTHTYPE_OPEN_SYSTEM = 0x0 ++ NL80211_AUTHTYPE_SAE = 0x4 ++ NL80211_AUTHTYPE_SHARED_KEY = 0x1 ++ NL80211_BAND_2GHZ = 0x0 ++ NL80211_BAND_5GHZ = 0x1 ++ NL80211_BAND_60GHZ = 0x2 ++ NL80211_BAND_6GHZ = 0x3 ++ NL80211_BAND_ATTR_EDMG_BW_CONFIG = 0xb ++ NL80211_BAND_ATTR_EDMG_CHANNELS = 0xa ++ NL80211_BAND_ATTR_FREQS = 0x1 ++ NL80211_BAND_ATTR_HT_AMPDU_DENSITY = 0x6 ++ NL80211_BAND_ATTR_HT_AMPDU_FACTOR = 0x5 ++ NL80211_BAND_ATTR_HT_CAPA = 0x4 ++ NL80211_BAND_ATTR_HT_MCS_SET = 0x3 ++ NL80211_BAND_ATTR_IFTYPE_DATA = 0x9 ++ NL80211_BAND_ATTR_MAX = 0xb ++ NL80211_BAND_ATTR_RATES = 0x2 ++ NL80211_BAND_ATTR_VHT_CAPA = 0x8 ++ NL80211_BAND_ATTR_VHT_MCS_SET = 0x7 ++ NL80211_BAND_IFTYPE_ATTR_HE_6GHZ_CAPA = 0x6 ++ NL80211_BAND_IFTYPE_ATTR_HE_CAP_MAC = 0x2 ++ NL80211_BAND_IFTYPE_ATTR_HE_CAP_MCS_SET = 0x4 ++ NL80211_BAND_IFTYPE_ATTR_HE_CAP_PHY = 0x3 ++ NL80211_BAND_IFTYPE_ATTR_HE_CAP_PPE = 0x5 ++ NL80211_BAND_IFTYPE_ATTR_IFTYPES = 0x1 ++ NL80211_BAND_IFTYPE_ATTR_MAX = 0x6 ++ NL80211_BAND_S1GHZ = 0x4 ++ NL80211_BITRATE_ATTR_2GHZ_SHORTPREAMBLE = 0x2 ++ NL80211_BITRATE_ATTR_MAX = 0x2 ++ NL80211_BITRATE_ATTR_RATE = 0x1 ++ NL80211_BSS_BEACON_IES = 0xb ++ NL80211_BSS_BEACON_INTERVAL = 0x4 ++ NL80211_BSS_BEACON_TSF = 0xd ++ NL80211_BSS_BSSID = 0x1 ++ NL80211_BSS_CAPABILITY = 0x5 ++ NL80211_BSS_CHAIN_SIGNAL = 0x13 ++ NL80211_BSS_CHAN_WIDTH_10 = 0x1 ++ NL80211_BSS_CHAN_WIDTH_1 = 0x3 ++ NL80211_BSS_CHAN_WIDTH_20 = 0x0 ++ NL80211_BSS_CHAN_WIDTH_2 = 0x4 ++ NL80211_BSS_CHAN_WIDTH_5 = 0x2 ++ NL80211_BSS_CHAN_WIDTH = 0xc ++ NL80211_BSS_FREQUENCY = 0x2 ++ NL80211_BSS_FREQUENCY_OFFSET = 0x14 ++ NL80211_BSS_INFORMATION_ELEMENTS = 0x6 ++ NL80211_BSS_LAST_SEEN_BOOTTIME = 0xf ++ NL80211_BSS_MAX = 0x14 ++ NL80211_BSS_PAD = 0x10 ++ NL80211_BSS_PARENT_BSSID = 0x12 ++ NL80211_BSS_PARENT_TSF = 0x11 ++ NL80211_BSS_PRESP_DATA = 0xe ++ NL80211_BSS_SEEN_MS_AGO = 0xa ++ NL80211_BSS_SELECT_ATTR_BAND_PREF = 0x2 ++ NL80211_BSS_SELECT_ATTR_MAX = 0x3 ++ NL80211_BSS_SELECT_ATTR_RSSI_ADJUST = 0x3 ++ NL80211_BSS_SELECT_ATTR_RSSI = 0x1 ++ NL80211_BSS_SIGNAL_MBM = 0x7 ++ NL80211_BSS_SIGNAL_UNSPEC = 0x8 ++ NL80211_BSS_STATUS_ASSOCIATED = 0x1 ++ NL80211_BSS_STATUS_AUTHENTICATED = 0x0 ++ NL80211_BSS_STATUS = 0x9 ++ NL80211_BSS_STATUS_IBSS_JOINED = 0x2 ++ NL80211_BSS_TSF = 0x3 ++ NL80211_CHAN_HT20 = 0x1 ++ NL80211_CHAN_HT40MINUS = 0x2 ++ NL80211_CHAN_HT40PLUS = 0x3 ++ NL80211_CHAN_NO_HT = 0x0 ++ NL80211_CHAN_WIDTH_10 = 0x7 ++ NL80211_CHAN_WIDTH_160 = 0x5 ++ NL80211_CHAN_WIDTH_16 = 0xc ++ NL80211_CHAN_WIDTH_1 = 0x8 ++ NL80211_CHAN_WIDTH_20 = 0x1 ++ NL80211_CHAN_WIDTH_20_NOHT = 0x0 ++ NL80211_CHAN_WIDTH_2 = 0x9 ++ NL80211_CHAN_WIDTH_40 = 0x2 ++ NL80211_CHAN_WIDTH_4 = 0xa ++ NL80211_CHAN_WIDTH_5 = 0x6 ++ NL80211_CHAN_WIDTH_80 = 0x3 ++ NL80211_CHAN_WIDTH_80P80 = 0x4 ++ NL80211_CHAN_WIDTH_8 = 0xb ++ NL80211_CMD_ABORT_SCAN = 0x72 ++ NL80211_CMD_ACTION = 0x3b ++ NL80211_CMD_ACTION_TX_STATUS = 0x3c ++ NL80211_CMD_ADD_NAN_FUNCTION = 0x75 ++ NL80211_CMD_ADD_TX_TS = 0x69 ++ NL80211_CMD_ASSOCIATE = 0x26 ++ NL80211_CMD_AUTHENTICATE = 0x25 ++ NL80211_CMD_CANCEL_REMAIN_ON_CHANNEL = 0x38 ++ NL80211_CMD_CHANGE_NAN_CONFIG = 0x77 ++ NL80211_CMD_CHANNEL_SWITCH = 0x66 ++ NL80211_CMD_CH_SWITCH_NOTIFY = 0x58 ++ NL80211_CMD_CH_SWITCH_STARTED_NOTIFY = 0x6e ++ NL80211_CMD_CONNECT = 0x2e ++ NL80211_CMD_CONN_FAILED = 0x5b ++ NL80211_CMD_CONTROL_PORT_FRAME = 0x81 ++ NL80211_CMD_CONTROL_PORT_FRAME_TX_STATUS = 0x8b ++ NL80211_CMD_CRIT_PROTOCOL_START = 0x62 ++ NL80211_CMD_CRIT_PROTOCOL_STOP = 0x63 ++ NL80211_CMD_DEAUTHENTICATE = 0x27 ++ NL80211_CMD_DEL_BEACON = 0x10 ++ NL80211_CMD_DEL_INTERFACE = 0x8 ++ NL80211_CMD_DEL_KEY = 0xc ++ NL80211_CMD_DEL_MPATH = 0x18 ++ NL80211_CMD_DEL_NAN_FUNCTION = 0x76 ++ NL80211_CMD_DEL_PMK = 0x7c ++ NL80211_CMD_DEL_PMKSA = 0x35 ++ NL80211_CMD_DEL_STATION = 0x14 ++ NL80211_CMD_DEL_TX_TS = 0x6a ++ NL80211_CMD_DEL_WIPHY = 0x4 ++ NL80211_CMD_DISASSOCIATE = 0x28 ++ NL80211_CMD_DISCONNECT = 0x30 ++ NL80211_CMD_EXTERNAL_AUTH = 0x7f ++ NL80211_CMD_FLUSH_PMKSA = 0x36 ++ NL80211_CMD_FRAME = 0x3b ++ NL80211_CMD_FRAME_TX_STATUS = 0x3c ++ NL80211_CMD_FRAME_WAIT_CANCEL = 0x43 ++ NL80211_CMD_FT_EVENT = 0x61 ++ NL80211_CMD_GET_BEACON = 0xd ++ NL80211_CMD_GET_COALESCE = 0x64 ++ NL80211_CMD_GET_FTM_RESPONDER_STATS = 0x82 ++ NL80211_CMD_GET_INTERFACE = 0x5 ++ NL80211_CMD_GET_KEY = 0x9 ++ NL80211_CMD_GET_MESH_CONFIG = 0x1c ++ NL80211_CMD_GET_MESH_PARAMS = 0x1c ++ NL80211_CMD_GET_MPATH = 0x15 ++ NL80211_CMD_GET_MPP = 0x6b ++ NL80211_CMD_GET_POWER_SAVE = 0x3e ++ NL80211_CMD_GET_PROTOCOL_FEATURES = 0x5f ++ NL80211_CMD_GET_REG = 0x1f ++ NL80211_CMD_GET_SCAN = 0x20 ++ NL80211_CMD_GET_STATION = 0x11 ++ NL80211_CMD_GET_SURVEY = 0x32 ++ NL80211_CMD_GET_WIPHY = 0x1 ++ NL80211_CMD_GET_WOWLAN = 0x49 ++ NL80211_CMD_JOIN_IBSS = 0x2b ++ NL80211_CMD_JOIN_MESH = 0x44 ++ NL80211_CMD_JOIN_OCB = 0x6c ++ NL80211_CMD_LEAVE_IBSS = 0x2c ++ NL80211_CMD_LEAVE_MESH = 0x45 ++ NL80211_CMD_LEAVE_OCB = 0x6d ++ NL80211_CMD_MAX = 0x8b ++ NL80211_CMD_MICHAEL_MIC_FAILURE = 0x29 ++ NL80211_CMD_NAN_MATCH = 0x78 ++ NL80211_CMD_NEW_BEACON = 0xf ++ NL80211_CMD_NEW_INTERFACE = 0x7 ++ NL80211_CMD_NEW_KEY = 0xb ++ NL80211_CMD_NEW_MPATH = 0x17 ++ NL80211_CMD_NEW_PEER_CANDIDATE = 0x48 ++ NL80211_CMD_NEW_SCAN_RESULTS = 0x22 ++ NL80211_CMD_NEW_STATION = 0x13 ++ NL80211_CMD_NEW_SURVEY_RESULTS = 0x33 ++ NL80211_CMD_NEW_WIPHY = 0x3 ++ NL80211_CMD_NOTIFY_CQM = 0x40 ++ NL80211_CMD_NOTIFY_RADAR = 0x86 ++ NL80211_CMD_PEER_MEASUREMENT_COMPLETE = 0x85 ++ NL80211_CMD_PEER_MEASUREMENT_RESULT = 0x84 ++ NL80211_CMD_PEER_MEASUREMENT_START = 0x83 ++ NL80211_CMD_PMKSA_CANDIDATE = 0x50 ++ NL80211_CMD_PORT_AUTHORIZED = 0x7d ++ NL80211_CMD_PROBE_CLIENT = 0x54 ++ NL80211_CMD_PROBE_MESH_LINK = 0x88 ++ NL80211_CMD_RADAR_DETECT = 0x5e ++ NL80211_CMD_REG_BEACON_HINT = 0x2a ++ NL80211_CMD_REG_CHANGE = 0x24 ++ NL80211_CMD_REGISTER_ACTION = 0x3a ++ NL80211_CMD_REGISTER_BEACONS = 0x55 ++ NL80211_CMD_REGISTER_FRAME = 0x3a ++ NL80211_CMD_RELOAD_REGDB = 0x7e ++ NL80211_CMD_REMAIN_ON_CHANNEL = 0x37 ++ NL80211_CMD_REQ_SET_REG = 0x1b ++ NL80211_CMD_ROAM = 0x2f ++ NL80211_CMD_SCAN_ABORTED = 0x23 ++ NL80211_CMD_SCHED_SCAN_RESULTS = 0x4d ++ NL80211_CMD_SCHED_SCAN_STOPPED = 0x4e ++ NL80211_CMD_SET_BEACON = 0xe ++ NL80211_CMD_SET_BSS = 0x19 ++ NL80211_CMD_SET_CHANNEL = 0x41 ++ NL80211_CMD_SET_COALESCE = 0x65 ++ NL80211_CMD_SET_CQM = 0x3f ++ NL80211_CMD_SET_INTERFACE = 0x6 ++ NL80211_CMD_SET_KEY = 0xa ++ NL80211_CMD_SET_MAC_ACL = 0x5d ++ NL80211_CMD_SET_MCAST_RATE = 0x5c ++ NL80211_CMD_SET_MESH_CONFIG = 0x1d ++ NL80211_CMD_SET_MESH_PARAMS = 0x1d ++ NL80211_CMD_SET_MGMT_EXTRA_IE = 0x1e ++ NL80211_CMD_SET_MPATH = 0x16 ++ NL80211_CMD_SET_MULTICAST_TO_UNICAST = 0x79 ++ NL80211_CMD_SET_NOACK_MAP = 0x57 ++ NL80211_CMD_SET_PMK = 0x7b ++ NL80211_CMD_SET_PMKSA = 0x34 ++ NL80211_CMD_SET_POWER_SAVE = 0x3d ++ NL80211_CMD_SET_QOS_MAP = 0x68 ++ NL80211_CMD_SET_REG = 0x1a ++ NL80211_CMD_SET_REKEY_OFFLOAD = 0x4f ++ ++ NL80211_CMD_SET_STATION = 0x12 ++ NL80211_CMD_SET_TID_CONFIG = 0x89 ++ NL80211_CMD_SET_TX_BITRATE_MASK = 0x39 ++ NL80211_CMD_SET_WDS_PEER = 0x42 ++ NL80211_CMD_SET_WIPHY = 0x2 ++ NL80211_CMD_SET_WIPHY_NETNS = 0x31 ++ NL80211_CMD_SET_WOWLAN = 0x4a ++ NL80211_CMD_STA_OPMODE_CHANGED = 0x80 ++ NL80211_CMD_START_AP = 0xf ++ NL80211_CMD_START_NAN = 0x73 ++ NL80211_CMD_START_P2P_DEVICE = 0x59 ++ NL80211_CMD_START_SCHED_SCAN = 0x4b ++ NL80211_CMD_STOP_AP = 0x10 ++ NL80211_CMD_STOP_NAN = 0x74 ++ NL80211_CMD_STOP_P2P_DEVICE = 0x5a ++ NL80211_CMD_STOP_SCHED_SCAN = 0x4c ++ NL80211_CMD_TDLS_CANCEL_CHANNEL_SWITCH = 0x70 ++ NL80211_CMD_TDLS_CHANNEL_SWITCH = 0x6f ++ NL80211_CMD_TDLS_MGMT = 0x52 ++ NL80211_CMD_TDLS_OPER = 0x51 ++ NL80211_CMD_TESTMODE = 0x2d ++ NL80211_CMD_TRIGGER_SCAN = 0x21 ++ NL80211_CMD_UNEXPECTED_4ADDR_FRAME = 0x56 ++ NL80211_CMD_UNEXPECTED_FRAME = 0x53 ++ NL80211_CMD_UNPROT_BEACON = 0x8a ++ NL80211_CMD_UNPROT_DEAUTHENTICATE = 0x46 ++ NL80211_CMD_UNPROT_DISASSOCIATE = 0x47 ++ NL80211_CMD_UNSPEC = 0x0 ++ NL80211_CMD_UPDATE_CONNECT_PARAMS = 0x7a ++ NL80211_CMD_UPDATE_FT_IES = 0x60 ++ NL80211_CMD_UPDATE_OWE_INFO = 0x87 ++ NL80211_CMD_VENDOR = 0x67 ++ NL80211_CMD_WIPHY_REG_CHANGE = 0x71 ++ NL80211_COALESCE_CONDITION_MATCH = 0x0 ++ NL80211_COALESCE_CONDITION_NO_MATCH = 0x1 ++ NL80211_CONN_FAIL_BLOCKED_CLIENT = 0x1 ++ NL80211_CONN_FAIL_MAX_CLIENTS = 0x0 ++ NL80211_CQM_RSSI_BEACON_LOSS_EVENT = 0x2 ++ NL80211_CQM_RSSI_THRESHOLD_EVENT_HIGH = 0x1 ++ NL80211_CQM_RSSI_THRESHOLD_EVENT_LOW = 0x0 ++ NL80211_CQM_TXE_MAX_INTVL = 0x708 ++ NL80211_CRIT_PROTO_APIPA = 0x3 ++ NL80211_CRIT_PROTO_DHCP = 0x1 ++ NL80211_CRIT_PROTO_EAPOL = 0x2 ++ NL80211_CRIT_PROTO_MAX_DURATION = 0x1388 ++ NL80211_CRIT_PROTO_UNSPEC = 0x0 ++ NL80211_DFS_AVAILABLE = 0x2 ++ NL80211_DFS_ETSI = 0x2 ++ NL80211_DFS_FCC = 0x1 ++ NL80211_DFS_JP = 0x3 ++ NL80211_DFS_UNAVAILABLE = 0x1 ++ NL80211_DFS_UNSET = 0x0 ++ NL80211_DFS_USABLE = 0x0 ++ NL80211_EDMG_BW_CONFIG_MAX = 0xf ++ NL80211_EDMG_BW_CONFIG_MIN = 0x4 ++ NL80211_EDMG_CHANNELS_MAX = 0x3c ++ NL80211_EDMG_CHANNELS_MIN = 0x1 ++ NL80211_EXTERNAL_AUTH_ABORT = 0x1 ++ NL80211_EXTERNAL_AUTH_START = 0x0 ++ NL80211_EXT_FEATURE_4WAY_HANDSHAKE_AP_PSK = 0x32 ++ NL80211_EXT_FEATURE_4WAY_HANDSHAKE_STA_1X = 0x10 ++ NL80211_EXT_FEATURE_4WAY_HANDSHAKE_STA_PSK = 0xf ++ NL80211_EXT_FEATURE_ACCEPT_BCAST_PROBE_RESP = 0x12 ++ NL80211_EXT_FEATURE_ACK_SIGNAL_SUPPORT = 0x1b ++ NL80211_EXT_FEATURE_AIRTIME_FAIRNESS = 0x21 ++ NL80211_EXT_FEATURE_AP_PMKSA_CACHING = 0x22 ++ NL80211_EXT_FEATURE_AQL = 0x28 ++ NL80211_EXT_FEATURE_BEACON_PROTECTION_CLIENT = 0x2e ++ NL80211_EXT_FEATURE_BEACON_PROTECTION = 0x29 ++ ++ NL80211_EXT_FEATURE_BEACON_RATE_HT = 0x7 ++ NL80211_EXT_FEATURE_BEACON_RATE_LEGACY = 0x6 ++ NL80211_EXT_FEATURE_BEACON_RATE_VHT = 0x8 ++ NL80211_EXT_FEATURE_BSS_PARENT_TSF = 0x4 ++ NL80211_EXT_FEATURE_CAN_REPLACE_PTK0 = 0x1f ++ NL80211_EXT_FEATURE_CONTROL_PORT_NO_PREAUTH = 0x2a ++ NL80211_EXT_FEATURE_CONTROL_PORT_OVER_NL80211 = 0x1a ++ NL80211_EXT_FEATURE_CONTROL_PORT_OVER_NL80211_TX_STATUS = 0x30 ++ NL80211_EXT_FEATURE_CQM_RSSI_LIST = 0xd ++ NL80211_EXT_FEATURE_DATA_ACK_SIGNAL_SUPPORT = 0x1b ++ NL80211_EXT_FEATURE_DEL_IBSS_STA = 0x2c ++ NL80211_EXT_FEATURE_DFS_OFFLOAD = 0x19 ++ NL80211_EXT_FEATURE_ENABLE_FTM_RESPONDER = 0x20 ++ NL80211_EXT_FEATURE_EXT_KEY_ID = 0x24 ++ NL80211_EXT_FEATURE_FILS_DISCOVERY = 0x34 ++ NL80211_EXT_FEATURE_FILS_MAX_CHANNEL_TIME = 0x11 ++ NL80211_EXT_FEATURE_FILS_SK_OFFLOAD = 0xe ++ NL80211_EXT_FEATURE_FILS_STA = 0x9 ++ NL80211_EXT_FEATURE_HIGH_ACCURACY_SCAN = 0x18 ++ NL80211_EXT_FEATURE_LOW_POWER_SCAN = 0x17 ++ NL80211_EXT_FEATURE_LOW_SPAN_SCAN = 0x16 ++ NL80211_EXT_FEATURE_MFP_OPTIONAL = 0x15 ++ NL80211_EXT_FEATURE_MGMT_TX_RANDOM_TA = 0xa ++ NL80211_EXT_FEATURE_MGMT_TX_RANDOM_TA_CONNECTED = 0xb ++ NL80211_EXT_FEATURE_MULTICAST_REGISTRATIONS = 0x2d ++ NL80211_EXT_FEATURE_MU_MIMO_AIR_SNIFFER = 0x2 ++ NL80211_EXT_FEATURE_OCE_PROBE_REQ_DEFERRAL_SUPPRESSION = 0x14 ++ NL80211_EXT_FEATURE_OCE_PROBE_REQ_HIGH_TX_RATE = 0x13 ++ NL80211_EXT_FEATURE_OPERATING_CHANNEL_VALIDATION = 0x31 ++ NL80211_EXT_FEATURE_PROTECTED_TWT = 0x2b ++ ++ NL80211_EXT_FEATURE_RRM = 0x1 ++ NL80211_EXT_FEATURE_SAE_OFFLOAD_AP = 0x33 ++ NL80211_EXT_FEATURE_SAE_OFFLOAD = 0x26 ++ NL80211_EXT_FEATURE_SCAN_FREQ_KHZ = 0x2f ++ NL80211_EXT_FEATURE_SCAN_MIN_PREQ_CONTENT = 0x1e ++ NL80211_EXT_FEATURE_SCAN_RANDOM_SN = 0x1d ++ NL80211_EXT_FEATURE_SCAN_START_TIME = 0x3 ++ NL80211_EXT_FEATURE_SCHED_SCAN_BAND_SPECIFIC_RSSI_THOLD = 0x23 ++ NL80211_EXT_FEATURE_SCHED_SCAN_RELATIVE_RSSI = 0xc ++ ++ NL80211_EXT_FEATURE_SET_SCAN_DWELL = 0x5 ++ NL80211_EXT_FEATURE_STA_TX_PWR = 0x25 ++ NL80211_EXT_FEATURE_TXQS = 0x1c ++ NL80211_EXT_FEATURE_UNSOL_BCAST_PROBE_RESP = 0x35 ++ NL80211_EXT_FEATURE_VHT_IBSS = 0x0 ++ NL80211_EXT_FEATURE_VLAN_OFFLOAD = 0x27 ++ NL80211_FEATURE_ACKTO_ESTIMATION = 0x800000 ++ NL80211_FEATURE_ACTIVE_MONITOR = 0x20000 ++ NL80211_FEATURE_ADVERTISE_CHAN_LIMITS = 0x4000 ++ NL80211_FEATURE_AP_MODE_CHAN_WIDTH_CHANGE = 0x40000 ++ NL80211_FEATURE_AP_SCAN = 0x100 ++ NL80211_FEATURE_CELL_BASE_REG_HINTS = 0x8 ++ NL80211_FEATURE_DS_PARAM_SET_IE_IN_PROBES = 0x80000 ++ NL80211_FEATURE_DYNAMIC_SMPS = 0x2000000 ++ NL80211_FEATURE_FULL_AP_CLIENT_STATE = 0x8000 ++ NL80211_FEATURE_HT_IBSS = 0x2 ++ NL80211_FEATURE_INACTIVITY_TIMER = 0x4 ++ NL80211_FEATURE_LOW_PRIORITY_SCAN = 0x40 ++ NL80211_FEATURE_MAC_ON_CREATE = 0x8000000 ++ NL80211_FEATURE_ND_RANDOM_MAC_ADDR = 0x80000000 ++ NL80211_FEATURE_NEED_OBSS_SCAN = 0x400 ++ NL80211_FEATURE_P2P_DEVICE_NEEDS_CHANNEL = 0x10 ++ NL80211_FEATURE_P2P_GO_CTWIN = 0x800 ++ NL80211_FEATURE_P2P_GO_OPPPS = 0x1000 ++ NL80211_FEATURE_QUIET = 0x200000 ++ NL80211_FEATURE_SAE = 0x20 ++ NL80211_FEATURE_SCAN_FLUSH = 0x80 ++ NL80211_FEATURE_SCAN_RANDOM_MAC_ADDR = 0x20000000 ++ NL80211_FEATURE_SCHED_SCAN_RANDOM_MAC_ADDR = 0x40000000 ++ NL80211_FEATURE_SK_TX_STATUS = 0x1 ++ NL80211_FEATURE_STATIC_SMPS = 0x1000000 ++ NL80211_FEATURE_SUPPORTS_WMM_ADMISSION = 0x4000000 ++ NL80211_FEATURE_TDLS_CHANNEL_SWITCH = 0x10000000 ++ NL80211_FEATURE_TX_POWER_INSERTION = 0x400000 ++ NL80211_FEATURE_USERSPACE_MPM = 0x10000 ++ NL80211_FEATURE_VIF_TXPOWER = 0x200 ++ NL80211_FEATURE_WFA_TPC_IE_IN_PROBES = 0x100000 ++ NL80211_FILS_DISCOVERY_ATTR_INT_MAX = 0x2 ++ NL80211_FILS_DISCOVERY_ATTR_INT_MIN = 0x1 ++ NL80211_FILS_DISCOVERY_ATTR_MAX = 0x3 ++ NL80211_FILS_DISCOVERY_ATTR_TMPL = 0x3 ++ NL80211_FILS_DISCOVERY_TMPL_MIN_LEN = 0x2a ++ NL80211_FREQUENCY_ATTR_16MHZ = 0x19 ++ NL80211_FREQUENCY_ATTR_1MHZ = 0x15 ++ NL80211_FREQUENCY_ATTR_2MHZ = 0x16 ++ NL80211_FREQUENCY_ATTR_4MHZ = 0x17 ++ NL80211_FREQUENCY_ATTR_8MHZ = 0x18 ++ NL80211_FREQUENCY_ATTR_DFS_CAC_TIME = 0xd ++ NL80211_FREQUENCY_ATTR_DFS_STATE = 0x7 ++ NL80211_FREQUENCY_ATTR_DFS_TIME = 0x8 ++ NL80211_FREQUENCY_ATTR_DISABLED = 0x2 ++ NL80211_FREQUENCY_ATTR_FREQ = 0x1 ++ NL80211_FREQUENCY_ATTR_GO_CONCURRENT = 0xf ++ NL80211_FREQUENCY_ATTR_INDOOR_ONLY = 0xe ++ NL80211_FREQUENCY_ATTR_IR_CONCURRENT = 0xf ++ NL80211_FREQUENCY_ATTR_MAX = 0x19 ++ NL80211_FREQUENCY_ATTR_MAX_TX_POWER = 0x6 ++ NL80211_FREQUENCY_ATTR_NO_10MHZ = 0x11 ++ NL80211_FREQUENCY_ATTR_NO_160MHZ = 0xc ++ NL80211_FREQUENCY_ATTR_NO_20MHZ = 0x10 ++ NL80211_FREQUENCY_ATTR_NO_80MHZ = 0xb ++ NL80211_FREQUENCY_ATTR_NO_HE = 0x13 ++ NL80211_FREQUENCY_ATTR_NO_HT40_MINUS = 0x9 ++ NL80211_FREQUENCY_ATTR_NO_HT40_PLUS = 0xa ++ NL80211_FREQUENCY_ATTR_NO_IBSS = 0x3 ++ NL80211_FREQUENCY_ATTR_NO_IR = 0x3 ++ NL80211_FREQUENCY_ATTR_OFFSET = 0x14 ++ NL80211_FREQUENCY_ATTR_PASSIVE_SCAN = 0x3 ++ NL80211_FREQUENCY_ATTR_RADAR = 0x5 ++ NL80211_FREQUENCY_ATTR_WMM = 0x12 ++ NL80211_FTM_RESP_ATTR_CIVICLOC = 0x3 ++ NL80211_FTM_RESP_ATTR_ENABLED = 0x1 ++ NL80211_FTM_RESP_ATTR_LCI = 0x2 ++ NL80211_FTM_RESP_ATTR_MAX = 0x3 ++ NL80211_FTM_STATS_ASAP_NUM = 0x4 ++ NL80211_FTM_STATS_FAILED_NUM = 0x3 ++ NL80211_FTM_STATS_MAX = 0xa ++ NL80211_FTM_STATS_NON_ASAP_NUM = 0x5 ++ NL80211_FTM_STATS_OUT_OF_WINDOW_TRIGGERS_NUM = 0x9 ++ NL80211_FTM_STATS_PAD = 0xa ++ NL80211_FTM_STATS_PARTIAL_NUM = 0x2 ++ NL80211_FTM_STATS_RESCHEDULE_REQUESTS_NUM = 0x8 ++ NL80211_FTM_STATS_SUCCESS_NUM = 0x1 ++ NL80211_FTM_STATS_TOTAL_DURATION_MSEC = 0x6 ++ NL80211_FTM_STATS_UNKNOWN_TRIGGERS_NUM = 0x7 ++ NL80211_GENL_NAME = "nl80211" ++ NL80211_HE_BSS_COLOR_ATTR_COLOR = 0x1 ++ NL80211_HE_BSS_COLOR_ATTR_DISABLED = 0x2 ++ NL80211_HE_BSS_COLOR_ATTR_MAX = 0x3 ++ NL80211_HE_BSS_COLOR_ATTR_PARTIAL = 0x3 ++ NL80211_HE_MAX_CAPABILITY_LEN = 0x36 ++ NL80211_HE_MIN_CAPABILITY_LEN = 0x10 ++ NL80211_HE_NSS_MAX = 0x8 ++ NL80211_HE_OBSS_PD_ATTR_BSS_COLOR_BITMAP = 0x4 ++ NL80211_HE_OBSS_PD_ATTR_MAX = 0x6 ++ NL80211_HE_OBSS_PD_ATTR_MAX_OFFSET = 0x2 ++ NL80211_HE_OBSS_PD_ATTR_MIN_OFFSET = 0x1 ++ NL80211_HE_OBSS_PD_ATTR_NON_SRG_MAX_OFFSET = 0x3 ++ NL80211_HE_OBSS_PD_ATTR_PARTIAL_BSSID_BITMAP = 0x5 ++ NL80211_HE_OBSS_PD_ATTR_SR_CTRL = 0x6 ++ NL80211_HIDDEN_SSID_NOT_IN_USE = 0x0 ++ NL80211_HIDDEN_SSID_ZERO_CONTENTS = 0x2 ++ NL80211_HIDDEN_SSID_ZERO_LEN = 0x1 ++ NL80211_HT_CAPABILITY_LEN = 0x1a ++ NL80211_IFACE_COMB_BI_MIN_GCD = 0x7 ++ NL80211_IFACE_COMB_LIMITS = 0x1 ++ NL80211_IFACE_COMB_MAXNUM = 0x2 ++ NL80211_IFACE_COMB_NUM_CHANNELS = 0x4 ++ NL80211_IFACE_COMB_RADAR_DETECT_REGIONS = 0x6 ++ NL80211_IFACE_COMB_RADAR_DETECT_WIDTHS = 0x5 ++ NL80211_IFACE_COMB_STA_AP_BI_MATCH = 0x3 ++ NL80211_IFACE_COMB_UNSPEC = 0x0 ++ NL80211_IFACE_LIMIT_MAX = 0x1 ++ NL80211_IFACE_LIMIT_TYPES = 0x2 ++ NL80211_IFACE_LIMIT_UNSPEC = 0x0 ++ NL80211_IFTYPE_ADHOC = 0x1 ++ NL80211_IFTYPE_AKM_ATTR_IFTYPES = 0x1 ++ NL80211_IFTYPE_AKM_ATTR_MAX = 0x2 ++ NL80211_IFTYPE_AKM_ATTR_SUITES = 0x2 ++ NL80211_IFTYPE_AP = 0x3 ++ NL80211_IFTYPE_AP_VLAN = 0x4 ++ NL80211_IFTYPE_MAX = 0xc ++ NL80211_IFTYPE_MESH_POINT = 0x7 ++ NL80211_IFTYPE_MONITOR = 0x6 ++ NL80211_IFTYPE_NAN = 0xc ++ NL80211_IFTYPE_OCB = 0xb ++ NL80211_IFTYPE_P2P_CLIENT = 0x8 ++ NL80211_IFTYPE_P2P_DEVICE = 0xa ++ NL80211_IFTYPE_P2P_GO = 0x9 ++ NL80211_IFTYPE_STATION = 0x2 ++ NL80211_IFTYPE_UNSPECIFIED = 0x0 ++ NL80211_IFTYPE_WDS = 0x5 ++ NL80211_KCK_EXT_LEN = 0x18 ++ NL80211_KCK_LEN = 0x10 ++ NL80211_KEK_EXT_LEN = 0x20 ++ NL80211_KEK_LEN = 0x10 ++ NL80211_KEY_CIPHER = 0x3 ++ NL80211_KEY_DATA = 0x1 ++ NL80211_KEY_DEFAULT_BEACON = 0xa ++ NL80211_KEY_DEFAULT = 0x5 ++ NL80211_KEY_DEFAULT_MGMT = 0x6 ++ NL80211_KEY_DEFAULT_TYPE_MULTICAST = 0x2 ++ NL80211_KEY_DEFAULT_TYPES = 0x8 ++ NL80211_KEY_DEFAULT_TYPE_UNICAST = 0x1 ++ NL80211_KEY_IDX = 0x2 ++ NL80211_KEY_MAX = 0xa ++ NL80211_KEY_MODE = 0x9 ++ NL80211_KEY_NO_TX = 0x1 ++ NL80211_KEY_RX_TX = 0x0 ++ NL80211_KEY_SEQ = 0x4 ++ NL80211_KEY_SET_TX = 0x2 ++ NL80211_KEY_TYPE = 0x7 ++ NL80211_KEYTYPE_GROUP = 0x0 ++ NL80211_KEYTYPE_PAIRWISE = 0x1 ++ NL80211_KEYTYPE_PEERKEY = 0x2 ++ NL80211_MAX_NR_AKM_SUITES = 0x2 ++ NL80211_MAX_NR_CIPHER_SUITES = 0x5 ++ NL80211_MAX_SUPP_HT_RATES = 0x4d ++ NL80211_MAX_SUPP_RATES = 0x20 ++ NL80211_MAX_SUPP_REG_RULES = 0x80 ++ NL80211_MESHCONF_ATTR_MAX = 0x1f ++ NL80211_MESHCONF_AUTO_OPEN_PLINKS = 0x7 ++ NL80211_MESHCONF_AWAKE_WINDOW = 0x1b ++ NL80211_MESHCONF_CONFIRM_TIMEOUT = 0x2 ++ NL80211_MESHCONF_CONNECTED_TO_AS = 0x1f ++ NL80211_MESHCONF_CONNECTED_TO_GATE = 0x1d ++ NL80211_MESHCONF_ELEMENT_TTL = 0xf ++ NL80211_MESHCONF_FORWARDING = 0x13 ++ NL80211_MESHCONF_GATE_ANNOUNCEMENTS = 0x11 ++ NL80211_MESHCONF_HOLDING_TIMEOUT = 0x3 ++ NL80211_MESHCONF_HT_OPMODE = 0x16 ++ NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT = 0xb ++ NL80211_MESHCONF_HWMP_CONFIRMATION_INTERVAL = 0x19 ++ NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES = 0x8 ++ NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME = 0xd ++ NL80211_MESHCONF_HWMP_PATH_TO_ROOT_TIMEOUT = 0x17 ++ NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL = 0x12 ++ NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL = 0xc ++ NL80211_MESHCONF_HWMP_RANN_INTERVAL = 0x10 ++ NL80211_MESHCONF_HWMP_ROOT_INTERVAL = 0x18 ++ NL80211_MESHCONF_HWMP_ROOTMODE = 0xe ++ NL80211_MESHCONF_MAX_PEER_LINKS = 0x4 ++ NL80211_MESHCONF_MAX_RETRIES = 0x5 ++ NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT = 0xa ++ NL80211_MESHCONF_NOLEARN = 0x1e ++ NL80211_MESHCONF_PATH_REFRESH_TIME = 0x9 ++ NL80211_MESHCONF_PLINK_TIMEOUT = 0x1c ++ NL80211_MESHCONF_POWER_MODE = 0x1a ++ NL80211_MESHCONF_RETRY_TIMEOUT = 0x1 ++ NL80211_MESHCONF_RSSI_THRESHOLD = 0x14 ++ NL80211_MESHCONF_SYNC_OFFSET_MAX_NEIGHBOR = 0x15 ++ NL80211_MESHCONF_TTL = 0x6 ++ NL80211_MESH_POWER_ACTIVE = 0x1 ++ NL80211_MESH_POWER_DEEP_SLEEP = 0x3 ++ NL80211_MESH_POWER_LIGHT_SLEEP = 0x2 ++ NL80211_MESH_POWER_MAX = 0x3 ++ NL80211_MESH_POWER_UNKNOWN = 0x0 ++ NL80211_MESH_SETUP_ATTR_MAX = 0x8 ++ NL80211_MESH_SETUP_AUTH_PROTOCOL = 0x8 ++ NL80211_MESH_SETUP_ENABLE_VENDOR_METRIC = 0x2 ++ NL80211_MESH_SETUP_ENABLE_VENDOR_PATH_SEL = 0x1 ++ NL80211_MESH_SETUP_ENABLE_VENDOR_SYNC = 0x6 ++ NL80211_MESH_SETUP_IE = 0x3 ++ NL80211_MESH_SETUP_USERSPACE_AMPE = 0x5 ++ NL80211_MESH_SETUP_USERSPACE_AUTH = 0x4 ++ NL80211_MESH_SETUP_USERSPACE_MPM = 0x7 ++ NL80211_MESH_SETUP_VENDOR_PATH_SEL_IE = 0x3 ++ NL80211_MFP_NO = 0x0 ++ NL80211_MFP_OPTIONAL = 0x2 ++ NL80211_MFP_REQUIRED = 0x1 ++ NL80211_MIN_REMAIN_ON_CHANNEL_TIME = 0xa ++ NL80211_MNTR_FLAG_ACTIVE = 0x6 ++ NL80211_MNTR_FLAG_CONTROL = 0x3 ++ NL80211_MNTR_FLAG_COOK_FRAMES = 0x5 ++ NL80211_MNTR_FLAG_FCSFAIL = 0x1 ++ NL80211_MNTR_FLAG_MAX = 0x6 ++ NL80211_MNTR_FLAG_OTHER_BSS = 0x4 ++ NL80211_MNTR_FLAG_PLCPFAIL = 0x2 ++ NL80211_MPATH_FLAG_ACTIVE = 0x1 ++ NL80211_MPATH_FLAG_FIXED = 0x8 ++ NL80211_MPATH_FLAG_RESOLVED = 0x10 ++ NL80211_MPATH_FLAG_RESOLVING = 0x2 ++ NL80211_MPATH_FLAG_SN_VALID = 0x4 ++ NL80211_MPATH_INFO_DISCOVERY_RETRIES = 0x7 ++ NL80211_MPATH_INFO_DISCOVERY_TIMEOUT = 0x6 ++ NL80211_MPATH_INFO_EXPTIME = 0x4 ++ NL80211_MPATH_INFO_FLAGS = 0x5 ++ NL80211_MPATH_INFO_FRAME_QLEN = 0x1 ++ NL80211_MPATH_INFO_HOP_COUNT = 0x8 ++ NL80211_MPATH_INFO_MAX = 0x9 ++ NL80211_MPATH_INFO_METRIC = 0x3 ++ NL80211_MPATH_INFO_PATH_CHANGE = 0x9 ++ NL80211_MPATH_INFO_SN = 0x2 ++ NL80211_MULTICAST_GROUP_CONFIG = "config" ++ NL80211_MULTICAST_GROUP_MLME = "mlme" ++ NL80211_MULTICAST_GROUP_NAN = "nan" ++ NL80211_MULTICAST_GROUP_REG = "regulatory" ++ NL80211_MULTICAST_GROUP_SCAN = "scan" ++ NL80211_MULTICAST_GROUP_TESTMODE = "testmode" ++ NL80211_MULTICAST_GROUP_VENDOR = "vendor" ++ NL80211_NAN_FUNC_ATTR_MAX = 0x10 ++ NL80211_NAN_FUNC_CLOSE_RANGE = 0x9 ++ NL80211_NAN_FUNC_FOLLOW_UP = 0x2 ++ NL80211_NAN_FUNC_FOLLOW_UP_DEST = 0x8 ++ NL80211_NAN_FUNC_FOLLOW_UP_ID = 0x6 ++ NL80211_NAN_FUNC_FOLLOW_UP_REQ_ID = 0x7 ++ NL80211_NAN_FUNC_INSTANCE_ID = 0xf ++ NL80211_NAN_FUNC_MAX_TYPE = 0x2 ++ NL80211_NAN_FUNC_PUBLISH_BCAST = 0x4 ++ NL80211_NAN_FUNC_PUBLISH = 0x0 ++ NL80211_NAN_FUNC_PUBLISH_TYPE = 0x3 ++ NL80211_NAN_FUNC_RX_MATCH_FILTER = 0xd ++ NL80211_NAN_FUNC_SERVICE_ID = 0x2 ++ NL80211_NAN_FUNC_SERVICE_ID_LEN = 0x6 ++ NL80211_NAN_FUNC_SERVICE_INFO = 0xb ++ NL80211_NAN_FUNC_SERVICE_SPEC_INFO_MAX_LEN = 0xff ++ NL80211_NAN_FUNC_SRF = 0xc ++ NL80211_NAN_FUNC_SRF_MAX_LEN = 0xff ++ NL80211_NAN_FUNC_SUBSCRIBE_ACTIVE = 0x5 ++ NL80211_NAN_FUNC_SUBSCRIBE = 0x1 ++ NL80211_NAN_FUNC_TERM_REASON = 0x10 ++ NL80211_NAN_FUNC_TERM_REASON_ERROR = 0x2 ++ NL80211_NAN_FUNC_TERM_REASON_TTL_EXPIRED = 0x1 ++ NL80211_NAN_FUNC_TERM_REASON_USER_REQUEST = 0x0 ++ NL80211_NAN_FUNC_TTL = 0xa ++ NL80211_NAN_FUNC_TX_MATCH_FILTER = 0xe ++ NL80211_NAN_FUNC_TYPE = 0x1 ++ NL80211_NAN_MATCH_ATTR_MAX = 0x2 ++ NL80211_NAN_MATCH_FUNC_LOCAL = 0x1 ++ NL80211_NAN_MATCH_FUNC_PEER = 0x2 ++ NL80211_NAN_SOLICITED_PUBLISH = 0x1 ++ NL80211_NAN_SRF_ATTR_MAX = 0x4 ++ NL80211_NAN_SRF_BF = 0x2 ++ NL80211_NAN_SRF_BF_IDX = 0x3 ++ NL80211_NAN_SRF_INCLUDE = 0x1 ++ NL80211_NAN_SRF_MAC_ADDRS = 0x4 ++ NL80211_NAN_UNSOLICITED_PUBLISH = 0x2 ++ NL80211_NUM_ACS = 0x4 ++ NL80211_P2P_PS_SUPPORTED = 0x1 ++ NL80211_P2P_PS_UNSUPPORTED = 0x0 ++ NL80211_PKTPAT_MASK = 0x1 ++ NL80211_PKTPAT_OFFSET = 0x3 ++ NL80211_PKTPAT_PATTERN = 0x2 ++ NL80211_PLINK_ACTION_BLOCK = 0x2 ++ NL80211_PLINK_ACTION_NO_ACTION = 0x0 ++ NL80211_PLINK_ACTION_OPEN = 0x1 ++ NL80211_PLINK_BLOCKED = 0x6 ++ NL80211_PLINK_CNF_RCVD = 0x3 ++ NL80211_PLINK_ESTAB = 0x4 ++ NL80211_PLINK_HOLDING = 0x5 ++ NL80211_PLINK_LISTEN = 0x0 ++ NL80211_PLINK_OPN_RCVD = 0x2 ++ NL80211_PLINK_OPN_SNT = 0x1 ++ NL80211_PMKSA_CANDIDATE_BSSID = 0x2 ++ NL80211_PMKSA_CANDIDATE_INDEX = 0x1 ++ NL80211_PMKSA_CANDIDATE_PREAUTH = 0x3 ++ NL80211_PMSR_ATTR_MAX = 0x5 ++ NL80211_PMSR_ATTR_MAX_PEERS = 0x1 ++ NL80211_PMSR_ATTR_PEERS = 0x5 ++ NL80211_PMSR_ATTR_RANDOMIZE_MAC_ADDR = 0x3 ++ NL80211_PMSR_ATTR_REPORT_AP_TSF = 0x2 ++ NL80211_PMSR_ATTR_TYPE_CAPA = 0x4 ++ NL80211_PMSR_FTM_CAPA_ATTR_ASAP = 0x1 ++ NL80211_PMSR_FTM_CAPA_ATTR_BANDWIDTHS = 0x6 ++ NL80211_PMSR_FTM_CAPA_ATTR_MAX_BURSTS_EXPONENT = 0x7 ++ NL80211_PMSR_FTM_CAPA_ATTR_MAX = 0xa ++ NL80211_PMSR_FTM_CAPA_ATTR_MAX_FTMS_PER_BURST = 0x8 ++ NL80211_PMSR_FTM_CAPA_ATTR_NON_ASAP = 0x2 ++ NL80211_PMSR_FTM_CAPA_ATTR_NON_TRIGGER_BASED = 0xa ++ NL80211_PMSR_FTM_CAPA_ATTR_PREAMBLES = 0x5 ++ NL80211_PMSR_FTM_CAPA_ATTR_REQ_CIVICLOC = 0x4 ++ NL80211_PMSR_FTM_CAPA_ATTR_REQ_LCI = 0x3 ++ NL80211_PMSR_FTM_CAPA_ATTR_TRIGGER_BASED = 0x9 ++ NL80211_PMSR_FTM_FAILURE_BAD_CHANGED_PARAMS = 0x7 ++ NL80211_PMSR_FTM_FAILURE_INVALID_TIMESTAMP = 0x5 ++ NL80211_PMSR_FTM_FAILURE_NO_RESPONSE = 0x1 ++ NL80211_PMSR_FTM_FAILURE_PEER_BUSY = 0x6 ++ NL80211_PMSR_FTM_FAILURE_PEER_NOT_CAPABLE = 0x4 ++ NL80211_PMSR_FTM_FAILURE_REJECTED = 0x2 ++ NL80211_PMSR_FTM_FAILURE_UNSPECIFIED = 0x0 ++ NL80211_PMSR_FTM_FAILURE_WRONG_CHANNEL = 0x3 ++ NL80211_PMSR_FTM_REQ_ATTR_ASAP = 0x1 ++ NL80211_PMSR_FTM_REQ_ATTR_BURST_DURATION = 0x5 ++ NL80211_PMSR_FTM_REQ_ATTR_BURST_PERIOD = 0x4 ++ NL80211_PMSR_FTM_REQ_ATTR_FTMS_PER_BURST = 0x6 ++ ++ NL80211_PMSR_FTM_REQ_ATTR_MAX = 0xb ++ NL80211_PMSR_FTM_REQ_ATTR_NON_TRIGGER_BASED = 0xb ++ NL80211_PMSR_FTM_REQ_ATTR_NUM_BURSTS_EXP = 0x3 ++ NL80211_PMSR_FTM_REQ_ATTR_NUM_FTMR_RETRIES = 0x7 ++ NL80211_PMSR_FTM_REQ_ATTR_PREAMBLE = 0x2 ++ NL80211_PMSR_FTM_REQ_ATTR_REQUEST_CIVICLOC = 0x9 ++ NL80211_PMSR_FTM_REQ_ATTR_REQUEST_LCI = 0x8 ++ NL80211_PMSR_FTM_REQ_ATTR_TRIGGER_BASED = 0xa ++ NL80211_PMSR_FTM_RESP_ATTR_BURST_DURATION = 0x7 ++ NL80211_PMSR_FTM_RESP_ATTR_BURST_INDEX = 0x2 ++ NL80211_PMSR_FTM_RESP_ATTR_BUSY_RETRY_TIME = 0x5 ++ NL80211_PMSR_FTM_RESP_ATTR_CIVICLOC = 0x14 ++ NL80211_PMSR_FTM_RESP_ATTR_DIST_AVG = 0x10 ++ NL80211_PMSR_FTM_RESP_ATTR_DIST_SPREAD = 0x12 ++ NL80211_PMSR_FTM_RESP_ATTR_DIST_VARIANCE = 0x11 ++ NL80211_PMSR_FTM_RESP_ATTR_FAIL_REASON = 0x1 ++ NL80211_PMSR_FTM_RESP_ATTR_FTMS_PER_BURST = 0x8 ++ NL80211_PMSR_FTM_RESP_ATTR_LCI = 0x13 ++ NL80211_PMSR_FTM_RESP_ATTR_MAX = 0x15 ++ NL80211_PMSR_FTM_RESP_ATTR_NUM_BURSTS_EXP = 0x6 ++ NL80211_PMSR_FTM_RESP_ATTR_NUM_FTMR_ATTEMPTS = 0x3 ++ NL80211_PMSR_FTM_RESP_ATTR_NUM_FTMR_SUCCESSES = 0x4 ++ NL80211_PMSR_FTM_RESP_ATTR_PAD = 0x15 ++ NL80211_PMSR_FTM_RESP_ATTR_RSSI_AVG = 0x9 ++ NL80211_PMSR_FTM_RESP_ATTR_RSSI_SPREAD = 0xa ++ NL80211_PMSR_FTM_RESP_ATTR_RTT_AVG = 0xd ++ NL80211_PMSR_FTM_RESP_ATTR_RTT_SPREAD = 0xf ++ NL80211_PMSR_FTM_RESP_ATTR_RTT_VARIANCE = 0xe ++ NL80211_PMSR_FTM_RESP_ATTR_RX_RATE = 0xc ++ NL80211_PMSR_FTM_RESP_ATTR_TX_RATE = 0xb ++ NL80211_PMSR_PEER_ATTR_ADDR = 0x1 ++ NL80211_PMSR_PEER_ATTR_CHAN = 0x2 ++ NL80211_PMSR_PEER_ATTR_MAX = 0x4 ++ NL80211_PMSR_PEER_ATTR_REQ = 0x3 ++ NL80211_PMSR_PEER_ATTR_RESP = 0x4 ++ NL80211_PMSR_REQ_ATTR_DATA = 0x1 ++ NL80211_PMSR_REQ_ATTR_GET_AP_TSF = 0x2 ++ NL80211_PMSR_REQ_ATTR_MAX = 0x2 ++ NL80211_PMSR_RESP_ATTR_AP_TSF = 0x4 ++ NL80211_PMSR_RESP_ATTR_DATA = 0x1 ++ NL80211_PMSR_RESP_ATTR_FINAL = 0x5 ++ NL80211_PMSR_RESP_ATTR_HOST_TIME = 0x3 ++ NL80211_PMSR_RESP_ATTR_MAX = 0x6 ++ NL80211_PMSR_RESP_ATTR_PAD = 0x6 ++ NL80211_PMSR_RESP_ATTR_STATUS = 0x2 ++ NL80211_PMSR_STATUS_FAILURE = 0x3 ++ NL80211_PMSR_STATUS_REFUSED = 0x1 ++ NL80211_PMSR_STATUS_SUCCESS = 0x0 ++ NL80211_PMSR_STATUS_TIMEOUT = 0x2 ++ NL80211_PMSR_TYPE_FTM = 0x1 ++ NL80211_PMSR_TYPE_INVALID = 0x0 ++ NL80211_PMSR_TYPE_MAX = 0x1 ++ NL80211_PREAMBLE_DMG = 0x3 ++ NL80211_PREAMBLE_HE = 0x4 ++ NL80211_PREAMBLE_HT = 0x1 ++ NL80211_PREAMBLE_LEGACY = 0x0 ++ NL80211_PREAMBLE_VHT = 0x2 ++ NL80211_PROBE_RESP_OFFLOAD_SUPPORT_80211U = 0x8 ++ NL80211_PROBE_RESP_OFFLOAD_SUPPORT_P2P = 0x4 ++ NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS2 = 0x2 ++ NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS = 0x1 ++ NL80211_PROTOCOL_FEATURE_SPLIT_WIPHY_DUMP = 0x1 ++ NL80211_PS_DISABLED = 0x0 ++ NL80211_PS_ENABLED = 0x1 ++ NL80211_RADAR_CAC_ABORTED = 0x2 ++ NL80211_RADAR_CAC_FINISHED = 0x1 ++ NL80211_RADAR_CAC_STARTED = 0x5 ++ NL80211_RADAR_DETECTED = 0x0 ++ NL80211_RADAR_NOP_FINISHED = 0x3 ++ NL80211_RADAR_PRE_CAC_EXPIRED = 0x4 ++ NL80211_RATE_INFO_10_MHZ_WIDTH = 0xb ++ NL80211_RATE_INFO_160_MHZ_WIDTH = 0xa ++ NL80211_RATE_INFO_40_MHZ_WIDTH = 0x3 ++ NL80211_RATE_INFO_5_MHZ_WIDTH = 0xc ++ NL80211_RATE_INFO_80_MHZ_WIDTH = 0x8 ++ NL80211_RATE_INFO_80P80_MHZ_WIDTH = 0x9 ++ NL80211_RATE_INFO_BITRATE32 = 0x5 ++ NL80211_RATE_INFO_BITRATE = 0x1 ++ NL80211_RATE_INFO_HE_1XLTF = 0x0 ++ NL80211_RATE_INFO_HE_2XLTF = 0x1 ++ NL80211_RATE_INFO_HE_4XLTF = 0x2 ++ NL80211_RATE_INFO_HE_DCM = 0x10 ++ NL80211_RATE_INFO_HE_GI_0_8 = 0x0 ++ NL80211_RATE_INFO_HE_GI_1_6 = 0x1 ++ NL80211_RATE_INFO_HE_GI_3_2 = 0x2 ++ NL80211_RATE_INFO_HE_GI = 0xf ++ NL80211_RATE_INFO_HE_MCS = 0xd ++ NL80211_RATE_INFO_HE_NSS = 0xe ++ NL80211_RATE_INFO_HE_RU_ALLOC_106 = 0x2 ++ NL80211_RATE_INFO_HE_RU_ALLOC_242 = 0x3 ++ NL80211_RATE_INFO_HE_RU_ALLOC_26 = 0x0 ++ NL80211_RATE_INFO_HE_RU_ALLOC_2x996 = 0x6 ++ NL80211_RATE_INFO_HE_RU_ALLOC_484 = 0x4 ++ NL80211_RATE_INFO_HE_RU_ALLOC_52 = 0x1 ++ NL80211_RATE_INFO_HE_RU_ALLOC_996 = 0x5 ++ NL80211_RATE_INFO_HE_RU_ALLOC = 0x11 ++ NL80211_RATE_INFO_MAX = 0x11 ++ NL80211_RATE_INFO_MCS = 0x2 ++ NL80211_RATE_INFO_SHORT_GI = 0x4 ++ NL80211_RATE_INFO_VHT_MCS = 0x6 ++ NL80211_RATE_INFO_VHT_NSS = 0x7 ++ NL80211_REGDOM_SET_BY_CORE = 0x0 ++ NL80211_REGDOM_SET_BY_COUNTRY_IE = 0x3 ++ NL80211_REGDOM_SET_BY_DRIVER = 0x2 ++ NL80211_REGDOM_SET_BY_USER = 0x1 ++ NL80211_REGDOM_TYPE_COUNTRY = 0x0 ++ NL80211_REGDOM_TYPE_CUSTOM_WORLD = 0x2 ++ NL80211_REGDOM_TYPE_INTERSECTION = 0x3 ++ NL80211_REGDOM_TYPE_WORLD = 0x1 ++ NL80211_REG_RULE_ATTR_MAX = 0x7 ++ NL80211_REKEY_DATA_AKM = 0x4 ++ NL80211_REKEY_DATA_KCK = 0x2 ++ NL80211_REKEY_DATA_KEK = 0x1 ++ NL80211_REKEY_DATA_REPLAY_CTR = 0x3 ++ NL80211_REPLAY_CTR_LEN = 0x8 ++ NL80211_RRF_AUTO_BW = 0x800 ++ NL80211_RRF_DFS = 0x10 ++ NL80211_RRF_GO_CONCURRENT = 0x1000 ++ NL80211_RRF_IR_CONCURRENT = 0x1000 ++ NL80211_RRF_NO_160MHZ = 0x10000 ++ NL80211_RRF_NO_80MHZ = 0x8000 ++ NL80211_RRF_NO_CCK = 0x2 ++ NL80211_RRF_NO_HE = 0x20000 ++ NL80211_RRF_NO_HT40 = 0x6000 ++ NL80211_RRF_NO_HT40MINUS = 0x2000 ++ NL80211_RRF_NO_HT40PLUS = 0x4000 ++ NL80211_RRF_NO_IBSS = 0x80 ++ NL80211_RRF_NO_INDOOR = 0x4 ++ NL80211_RRF_NO_IR_ALL = 0x180 ++ NL80211_RRF_NO_IR = 0x80 ++ NL80211_RRF_NO_OFDM = 0x1 ++ NL80211_RRF_NO_OUTDOOR = 0x8 ++ NL80211_RRF_PASSIVE_SCAN = 0x80 ++ NL80211_RRF_PTMP_ONLY = 0x40 ++ NL80211_RRF_PTP_ONLY = 0x20 ++ NL80211_RXMGMT_FLAG_ANSWERED = 0x1 ++ NL80211_RXMGMT_FLAG_EXTERNAL_AUTH = 0x2 ++ ++ NL80211_SCAN_FLAG_ACCEPT_BCAST_PROBE_RESP = 0x20 ++ NL80211_SCAN_FLAG_AP = 0x4 ++ NL80211_SCAN_FLAG_COLOCATED_6GHZ = 0x4000 ++ NL80211_SCAN_FLAG_FILS_MAX_CHANNEL_TIME = 0x10 ++ NL80211_SCAN_FLAG_FLUSH = 0x2 ++ NL80211_SCAN_FLAG_FREQ_KHZ = 0x2000 ++ NL80211_SCAN_FLAG_HIGH_ACCURACY = 0x400 ++ NL80211_SCAN_FLAG_LOW_POWER = 0x200 ++ NL80211_SCAN_FLAG_LOW_PRIORITY = 0x1 ++ NL80211_SCAN_FLAG_LOW_SPAN = 0x100 ++ NL80211_SCAN_FLAG_MIN_PREQ_CONTENT = 0x1000 ++ NL80211_SCAN_FLAG_OCE_PROBE_REQ_DEFERRAL_SUPPRESSION = 0x80 ++ NL80211_SCAN_FLAG_OCE_PROBE_REQ_HIGH_TX_RATE = 0x40 ++ NL80211_SCAN_FLAG_RANDOM_ADDR = 0x8 ++ NL80211_SCAN_FLAG_RANDOM_SN = 0x800 ++ NL80211_SCAN_RSSI_THOLD_OFF = -0x12c ++ NL80211_SCHED_SCAN_MATCH_ATTR_BSSID = 0x5 ++ NL80211_SCHED_SCAN_MATCH_ATTR_MAX = 0x6 ++ NL80211_SCHED_SCAN_MATCH_ATTR_RELATIVE_RSSI = 0x3 ++ NL80211_SCHED_SCAN_MATCH_ATTR_RSSI_ADJUST = 0x4 ++ NL80211_SCHED_SCAN_MATCH_ATTR_RSSI = 0x2 ++ NL80211_SCHED_SCAN_MATCH_ATTR_SSID = 0x1 ++ NL80211_SCHED_SCAN_MATCH_PER_BAND_RSSI = 0x6 ++ NL80211_SCHED_SCAN_PLAN_INTERVAL = 0x1 ++ NL80211_SCHED_SCAN_PLAN_ITERATIONS = 0x2 ++ NL80211_SCHED_SCAN_PLAN_MAX = 0x2 ++ NL80211_SMPS_DYNAMIC = 0x2 ++ NL80211_SMPS_MAX = 0x2 ++ NL80211_SMPS_OFF = 0x0 ++ NL80211_SMPS_STATIC = 0x1 ++ NL80211_STA_BSS_PARAM_BEACON_INTERVAL = 0x5 ++ NL80211_STA_BSS_PARAM_CTS_PROT = 0x1 ++ NL80211_STA_BSS_PARAM_DTIM_PERIOD = 0x4 ++ NL80211_STA_BSS_PARAM_MAX = 0x5 ++ NL80211_STA_BSS_PARAM_SHORT_PREAMBLE = 0x2 ++ NL80211_STA_BSS_PARAM_SHORT_SLOT_TIME = 0x3 ++ NL80211_STA_FLAG_ASSOCIATED = 0x7 ++ NL80211_STA_FLAG_AUTHENTICATED = 0x5 ++ NL80211_STA_FLAG_AUTHORIZED = 0x1 ++ NL80211_STA_FLAG_MAX = 0x7 ++ NL80211_STA_FLAG_MAX_OLD_API = 0x6 ++ NL80211_STA_FLAG_MFP = 0x4 ++ NL80211_STA_FLAG_SHORT_PREAMBLE = 0x2 ++ NL80211_STA_FLAG_TDLS_PEER = 0x6 ++ NL80211_STA_FLAG_WME = 0x3 ++ NL80211_STA_INFO_ACK_SIGNAL_AVG = 0x23 ++ NL80211_STA_INFO_ACK_SIGNAL = 0x22 ++ NL80211_STA_INFO_AIRTIME_LINK_METRIC = 0x29 ++ NL80211_STA_INFO_AIRTIME_WEIGHT = 0x28 ++ NL80211_STA_INFO_ASSOC_AT_BOOTTIME = 0x2a ++ NL80211_STA_INFO_BEACON_LOSS = 0x12 ++ NL80211_STA_INFO_BEACON_RX = 0x1d ++ NL80211_STA_INFO_BEACON_SIGNAL_AVG = 0x1e ++ NL80211_STA_INFO_BSS_PARAM = 0xf ++ NL80211_STA_INFO_CHAIN_SIGNAL_AVG = 0x1a ++ NL80211_STA_INFO_CHAIN_SIGNAL = 0x19 ++ NL80211_STA_INFO_CONNECTED_TIME = 0x10 ++ NL80211_STA_INFO_CONNECTED_TO_AS = 0x2b ++ NL80211_STA_INFO_CONNECTED_TO_GATE = 0x26 ++ NL80211_STA_INFO_DATA_ACK_SIGNAL_AVG = 0x23 ++ NL80211_STA_INFO_EXPECTED_THROUGHPUT = 0x1b ++ NL80211_STA_INFO_FCS_ERROR_COUNT = 0x25 ++ NL80211_STA_INFO_INACTIVE_TIME = 0x1 ++ NL80211_STA_INFO_LLID = 0x4 ++ NL80211_STA_INFO_LOCAL_PM = 0x14 ++ NL80211_STA_INFO_MAX = 0x2b ++ NL80211_STA_INFO_NONPEER_PM = 0x16 ++ NL80211_STA_INFO_PAD = 0x21 ++ NL80211_STA_INFO_PEER_PM = 0x15 ++ NL80211_STA_INFO_PLID = 0x5 ++ NL80211_STA_INFO_PLINK_STATE = 0x6 ++ NL80211_STA_INFO_RX_BITRATE = 0xe ++ NL80211_STA_INFO_RX_BYTES64 = 0x17 ++ NL80211_STA_INFO_RX_BYTES = 0x2 ++ NL80211_STA_INFO_RX_DROP_MISC = 0x1c ++ NL80211_STA_INFO_RX_DURATION = 0x20 ++ NL80211_STA_INFO_RX_MPDUS = 0x24 ++ NL80211_STA_INFO_RX_PACKETS = 0x9 ++ NL80211_STA_INFO_SIGNAL_AVG = 0xd ++ NL80211_STA_INFO_SIGNAL = 0x7 ++ NL80211_STA_INFO_STA_FLAGS = 0x11 ++ NL80211_STA_INFO_TID_STATS = 0x1f ++ NL80211_STA_INFO_T_OFFSET = 0x13 ++ NL80211_STA_INFO_TX_BITRATE = 0x8 ++ NL80211_STA_INFO_TX_BYTES64 = 0x18 ++ NL80211_STA_INFO_TX_BYTES = 0x3 ++ NL80211_STA_INFO_TX_DURATION = 0x27 ++ NL80211_STA_INFO_TX_FAILED = 0xc ++ NL80211_STA_INFO_TX_PACKETS = 0xa ++ NL80211_STA_INFO_TX_RETRIES = 0xb ++ NL80211_STA_WME_MAX = 0x2 ++ NL80211_STA_WME_MAX_SP = 0x2 ++ NL80211_STA_WME_UAPSD_QUEUES = 0x1 ++ NL80211_SURVEY_INFO_CHANNEL_TIME_BUSY = 0x5 ++ NL80211_SURVEY_INFO_CHANNEL_TIME = 0x4 ++ NL80211_SURVEY_INFO_CHANNEL_TIME_EXT_BUSY = 0x6 ++ NL80211_SURVEY_INFO_CHANNEL_TIME_RX = 0x7 ++ NL80211_SURVEY_INFO_CHANNEL_TIME_TX = 0x8 ++ NL80211_SURVEY_INFO_FREQUENCY = 0x1 ++ NL80211_SURVEY_INFO_FREQUENCY_OFFSET = 0xc ++ NL80211_SURVEY_INFO_IN_USE = 0x3 ++ NL80211_SURVEY_INFO_MAX = 0xc ++ NL80211_SURVEY_INFO_NOISE = 0x2 ++ NL80211_SURVEY_INFO_PAD = 0xa ++ NL80211_SURVEY_INFO_TIME_BSS_RX = 0xb ++ NL80211_SURVEY_INFO_TIME_BUSY = 0x5 ++ NL80211_SURVEY_INFO_TIME = 0x4 ++ NL80211_SURVEY_INFO_TIME_EXT_BUSY = 0x6 ++ NL80211_SURVEY_INFO_TIME_RX = 0x7 ++ NL80211_SURVEY_INFO_TIME_SCAN = 0x9 ++ NL80211_SURVEY_INFO_TIME_TX = 0x8 ++ NL80211_TDLS_DISABLE_LINK = 0x4 ++ NL80211_TDLS_DISCOVERY_REQ = 0x0 ++ NL80211_TDLS_ENABLE_LINK = 0x3 ++ ++ NL80211_TDLS_PEER_HT = 0x1 ++ NL80211_TDLS_PEER_VHT = 0x2 ++ NL80211_TDLS_PEER_WMM = 0x4 ++ NL80211_TDLS_SETUP = 0x1 ++ NL80211_TDLS_TEARDOWN = 0x2 ++ NL80211_TID_CONFIG_ATTR_AMPDU_CTRL = 0x9 ++ NL80211_TID_CONFIG_ATTR_AMSDU_CTRL = 0xb ++ NL80211_TID_CONFIG_ATTR_MAX = 0xd ++ NL80211_TID_CONFIG_ATTR_NOACK = 0x6 ++ NL80211_TID_CONFIG_ATTR_OVERRIDE = 0x4 ++ NL80211_TID_CONFIG_ATTR_PAD = 0x1 ++ NL80211_TID_CONFIG_ATTR_PEER_SUPP = 0x3 ++ NL80211_TID_CONFIG_ATTR_RETRY_LONG = 0x8 ++ NL80211_TID_CONFIG_ATTR_RETRY_SHORT = 0x7 ++ NL80211_TID_CONFIG_ATTR_RTSCTS_CTRL = 0xa ++ NL80211_TID_CONFIG_ATTR_TIDS = 0x5 ++ NL80211_TID_CONFIG_ATTR_TX_RATE = 0xd ++ NL80211_TID_CONFIG_ATTR_TX_RATE_TYPE = 0xc ++ NL80211_TID_CONFIG_ATTR_VIF_SUPP = 0x2 ++ NL80211_TID_CONFIG_DISABLE = 0x1 ++ NL80211_TID_CONFIG_ENABLE = 0x0 ++ NL80211_TID_STATS_MAX = 0x6 ++ NL80211_TID_STATS_PAD = 0x5 ++ NL80211_TID_STATS_RX_MSDU = 0x1 ++ NL80211_TID_STATS_TX_MSDU = 0x2 ++ NL80211_TID_STATS_TX_MSDU_FAILED = 0x4 ++ NL80211_TID_STATS_TX_MSDU_RETRIES = 0x3 ++ NL80211_TID_STATS_TXQ_STATS = 0x6 ++ NL80211_TIMEOUT_ASSOC = 0x3 ++ NL80211_TIMEOUT_AUTH = 0x2 ++ NL80211_TIMEOUT_SCAN = 0x1 ++ NL80211_TIMEOUT_UNSPECIFIED = 0x0 ++ NL80211_TKIP_DATA_OFFSET_ENCR_KEY = 0x0 ++ NL80211_TKIP_DATA_OFFSET_RX_MIC_KEY = 0x18 ++ NL80211_TKIP_DATA_OFFSET_TX_MIC_KEY = 0x10 ++ NL80211_TX_POWER_AUTOMATIC = 0x0 ++ NL80211_TX_POWER_FIXED = 0x2 ++ NL80211_TX_POWER_LIMITED = 0x1 ++ NL80211_TXQ_ATTR_AC = 0x1 ++ NL80211_TXQ_ATTR_AIFS = 0x5 ++ NL80211_TXQ_ATTR_CWMAX = 0x4 ++ NL80211_TXQ_ATTR_CWMIN = 0x3 ++ NL80211_TXQ_ATTR_MAX = 0x5 ++ NL80211_TXQ_ATTR_QUEUE = 0x1 ++ NL80211_TXQ_ATTR_TXOP = 0x2 ++ NL80211_TXQ_Q_BE = 0x2 ++ NL80211_TXQ_Q_BK = 0x3 ++ NL80211_TXQ_Q_VI = 0x1 ++ NL80211_TXQ_Q_VO = 0x0 ++ NL80211_TXQ_STATS_BACKLOG_BYTES = 0x1 ++ NL80211_TXQ_STATS_BACKLOG_PACKETS = 0x2 ++ NL80211_TXQ_STATS_COLLISIONS = 0x8 ++ NL80211_TXQ_STATS_DROPS = 0x4 ++ NL80211_TXQ_STATS_ECN_MARKS = 0x5 ++ NL80211_TXQ_STATS_FLOWS = 0x3 ++ NL80211_TXQ_STATS_MAX = 0xb ++ NL80211_TXQ_STATS_MAX_FLOWS = 0xb ++ NL80211_TXQ_STATS_OVERLIMIT = 0x6 ++ NL80211_TXQ_STATS_OVERMEMORY = 0x7 ++ NL80211_TXQ_STATS_TX_BYTES = 0x9 ++ NL80211_TXQ_STATS_TX_PACKETS = 0xa ++ NL80211_TX_RATE_AUTOMATIC = 0x0 ++ NL80211_TXRATE_DEFAULT_GI = 0x0 ++ NL80211_TX_RATE_FIXED = 0x2 ++ NL80211_TXRATE_FORCE_LGI = 0x2 ++ NL80211_TXRATE_FORCE_SGI = 0x1 ++ NL80211_TXRATE_GI = 0x4 ++ NL80211_TXRATE_HE = 0x5 ++ NL80211_TXRATE_HE_GI = 0x6 ++ NL80211_TXRATE_HE_LTF = 0x7 ++ NL80211_TXRATE_HT = 0x2 ++ NL80211_TXRATE_LEGACY = 0x1 ++ NL80211_TX_RATE_LIMITED = 0x1 ++ NL80211_TXRATE_MAX = 0x7 ++ NL80211_TXRATE_MCS = 0x2 ++ NL80211_TXRATE_VHT = 0x3 ++ NL80211_UNSOL_BCAST_PROBE_RESP_ATTR_INT = 0x1 ++ NL80211_UNSOL_BCAST_PROBE_RESP_ATTR_MAX = 0x2 ++ NL80211_UNSOL_BCAST_PROBE_RESP_ATTR_TMPL = 0x2 ++ NL80211_USER_REG_HINT_CELL_BASE = 0x1 ++ NL80211_USER_REG_HINT_INDOOR = 0x2 ++ NL80211_USER_REG_HINT_USER = 0x0 ++ NL80211_VENDOR_ID_IS_LINUX = 0x80000000 ++ NL80211_VHT_CAPABILITY_LEN = 0xc ++ NL80211_VHT_NSS_MAX = 0x8 ++ NL80211_WIPHY_NAME_MAXLEN = 0x40 ++ NL80211_WMMR_AIFSN = 0x3 ++ NL80211_WMMR_CW_MAX = 0x2 ++ NL80211_WMMR_CW_MIN = 0x1 ++ NL80211_WMMR_MAX = 0x4 ++ NL80211_WMMR_TXOP = 0x4 ++ NL80211_WOWLAN_PKTPAT_MASK = 0x1 ++ NL80211_WOWLAN_PKTPAT_OFFSET = 0x3 ++ NL80211_WOWLAN_PKTPAT_PATTERN = 0x2 ++ NL80211_WOWLAN_TCP_DATA_INTERVAL = 0x9 ++ NL80211_WOWLAN_TCP_DATA_PAYLOAD = 0x6 ++ NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ = 0x7 ++ NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN = 0x8 ++ NL80211_WOWLAN_TCP_DST_IPV4 = 0x2 ++ NL80211_WOWLAN_TCP_DST_MAC = 0x3 ++ NL80211_WOWLAN_TCP_DST_PORT = 0x5 ++ NL80211_WOWLAN_TCP_SRC_IPV4 = 0x1 ++ NL80211_WOWLAN_TCP_SRC_PORT = 0x4 ++ NL80211_WOWLAN_TCP_WAKE_MASK = 0xb ++ NL80211_WOWLAN_TCP_WAKE_PAYLOAD = 0xa ++ NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE = 0x8 ++ NL80211_WOWLAN_TRIG_ANY = 0x1 ++ NL80211_WOWLAN_TRIG_DISCONNECT = 0x2 ++ NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST = 0x7 ++ NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE = 0x6 ++ NL80211_WOWLAN_TRIG_GTK_REKEY_SUPPORTED = 0x5 ++ NL80211_WOWLAN_TRIG_MAGIC_PKT = 0x3 ++ NL80211_WOWLAN_TRIG_NET_DETECT = 0x12 ++ NL80211_WOWLAN_TRIG_NET_DETECT_RESULTS = 0x13 ++ NL80211_WOWLAN_TRIG_PKT_PATTERN = 0x4 ++ NL80211_WOWLAN_TRIG_RFKILL_RELEASE = 0x9 ++ NL80211_WOWLAN_TRIG_TCP_CONNECTION = 0xe ++ NL80211_WOWLAN_TRIG_WAKEUP_PKT_80211 = 0xa ++ NL80211_WOWLAN_TRIG_WAKEUP_PKT_80211_LEN = 0xb ++ NL80211_WOWLAN_TRIG_WAKEUP_PKT_8023 = 0xc ++ NL80211_WOWLAN_TRIG_WAKEUP_PKT_8023_LEN = 0xd ++ NL80211_WOWLAN_TRIG_WAKEUP_TCP_CONNLOST = 0x10 ++ NL80211_WOWLAN_TRIG_WAKEUP_TCP_MATCH = 0xf ++ NL80211_WOWLAN_TRIG_WAKEUP_TCP_NOMORETOKENS = 0x11 ++ NL80211_WPA_VERSION_1 = 0x1 ++ NL80211_WPA_VERSION_2 = 0x2 ++ NL80211_WPA_VERSION_3 = 0x4 ++) ++ ++const ( ++ FRA_UNSPEC = 0x0 ++ FRA_DST = 0x1 ++ FRA_SRC = 0x2 ++ FRA_IIFNAME = 0x3 ++ FRA_GOTO = 0x4 ++ FRA_UNUSED2 = 0x5 ++ FRA_PRIORITY = 0x6 ++ FRA_UNUSED3 = 0x7 ++ FRA_UNUSED4 = 0x8 ++ FRA_UNUSED5 = 0x9 ++ FRA_FWMARK = 0xa ++ FRA_FLOW = 0xb ++ FRA_TUN_ID = 0xc ++ FRA_SUPPRESS_IFGROUP = 0xd ++ FRA_SUPPRESS_PREFIXLEN = 0xe ++ FRA_TABLE = 0xf ++ FRA_FWMASK = 0x10 ++ FRA_OIFNAME = 0x11 ++ FRA_PAD = 0x12 ++ FRA_L3MDEV = 0x13 ++ FRA_UID_RANGE = 0x14 ++ FRA_PROTOCOL = 0x15 ++ FRA_IP_PROTO = 0x16 ++ FRA_SPORT_RANGE = 0x17 ++ FRA_DPORT_RANGE = 0x18 ++ FR_ACT_UNSPEC = 0x0 ++ FR_ACT_TO_TBL = 0x1 ++ FR_ACT_GOTO = 0x2 ++ FR_ACT_NOP = 0x3 ++ FR_ACT_RES3 = 0x4 ++ FR_ACT_RES4 = 0x5 ++ FR_ACT_BLACKHOLE = 0x6 ++ FR_ACT_UNREACHABLE = 0x7 ++ FR_ACT_PROHIBIT = 0x8 ++) ++ ++const ( ++ AUDIT_NLGRP_NONE = 0x0 ++ AUDIT_NLGRP_READLOG = 0x1 ++) diff --git a/containerd.spec b/containerd.spec index 95c152c9b805e8cee4db6f07704134be8efac5ef..2e109aafb073bd255c9db5a70cf4c67e96a14793 100644 --- a/containerd.spec +++ b/containerd.spec @@ -1,7 +1,7 @@ %define anolis_release 1 # Generated by go2rpm # arm support not fully implemented: not implemented -%ifnarch %{arm} +%ifnarch %{arm} %bcond_without check %endif %bcond_with bootstrap @@ -38,11 +38,17 @@ export PATH=$PWD/_bin${PATH:+:$PATH} export GOPATH=$GO_BUILD_PATH:%{gopath} export GO111MODULE=auto } +%ifarch sw_64 +%define gobuild(o:) %{expand: +%global _dwz_low_mem_die_limit 0 +go build -compiler gc -tags="rpm_crashtraceback ${BUILDTAGS:-}" -ldflags "${LDFLAGS:-} -B 0x$(head -c20 /dev/urandom|od -An -tx1|tr -d ' \\n') -extldflags '%__global_ldflags %{?__golang_extldflags}'" -a -v -x %{?**}; +} +%else %define gobuild(o:) %{expand: %global _dwz_low_mem_die_limit 0 go build -buildmode pie -compiler gc -tags="rpm_crashtraceback ${BUILDTAGS:-}" -ldflags "${LDFLAGS:-} -B 0x$(head -c20 /dev/urandom|od -An -tx1|tr -d ' \\n') -extldflags '%__global_ldflags %{?__golang_extldflags}'" -a -v -x %{?**}; } - +%endif Name: %{goname} Release: %{anolis_release}%{?dist} Summary: Open and reliable container runtime @@ -56,12 +62,11 @@ Source2: containerd.toml # Carve out code requiring github.com/Microsoft/hcsshim Patch0: 0001-Revert-commit-for-Windows-metrics.patch Patch1: 0002-Remove-windows-only-dep.patch - +Patch2: containerd-1.5.9-sw.patch BuildRequires: golang >= 1.13 BuildRequires: go-md2man BuildRequires: systemd BuildRequires: git - Requires: runc # Be compatible with containerd.io, exactly we are the same