#ifndef __VMLINUX_H__
#define __VMLINUX_H__

#ifndef BPF_NO_PRESERVE_ACCESS_INDEX
#pragma clang attribute push (__attribute__((preserve_access_index)), apply_to = record)
#endif

#ifndef __ksym
#define __ksym __attribute__((section(".ksyms")))
#endif

#ifndef __weak
#define __weak __attribute__((weak))
#endif

#ifndef __bpf_fastcall
#if __has_attribute(bpf_fastcall)
#define __bpf_fastcall __attribute__((bpf_fastcall))
#else
#define __bpf_fastcall
#endif
#endif

enum {
    AAFS_LOADDATA_ABI = 0,
    AAFS_LOADDATA_REVISION = 1,
    AAFS_LOADDATA_HASH = 2,
    AAFS_LOADDATA_DATA = 3,
    AAFS_LOADDATA_COMPRESSED_SIZE = 4,
    AAFS_LOADDATA_DIR = 5,
    AAFS_LOADDATA_NDENTS = 6,
};

enum {
    ACTION_FAIL = 0,
    ACTION_REPREP = 1,
    ACTION_DELAYED_REPREP = 2,
    ACTION_RETRY = 3,
    ACTION_DELAYED_RETRY = 4,
};

enum {
    AFFINITY = 0,
    AFFINITY_LIST = 1,
    EFFECTIVE = 2,
    EFFECTIVE_LIST = 3,
};

enum {
    ASCII_NULL = 0,
    ASCII_BELL = 7,
    ASCII_BACKSPACE = 8,
    ASCII_IGNORE_FIRST = 8,
    ASCII_HTAB = 9,
    ASCII_LINEFEED = 10,
    ASCII_VTAB = 11,
    ASCII_FORMFEED = 12,
    ASCII_CAR_RET = 13,
    ASCII_IGNORE_LAST = 13,
    ASCII_SHIFTOUT = 14,
    ASCII_SHIFTIN = 15,
    ASCII_CANCEL = 24,
    ASCII_SUBSTITUTE = 26,
    ASCII_ESCAPE = 27,
    ASCII_CSI_IGNORE_FIRST = 32,
    ASCII_CSI_IGNORE_LAST = 63,
    ASCII_DEL = 127,
    ASCII_EXT_CSI = 155,
};

enum {
    ASSUME_PERFECT = 255,
    ASSUME_VALID_DTB = 1,
    ASSUME_VALID_INPUT = 2,
    ASSUME_LATEST = 4,
    ASSUME_NO_ROLLBACK = 8,
    ASSUME_LIBFDT_ORDER = 16,
    ASSUME_LIBFDT_FLAWLESS = 32,
};

enum {
    AT_PKT_END = -1,
    BEYOND_PKT_END = -2,
};

enum {
    AX25_VALUES_IPDEFMODE = 0,
    AX25_VALUES_AXDEFMODE = 1,
    AX25_VALUES_BACKOFF = 2,
    AX25_VALUES_CONMODE = 3,
    AX25_VALUES_WINDOW = 4,
    AX25_VALUES_EWINDOW = 5,
    AX25_VALUES_T1 = 6,
    AX25_VALUES_T2 = 7,
    AX25_VALUES_T3 = 8,
    AX25_VALUES_IDLE = 9,
    AX25_VALUES_N2 = 10,
    AX25_VALUES_PACLEN = 11,
    AX25_VALUES_PROTOCOL = 12,
    AX25_VALUES_DS_TIMEOUT = 13,
    AX25_MAX_VALUES = 14,
};

enum {
    Audit_equal = 0,
    Audit_not_equal = 1,
    Audit_bitmask = 2,
    Audit_bittest = 3,
    Audit_lt = 4,
    Audit_gt = 5,
    Audit_le = 6,
    Audit_ge = 7,
    Audit_bad = 8,
};

enum {
    BAD_STACK = -1,
    NOT_STACK = 0,
    GOOD_FRAME = 1,
    GOOD_STACK = 2,
};

enum {
    BIAS = 2147483648,
};

enum {
    BIOSET_NEED_BVECS = 1,
    BIOSET_NEED_RESCUER = 2,
    BIOSET_PERCPU_CACHE = 4,
};

enum {
    BIO_PAGE_PINNED = 0,
    BIO_CLONED = 1,
    BIO_BOUNCED = 2,
    BIO_QUIET = 3,
    BIO_CHAIN = 4,
    BIO_REFFED = 5,
    BIO_BPS_THROTTLED = 6,
    BIO_TRACE_COMPLETION = 7,
    BIO_CGROUP_ACCT = 8,
    BIO_QOS_THROTTLED = 9,
    BIO_QOS_MERGED = 10,
    BIO_REMAPPED = 11,
    BIO_ZONE_WRITE_PLUGGING = 12,
    BIO_EMULATES_ZONE_APPEND = 13,
    BIO_FLAG_LAST = 14,
};

enum {
    BLK_MQ_F_TAG_QUEUE_SHARED = 2,
    BLK_MQ_F_STACKING = 4,
    BLK_MQ_F_TAG_HCTX_SHARED = 8,
    BLK_MQ_F_BLOCKING = 16,
    BLK_MQ_F_TAG_RR = 32,
    BLK_MQ_F_NO_SCHED_BY_DEFAULT = 64,
    BLK_MQ_F_MAX = 128,
};

enum {
    BLK_MQ_NO_TAG = 4294967295,
    BLK_MQ_TAG_MIN = 1,
    BLK_MQ_TAG_MAX = 4294967294,
};

enum {
    BLK_MQ_REQ_NOWAIT = 1,
    BLK_MQ_REQ_RESERVED = 2,
    BLK_MQ_REQ_PM = 4,
};

enum {
    BLK_MQ_S_STOPPED = 0,
    BLK_MQ_S_TAG_ACTIVE = 1,
    BLK_MQ_S_SCHED_RESTART = 2,
    BLK_MQ_S_INACTIVE = 3,
    BLK_MQ_S_MAX = 4,
};

enum {
    BLK_MQ_UNIQUE_TAG_BITS = 16,
    BLK_MQ_UNIQUE_TAG_MASK = 65535,
};

enum {
    BLOCK_BITMAP = 0,
    INODE_BITMAP = 1,
    INODE_TABLE = 2,
    GROUP_TABLE_COUNT = 3,
};

enum {
    BPF_ADJ_ROOM_ENCAP_L2_MASK = 255,
    BPF_ADJ_ROOM_ENCAP_L2_SHIFT = 56,
};

enum {
    BPF_ANY = 0,
    BPF_NOEXIST = 1,
    BPF_EXIST = 2,
    BPF_F_LOCK = 4,
};

enum {
    BPF_CSUM_LEVEL_QUERY = 0,
    BPF_CSUM_LEVEL_INC = 1,
    BPF_CSUM_LEVEL_DEC = 2,
    BPF_CSUM_LEVEL_RESET = 3,
};

enum {
    BPF_FIB_LKUP_RET_SUCCESS = 0,
    BPF_FIB_LKUP_RET_BLACKHOLE = 1,
    BPF_FIB_LKUP_RET_UNREACHABLE = 2,
    BPF_FIB_LKUP_RET_PROHIBIT = 3,
    BPF_FIB_LKUP_RET_NOT_FWDED = 4,
    BPF_FIB_LKUP_RET_FWD_DISABLED = 5,
    BPF_FIB_LKUP_RET_UNSUPP_LWT = 6,
    BPF_FIB_LKUP_RET_NO_NEIGH = 7,
    BPF_FIB_LKUP_RET_FRAG_NEEDED = 8,
    BPF_FIB_LKUP_RET_NO_SRC_ADDR = 9,
};

enum {
    BPF_FIB_LOOKUP_DIRECT = 1,
    BPF_FIB_LOOKUP_OUTPUT = 2,
    BPF_FIB_LOOKUP_SKIP_NEIGH = 4,
    BPF_FIB_LOOKUP_TBID = 8,
    BPF_FIB_LOOKUP_SRC = 16,
    BPF_FIB_LOOKUP_MARK = 32,
};

enum {
    BPF_FLOW_DISSECTOR_F_PARSE_1ST_FRAG = 1,
    BPF_FLOW_DISSECTOR_F_STOP_AT_FLOW_LABEL = 2,
    BPF_FLOW_DISSECTOR_F_STOP_AT_ENCAP = 4,
};

enum {
    BPF_F_ADJ_ROOM_FIXED_GSO = 1,
    BPF_F_ADJ_ROOM_ENCAP_L3_IPV4 = 2,
    BPF_F_ADJ_ROOM_ENCAP_L3_IPV6 = 4,
    BPF_F_ADJ_ROOM_ENCAP_L4_GRE = 8,
    BPF_F_ADJ_ROOM_ENCAP_L4_UDP = 16,
    BPF_F_ADJ_ROOM_NO_CSUM_RESET = 32,
    BPF_F_ADJ_ROOM_ENCAP_L2_ETH = 64,
    BPF_F_ADJ_ROOM_DECAP_L3_IPV4 = 128,
    BPF_F_ADJ_ROOM_DECAP_L3_IPV6 = 256,
};

enum {
    BPF_F_CURRENT_NETNS = -1,
};

enum {
    BPF_F_GET_BRANCH_RECORDS_SIZE = 1,
};

enum {
    BPF_F_HDR_FIELD_MASK = 15,
};

enum {
    BPF_F_INDEX_MASK = 4294967295ULL,
    BPF_F_CURRENT_CPU = 4294967295ULL,
    BPF_F_CTXLEN_MASK = 4503595332403200ULL,
};

enum {
    BPF_F_INGRESS = 1,
    BPF_F_BROADCAST = 8,
    BPF_F_EXCLUDE_INGRESS = 16,
};

enum {
    BPF_F_KPROBE_MULTI_RETURN = 1,
};

enum {
    BPF_F_NEIGH = 65536,
    BPF_F_PEER = 131072,
    BPF_F_NEXTHOP = 262144,
};

enum {
    BPF_F_NO_PREALLOC = 1,
    BPF_F_NO_COMMON_LRU = 2,
    BPF_F_NUMA_NODE = 4,
    BPF_F_RDONLY = 8,
    BPF_F_WRONLY = 16,
    BPF_F_STACK_BUILD_ID = 32,
    BPF_F_ZERO_SEED = 64,
    BPF_F_RDONLY_PROG = 128,
    BPF_F_WRONLY_PROG = 256,
    BPF_F_CLONE = 512,
    BPF_F_MMAPABLE = 1024,
    BPF_F_PRESERVE_ELEMS = 2048,
    BPF_F_INNER_MAP = 4096,
    BPF_F_LINK = 8192,
    BPF_F_PATH_FD = 16384,
    BPF_F_VTYPE_BTF_OBJ_FD = 32768,
    BPF_F_TOKEN_FD = 65536,
    BPF_F_SEGV_ON_FAULT = 131072,
    BPF_F_NO_USER_CONV = 262144,
};

enum {
    BPF_F_PSEUDO_HDR = 16,
    BPF_F_MARK_MANGLED_0 = 32,
    BPF_F_MARK_ENFORCE = 64,
};

enum {
    BPF_F_RECOMPUTE_CSUM = 1,
    BPF_F_INVALIDATE_HASH = 2,
};

enum {
    BPF_F_SKIP_FIELD_MASK = 255,
    BPF_F_USER_STACK = 256,
    BPF_F_FAST_STACK_CMP = 512,
    BPF_F_REUSE_STACKID = 1024,
    BPF_F_USER_BUILD_ID = 2048,
};

enum {
    BPF_F_SYSCTL_BASE_NAME = 1,
};

enum {
    BPF_F_TIMER_ABS = 1,
    BPF_F_TIMER_CPU_PIN = 2,
};

enum {
    BPF_F_TUNINFO_FLAGS = 16,
};

enum {
    BPF_F_TUNINFO_IPV6 = 1,
};

enum {
    BPF_F_UPROBE_MULTI_RETURN = 1,
};

enum {
    BPF_F_ZERO_CSUM_TX = 2,
    BPF_F_DONT_FRAGMENT = 4,
    BPF_F_SEQ_NUMBER = 8,
    BPF_F_NO_TUNNEL_KEY = 16,
};

enum {
    BPF_LOAD_HDR_OPT_TCP_SYN = 1,
};

enum {
    BPF_LOCAL_STORAGE_GET_F_CREATE = 1,
    BPF_SK_STORAGE_GET_F_CREATE = 1,
};

enum {
    BPF_MAX_LOOPS = 8388608,
};

enum {
    BPF_MAX_TRAMP_LINKS = 38,
};

enum {
    BPF_RB_AVAIL_DATA = 0,
    BPF_RB_RING_SIZE = 1,
    BPF_RB_CONS_POS = 2,
    BPF_RB_PROD_POS = 3,
};

enum {
    BPF_RB_NO_WAKEUP = 1,
    BPF_RB_FORCE_WAKEUP = 2,
};

enum {
    BPF_REG_0 = 0,
    BPF_REG_1 = 1,
    BPF_REG_2 = 2,
    BPF_REG_3 = 3,
    BPF_REG_4 = 4,
    BPF_REG_5 = 5,
    BPF_REG_6 = 6,
    BPF_REG_7 = 7,
    BPF_REG_8 = 8,
    BPF_REG_9 = 9,
    BPF_REG_10 = 10,
    __MAX_BPF_REG = 11,
};

enum {
    BPF_RINGBUF_BUSY_BIT = 2147483648,
    BPF_RINGBUF_DISCARD_BIT = 1073741824,
    BPF_RINGBUF_HDR_SZ = 8,
};

enum {
    BPF_SKB_TSTAMP_UNSPEC = 0,
    BPF_SKB_TSTAMP_DELIVERY_MONO = 1,
    BPF_SKB_CLOCK_REALTIME = 0,
    BPF_SKB_CLOCK_MONOTONIC = 1,
    BPF_SKB_CLOCK_TAI = 2,
};

enum {
    BPF_SK_LOOKUP_F_REPLACE = 1,
    BPF_SK_LOOKUP_F_NO_REUSEPORT = 2,
};

enum {
    BPF_SOCK_OPS_RTO_CB_FLAG = 1,
    BPF_SOCK_OPS_RETRANS_CB_FLAG = 2,
    BPF_SOCK_OPS_STATE_CB_FLAG = 4,
    BPF_SOCK_OPS_RTT_CB_FLAG = 8,
    BPF_SOCK_OPS_PARSE_ALL_HDR_OPT_CB_FLAG = 16,
    BPF_SOCK_OPS_PARSE_UNKNOWN_HDR_OPT_CB_FLAG = 32,
    BPF_SOCK_OPS_WRITE_HDR_OPT_CB_FLAG = 64,
    BPF_SOCK_OPS_ALL_CB_FLAGS = 127,
};

enum {
    BPF_SOCK_OPS_VOID = 0,
    BPF_SOCK_OPS_TIMEOUT_INIT = 1,
    BPF_SOCK_OPS_RWND_INIT = 2,
    BPF_SOCK_OPS_TCP_CONNECT_CB = 3,
    BPF_SOCK_OPS_ACTIVE_ESTABLISHED_CB = 4,
    BPF_SOCK_OPS_PASSIVE_ESTABLISHED_CB = 5,
    BPF_SOCK_OPS_NEEDS_ECN = 6,
    BPF_SOCK_OPS_BASE_RTT = 7,
    BPF_SOCK_OPS_RTO_CB = 8,
    BPF_SOCK_OPS_RETRANS_CB = 9,
    BPF_SOCK_OPS_STATE_CB = 10,
    BPF_SOCK_OPS_TCP_LISTEN_CB = 11,
    BPF_SOCK_OPS_RTT_CB = 12,
    BPF_SOCK_OPS_PARSE_HDR_OPT_CB = 13,
    BPF_SOCK_OPS_HDR_OPT_LEN_CB = 14,
    BPF_SOCK_OPS_WRITE_HDR_OPT_CB = 15,
};

enum {
    BPF_TASK_ITER_ALL_PROCS = 0,
    BPF_TASK_ITER_ALL_THREADS = 1,
    BPF_TASK_ITER_PROC_THREADS = 2,
};

enum {
    BPF_TCP_ESTABLISHED = 1,
    BPF_TCP_SYN_SENT = 2,
    BPF_TCP_SYN_RECV = 3,
    BPF_TCP_FIN_WAIT1 = 4,
    BPF_TCP_FIN_WAIT2 = 5,
    BPF_TCP_TIME_WAIT = 6,
    BPF_TCP_CLOSE = 7,
    BPF_TCP_CLOSE_WAIT = 8,
    BPF_TCP_LAST_ACK = 9,
    BPF_TCP_LISTEN = 10,
    BPF_TCP_CLOSING = 11,
    BPF_TCP_NEW_SYN_RECV = 12,
    BPF_TCP_BOUND_INACTIVE = 13,
    BPF_TCP_MAX_STATES = 14,
};

enum {
    BPF_WRITE_HDR_TCP_CURRENT_MSS = 1,
    BPF_WRITE_HDR_TCP_SYNACK_COOKIE = 2,
};

enum {
    BPF_XFRM_STATE_OPTS_SZ = 36,
};

enum {
    BR_MCAST_DIR_RX = 0,
    BR_MCAST_DIR_TX = 1,
    BR_MCAST_DIR_SIZE = 2,
};

enum {
    BTF_FIELDS_MAX = 11,
};

enum {
    BTF_FIELD_IGNORE = 0,
    BTF_FIELD_FOUND = 1,
};

enum {
    BTF_F_COMPACT = 1,
    BTF_F_NONAME = 2,
    BTF_F_PTR_RAW = 4,
    BTF_F_ZERO = 8,
};

enum {
    BTF_KFUNC_SET_MAX_CNT = 256,
    BTF_DTOR_KFUNC_MAX_CNT = 256,
    BTF_KFUNC_FILTER_MAX_CNT = 16,
};

enum {
    BTF_KIND_UNKN = 0,
    BTF_KIND_INT = 1,
    BTF_KIND_PTR = 2,
    BTF_KIND_ARRAY = 3,
    BTF_KIND_STRUCT = 4,
    BTF_KIND_UNION = 5,
    BTF_KIND_ENUM = 6,
    BTF_KIND_FWD = 7,
    BTF_KIND_TYPEDEF = 8,
    BTF_KIND_VOLATILE = 9,
    BTF_KIND_CONST = 10,
    BTF_KIND_RESTRICT = 11,
    BTF_KIND_FUNC = 12,
    BTF_KIND_FUNC_PROTO = 13,
    BTF_KIND_VAR = 14,
    BTF_KIND_DATASEC = 15,
    BTF_KIND_FLOAT = 16,
    BTF_KIND_DECL_TAG = 17,
    BTF_KIND_TYPE_TAG = 18,
    BTF_KIND_ENUM64 = 19,
    NR_BTF_KINDS = 20,
    BTF_KIND_MAX = 19,
};

enum {
    BTF_MODULE_F_LIVE = 1,
};

enum {
    BTF_SOCK_TYPE_INET = 0,
    BTF_SOCK_TYPE_INET_CONN = 1,
    BTF_SOCK_TYPE_INET_REQ = 2,
    BTF_SOCK_TYPE_INET_TW = 3,
    BTF_SOCK_TYPE_REQ = 4,
    BTF_SOCK_TYPE_SOCK = 5,
    BTF_SOCK_TYPE_SOCK_COMMON = 6,
    BTF_SOCK_TYPE_TCP = 7,
    BTF_SOCK_TYPE_TCP_REQ = 8,
    BTF_SOCK_TYPE_TCP_TW = 9,
    BTF_SOCK_TYPE_TCP6 = 10,
    BTF_SOCK_TYPE_UDP = 11,
    BTF_SOCK_TYPE_UDP6 = 12,
    BTF_SOCK_TYPE_UNIX = 13,
    BTF_SOCK_TYPE_MPTCP = 14,
    BTF_SOCK_TYPE_SOCKET = 15,
    MAX_BTF_SOCK_TYPE = 16,
};

enum {
    BTF_TRACING_TYPE_TASK = 0,
    BTF_TRACING_TYPE_FILE = 1,
    BTF_TRACING_TYPE_VMA = 2,
    MAX_BTF_TRACING_TYPE = 3,
};

enum {
    BTF_VAR_STATIC = 0,
    BTF_VAR_GLOBAL_ALLOCATED = 1,
    BTF_VAR_GLOBAL_EXTERN = 2,
};

enum {
    Blktrace_setup = 1,
    Blktrace_running = 2,
    Blktrace_stopped = 3,
};

enum {
    CAP_HWCAP = 1,
    CAP_COMPAT_HWCAP = 2,
    CAP_COMPAT_HWCAP2 = 3,
};

enum {
    CFTYPE_ONLY_ON_ROOT = 1,
    CFTYPE_NOT_ON_ROOT = 2,
    CFTYPE_NS_DELEGATABLE = 4,
    CFTYPE_NO_PREFIX = 8,
    CFTYPE_WORLD_WRITABLE = 16,
    CFTYPE_DEBUG = 32,
    __CFTYPE_ONLY_ON_DFL = 65536,
    __CFTYPE_NOT_ON_DFL = 131072,
    __CFTYPE_ADDED = 262144,
};

enum {
    CGROUPSTATS_CMD_ATTR_UNSPEC = 0,
    CGROUPSTATS_CMD_ATTR_FD = 1,
    __CGROUPSTATS_CMD_ATTR_MAX = 2,
};

enum {
    CGROUPSTATS_CMD_UNSPEC = 3,
    CGROUPSTATS_CMD_GET = 4,
    CGROUPSTATS_CMD_NEW = 5,
    __CGROUPSTATS_CMD_MAX = 6,
};

enum {
    CGROUPSTATS_TYPE_UNSPEC = 0,
    CGROUPSTATS_TYPE_CGROUP_STATS = 1,
    __CGROUPSTATS_TYPE_MAX = 2,
};

enum {
    CGRP_NOTIFY_ON_RELEASE = 0,
    CGRP_CPUSET_CLONE_CHILDREN = 1,
    CGRP_FREEZE = 2,
    CGRP_FROZEN = 3,
};

enum {
    CGRP_ROOT_NOPREFIX = 2,
    CGRP_ROOT_XATTR = 4,
    CGRP_ROOT_NS_DELEGATE = 8,
    CGRP_ROOT_FAVOR_DYNMODS = 16,
    CGRP_ROOT_CPUSET_V2_MODE = 65536,
    CGRP_ROOT_MEMORY_LOCAL_EVENTS = 131072,
    CGRP_ROOT_MEMORY_RECURSIVE_PROT = 262144,
    CGRP_ROOT_MEMORY_HUGETLB_ACCOUNTING = 524288,
    CGRP_ROOT_PIDS_LOCAL_EVENTS = 1048576,
};

enum {
    CMIS_MODULE_LOW_PWR = 1,
    CMIS_MODULE_READY = 3,
};

enum {
    CRNG_EMPTY = 0,
    CRNG_EARLY = 1,
    CRNG_READY = 2,
};

enum {
    CRNG_RESEED_START_INTERVAL = 1000,
    CRNG_RESEED_INTERVAL = 60000,
};

enum {
    CRYPTOA_UNSPEC = 0,
    CRYPTOA_ALG = 1,
    CRYPTOA_TYPE = 2,
    __CRYPTOA_MAX = 3,
};

enum {
    CRYPTO_KPP_SECRET_TYPE_UNKNOWN = 0,
    CRYPTO_KPP_SECRET_TYPE_DH = 1,
    CRYPTO_KPP_SECRET_TYPE_ECDH = 2,
};

enum {
    CRYPTO_MSG_ALG_REQUEST = 0,
    CRYPTO_MSG_ALG_REGISTER = 1,
    CRYPTO_MSG_ALG_LOADED = 2,
};

enum {
    CSD_FLAG_LOCK = 1,
    IRQ_WORK_PENDING = 1,
    IRQ_WORK_BUSY = 2,
    IRQ_WORK_LAZY = 4,
    IRQ_WORK_HARD_IRQ = 8,
    IRQ_WORK_CLAIMED = 3,
    CSD_TYPE_ASYNC = 0,
    CSD_TYPE_SYNC = 16,
    CSD_TYPE_IRQ_WORK = 32,
    CSD_TYPE_TTWU = 48,
    CSD_FLAG_TYPE_MASK = 240,
};

enum {
    CSI_DEC_hl_CURSOR_KEYS = 1,
    CSI_DEC_hl_132_COLUMNS = 3,
    CSI_DEC_hl_REVERSE_VIDEO = 5,
    CSI_DEC_hl_ORIGIN_MODE = 6,
    CSI_DEC_hl_AUTOWRAP = 7,
    CSI_DEC_hl_AUTOREPEAT = 8,
    CSI_DEC_hl_MOUSE_X10 = 9,
    CSI_DEC_hl_SHOW_CURSOR = 25,
    CSI_DEC_hl_MOUSE_VT200 = 1000,
};

enum {
    CSI_K_CURSOR_TO_LINEEND = 0,
    CSI_K_LINESTART_TO_CURSOR = 1,
    CSI_K_LINE = 2,
};

enum {
    CSI_hl_DISPLAY_CTRL = 3,
    CSI_hl_INSERT = 4,
    CSI_hl_AUTO_NL = 20,
};

enum {
    CSI_m_DEFAULT = 0,
    CSI_m_BOLD = 1,
    CSI_m_HALF_BRIGHT = 2,
    CSI_m_ITALIC = 3,
    CSI_m_UNDERLINE = 4,
    CSI_m_BLINK = 5,
    CSI_m_REVERSE = 7,
    CSI_m_PRI_FONT = 10,
    CSI_m_ALT_FONT1 = 11,
    CSI_m_ALT_FONT2 = 12,
    CSI_m_DOUBLE_UNDERLINE = 21,
    CSI_m_NORMAL_INTENSITY = 22,
    CSI_m_NO_ITALIC = 23,
    CSI_m_NO_UNDERLINE = 24,
    CSI_m_NO_BLINK = 25,
    CSI_m_NO_REVERSE = 27,
    CSI_m_FG_COLOR_BEG = 30,
    CSI_m_FG_COLOR_END = 37,
    CSI_m_FG_COLOR = 38,
    CSI_m_DEFAULT_FG_COLOR = 39,
    CSI_m_BG_COLOR_BEG = 40,
    CSI_m_BG_COLOR_END = 47,
    CSI_m_BG_COLOR = 48,
    CSI_m_DEFAULT_BG_COLOR = 49,
    CSI_m_BRIGHT_FG_COLOR_BEG = 90,
    CSI_m_BRIGHT_FG_COLOR_END = 97,
    CSI_m_BRIGHT_FG_COLOR_OFF = 60,
    CSI_m_BRIGHT_BG_COLOR_BEG = 100,
    CSI_m_BRIGHT_BG_COLOR_END = 107,
    CSI_m_BRIGHT_BG_COLOR_OFF = 60,
};

enum {
    CSS_NO_REF = 1,
    CSS_ONLINE = 2,
    CSS_RELEASED = 4,
    CSS_VISIBLE = 8,
    CSS_DYING = 16,
};

enum {
    CSS_TASK_ITER_PROCS = 1,
    CSS_TASK_ITER_THREADED = 2,
    CSS_TASK_ITER_SKIPPED = 65536,
};

enum {
    CTRL_ATTR_MCAST_GRP_UNSPEC = 0,
    CTRL_ATTR_MCAST_GRP_NAME = 1,
    CTRL_ATTR_MCAST_GRP_ID = 2,
    __CTRL_ATTR_MCAST_GRP_MAX = 3,
};

enum {
    CTRL_ATTR_OP_UNSPEC = 0,
    CTRL_ATTR_OP_ID = 1,
    CTRL_ATTR_OP_FLAGS = 2,
    __CTRL_ATTR_OP_MAX = 3,
};

enum {
    CTRL_ATTR_POLICY_UNSPEC = 0,
    CTRL_ATTR_POLICY_DO = 1,
    CTRL_ATTR_POLICY_DUMP = 2,
    __CTRL_ATTR_POLICY_DUMP_MAX = 3,
    CTRL_ATTR_POLICY_DUMP_MAX = 2,
};

enum {
    CTRL_ATTR_UNSPEC = 0,
    CTRL_ATTR_FAMILY_ID = 1,
    CTRL_ATTR_FAMILY_NAME = 2,
    CTRL_ATTR_VERSION = 3,
    CTRL_ATTR_HDRSIZE = 4,
    CTRL_ATTR_MAXATTR = 5,
    CTRL_ATTR_OPS = 6,
    CTRL_ATTR_MCAST_GROUPS = 7,
    CTRL_ATTR_POLICY = 8,
    CTRL_ATTR_OP_POLICY = 9,
    CTRL_ATTR_OP = 10,
    __CTRL_ATTR_MAX = 11,
};

enum {
    CTRL_CMD_UNSPEC = 0,
    CTRL_CMD_NEWFAMILY = 1,
    CTRL_CMD_DELFAMILY = 2,
    CTRL_CMD_GETFAMILY = 3,
    CTRL_CMD_NEWOPS = 4,
    CTRL_CMD_DELOPS = 5,
    CTRL_CMD_GETOPS = 6,
    CTRL_CMD_NEWMCAST_GRP = 7,
    CTRL_CMD_DELMCAST_GRP = 8,
    CTRL_CMD_GETMCAST_GRP = 9,
    CTRL_CMD_GETPOLICY = 10,
    __CTRL_CMD_MAX = 11,
};

enum {
    DAD_PROCESS = 0,
    DAD_BEGIN = 1,
    DAD_ABORT = 2,
};

enum {
    DD_DIR_COUNT = 2,
};

enum {
    DD_PRIO_COUNT = 3,
};

enum {
    DEBUG_ENTRIES = 0,
    DEBUG_SLOT_HANDLER_COUNT = 1,
    DEBUG_SLOT_HANDLER_LINE = 2,
    DEBUG_PARSE_LINE = 3,
    DEBUG_PARSE_HEADER = 4,
    DEBUG_PARSE_MSGID = 5,
    DEBUG_AWAIT_COMPLETION_LINE = 6,
    DEBUG_DEQUEUE_MESSAGE_LINE = 7,
    DEBUG_SERVICE_CALLBACK_LINE = 8,
    DEBUG_MSG_QUEUE_FULL_COUNT = 9,
    DEBUG_COMPLETION_QUEUE_FULL_COUNT = 10,
    DEBUG_MAX = 11,
};

enum {
    DEVCONF_FORWARDING = 0,
    DEVCONF_HOPLIMIT = 1,
    DEVCONF_MTU6 = 2,
    DEVCONF_ACCEPT_RA = 3,
    DEVCONF_ACCEPT_REDIRECTS = 4,
    DEVCONF_AUTOCONF = 5,
    DEVCONF_DAD_TRANSMITS = 6,
    DEVCONF_RTR_SOLICITS = 7,
    DEVCONF_RTR_SOLICIT_INTERVAL = 8,
    DEVCONF_RTR_SOLICIT_DELAY = 9,
    DEVCONF_USE_TEMPADDR = 10,
    DEVCONF_TEMP_VALID_LFT = 11,
    DEVCONF_TEMP_PREFERED_LFT = 12,
    DEVCONF_REGEN_MAX_RETRY = 13,
    DEVCONF_MAX_DESYNC_FACTOR = 14,
    DEVCONF_MAX_ADDRESSES = 15,
    DEVCONF_FORCE_MLD_VERSION = 16,
    DEVCONF_ACCEPT_RA_DEFRTR = 17,
    DEVCONF_ACCEPT_RA_PINFO = 18,
    DEVCONF_ACCEPT_RA_RTR_PREF = 19,
    DEVCONF_RTR_PROBE_INTERVAL = 20,
    DEVCONF_ACCEPT_RA_RT_INFO_MAX_PLEN = 21,
    DEVCONF_PROXY_NDP = 22,
    DEVCONF_OPTIMISTIC_DAD = 23,
    DEVCONF_ACCEPT_SOURCE_ROUTE = 24,
    DEVCONF_MC_FORWARDING = 25,
    DEVCONF_DISABLE_IPV6 = 26,
    DEVCONF_ACCEPT_DAD = 27,
    DEVCONF_FORCE_TLLAO = 28,
    DEVCONF_NDISC_NOTIFY = 29,
    DEVCONF_MLDV1_UNSOLICITED_REPORT_INTERVAL = 30,
    DEVCONF_MLDV2_UNSOLICITED_REPORT_INTERVAL = 31,
    DEVCONF_SUPPRESS_FRAG_NDISC = 32,
    DEVCONF_ACCEPT_RA_FROM_LOCAL = 33,
    DEVCONF_USE_OPTIMISTIC = 34,
    DEVCONF_ACCEPT_RA_MTU = 35,
    DEVCONF_STABLE_SECRET = 36,
    DEVCONF_USE_OIF_ADDRS_ONLY = 37,
    DEVCONF_ACCEPT_RA_MIN_HOP_LIMIT = 38,
    DEVCONF_IGNORE_ROUTES_WITH_LINKDOWN = 39,
    DEVCONF_DROP_UNICAST_IN_L2_MULTICAST = 40,
    DEVCONF_DROP_UNSOLICITED_NA = 41,
    DEVCONF_KEEP_ADDR_ON_DOWN = 42,
    DEVCONF_RTR_SOLICIT_MAX_INTERVAL = 43,
    DEVCONF_SEG6_ENABLED = 44,
    DEVCONF_SEG6_REQUIRE_HMAC = 45,
    DEVCONF_ENHANCED_DAD = 46,
    DEVCONF_ADDR_GEN_MODE = 47,
    DEVCONF_DISABLE_POLICY = 48,
    DEVCONF_ACCEPT_RA_RT_INFO_MIN_PLEN = 49,
    DEVCONF_NDISC_TCLASS = 50,
    DEVCONF_RPL_SEG_ENABLED = 51,
    DEVCONF_RA_DEFRTR_METRIC = 52,
    DEVCONF_IOAM6_ENABLED = 53,
    DEVCONF_IOAM6_ID = 54,
    DEVCONF_IOAM6_ID_WIDE = 55,
    DEVCONF_NDISC_EVICT_NOCARRIER = 56,
    DEVCONF_ACCEPT_UNTRACKED_NA = 57,
    DEVCONF_ACCEPT_RA_MIN_LFT = 58,
    DEVCONF_MAX = 59,
};

enum {
    DEVLINK_ATTR_STATS_RX_PACKETS = 0,
    DEVLINK_ATTR_STATS_RX_BYTES = 1,
    DEVLINK_ATTR_STATS_RX_DROPPED = 2,
    __DEVLINK_ATTR_STATS_MAX = 3,
    DEVLINK_ATTR_STATS_MAX = 2,
};

enum {
    DEVLINK_ATTR_TRAP_METADATA_TYPE_IN_PORT = 0,
    DEVLINK_ATTR_TRAP_METADATA_TYPE_FA_COOKIE = 1,
};

enum {
    DIO_LOCKING = 1,
    DIO_SKIP_HOLES = 2,
};

enum {
    DIO_SHOULD_DIRTY = 1,
    DIO_IS_SYNC = 2,
};

enum {
    DIR_OFFSET_FIRST = 2,
    DIR_OFFSET_EOD = 2147483647,
};

enum {
    DIR_OFFSET_MIN = 3,
    DIR_OFFSET_MAX = 2147483646,
};

enum {
    DISCOVERED = 16,
    EXPLORED = 32,
    FALLTHROUGH = 1,
    BRANCH = 2,
};

enum {
    DISK_EVENT_FLAG_POLL = 1,
    DISK_EVENT_FLAG_UEVENT = 2,
    DISK_EVENT_FLAG_BLOCK_ON_EXCL_WRITE = 4,
};

enum {
    DISK_EVENT_MEDIA_CHANGE = 1,
    DISK_EVENT_EJECT_REQUEST = 2,
};

enum {
    DONE_EXPLORING = 0,
    KEEP_EXPLORING = 1,
};

enum {
    DPLL_NLGRP_MONITOR = 0,
};

enum {
    DQF_INFO_DIRTY_B = 17,
};

enum {
    DQF_ROOT_SQUASH_B = 0,
    DQF_SYS_FILE_B = 16,
    DQF_PRIVATE = 17,
};

enum {
    DQST_LOOKUPS = 0,
    DQST_DROPS = 1,
    DQST_READS = 2,
    DQST_WRITES = 3,
    DQST_CACHE_HITS = 4,
    DQST_ALLOC_DQUOTS = 5,
    DQST_FREE_DQUOTS = 6,
    DQST_SYNCS = 7,
    _DQST_DQSTAT_LAST = 8,
};

enum {
    DRV_FIXED = 0,
    DRV_GRP0 = 1,
    DRV_GRP1 = 2,
    DRV_GRP2 = 3,
    DRV_GRP3 = 4,
    DRV_GRP4 = 5,
    DRV_GRP_MAX = 6,
};

enum {
    DUMP_PREFIX_NONE = 0,
    DUMP_PREFIX_ADDRESS = 1,
    DUMP_PREFIX_OFFSET = 2,
};

enum {
    DWAXIDMAC_ARWLEN_1 = 0,
    DWAXIDMAC_ARWLEN_2 = 1,
    DWAXIDMAC_ARWLEN_4 = 3,
    DWAXIDMAC_ARWLEN_8 = 7,
    DWAXIDMAC_ARWLEN_16 = 15,
    DWAXIDMAC_ARWLEN_32 = 31,
    DWAXIDMAC_ARWLEN_64 = 63,
    DWAXIDMAC_ARWLEN_128 = 127,
    DWAXIDMAC_ARWLEN_256 = 255,
    DWAXIDMAC_ARWLEN_MIN = 0,
    DWAXIDMAC_ARWLEN_MAX = 255,
};

enum {
    DWAXIDMAC_BURST_TRANS_LEN_1 = 0,
    DWAXIDMAC_BURST_TRANS_LEN_4 = 1,
    DWAXIDMAC_BURST_TRANS_LEN_8 = 2,
    DWAXIDMAC_BURST_TRANS_LEN_16 = 3,
    DWAXIDMAC_BURST_TRANS_LEN_32 = 4,
    DWAXIDMAC_BURST_TRANS_LEN_64 = 5,
    DWAXIDMAC_BURST_TRANS_LEN_128 = 6,
    DWAXIDMAC_BURST_TRANS_LEN_256 = 7,
    DWAXIDMAC_BURST_TRANS_LEN_512 = 8,
    DWAXIDMAC_BURST_TRANS_LEN_1024 = 9,
};

enum {
    DWAXIDMAC_CH_CTL_L_INC = 0,
    DWAXIDMAC_CH_CTL_L_NOINC = 1,
};

enum {
    DWAXIDMAC_HS_SEL_HW = 0,
    DWAXIDMAC_HS_SEL_SW = 1,
};

enum {
    DWAXIDMAC_IRQ_NONE = 0,
    DWAXIDMAC_IRQ_BLOCK_TRF = 1,
    DWAXIDMAC_IRQ_DMA_TRF = 2,
    DWAXIDMAC_IRQ_SRC_TRAN = 8,
    DWAXIDMAC_IRQ_DST_TRAN = 16,
    DWAXIDMAC_IRQ_SRC_DEC_ERR = 32,
    DWAXIDMAC_IRQ_DST_DEC_ERR = 64,
    DWAXIDMAC_IRQ_SRC_SLV_ERR = 128,
    DWAXIDMAC_IRQ_DST_SLV_ERR = 256,
    DWAXIDMAC_IRQ_LLI_RD_DEC_ERR = 512,
    DWAXIDMAC_IRQ_LLI_WR_DEC_ERR = 1024,
    DWAXIDMAC_IRQ_LLI_RD_SLV_ERR = 2048,
    DWAXIDMAC_IRQ_LLI_WR_SLV_ERR = 4096,
    DWAXIDMAC_IRQ_INVALID_ERR = 8192,
    DWAXIDMAC_IRQ_MULTIBLKTYPE_ERR = 16384,
    DWAXIDMAC_IRQ_DEC_ERR = 65536,
    DWAXIDMAC_IRQ_WR2RO_ERR = 131072,
    DWAXIDMAC_IRQ_RD2RWO_ERR = 262144,
    DWAXIDMAC_IRQ_WRONCHEN_ERR = 524288,
    DWAXIDMAC_IRQ_SHADOWREG_ERR = 1048576,
    DWAXIDMAC_IRQ_WRONHOLD_ERR = 2097152,
    DWAXIDMAC_IRQ_LOCK_CLEARED = 134217728,
    DWAXIDMAC_IRQ_SRC_SUSPENDED = 268435456,
    DWAXIDMAC_IRQ_SUSPENDED = 536870912,
    DWAXIDMAC_IRQ_DISABLED = 1073741824,
    DWAXIDMAC_IRQ_ABORTED = 2147483648,
    DWAXIDMAC_IRQ_ALL_ERR = 4161504,
    DWAXIDMAC_IRQ_ALL = 4294967295,
};

enum {
    DWAXIDMAC_MBLK_TYPE_CONTIGUOUS = 0,
    DWAXIDMAC_MBLK_TYPE_RELOAD = 1,
    DWAXIDMAC_MBLK_TYPE_SHADOW_REG = 2,
    DWAXIDMAC_MBLK_TYPE_LL = 3,
};

enum {
    DWAXIDMAC_TRANS_WIDTH_8 = 0,
    DWAXIDMAC_TRANS_WIDTH_16 = 1,
    DWAXIDMAC_TRANS_WIDTH_32 = 2,
    DWAXIDMAC_TRANS_WIDTH_64 = 3,
    DWAXIDMAC_TRANS_WIDTH_128 = 4,
    DWAXIDMAC_TRANS_WIDTH_256 = 5,
    DWAXIDMAC_TRANS_WIDTH_512 = 6,
    DWAXIDMAC_TRANS_WIDTH_MAX = 6,
};

enum {
    DWAXIDMAC_TT_FC_MEM_TO_MEM_DMAC = 0,
    DWAXIDMAC_TT_FC_MEM_TO_PER_DMAC = 1,
    DWAXIDMAC_TT_FC_PER_TO_MEM_DMAC = 2,
    DWAXIDMAC_TT_FC_PER_TO_PER_DMAC = 3,
    DWAXIDMAC_TT_FC_PER_TO_MEM_SRC = 4,
    DWAXIDMAC_TT_FC_PER_TO_PER_SRC = 5,
    DWAXIDMAC_TT_FC_MEM_TO_PER_DST = 6,
    DWAXIDMAC_TT_FC_PER_TO_PER_DST = 7,
};

enum {
    EPecma = 0,
    EPdec = 1,
    EPeq = 2,
    EPgt = 3,
    EPlt = 4,
};

enum {
    ERASE = 0,
    WERASE = 1,
    KILL = 2,
};

enum {
    ES_WRITTEN_B = 0,
    ES_UNWRITTEN_B = 1,
    ES_DELAYED_B = 2,
    ES_HOLE_B = 3,
    ES_REFERENCED_B = 4,
    ES_FLAGS = 5,
};

enum {
    ETHTOOL_A_BITSET_BITS_UNSPEC = 0,
    ETHTOOL_A_BITSET_BITS_BIT = 1,
    __ETHTOOL_A_BITSET_BITS_CNT = 2,
    ETHTOOL_A_BITSET_BITS_MAX = 1,
};

enum {
    ETHTOOL_A_BITSET_BIT_UNSPEC = 0,
    ETHTOOL_A_BITSET_BIT_INDEX = 1,
    ETHTOOL_A_BITSET_BIT_NAME = 2,
    ETHTOOL_A_BITSET_BIT_VALUE = 3,
    __ETHTOOL_A_BITSET_BIT_CNT = 4,
    ETHTOOL_A_BITSET_BIT_MAX = 3,
};

enum {
    ETHTOOL_A_BITSET_UNSPEC = 0,
    ETHTOOL_A_BITSET_NOMASK = 1,
    ETHTOOL_A_BITSET_SIZE = 2,
    ETHTOOL_A_BITSET_BITS = 3,
    ETHTOOL_A_BITSET_VALUE = 4,
    ETHTOOL_A_BITSET_MASK = 5,
    __ETHTOOL_A_BITSET_CNT = 6,
    ETHTOOL_A_BITSET_MAX = 5,
};

enum {
    ETHTOOL_A_C33_PSE_PW_LIMIT_UNSPEC = 0,
    ETHTOOL_A_C33_PSE_PW_LIMIT_MIN = 1,
    ETHTOOL_A_C33_PSE_PW_LIMIT_MAX = 2,
    __ETHTOOL_A_C33_PSE_PW_LIMIT_CNT = 3,
    __ETHTOOL_A_C33_PSE_PW_LIMIT_MAX = 2,
};

enum {
    ETHTOOL_A_CABLE_AMPLITUDE_UNSPEC = 0,
    ETHTOOL_A_CABLE_AMPLITUDE_PAIR = 1,
    ETHTOOL_A_CABLE_AMPLITUDE_mV = 2,
    __ETHTOOL_A_CABLE_AMPLITUDE_CNT = 3,
    ETHTOOL_A_CABLE_AMPLITUDE_MAX = 2,
};

enum {
    ETHTOOL_A_CABLE_FAULT_LENGTH_UNSPEC = 0,
    ETHTOOL_A_CABLE_FAULT_LENGTH_PAIR = 1,
    ETHTOOL_A_CABLE_FAULT_LENGTH_CM = 2,
    ETHTOOL_A_CABLE_FAULT_LENGTH_SRC = 3,
    __ETHTOOL_A_CABLE_FAULT_LENGTH_CNT = 4,
    ETHTOOL_A_CABLE_FAULT_LENGTH_MAX = 3,
};

enum {
    ETHTOOL_A_CABLE_INF_SRC_UNSPEC = 0,
    ETHTOOL_A_CABLE_INF_SRC_TDR = 1,
    ETHTOOL_A_CABLE_INF_SRC_ALCD = 2,
};

enum {
    ETHTOOL_A_CABLE_NEST_UNSPEC = 0,
    ETHTOOL_A_CABLE_NEST_RESULT = 1,
    ETHTOOL_A_CABLE_NEST_FAULT_LENGTH = 2,
    __ETHTOOL_A_CABLE_NEST_CNT = 3,
    ETHTOOL_A_CABLE_NEST_MAX = 2,
};

enum {
    ETHTOOL_A_CABLE_PAIR_A = 0,
    ETHTOOL_A_CABLE_PAIR_B = 1,
    ETHTOOL_A_CABLE_PAIR_C = 2,
    ETHTOOL_A_CABLE_PAIR_D = 3,
};

enum {
    ETHTOOL_A_CABLE_PULSE_UNSPEC = 0,
    ETHTOOL_A_CABLE_PULSE_mV = 1,
    __ETHTOOL_A_CABLE_PULSE_CNT = 2,
    ETHTOOL_A_CABLE_PULSE_MAX = 1,
};

enum {
    ETHTOOL_A_CABLE_RESULT_CODE_UNSPEC = 0,
    ETHTOOL_A_CABLE_RESULT_CODE_OK = 1,
    ETHTOOL_A_CABLE_RESULT_CODE_OPEN = 2,
    ETHTOOL_A_CABLE_RESULT_CODE_SAME_SHORT = 3,
    ETHTOOL_A_CABLE_RESULT_CODE_CROSS_SHORT = 4,
    ETHTOOL_A_CABLE_RESULT_CODE_IMPEDANCE_MISMATCH = 5,
    ETHTOOL_A_CABLE_RESULT_CODE_NOISE = 6,
    ETHTOOL_A_CABLE_RESULT_CODE_RESOLUTION_NOT_POSSIBLE = 7,
};

enum {
    ETHTOOL_A_CABLE_RESULT_UNSPEC = 0,
    ETHTOOL_A_CABLE_RESULT_PAIR = 1,
    ETHTOOL_A_CABLE_RESULT_CODE = 2,
    ETHTOOL_A_CABLE_RESULT_SRC = 3,
    __ETHTOOL_A_CABLE_RESULT_CNT = 4,
    ETHTOOL_A_CABLE_RESULT_MAX = 3,
};

enum {
    ETHTOOL_A_CABLE_STEP_UNSPEC = 0,
    ETHTOOL_A_CABLE_STEP_FIRST_DISTANCE = 1,
    ETHTOOL_A_CABLE_STEP_LAST_DISTANCE = 2,
    ETHTOOL_A_CABLE_STEP_STEP_DISTANCE = 3,
    __ETHTOOL_A_CABLE_STEP_CNT = 4,
    ETHTOOL_A_CABLE_STEP_MAX = 3,
};

enum {
    ETHTOOL_A_CABLE_TDR_NEST_UNSPEC = 0,
    ETHTOOL_A_CABLE_TDR_NEST_STEP = 1,
    ETHTOOL_A_CABLE_TDR_NEST_AMPLITUDE = 2,
    ETHTOOL_A_CABLE_TDR_NEST_PULSE = 3,
    __ETHTOOL_A_CABLE_TDR_NEST_CNT = 4,
    ETHTOOL_A_CABLE_TDR_NEST_MAX = 3,
};

enum {
    ETHTOOL_A_CABLE_TEST_NTF_STATUS_UNSPEC = 0,
    ETHTOOL_A_CABLE_TEST_NTF_STATUS_STARTED = 1,
    ETHTOOL_A_CABLE_TEST_NTF_STATUS_COMPLETED = 2,
};

enum {
    ETHTOOL_A_CABLE_TEST_NTF_UNSPEC = 0,
    ETHTOOL_A_CABLE_TEST_NTF_HEADER = 1,
    ETHTOOL_A_CABLE_TEST_NTF_STATUS = 2,
    ETHTOOL_A_CABLE_TEST_NTF_NEST = 3,
    __ETHTOOL_A_CABLE_TEST_NTF_CNT = 4,
    ETHTOOL_A_CABLE_TEST_NTF_MAX = 3,
};

enum {
    ETHTOOL_A_CABLE_TEST_TDR_CFG_UNSPEC = 0,
    ETHTOOL_A_CABLE_TEST_TDR_CFG_FIRST = 1,
    ETHTOOL_A_CABLE_TEST_TDR_CFG_LAST = 2,
    ETHTOOL_A_CABLE_TEST_TDR_CFG_STEP = 3,
    ETHTOOL_A_CABLE_TEST_TDR_CFG_PAIR = 4,
    __ETHTOOL_A_CABLE_TEST_TDR_CFG_CNT = 5,
    ETHTOOL_A_CABLE_TEST_TDR_CFG_MAX = 4,
};

enum {
    ETHTOOL_A_CABLE_TEST_TDR_UNSPEC = 0,
    ETHTOOL_A_CABLE_TEST_TDR_HEADER = 1,
    ETHTOOL_A_CABLE_TEST_TDR_CFG = 2,
    __ETHTOOL_A_CABLE_TEST_TDR_CNT = 3,
    ETHTOOL_A_CABLE_TEST_TDR_MAX = 2,
};

enum {
    ETHTOOL_A_CABLE_TEST_UNSPEC = 0,
    ETHTOOL_A_CABLE_TEST_HEADER = 1,
    __ETHTOOL_A_CABLE_TEST_CNT = 2,
    ETHTOOL_A_CABLE_TEST_MAX = 1,
};

enum {
    ETHTOOL_A_CHANNELS_UNSPEC = 0,
    ETHTOOL_A_CHANNELS_HEADER = 1,
    ETHTOOL_A_CHANNELS_RX_MAX = 2,
    ETHTOOL_A_CHANNELS_TX_MAX = 3,
    ETHTOOL_A_CHANNELS_OTHER_MAX = 4,
    ETHTOOL_A_CHANNELS_COMBINED_MAX = 5,
    ETHTOOL_A_CHANNELS_RX_COUNT = 6,
    ETHTOOL_A_CHANNELS_TX_COUNT = 7,
    ETHTOOL_A_CHANNELS_OTHER_COUNT = 8,
    ETHTOOL_A_CHANNELS_COMBINED_COUNT = 9,
    __ETHTOOL_A_CHANNELS_CNT = 10,
    ETHTOOL_A_CHANNELS_MAX = 9,
};

enum {
    ETHTOOL_A_COALESCE_UNSPEC = 0,
    ETHTOOL_A_COALESCE_HEADER = 1,
    ETHTOOL_A_COALESCE_RX_USECS = 2,
    ETHTOOL_A_COALESCE_RX_MAX_FRAMES = 3,
    ETHTOOL_A_COALESCE_RX_USECS_IRQ = 4,
    ETHTOOL_A_COALESCE_RX_MAX_FRAMES_IRQ = 5,
    ETHTOOL_A_COALESCE_TX_USECS = 6,
    ETHTOOL_A_COALESCE_TX_MAX_FRAMES = 7,
    ETHTOOL_A_COALESCE_TX_USECS_IRQ = 8,
    ETHTOOL_A_COALESCE_TX_MAX_FRAMES_IRQ = 9,
    ETHTOOL_A_COALESCE_STATS_BLOCK_USECS = 10,
    ETHTOOL_A_COALESCE_USE_ADAPTIVE_RX = 11,
    ETHTOOL_A_COALESCE_USE_ADAPTIVE_TX = 12,
    ETHTOOL_A_COALESCE_PKT_RATE_LOW = 13,
    ETHTOOL_A_COALESCE_RX_USECS_LOW = 14,
    ETHTOOL_A_COALESCE_RX_MAX_FRAMES_LOW = 15,
    ETHTOOL_A_COALESCE_TX_USECS_LOW = 16,
    ETHTOOL_A_COALESCE_TX_MAX_FRAMES_LOW = 17,
    ETHTOOL_A_COALESCE_PKT_RATE_HIGH = 18,
    ETHTOOL_A_COALESCE_RX_USECS_HIGH = 19,
    ETHTOOL_A_COALESCE_RX_MAX_FRAMES_HIGH = 20,
    ETHTOOL_A_COALESCE_TX_USECS_HIGH = 21,
    ETHTOOL_A_COALESCE_TX_MAX_FRAMES_HIGH = 22,
    ETHTOOL_A_COALESCE_RATE_SAMPLE_INTERVAL = 23,
    ETHTOOL_A_COALESCE_USE_CQE_MODE_TX = 24,
    ETHTOOL_A_COALESCE_USE_CQE_MODE_RX = 25,
    ETHTOOL_A_COALESCE_TX_AGGR_MAX_BYTES = 26,
    ETHTOOL_A_COALESCE_TX_AGGR_MAX_FRAMES = 27,
    ETHTOOL_A_COALESCE_TX_AGGR_TIME_USECS = 28,
    ETHTOOL_A_COALESCE_RX_PROFILE = 29,
    ETHTOOL_A_COALESCE_TX_PROFILE = 30,
    __ETHTOOL_A_COALESCE_CNT = 31,
    ETHTOOL_A_COALESCE_MAX = 30,
};

enum {
    ETHTOOL_A_DEBUG_UNSPEC = 0,
    ETHTOOL_A_DEBUG_HEADER = 1,
    ETHTOOL_A_DEBUG_MSGMASK = 2,
    __ETHTOOL_A_DEBUG_CNT = 3,
    ETHTOOL_A_DEBUG_MAX = 2,
};

enum {
    ETHTOOL_A_EEE_UNSPEC = 0,
    ETHTOOL_A_EEE_HEADER = 1,
    ETHTOOL_A_EEE_MODES_OURS = 2,
    ETHTOOL_A_EEE_MODES_PEER = 3,
    ETHTOOL_A_EEE_ACTIVE = 4,
    ETHTOOL_A_EEE_ENABLED = 5,
    ETHTOOL_A_EEE_TX_LPI_ENABLED = 6,
    ETHTOOL_A_EEE_TX_LPI_TIMER = 7,
    __ETHTOOL_A_EEE_CNT = 8,
    ETHTOOL_A_EEE_MAX = 7,
};

enum {
    ETHTOOL_A_FEATURES_UNSPEC = 0,
    ETHTOOL_A_FEATURES_HEADER = 1,
    ETHTOOL_A_FEATURES_HW = 2,
    ETHTOOL_A_FEATURES_WANTED = 3,
    ETHTOOL_A_FEATURES_ACTIVE = 4,
    ETHTOOL_A_FEATURES_NOCHANGE = 5,
    __ETHTOOL_A_FEATURES_CNT = 6,
    ETHTOOL_A_FEATURES_MAX = 5,
};

enum {
    ETHTOOL_A_FEC_STAT_UNSPEC = 0,
    ETHTOOL_A_FEC_STAT_PAD = 1,
    ETHTOOL_A_FEC_STAT_CORRECTED = 2,
    ETHTOOL_A_FEC_STAT_UNCORR = 3,
    ETHTOOL_A_FEC_STAT_CORR_BITS = 4,
    __ETHTOOL_A_FEC_STAT_CNT = 5,
    ETHTOOL_A_FEC_STAT_MAX = 4,
};

enum {
    ETHTOOL_A_FEC_UNSPEC = 0,
    ETHTOOL_A_FEC_HEADER = 1,
    ETHTOOL_A_FEC_MODES = 2,
    ETHTOOL_A_FEC_AUTO = 3,
    ETHTOOL_A_FEC_ACTIVE = 4,
    ETHTOOL_A_FEC_STATS = 5,
    __ETHTOOL_A_FEC_CNT = 6,
    ETHTOOL_A_FEC_MAX = 5,
};

enum {
    ETHTOOL_A_HEADER_UNSPEC = 0,
    ETHTOOL_A_HEADER_DEV_INDEX = 1,
    ETHTOOL_A_HEADER_DEV_NAME = 2,
    ETHTOOL_A_HEADER_FLAGS = 3,
    ETHTOOL_A_HEADER_PHY_INDEX = 4,
    __ETHTOOL_A_HEADER_CNT = 5,
    ETHTOOL_A_HEADER_MAX = 4,
};

enum {
    ETHTOOL_A_IRQ_MODERATION_UNSPEC = 0,
    ETHTOOL_A_IRQ_MODERATION_USEC = 1,
    ETHTOOL_A_IRQ_MODERATION_PKTS = 2,
    ETHTOOL_A_IRQ_MODERATION_COMPS = 3,
    __ETHTOOL_A_IRQ_MODERATION_CNT = 4,
    ETHTOOL_A_IRQ_MODERATION_MAX = 3,
};

enum {
    ETHTOOL_A_LINKINFO_UNSPEC = 0,
    ETHTOOL_A_LINKINFO_HEADER = 1,
    ETHTOOL_A_LINKINFO_PORT = 2,
    ETHTOOL_A_LINKINFO_PHYADDR = 3,
    ETHTOOL_A_LINKINFO_TP_MDIX = 4,
    ETHTOOL_A_LINKINFO_TP_MDIX_CTRL = 5,
    ETHTOOL_A_LINKINFO_TRANSCEIVER = 6,
    __ETHTOOL_A_LINKINFO_CNT = 7,
    ETHTOOL_A_LINKINFO_MAX = 6,
};

enum {
    ETHTOOL_A_LINKMODES_UNSPEC = 0,
    ETHTOOL_A_LINKMODES_HEADER = 1,
    ETHTOOL_A_LINKMODES_AUTONEG = 2,
    ETHTOOL_A_LINKMODES_OURS = 3,
    ETHTOOL_A_LINKMODES_PEER = 4,
    ETHTOOL_A_LINKMODES_SPEED = 5,
    ETHTOOL_A_LINKMODES_DUPLEX = 6,
    ETHTOOL_A_LINKMODES_MASTER_SLAVE_CFG = 7,
    ETHTOOL_A_LINKMODES_MASTER_SLAVE_STATE = 8,
    ETHTOOL_A_LINKMODES_LANES = 9,
    ETHTOOL_A_LINKMODES_RATE_MATCHING = 10,
    __ETHTOOL_A_LINKMODES_CNT = 11,
    ETHTOOL_A_LINKMODES_MAX = 10,
};

enum {
    ETHTOOL_A_LINKSTATE_UNSPEC = 0,
    ETHTOOL_A_LINKSTATE_HEADER = 1,
    ETHTOOL_A_LINKSTATE_LINK = 2,
    ETHTOOL_A_LINKSTATE_SQI = 3,
    ETHTOOL_A_LINKSTATE_SQI_MAX = 4,
    ETHTOOL_A_LINKSTATE_EXT_STATE = 5,
    ETHTOOL_A_LINKSTATE_EXT_SUBSTATE = 6,
    ETHTOOL_A_LINKSTATE_EXT_DOWN_CNT = 7,
    __ETHTOOL_A_LINKSTATE_CNT = 8,
    ETHTOOL_A_LINKSTATE_MAX = 7,
};

enum {
    ETHTOOL_A_MM_STAT_UNSPEC = 0,
    ETHTOOL_A_MM_STAT_PAD = 1,
    ETHTOOL_A_MM_STAT_REASSEMBLY_ERRORS = 2,
    ETHTOOL_A_MM_STAT_SMD_ERRORS = 3,
    ETHTOOL_A_MM_STAT_REASSEMBLY_OK = 4,
    ETHTOOL_A_MM_STAT_RX_FRAG_COUNT = 5,
    ETHTOOL_A_MM_STAT_TX_FRAG_COUNT = 6,
    ETHTOOL_A_MM_STAT_HOLD_COUNT = 7,
    __ETHTOOL_A_MM_STAT_CNT = 8,
    ETHTOOL_A_MM_STAT_MAX = 7,
};

enum {
    ETHTOOL_A_MM_UNSPEC = 0,
    ETHTOOL_A_MM_HEADER = 1,
    ETHTOOL_A_MM_PMAC_ENABLED = 2,
    ETHTOOL_A_MM_TX_ENABLED = 3,
    ETHTOOL_A_MM_TX_ACTIVE = 4,
    ETHTOOL_A_MM_TX_MIN_FRAG_SIZE = 5,
    ETHTOOL_A_MM_RX_MIN_FRAG_SIZE = 6,
    ETHTOOL_A_MM_VERIFY_ENABLED = 7,
    ETHTOOL_A_MM_VERIFY_STATUS = 8,
    ETHTOOL_A_MM_VERIFY_TIME = 9,
    ETHTOOL_A_MM_MAX_VERIFY_TIME = 10,
    ETHTOOL_A_MM_STATS = 11,
    __ETHTOOL_A_MM_CNT = 12,
    ETHTOOL_A_MM_MAX = 11,
};

enum {
    ETHTOOL_A_MODULE_EEPROM_UNSPEC = 0,
    ETHTOOL_A_MODULE_EEPROM_HEADER = 1,
    ETHTOOL_A_MODULE_EEPROM_OFFSET = 2,
    ETHTOOL_A_MODULE_EEPROM_LENGTH = 3,
    ETHTOOL_A_MODULE_EEPROM_PAGE = 4,
    ETHTOOL_A_MODULE_EEPROM_BANK = 5,
    ETHTOOL_A_MODULE_EEPROM_I2C_ADDRESS = 6,
    ETHTOOL_A_MODULE_EEPROM_DATA = 7,
    __ETHTOOL_A_MODULE_EEPROM_CNT = 8,
    ETHTOOL_A_MODULE_EEPROM_MAX = 7,
};

enum {
    ETHTOOL_A_MODULE_FW_FLASH_UNSPEC = 0,
    ETHTOOL_A_MODULE_FW_FLASH_HEADER = 1,
    ETHTOOL_A_MODULE_FW_FLASH_FILE_NAME = 2,
    ETHTOOL_A_MODULE_FW_FLASH_PASSWORD = 3,
    ETHTOOL_A_MODULE_FW_FLASH_STATUS = 4,
    ETHTOOL_A_MODULE_FW_FLASH_STATUS_MSG = 5,
    ETHTOOL_A_MODULE_FW_FLASH_DONE = 6,
    ETHTOOL_A_MODULE_FW_FLASH_TOTAL = 7,
    __ETHTOOL_A_MODULE_FW_FLASH_CNT = 8,
    ETHTOOL_A_MODULE_FW_FLASH_MAX = 7,
};

enum {
    ETHTOOL_A_MODULE_UNSPEC = 0,
    ETHTOOL_A_MODULE_HEADER = 1,
    ETHTOOL_A_MODULE_POWER_MODE_POLICY = 2,
    ETHTOOL_A_MODULE_POWER_MODE = 3,
    __ETHTOOL_A_MODULE_CNT = 4,
    ETHTOOL_A_MODULE_MAX = 3,
};

enum {
    ETHTOOL_A_PAUSE_STAT_UNSPEC = 0,
    ETHTOOL_A_PAUSE_STAT_PAD = 1,
    ETHTOOL_A_PAUSE_STAT_TX_FRAMES = 2,
    ETHTOOL_A_PAUSE_STAT_RX_FRAMES = 3,
    __ETHTOOL_A_PAUSE_STAT_CNT = 4,
    ETHTOOL_A_PAUSE_STAT_MAX = 3,
};

enum {
    ETHTOOL_A_PAUSE_UNSPEC = 0,
    ETHTOOL_A_PAUSE_HEADER = 1,
    ETHTOOL_A_PAUSE_AUTONEG = 2,
    ETHTOOL_A_PAUSE_RX = 3,
    ETHTOOL_A_PAUSE_TX = 4,
    ETHTOOL_A_PAUSE_STATS = 5,
    ETHTOOL_A_PAUSE_STATS_SRC = 6,
    __ETHTOOL_A_PAUSE_CNT = 7,
    ETHTOOL_A_PAUSE_MAX = 6,
};

enum {
    ETHTOOL_A_PHC_VCLOCKS_UNSPEC = 0,
    ETHTOOL_A_PHC_VCLOCKS_HEADER = 1,
    ETHTOOL_A_PHC_VCLOCKS_NUM = 2,
    ETHTOOL_A_PHC_VCLOCKS_INDEX = 3,
    __ETHTOOL_A_PHC_VCLOCKS_CNT = 4,
    ETHTOOL_A_PHC_VCLOCKS_MAX = 3,
};

enum {
    ETHTOOL_A_PHY_UNSPEC = 0,
    ETHTOOL_A_PHY_HEADER = 1,
    ETHTOOL_A_PHY_INDEX = 2,
    ETHTOOL_A_PHY_DRVNAME = 3,
    ETHTOOL_A_PHY_NAME = 4,
    ETHTOOL_A_PHY_UPSTREAM_TYPE = 5,
    ETHTOOL_A_PHY_UPSTREAM_INDEX = 6,
    ETHTOOL_A_PHY_UPSTREAM_SFP_NAME = 7,
    ETHTOOL_A_PHY_DOWNSTREAM_SFP_NAME = 8,
    __ETHTOOL_A_PHY_CNT = 9,
    ETHTOOL_A_PHY_MAX = 8,
};

enum {
    ETHTOOL_A_PLCA_UNSPEC = 0,
    ETHTOOL_A_PLCA_HEADER = 1,
    ETHTOOL_A_PLCA_VERSION = 2,
    ETHTOOL_A_PLCA_ENABLED = 3,
    ETHTOOL_A_PLCA_STATUS = 4,
    ETHTOOL_A_PLCA_NODE_CNT = 5,
    ETHTOOL_A_PLCA_NODE_ID = 6,
    ETHTOOL_A_PLCA_TO_TMR = 7,
    ETHTOOL_A_PLCA_BURST_CNT = 8,
    ETHTOOL_A_PLCA_BURST_TMR = 9,
    __ETHTOOL_A_PLCA_CNT = 10,
    ETHTOOL_A_PLCA_MAX = 9,
};

enum {
    ETHTOOL_A_PRIVFLAGS_UNSPEC = 0,
    ETHTOOL_A_PRIVFLAGS_HEADER = 1,
    ETHTOOL_A_PRIVFLAGS_FLAGS = 2,
    __ETHTOOL_A_PRIVFLAGS_CNT = 3,
    ETHTOOL_A_PRIVFLAGS_MAX = 2,
};

enum {
    ETHTOOL_A_PROFILE_UNSPEC = 0,
    ETHTOOL_A_PROFILE_IRQ_MODERATION = 1,
    __ETHTOOL_A_PROFILE_CNT = 2,
    ETHTOOL_A_PROFILE_MAX = 1,
};

enum {
    ETHTOOL_A_PSE_UNSPEC = 0,
    ETHTOOL_A_PSE_HEADER = 1,
    ETHTOOL_A_PODL_PSE_ADMIN_STATE = 2,
    ETHTOOL_A_PODL_PSE_ADMIN_CONTROL = 3,
    ETHTOOL_A_PODL_PSE_PW_D_STATUS = 4,
    ETHTOOL_A_C33_PSE_ADMIN_STATE = 5,
    ETHTOOL_A_C33_PSE_ADMIN_CONTROL = 6,
    ETHTOOL_A_C33_PSE_PW_D_STATUS = 7,
    ETHTOOL_A_C33_PSE_PW_CLASS = 8,
    ETHTOOL_A_C33_PSE_ACTUAL_PW = 9,
    ETHTOOL_A_C33_PSE_EXT_STATE = 10,
    ETHTOOL_A_C33_PSE_EXT_SUBSTATE = 11,
    ETHTOOL_A_C33_PSE_AVAIL_PW_LIMIT = 12,
    ETHTOOL_A_C33_PSE_PW_LIMIT_RANGES = 13,
    __ETHTOOL_A_PSE_CNT = 14,
    ETHTOOL_A_PSE_MAX = 13,
};

enum {
    ETHTOOL_A_RINGS_UNSPEC = 0,
    ETHTOOL_A_RINGS_HEADER = 1,
    ETHTOOL_A_RINGS_RX_MAX = 2,
    ETHTOOL_A_RINGS_RX_MINI_MAX = 3,
    ETHTOOL_A_RINGS_RX_JUMBO_MAX = 4,
    ETHTOOL_A_RINGS_TX_MAX = 5,
    ETHTOOL_A_RINGS_RX = 6,
    ETHTOOL_A_RINGS_RX_MINI = 7,
    ETHTOOL_A_RINGS_RX_JUMBO = 8,
    ETHTOOL_A_RINGS_TX = 9,
    ETHTOOL_A_RINGS_RX_BUF_LEN = 10,
    ETHTOOL_A_RINGS_TCP_DATA_SPLIT = 11,
    ETHTOOL_A_RINGS_CQE_SIZE = 12,
    ETHTOOL_A_RINGS_TX_PUSH = 13,
    ETHTOOL_A_RINGS_RX_PUSH = 14,
    ETHTOOL_A_RINGS_TX_PUSH_BUF_LEN = 15,
    ETHTOOL_A_RINGS_TX_PUSH_BUF_LEN_MAX = 16,
    ETHTOOL_A_RINGS_HDS_THRESH = 17,
    ETHTOOL_A_RINGS_HDS_THRESH_MAX = 18,
    __ETHTOOL_A_RINGS_CNT = 19,
    ETHTOOL_A_RINGS_MAX = 18,
};

enum {
    ETHTOOL_A_RSS_UNSPEC = 0,
    ETHTOOL_A_RSS_HEADER = 1,
    ETHTOOL_A_RSS_CONTEXT = 2,
    ETHTOOL_A_RSS_HFUNC = 3,
    ETHTOOL_A_RSS_INDIR = 4,
    ETHTOOL_A_RSS_HKEY = 5,
    ETHTOOL_A_RSS_INPUT_XFRM = 6,
    ETHTOOL_A_RSS_START_CONTEXT = 7,
    __ETHTOOL_A_RSS_CNT = 8,
    ETHTOOL_A_RSS_MAX = 7,
};

enum {
    ETHTOOL_A_STATS_ETH_CTRL_3_TX = 0,
    ETHTOOL_A_STATS_ETH_CTRL_4_RX = 1,
    ETHTOOL_A_STATS_ETH_CTRL_5_RX_UNSUP = 2,
    __ETHTOOL_A_STATS_ETH_CTRL_CNT = 3,
    ETHTOOL_A_STATS_ETH_CTRL_MAX = 2,
};

enum {
    ETHTOOL_A_STATS_ETH_MAC_2_TX_PKT = 0,
    ETHTOOL_A_STATS_ETH_MAC_3_SINGLE_COL = 1,
    ETHTOOL_A_STATS_ETH_MAC_4_MULTI_COL = 2,
    ETHTOOL_A_STATS_ETH_MAC_5_RX_PKT = 3,
    ETHTOOL_A_STATS_ETH_MAC_6_FCS_ERR = 4,
    ETHTOOL_A_STATS_ETH_MAC_7_ALIGN_ERR = 5,
    ETHTOOL_A_STATS_ETH_MAC_8_TX_BYTES = 6,
    ETHTOOL_A_STATS_ETH_MAC_9_TX_DEFER = 7,
    ETHTOOL_A_STATS_ETH_MAC_10_LATE_COL = 8,
    ETHTOOL_A_STATS_ETH_MAC_11_XS_COL = 9,
    ETHTOOL_A_STATS_ETH_MAC_12_TX_INT_ERR = 10,
    ETHTOOL_A_STATS_ETH_MAC_13_CS_ERR = 11,
    ETHTOOL_A_STATS_ETH_MAC_14_RX_BYTES = 12,
    ETHTOOL_A_STATS_ETH_MAC_15_RX_INT_ERR = 13,
    ETHTOOL_A_STATS_ETH_MAC_18_TX_MCAST = 14,
    ETHTOOL_A_STATS_ETH_MAC_19_TX_BCAST = 15,
    ETHTOOL_A_STATS_ETH_MAC_20_XS_DEFER = 16,
    ETHTOOL_A_STATS_ETH_MAC_21_RX_MCAST = 17,
    ETHTOOL_A_STATS_ETH_MAC_22_RX_BCAST = 18,
    ETHTOOL_A_STATS_ETH_MAC_23_IR_LEN_ERR = 19,
    ETHTOOL_A_STATS_ETH_MAC_24_OOR_LEN = 20,
    ETHTOOL_A_STATS_ETH_MAC_25_TOO_LONG_ERR = 21,
    __ETHTOOL_A_STATS_ETH_MAC_CNT = 22,
    ETHTOOL_A_STATS_ETH_MAC_MAX = 21,
};

enum {
    ETHTOOL_A_STATS_ETH_PHY_5_SYM_ERR = 0,
    __ETHTOOL_A_STATS_ETH_PHY_CNT = 1,
    ETHTOOL_A_STATS_ETH_PHY_MAX = 0,
};

enum {
    ETHTOOL_A_STATS_GRP_UNSPEC = 0,
    ETHTOOL_A_STATS_GRP_PAD = 1,
    ETHTOOL_A_STATS_GRP_ID = 2,
    ETHTOOL_A_STATS_GRP_SS_ID = 3,
    ETHTOOL_A_STATS_GRP_STAT = 4,
    ETHTOOL_A_STATS_GRP_HIST_RX = 5,
    ETHTOOL_A_STATS_GRP_HIST_TX = 6,
    ETHTOOL_A_STATS_GRP_HIST_BKT_LOW = 7,
    ETHTOOL_A_STATS_GRP_HIST_BKT_HI = 8,
    ETHTOOL_A_STATS_GRP_HIST_VAL = 9,
    __ETHTOOL_A_STATS_GRP_CNT = 10,
    ETHTOOL_A_STATS_GRP_MAX = 9,
};

enum {
    ETHTOOL_A_STATS_PHY_RX_PKTS = 0,
    ETHTOOL_A_STATS_PHY_RX_BYTES = 1,
    ETHTOOL_A_STATS_PHY_RX_ERRORS = 2,
    ETHTOOL_A_STATS_PHY_TX_PKTS = 3,
    ETHTOOL_A_STATS_PHY_TX_BYTES = 4,
    ETHTOOL_A_STATS_PHY_TX_ERRORS = 5,
    __ETHTOOL_A_STATS_PHY_CNT = 6,
    ETHTOOL_A_STATS_PHY_MAX = 5,
};

enum {
    ETHTOOL_A_STATS_RMON_UNDERSIZE = 0,
    ETHTOOL_A_STATS_RMON_OVERSIZE = 1,
    ETHTOOL_A_STATS_RMON_FRAG = 2,
    ETHTOOL_A_STATS_RMON_JABBER = 3,
    __ETHTOOL_A_STATS_RMON_CNT = 4,
    ETHTOOL_A_STATS_RMON_MAX = 3,
};

enum {
    ETHTOOL_A_STATS_UNSPEC = 0,
    ETHTOOL_A_STATS_PAD = 1,
    ETHTOOL_A_STATS_HEADER = 2,
    ETHTOOL_A_STATS_GROUPS = 3,
    ETHTOOL_A_STATS_GRP = 4,
    ETHTOOL_A_STATS_SRC = 5,
    __ETHTOOL_A_STATS_CNT = 6,
    ETHTOOL_A_STATS_MAX = 5,
};

enum {
    ETHTOOL_A_STRINGSETS_UNSPEC = 0,
    ETHTOOL_A_STRINGSETS_STRINGSET = 1,
    __ETHTOOL_A_STRINGSETS_CNT = 2,
    ETHTOOL_A_STRINGSETS_MAX = 1,
};

enum {
    ETHTOOL_A_STRINGSET_UNSPEC = 0,
    ETHTOOL_A_STRINGSET_ID = 1,
    ETHTOOL_A_STRINGSET_COUNT = 2,
    ETHTOOL_A_STRINGSET_STRINGS = 3,
    __ETHTOOL_A_STRINGSET_CNT = 4,
    ETHTOOL_A_STRINGSET_MAX = 3,
};

enum {
    ETHTOOL_A_STRINGS_UNSPEC = 0,
    ETHTOOL_A_STRINGS_STRING = 1,
    __ETHTOOL_A_STRINGS_CNT = 2,
    ETHTOOL_A_STRINGS_MAX = 1,
};

enum {
    ETHTOOL_A_STRING_UNSPEC = 0,
    ETHTOOL_A_STRING_INDEX = 1,
    ETHTOOL_A_STRING_VALUE = 2,
    __ETHTOOL_A_STRING_CNT = 3,
    ETHTOOL_A_STRING_MAX = 2,
};

enum {
    ETHTOOL_A_STRSET_UNSPEC = 0,
    ETHTOOL_A_STRSET_HEADER = 1,
    ETHTOOL_A_STRSET_STRINGSETS = 2,
    ETHTOOL_A_STRSET_COUNTS_ONLY = 3,
    __ETHTOOL_A_STRSET_CNT = 4,
    ETHTOOL_A_STRSET_MAX = 3,
};

enum {
    ETHTOOL_A_TSCONFIG_UNSPEC = 0,
    ETHTOOL_A_TSCONFIG_HEADER = 1,
    ETHTOOL_A_TSCONFIG_HWTSTAMP_PROVIDER = 2,
    ETHTOOL_A_TSCONFIG_TX_TYPES = 3,
    ETHTOOL_A_TSCONFIG_RX_FILTERS = 4,
    ETHTOOL_A_TSCONFIG_HWTSTAMP_FLAGS = 5,
    __ETHTOOL_A_TSCONFIG_CNT = 6,
    ETHTOOL_A_TSCONFIG_MAX = 5,
};

enum {
    ETHTOOL_A_TSINFO_UNSPEC = 0,
    ETHTOOL_A_TSINFO_HEADER = 1,
    ETHTOOL_A_TSINFO_TIMESTAMPING = 2,
    ETHTOOL_A_TSINFO_TX_TYPES = 3,
    ETHTOOL_A_TSINFO_RX_FILTERS = 4,
    ETHTOOL_A_TSINFO_PHC_INDEX = 5,
    ETHTOOL_A_TSINFO_STATS = 6,
    ETHTOOL_A_TSINFO_HWTSTAMP_PROVIDER = 7,
    __ETHTOOL_A_TSINFO_CNT = 8,
    ETHTOOL_A_TSINFO_MAX = 7,
};

enum {
    ETHTOOL_A_TS_HWTSTAMP_PROVIDER_UNSPEC = 0,
    ETHTOOL_A_TS_HWTSTAMP_PROVIDER_INDEX = 1,
    ETHTOOL_A_TS_HWTSTAMP_PROVIDER_QUALIFIER = 2,
    __ETHTOOL_A_TS_HWTSTAMP_PROVIDER_CNT = 3,
    ETHTOOL_A_TS_HWTSTAMP_PROVIDER_MAX = 2,
};

enum {
    ETHTOOL_A_TS_STAT_UNSPEC = 0,
    ETHTOOL_A_TS_STAT_TX_PKTS = 1,
    ETHTOOL_A_TS_STAT_TX_LOST = 2,
    ETHTOOL_A_TS_STAT_TX_ERR = 3,
    ETHTOOL_A_TS_STAT_TX_ONESTEP_PKTS_UNCONFIRMED = 4,
    __ETHTOOL_A_TS_STAT_CNT = 5,
    ETHTOOL_A_TS_STAT_MAX = 4,
};

enum {
    ETHTOOL_A_TUNNEL_INFO_UNSPEC = 0,
    ETHTOOL_A_TUNNEL_INFO_HEADER = 1,
    ETHTOOL_A_TUNNEL_INFO_UDP_PORTS = 2,
    __ETHTOOL_A_TUNNEL_INFO_CNT = 3,
    ETHTOOL_A_TUNNEL_INFO_MAX = 2,
};

enum {
    ETHTOOL_A_TUNNEL_UDP_ENTRY_UNSPEC = 0,
    ETHTOOL_A_TUNNEL_UDP_ENTRY_PORT = 1,
    ETHTOOL_A_TUNNEL_UDP_ENTRY_TYPE = 2,
    __ETHTOOL_A_TUNNEL_UDP_ENTRY_CNT = 3,
    ETHTOOL_A_TUNNEL_UDP_ENTRY_MAX = 2,
};

enum {
    ETHTOOL_A_TUNNEL_UDP_TABLE_UNSPEC = 0,
    ETHTOOL_A_TUNNEL_UDP_TABLE_SIZE = 1,
    ETHTOOL_A_TUNNEL_UDP_TABLE_TYPES = 2,
    ETHTOOL_A_TUNNEL_UDP_TABLE_ENTRY = 3,
    __ETHTOOL_A_TUNNEL_UDP_TABLE_CNT = 4,
    ETHTOOL_A_TUNNEL_UDP_TABLE_MAX = 3,
};

enum {
    ETHTOOL_A_TUNNEL_UDP_UNSPEC = 0,
    ETHTOOL_A_TUNNEL_UDP_TABLE = 1,
    __ETHTOOL_A_TUNNEL_UDP_CNT = 2,
    ETHTOOL_A_TUNNEL_UDP_MAX = 1,
};

enum {
    ETHTOOL_A_WOL_UNSPEC = 0,
    ETHTOOL_A_WOL_HEADER = 1,
    ETHTOOL_A_WOL_MODES = 2,
    ETHTOOL_A_WOL_SOPASS = 3,
    __ETHTOOL_A_WOL_CNT = 4,
    ETHTOOL_A_WOL_MAX = 3,
};

enum {
    ETHTOOL_MSG_KERNEL_NONE = 0,
    ETHTOOL_MSG_STRSET_GET_REPLY = 1,
    ETHTOOL_MSG_LINKINFO_GET_REPLY = 2,
    ETHTOOL_MSG_LINKINFO_NTF = 3,
    ETHTOOL_MSG_LINKMODES_GET_REPLY = 4,
    ETHTOOL_MSG_LINKMODES_NTF = 5,
    ETHTOOL_MSG_LINKSTATE_GET_REPLY = 6,
    ETHTOOL_MSG_DEBUG_GET_REPLY = 7,
    ETHTOOL_MSG_DEBUG_NTF = 8,
    ETHTOOL_MSG_WOL_GET_REPLY = 9,
    ETHTOOL_MSG_WOL_NTF = 10,
    ETHTOOL_MSG_FEATURES_GET_REPLY = 11,
    ETHTOOL_MSG_FEATURES_SET_REPLY = 12,
    ETHTOOL_MSG_FEATURES_NTF = 13,
    ETHTOOL_MSG_PRIVFLAGS_GET_REPLY = 14,
    ETHTOOL_MSG_PRIVFLAGS_NTF = 15,
    ETHTOOL_MSG_RINGS_GET_REPLY = 16,
    ETHTOOL_MSG_RINGS_NTF = 17,
    ETHTOOL_MSG_CHANNELS_GET_REPLY = 18,
    ETHTOOL_MSG_CHANNELS_NTF = 19,
    ETHTOOL_MSG_COALESCE_GET_REPLY = 20,
    ETHTOOL_MSG_COALESCE_NTF = 21,
    ETHTOOL_MSG_PAUSE_GET_REPLY = 22,
    ETHTOOL_MSG_PAUSE_NTF = 23,
    ETHTOOL_MSG_EEE_GET_REPLY = 24,
    ETHTOOL_MSG_EEE_NTF = 25,
    ETHTOOL_MSG_TSINFO_GET_REPLY = 26,
    ETHTOOL_MSG_CABLE_TEST_NTF = 27,
    ETHTOOL_MSG_CABLE_TEST_TDR_NTF = 28,
    ETHTOOL_MSG_TUNNEL_INFO_GET_REPLY = 29,
    ETHTOOL_MSG_FEC_GET_REPLY = 30,
    ETHTOOL_MSG_FEC_NTF = 31,
    ETHTOOL_MSG_MODULE_EEPROM_GET_REPLY = 32,
    ETHTOOL_MSG_STATS_GET_REPLY = 33,
    ETHTOOL_MSG_PHC_VCLOCKS_GET_REPLY = 34,
    ETHTOOL_MSG_MODULE_GET_REPLY = 35,
    ETHTOOL_MSG_MODULE_NTF = 36,
    ETHTOOL_MSG_PSE_GET_REPLY = 37,
    ETHTOOL_MSG_RSS_GET_REPLY = 38,
    ETHTOOL_MSG_PLCA_GET_CFG_REPLY = 39,
    ETHTOOL_MSG_PLCA_GET_STATUS_REPLY = 40,
    ETHTOOL_MSG_PLCA_NTF = 41,
    ETHTOOL_MSG_MM_GET_REPLY = 42,
    ETHTOOL_MSG_MM_NTF = 43,
    ETHTOOL_MSG_MODULE_FW_FLASH_NTF = 44,
    ETHTOOL_MSG_PHY_GET_REPLY = 45,
    ETHTOOL_MSG_PHY_NTF = 46,
    ETHTOOL_MSG_TSCONFIG_GET_REPLY = 47,
    ETHTOOL_MSG_TSCONFIG_SET_REPLY = 48,
    __ETHTOOL_MSG_KERNEL_CNT = 49,
    ETHTOOL_MSG_KERNEL_MAX = 48,
};

enum {
    ETHTOOL_MSG_USER_NONE = 0,
    ETHTOOL_MSG_STRSET_GET = 1,
    ETHTOOL_MSG_LINKINFO_GET = 2,
    ETHTOOL_MSG_LINKINFO_SET = 3,
    ETHTOOL_MSG_LINKMODES_GET = 4,
    ETHTOOL_MSG_LINKMODES_SET = 5,
    ETHTOOL_MSG_LINKSTATE_GET = 6,
    ETHTOOL_MSG_DEBUG_GET = 7,
    ETHTOOL_MSG_DEBUG_SET = 8,
    ETHTOOL_MSG_WOL_GET = 9,
    ETHTOOL_MSG_WOL_SET = 10,
    ETHTOOL_MSG_FEATURES_GET = 11,
    ETHTOOL_MSG_FEATURES_SET = 12,
    ETHTOOL_MSG_PRIVFLAGS_GET = 13,
    ETHTOOL_MSG_PRIVFLAGS_SET = 14,
    ETHTOOL_MSG_RINGS_GET = 15,
    ETHTOOL_MSG_RINGS_SET = 16,
    ETHTOOL_MSG_CHANNELS_GET = 17,
    ETHTOOL_MSG_CHANNELS_SET = 18,
    ETHTOOL_MSG_COALESCE_GET = 19,
    ETHTOOL_MSG_COALESCE_SET = 20,
    ETHTOOL_MSG_PAUSE_GET = 21,
    ETHTOOL_MSG_PAUSE_SET = 22,
    ETHTOOL_MSG_EEE_GET = 23,
    ETHTOOL_MSG_EEE_SET = 24,
    ETHTOOL_MSG_TSINFO_GET = 25,
    ETHTOOL_MSG_CABLE_TEST_ACT = 26,
    ETHTOOL_MSG_CABLE_TEST_TDR_ACT = 27,
    ETHTOOL_MSG_TUNNEL_INFO_GET = 28,
    ETHTOOL_MSG_FEC_GET = 29,
    ETHTOOL_MSG_FEC_SET = 30,
    ETHTOOL_MSG_MODULE_EEPROM_GET = 31,
    ETHTOOL_MSG_STATS_GET = 32,
    ETHTOOL_MSG_PHC_VCLOCKS_GET = 33,
    ETHTOOL_MSG_MODULE_GET = 34,
    ETHTOOL_MSG_MODULE_SET = 35,
    ETHTOOL_MSG_PSE_GET = 36,
    ETHTOOL_MSG_PSE_SET = 37,
    ETHTOOL_MSG_RSS_GET = 38,
    ETHTOOL_MSG_PLCA_GET_CFG = 39,
    ETHTOOL_MSG_PLCA_SET_CFG = 40,
    ETHTOOL_MSG_PLCA_GET_STATUS = 41,
    ETHTOOL_MSG_MM_GET = 42,
    ETHTOOL_MSG_MM_SET = 43,
    ETHTOOL_MSG_MODULE_FW_FLASH_ACT = 44,
    ETHTOOL_MSG_PHY_GET = 45,
    ETHTOOL_MSG_TSCONFIG_GET = 46,
    ETHTOOL_MSG_TSCONFIG_SET = 47,
    __ETHTOOL_MSG_USER_CNT = 48,
    ETHTOOL_MSG_USER_MAX = 47,
};

enum {
    ETHTOOL_STATS_ETH_PHY = 0,
    ETHTOOL_STATS_ETH_MAC = 1,
    ETHTOOL_STATS_ETH_CTRL = 2,
    ETHTOOL_STATS_RMON = 3,
    ETHTOOL_STATS_PHY = 4,
    __ETHTOOL_STATS_CNT = 5,
};

enum {
    ETHTOOL_UDP_TUNNEL_TYPE_VXLAN = 0,
    ETHTOOL_UDP_TUNNEL_TYPE_GENEVE = 1,
    ETHTOOL_UDP_TUNNEL_TYPE_VXLAN_GPE = 2,
    __ETHTOOL_UDP_TUNNEL_TYPE_CNT = 3,
    ETHTOOL_UDP_TUNNEL_TYPE_MAX = 2,
};

enum {
    ETH_RSS_HASH_TOP_BIT = 0,
    ETH_RSS_HASH_XOR_BIT = 1,
    ETH_RSS_HASH_CRC32_BIT = 2,
    ETH_RSS_HASH_FUNCS_COUNT = 3,
};

enum {
    EVENTFS_SAVE_MODE = 65536,
    EVENTFS_SAVE_UID = 131072,
    EVENTFS_SAVE_GID = 262144,
};

enum {
    EVENT_FILE_FL_ENABLED = 1,
    EVENT_FILE_FL_RECORDED_CMD = 2,
    EVENT_FILE_FL_RECORDED_TGID = 4,
    EVENT_FILE_FL_FILTERED = 8,
    EVENT_FILE_FL_NO_SET_FILTER = 16,
    EVENT_FILE_FL_SOFT_MODE = 32,
    EVENT_FILE_FL_SOFT_DISABLED = 64,
    EVENT_FILE_FL_TRIGGER_MODE = 128,
    EVENT_FILE_FL_TRIGGER_COND = 256,
    EVENT_FILE_FL_PID_FILTER = 512,
    EVENT_FILE_FL_WAS_ENABLED = 1024,
    EVENT_FILE_FL_FREED = 2048,
};

enum {
    EVENT_FILE_FL_ENABLED_BIT = 0,
    EVENT_FILE_FL_RECORDED_CMD_BIT = 1,
    EVENT_FILE_FL_RECORDED_TGID_BIT = 2,
    EVENT_FILE_FL_FILTERED_BIT = 3,
    EVENT_FILE_FL_NO_SET_FILTER_BIT = 4,
    EVENT_FILE_FL_SOFT_MODE_BIT = 5,
    EVENT_FILE_FL_SOFT_DISABLED_BIT = 6,
    EVENT_FILE_FL_TRIGGER_MODE_BIT = 7,
    EVENT_FILE_FL_TRIGGER_COND_BIT = 8,
    EVENT_FILE_FL_PID_FILTER_BIT = 9,
    EVENT_FILE_FL_WAS_ENABLED_BIT = 10,
    EVENT_FILE_FL_FREED_BIT = 11,
};

enum {
    EVENT_TRIGGER_FL_PROBE = 1,
};

enum {
    EXT4_FC_REASON_XATTR = 0,
    EXT4_FC_REASON_CROSS_RENAME = 1,
    EXT4_FC_REASON_JOURNAL_FLAG_CHANGE = 2,
    EXT4_FC_REASON_NOMEM = 3,
    EXT4_FC_REASON_SWAP_BOOT = 4,
    EXT4_FC_REASON_RESIZE = 5,
    EXT4_FC_REASON_RENAME_DIR = 6,
    EXT4_FC_REASON_FALLOC_RANGE = 7,
    EXT4_FC_REASON_INODE_JOURNAL_DATA = 8,
    EXT4_FC_REASON_ENCRYPTED_FILENAME = 9,
    EXT4_FC_REASON_MAX = 10,
};

enum {
    EXT4_FC_STATUS_OK = 0,
    EXT4_FC_STATUS_INELIGIBLE = 1,
    EXT4_FC_STATUS_SKIPPED = 2,
    EXT4_FC_STATUS_FAILED = 3,
};

enum {
    EXT4_FLAGS_RESIZING = 0,
    EXT4_FLAGS_SHUTDOWN = 1,
    EXT4_FLAGS_BDEV_IS_DAX = 2,
    EXT4_FLAGS_EMERGENCY_RO = 3,
};

enum {
    EXT4_INODE_SECRM = 0,
    EXT4_INODE_UNRM = 1,
    EXT4_INODE_COMPR = 2,
    EXT4_INODE_SYNC = 3,
    EXT4_INODE_IMMUTABLE = 4,
    EXT4_INODE_APPEND = 5,
    EXT4_INODE_NODUMP = 6,
    EXT4_INODE_NOATIME = 7,
    EXT4_INODE_DIRTY = 8,
    EXT4_INODE_COMPRBLK = 9,
    EXT4_INODE_NOCOMPR = 10,
    EXT4_INODE_ENCRYPT = 11,
    EXT4_INODE_INDEX = 12,
    EXT4_INODE_IMAGIC = 13,
    EXT4_INODE_JOURNAL_DATA = 14,
    EXT4_INODE_NOTAIL = 15,
    EXT4_INODE_DIRSYNC = 16,
    EXT4_INODE_TOPDIR = 17,
    EXT4_INODE_HUGE_FILE = 18,
    EXT4_INODE_EXTENTS = 19,
    EXT4_INODE_VERITY = 20,
    EXT4_INODE_EA_INODE = 21,
    EXT4_INODE_DAX = 25,
    EXT4_INODE_INLINE_DATA = 28,
    EXT4_INODE_PROJINHERIT = 29,
    EXT4_INODE_CASEFOLD = 30,
    EXT4_INODE_RESERVED = 31,
};

enum {
    EXT4_MF_MNTDIR_SAMPLED = 0,
    EXT4_MF_FC_INELIGIBLE = 1,
    EXT4_MF_JOURNAL_DESTROY = 2,
};

enum {
    EXT4_STATE_NEW = 0,
    EXT4_STATE_XATTR = 1,
    EXT4_STATE_NO_EXPAND = 2,
    EXT4_STATE_DA_ALLOC_CLOSE = 3,
    EXT4_STATE_EXT_MIGRATE = 4,
    EXT4_STATE_NEWENTRY = 5,
    EXT4_STATE_MAY_INLINE_DATA = 6,
    EXT4_STATE_EXT_PRECACHED = 7,
    EXT4_STATE_LUSTRE_EA_INODE = 8,
    EXT4_STATE_VERITY_IN_PROGRESS = 9,
    EXT4_STATE_FC_COMMITTING = 10,
    EXT4_STATE_ORPHAN_FILE = 11,
};

enum {
    FAN_EVENT_INIT = 0,
    FAN_EVENT_REPORTED = 1,
    FAN_EVENT_ANSWERED = 2,
    FAN_EVENT_CANCELED = 3,
};

enum {
    FBCON_LOGO_CANSHOW = -1,
    FBCON_LOGO_DRAW = -2,
    FBCON_LOGO_DONTSHOW = -3,
};

enum {
    FB_BLANK_UNBLANK = 0,
    FB_BLANK_NORMAL = 1,
    FB_BLANK_VSYNC_SUSPEND = 2,
    FB_BLANK_HSYNC_SUSPEND = 3,
    FB_BLANK_POWERDOWN = 4,
};

enum {
    FGRAPH_TYPE_RESERVED = 0,
    FGRAPH_TYPE_BITMAP = 1,
    FGRAPH_TYPE_DATA = 2,
};

enum {
    FIB6_NO_SERNUM_CHANGE = 0,
};

enum {
    FILTER_OTHER = 0,
    FILTER_STATIC_STRING = 1,
    FILTER_DYN_STRING = 2,
    FILTER_RDYN_STRING = 3,
    FILTER_PTR_STRING = 4,
    FILTER_TRACE_FN = 5,
    FILTER_CPUMASK = 6,
    FILTER_COMM = 7,
    FILTER_CPU = 8,
    FILTER_STACKTRACE = 9,
};

enum {
    FILT_ERR_NONE = 0,
    FILT_ERR_INVALID_OP = 1,
    FILT_ERR_TOO_MANY_OPEN = 2,
    FILT_ERR_TOO_MANY_CLOSE = 3,
    FILT_ERR_MISSING_QUOTE = 4,
    FILT_ERR_MISSING_BRACE_OPEN = 5,
    FILT_ERR_MISSING_BRACE_CLOSE = 6,
    FILT_ERR_OPERAND_TOO_LONG = 7,
    FILT_ERR_EXPECT_STRING = 8,
    FILT_ERR_EXPECT_DIGIT = 9,
    FILT_ERR_ILLEGAL_FIELD_OP = 10,
    FILT_ERR_FIELD_NOT_FOUND = 11,
    FILT_ERR_ILLEGAL_INTVAL = 12,
    FILT_ERR_BAD_SUBSYS_FILTER = 13,
    FILT_ERR_TOO_MANY_PREDS = 14,
    FILT_ERR_INVALID_FILTER = 15,
    FILT_ERR_INVALID_CPULIST = 16,
    FILT_ERR_IP_FIELD_ONLY = 17,
    FILT_ERR_INVALID_VALUE = 18,
    FILT_ERR_NO_FUNCTION = 19,
    FILT_ERR_ERRNO = 20,
    FILT_ERR_NO_FILTER = 21,
};

enum {
    FLAGS_FILL_FULL = 268435456,
    FLAGS_FILL_START = 536870912,
    FLAGS_FILL_END = 805306368,
};

enum {
    FOLL_TOUCH = 65536,
    FOLL_TRIED = 131072,
    FOLL_REMOTE = 262144,
    FOLL_PIN = 524288,
    FOLL_FAST_ONLY = 1048576,
    FOLL_UNLOCKABLE = 2097152,
    FOLL_MADV_POPULATE = 4194304,
};

enum {
    FOLL_WRITE = 1,
    FOLL_GET = 2,
    FOLL_DUMP = 4,
    FOLL_FORCE = 8,
    FOLL_NOWAIT = 16,
    FOLL_NOFAULT = 32,
    FOLL_HWPOISON = 64,
    FOLL_ANON = 128,
    FOLL_LONGTERM = 256,
    FOLL_SPLIT_PMD = 512,
    FOLL_PCI_P2PDMA = 1024,
    FOLL_INTERRUPTIBLE = 2048,
    FOLL_HONOR_NUMA_FAULT = 4096,
};

enum {
    FORMAT_HEADER = 1,
    FORMAT_FIELD_SEPERATOR = 2,
    FORMAT_PRINTFMT = 3,
};

enum {
    FRACTION_DENOM = 128,
};

enum {
    FRA_UNSPEC = 0,
    FRA_DST = 1,
    FRA_SRC = 2,
    FRA_IIFNAME = 3,
    FRA_GOTO = 4,
    FRA_UNUSED2 = 5,
    FRA_PRIORITY = 6,
    FRA_UNUSED3 = 7,
    FRA_UNUSED4 = 8,
    FRA_UNUSED5 = 9,
    FRA_FWMARK = 10,
    FRA_FLOW = 11,
    FRA_TUN_ID = 12,
    FRA_SUPPRESS_IFGROUP = 13,
    FRA_SUPPRESS_PREFIXLEN = 14,
    FRA_TABLE = 15,
    FRA_FWMASK = 16,
    FRA_OIFNAME = 17,
    FRA_PAD = 18,
    FRA_L3MDEV = 19,
    FRA_UID_RANGE = 20,
    FRA_PROTOCOL = 21,
    FRA_IP_PROTO = 22,
    FRA_SPORT_RANGE = 23,
    FRA_DPORT_RANGE = 24,
    FRA_DSCP = 25,
    FRA_FLOWLABEL = 26,
    FRA_FLOWLABEL_MASK = 27,
    __FRA_MAX = 28,
};

enum {
    FR_ACT_UNSPEC = 0,
    FR_ACT_TO_TBL = 1,
    FR_ACT_GOTO = 2,
    FR_ACT_NOP = 3,
    FR_ACT_RES3 = 4,
    FR_ACT_RES4 = 5,
    FR_ACT_BLACKHOLE = 6,
    FR_ACT_UNREACHABLE = 7,
    FR_ACT_PROHIBIT = 8,
    __FR_ACT_MAX = 9,
};

enum {
    FTRACE_FL_ENABLED = 2147483648,
    FTRACE_FL_REGS = 1073741824,
    FTRACE_FL_REGS_EN = 536870912,
    FTRACE_FL_TRAMP = 268435456,
    FTRACE_FL_TRAMP_EN = 134217728,
    FTRACE_FL_IPMODIFY = 67108864,
    FTRACE_FL_DISABLED = 33554432,
    FTRACE_FL_DIRECT = 16777216,
    FTRACE_FL_DIRECT_EN = 8388608,
    FTRACE_FL_CALL_OPS = 4194304,
    FTRACE_FL_CALL_OPS_EN = 2097152,
    FTRACE_FL_TOUCHED = 1048576,
    FTRACE_FL_MODIFIED = 524288,
};

enum {
    FTRACE_HASH_FL_MOD = 1,
};

enum {
    FTRACE_ITER_FILTER = 1,
    FTRACE_ITER_NOTRACE = 2,
    FTRACE_ITER_PRINTALL = 4,
    FTRACE_ITER_DO_PROBES = 8,
    FTRACE_ITER_PROBE = 16,
    FTRACE_ITER_MOD = 32,
    FTRACE_ITER_ENABLED = 64,
    FTRACE_ITER_TOUCHED = 128,
    FTRACE_ITER_ADDRS = 256,
};

enum {
    FTRACE_MODIFY_ENABLE_FL = 1,
    FTRACE_MODIFY_MAY_SLEEP_FL = 2,
};

enum {
    FTRACE_OPS_FL_ENABLED = 1,
    FTRACE_OPS_FL_DYNAMIC = 2,
    FTRACE_OPS_FL_SAVE_REGS = 4,
    FTRACE_OPS_FL_SAVE_REGS_IF_SUPPORTED = 8,
    FTRACE_OPS_FL_RECURSION = 16,
    FTRACE_OPS_FL_STUB = 32,
    FTRACE_OPS_FL_INITIALIZED = 64,
    FTRACE_OPS_FL_DELETED = 128,
    FTRACE_OPS_FL_ADDING = 256,
    FTRACE_OPS_FL_REMOVING = 512,
    FTRACE_OPS_FL_MODIFYING = 1024,
    FTRACE_OPS_FL_ALLOC_TRAMP = 2048,
    FTRACE_OPS_FL_IPMODIFY = 4096,
    FTRACE_OPS_FL_PID = 8192,
    FTRACE_OPS_FL_RCU = 16384,
    FTRACE_OPS_FL_TRACE_ARRAY = 32768,
    FTRACE_OPS_FL_PERMANENT = 65536,
    FTRACE_OPS_FL_DIRECT = 131072,
    FTRACE_OPS_FL_SUBOP = 262144,
};

enum {
    FTRACE_UPDATE_CALLS = 1,
    FTRACE_DISABLE_CALLS = 2,
    FTRACE_UPDATE_TRACE_FUNC = 4,
    FTRACE_START_FUNC_RET = 8,
    FTRACE_STOP_FUNC_RET = 16,
    FTRACE_MAY_SLEEP = 32,
};

enum {
    FTRACE_UPDATE_IGNORE = 0,
    FTRACE_UPDATE_MAKE_CALL = 1,
    FTRACE_UPDATE_MODIFY_CALL = 2,
    FTRACE_UPDATE_MAKE_NOP = 3,
};

enum {
    FUTEX_STATE_OK = 0,
    FUTEX_STATE_EXITING = 1,
    FUTEX_STATE_DEAD = 2,
};

enum {
    GENHD_FL_REMOVABLE = 1,
    GENHD_FL_HIDDEN = 2,
    GENHD_FL_NO_PART = 4,
};

enum {
    GP_IDLE = 0,
    GP_ENTER = 1,
    GP_PASSED = 2,
    GP_EXIT = 3,
    GP_REPLAY = 4,
};

enum {
    HANDSHAKE_A_ACCEPT_SOCKFD = 1,
    HANDSHAKE_A_ACCEPT_HANDLER_CLASS = 2,
    HANDSHAKE_A_ACCEPT_MESSAGE_TYPE = 3,
    HANDSHAKE_A_ACCEPT_TIMEOUT = 4,
    HANDSHAKE_A_ACCEPT_AUTH_MODE = 5,
    HANDSHAKE_A_ACCEPT_PEER_IDENTITY = 6,
    HANDSHAKE_A_ACCEPT_CERTIFICATE = 7,
    HANDSHAKE_A_ACCEPT_PEERNAME = 8,
    __HANDSHAKE_A_ACCEPT_MAX = 9,
    HANDSHAKE_A_ACCEPT_MAX = 8,
};

enum {
    HANDSHAKE_A_DONE_STATUS = 1,
    HANDSHAKE_A_DONE_SOCKFD = 2,
    HANDSHAKE_A_DONE_REMOTE_AUTH = 3,
    __HANDSHAKE_A_DONE_MAX = 4,
    HANDSHAKE_A_DONE_MAX = 3,
};

enum {
    HANDSHAKE_A_X509_CERT = 1,
    HANDSHAKE_A_X509_PRIVKEY = 2,
    __HANDSHAKE_A_X509_MAX = 3,
    HANDSHAKE_A_X509_MAX = 2,
};

enum {
    HANDSHAKE_CMD_READY = 1,
    HANDSHAKE_CMD_ACCEPT = 2,
    HANDSHAKE_CMD_DONE = 3,
    __HANDSHAKE_CMD_MAX = 4,
    HANDSHAKE_CMD_MAX = 3,
};

enum {
    HANDSHAKE_NLGRP_NONE = 0,
    HANDSHAKE_NLGRP_TLSHD = 1,
};

enum {
    HASH_SIZE = 128,
};

enum {
    HAS_READ = 1,
    HAS_WRITE = 2,
    HAS_LSEEK = 4,
    HAS_POLL = 8,
    HAS_IOCTL = 16,
};

enum {
    HIST_ERR_NONE = 0,
    HIST_ERR_DUPLICATE_VAR = 1,
    HIST_ERR_VAR_NOT_UNIQUE = 2,
    HIST_ERR_TOO_MANY_VARS = 3,
    HIST_ERR_MALFORMED_ASSIGNMENT = 4,
    HIST_ERR_NAMED_MISMATCH = 5,
    HIST_ERR_TRIGGER_EEXIST = 6,
    HIST_ERR_TRIGGER_ENOENT_CLEAR = 7,
    HIST_ERR_SET_CLOCK_FAIL = 8,
    HIST_ERR_BAD_FIELD_MODIFIER = 9,
    HIST_ERR_TOO_MANY_SUBEXPR = 10,
    HIST_ERR_TIMESTAMP_MISMATCH = 11,
    HIST_ERR_TOO_MANY_FIELD_VARS = 12,
    HIST_ERR_EVENT_FILE_NOT_FOUND = 13,
    HIST_ERR_HIST_NOT_FOUND = 14,
    HIST_ERR_HIST_CREATE_FAIL = 15,
    HIST_ERR_SYNTH_VAR_NOT_FOUND = 16,
    HIST_ERR_SYNTH_EVENT_NOT_FOUND = 17,
    HIST_ERR_SYNTH_TYPE_MISMATCH = 18,
    HIST_ERR_SYNTH_COUNT_MISMATCH = 19,
    HIST_ERR_FIELD_VAR_PARSE_FAIL = 20,
    HIST_ERR_VAR_CREATE_FIND_FAIL = 21,
    HIST_ERR_ONX_NOT_VAR = 22,
    HIST_ERR_ONX_VAR_NOT_FOUND = 23,
    HIST_ERR_ONX_VAR_CREATE_FAIL = 24,
    HIST_ERR_FIELD_VAR_CREATE_FAIL = 25,
    HIST_ERR_TOO_MANY_PARAMS = 26,
    HIST_ERR_PARAM_NOT_FOUND = 27,
    HIST_ERR_INVALID_PARAM = 28,
    HIST_ERR_ACTION_NOT_FOUND = 29,
    HIST_ERR_NO_SAVE_PARAMS = 30,
    HIST_ERR_TOO_MANY_SAVE_ACTIONS = 31,
    HIST_ERR_ACTION_MISMATCH = 32,
    HIST_ERR_NO_CLOSING_PAREN = 33,
    HIST_ERR_SUBSYS_NOT_FOUND = 34,
    HIST_ERR_INVALID_SUBSYS_EVENT = 35,
    HIST_ERR_INVALID_REF_KEY = 36,
    HIST_ERR_VAR_NOT_FOUND = 37,
    HIST_ERR_FIELD_NOT_FOUND = 38,
    HIST_ERR_EMPTY_ASSIGNMENT = 39,
    HIST_ERR_INVALID_SORT_MODIFIER = 40,
    HIST_ERR_EMPTY_SORT_FIELD = 41,
    HIST_ERR_TOO_MANY_SORT_FIELDS = 42,
    HIST_ERR_INVALID_SORT_FIELD = 43,
    HIST_ERR_INVALID_STR_OPERAND = 44,
    HIST_ERR_EXPECT_NUMBER = 45,
    HIST_ERR_UNARY_MINUS_SUBEXPR = 46,
    HIST_ERR_DIVISION_BY_ZERO = 47,
    HIST_ERR_NEED_NOHC_VAL = 48,
};

enum {
    HI_SOFTIRQ = 0,
    TIMER_SOFTIRQ = 1,
    NET_TX_SOFTIRQ = 2,
    NET_RX_SOFTIRQ = 3,
    BLOCK_SOFTIRQ = 4,
    IRQ_POLL_SOFTIRQ = 5,
    TASKLET_SOFTIRQ = 6,
    SCHED_SOFTIRQ = 7,
    HRTIMER_SOFTIRQ = 8,
    RCU_SOFTIRQ = 9,
    NR_SOFTIRQS = 10,
};

enum {
    HMM_NEED_FAULT = 1,
    HMM_NEED_WRITE_FAULT = 2,
    HMM_NEED_ALL_BITS = 3,
};

enum {
    HP_THREAD_NONE = 0,
    HP_THREAD_ACTIVE = 1,
    HP_THREAD_PARKED = 2,
};

enum {
    HUGETLB_SHMFS_INODE = 1,
    HUGETLB_ANONHUGE_INODE = 2,
};

enum {
    HW_BREAKPOINT_EMPTY = 0,
    HW_BREAKPOINT_R = 1,
    HW_BREAKPOINT_W = 2,
    HW_BREAKPOINT_RW = 3,
    HW_BREAKPOINT_X = 4,
    HW_BREAKPOINT_INVALID = 7,
};

enum {
    HW_BREAKPOINT_LEN_1 = 1,
    HW_BREAKPOINT_LEN_2 = 2,
    HW_BREAKPOINT_LEN_3 = 3,
    HW_BREAKPOINT_LEN_4 = 4,
    HW_BREAKPOINT_LEN_5 = 5,
    HW_BREAKPOINT_LEN_6 = 6,
    HW_BREAKPOINT_LEN_7 = 7,
    HW_BREAKPOINT_LEN_8 = 8,
};

enum {
    ICMP6_MIB_NUM = 0,
    ICMP6_MIB_INMSGS = 1,
    ICMP6_MIB_INERRORS = 2,
    ICMP6_MIB_OUTMSGS = 3,
    ICMP6_MIB_OUTERRORS = 4,
    ICMP6_MIB_CSUMERRORS = 5,
    ICMP6_MIB_RATELIMITHOST = 6,
    __ICMP6_MIB_MAX = 7,
};

enum {
    ICMP_MIB_NUM = 0,
    ICMP_MIB_INMSGS = 1,
    ICMP_MIB_INERRORS = 2,
    ICMP_MIB_INDESTUNREACHS = 3,
    ICMP_MIB_INTIMEEXCDS = 4,
    ICMP_MIB_INPARMPROBS = 5,
    ICMP_MIB_INSRCQUENCHS = 6,
    ICMP_MIB_INREDIRECTS = 7,
    ICMP_MIB_INECHOS = 8,
    ICMP_MIB_INECHOREPS = 9,
    ICMP_MIB_INTIMESTAMPS = 10,
    ICMP_MIB_INTIMESTAMPREPS = 11,
    ICMP_MIB_INADDRMASKS = 12,
    ICMP_MIB_INADDRMASKREPS = 13,
    ICMP_MIB_OUTMSGS = 14,
    ICMP_MIB_OUTERRORS = 15,
    ICMP_MIB_OUTDESTUNREACHS = 16,
    ICMP_MIB_OUTTIMEEXCDS = 17,
    ICMP_MIB_OUTPARMPROBS = 18,
    ICMP_MIB_OUTSRCQUENCHS = 19,
    ICMP_MIB_OUTREDIRECTS = 20,
    ICMP_MIB_OUTECHOS = 21,
    ICMP_MIB_OUTECHOREPS = 22,
    ICMP_MIB_OUTTIMESTAMPS = 23,
    ICMP_MIB_OUTTIMESTAMPREPS = 24,
    ICMP_MIB_OUTADDRMASKS = 25,
    ICMP_MIB_OUTADDRMASKREPS = 26,
    ICMP_MIB_CSUMERRORS = 27,
    ICMP_MIB_RATELIMITGLOBAL = 28,
    ICMP_MIB_RATELIMITHOST = 29,
    __ICMP_MIB_MAX = 30,
};

enum {
    ICQ_EXITED = 4,
    ICQ_DESTROYED = 8,
};

enum {
    IDX_MODULE_ID = 0,
    IDX_ST_OPS_COMMON_VALUE_ID = 1,
};

enum {
    IFAL_ADDRESS = 1,
    IFAL_LABEL = 2,
    __IFAL_MAX = 3,
};

enum {
    IFA_UNSPEC = 0,
    IFA_ADDRESS = 1,
    IFA_LOCAL = 2,
    IFA_LABEL = 3,
    IFA_BROADCAST = 4,
    IFA_ANYCAST = 5,
    IFA_CACHEINFO = 6,
    IFA_MULTICAST = 7,
    IFA_FLAGS = 8,
    IFA_RT_PRIORITY = 9,
    IFA_TARGET_NETNSID = 10,
    IFA_PROTO = 11,
    __IFA_MAX = 12,
};

enum {
    IFLA_BRIDGE_FLAGS = 0,
    IFLA_BRIDGE_MODE = 1,
    IFLA_BRIDGE_VLAN_INFO = 2,
    IFLA_BRIDGE_VLAN_TUNNEL_INFO = 3,
    IFLA_BRIDGE_MRP = 4,
    IFLA_BRIDGE_CFM = 5,
    IFLA_BRIDGE_MST = 6,
    __IFLA_BRIDGE_MAX = 7,
};

enum {
    IFLA_BRPORT_UNSPEC = 0,
    IFLA_BRPORT_STATE = 1,
    IFLA_BRPORT_PRIORITY = 2,
    IFLA_BRPORT_COST = 3,
    IFLA_BRPORT_MODE = 4,
    IFLA_BRPORT_GUARD = 5,
    IFLA_BRPORT_PROTECT = 6,
    IFLA_BRPORT_FAST_LEAVE = 7,
    IFLA_BRPORT_LEARNING = 8,
    IFLA_BRPORT_UNICAST_FLOOD = 9,
    IFLA_BRPORT_PROXYARP = 10,
    IFLA_BRPORT_LEARNING_SYNC = 11,
    IFLA_BRPORT_PROXYARP_WIFI = 12,
    IFLA_BRPORT_ROOT_ID = 13,
    IFLA_BRPORT_BRIDGE_ID = 14,
    IFLA_BRPORT_DESIGNATED_PORT = 15,
    IFLA_BRPORT_DESIGNATED_COST = 16,
    IFLA_BRPORT_ID = 17,
    IFLA_BRPORT_NO = 18,
    IFLA_BRPORT_TOPOLOGY_CHANGE_ACK = 19,
    IFLA_BRPORT_CONFIG_PENDING = 20,
    IFLA_BRPORT_MESSAGE_AGE_TIMER = 21,
    IFLA_BRPORT_FORWARD_DELAY_TIMER = 22,
    IFLA_BRPORT_HOLD_TIMER = 23,
    IFLA_BRPORT_FLUSH = 24,
    IFLA_BRPORT_MULTICAST_ROUTER = 25,
    IFLA_BRPORT_PAD = 26,
    IFLA_BRPORT_MCAST_FLOOD = 27,
    IFLA_BRPORT_MCAST_TO_UCAST = 28,
    IFLA_BRPORT_VLAN_TUNNEL = 29,
    IFLA_BRPORT_BCAST_FLOOD = 30,
    IFLA_BRPORT_GROUP_FWD_MASK = 31,
    IFLA_BRPORT_NEIGH_SUPPRESS = 32,
    IFLA_BRPORT_ISOLATED = 33,
    IFLA_BRPORT_BACKUP_PORT = 34,
    IFLA_BRPORT_MRP_RING_OPEN = 35,
    IFLA_BRPORT_MRP_IN_OPEN = 36,
    IFLA_BRPORT_MCAST_EHT_HOSTS_LIMIT = 37,
    IFLA_BRPORT_MCAST_EHT_HOSTS_CNT = 38,
    IFLA_BRPORT_LOCKED = 39,
    IFLA_BRPORT_MAB = 40,
    IFLA_BRPORT_MCAST_N_GROUPS = 41,
    IFLA_BRPORT_MCAST_MAX_GROUPS = 42,
    IFLA_BRPORT_NEIGH_VLAN_SUPPRESS = 43,
    IFLA_BRPORT_BACKUP_NHID = 44,
    __IFLA_BRPORT_MAX = 45,
};

enum {
    IFLA_EVENT_NONE = 0,
    IFLA_EVENT_REBOOT = 1,
    IFLA_EVENT_FEATURES = 2,
    IFLA_EVENT_BONDING_FAILOVER = 3,
    IFLA_EVENT_NOTIFY_PEERS = 4,
    IFLA_EVENT_IGMP_RESEND = 5,
    IFLA_EVENT_BONDING_OPTIONS = 6,
};

enum {
    IFLA_INET6_UNSPEC = 0,
    IFLA_INET6_FLAGS = 1,
    IFLA_INET6_CONF = 2,
    IFLA_INET6_STATS = 3,
    IFLA_INET6_MCAST = 4,
    IFLA_INET6_CACHEINFO = 5,
    IFLA_INET6_ICMP6STATS = 6,
    IFLA_INET6_TOKEN = 7,
    IFLA_INET6_ADDR_GEN_MODE = 8,
    IFLA_INET6_RA_MTU = 9,
    __IFLA_INET6_MAX = 10,
};

enum {
    IFLA_INET_UNSPEC = 0,
    IFLA_INET_CONF = 1,
    __IFLA_INET_MAX = 2,
};

enum {
    IFLA_INFO_UNSPEC = 0,
    IFLA_INFO_KIND = 1,
    IFLA_INFO_DATA = 2,
    IFLA_INFO_XSTATS = 3,
    IFLA_INFO_SLAVE_KIND = 4,
    IFLA_INFO_SLAVE_DATA = 5,
    __IFLA_INFO_MAX = 6,
};

enum {
    IFLA_IPTUN_UNSPEC = 0,
    IFLA_IPTUN_LINK = 1,
    IFLA_IPTUN_LOCAL = 2,
    IFLA_IPTUN_REMOTE = 3,
    IFLA_IPTUN_TTL = 4,
    IFLA_IPTUN_TOS = 5,
    IFLA_IPTUN_ENCAP_LIMIT = 6,
    IFLA_IPTUN_FLOWINFO = 7,
    IFLA_IPTUN_FLAGS = 8,
    IFLA_IPTUN_PROTO = 9,
    IFLA_IPTUN_PMTUDISC = 10,
    IFLA_IPTUN_6RD_PREFIX = 11,
    IFLA_IPTUN_6RD_RELAY_PREFIX = 12,
    IFLA_IPTUN_6RD_PREFIXLEN = 13,
    IFLA_IPTUN_6RD_RELAY_PREFIXLEN = 14,
    IFLA_IPTUN_ENCAP_TYPE = 15,
    IFLA_IPTUN_ENCAP_FLAGS = 16,
    IFLA_IPTUN_ENCAP_SPORT = 17,
    IFLA_IPTUN_ENCAP_DPORT = 18,
    IFLA_IPTUN_COLLECT_METADATA = 19,
    IFLA_IPTUN_FWMARK = 20,
    __IFLA_IPTUN_VENDOR_BREAK = 21,
    IFLA_IPTUN_FAN_MAP = 33,
    __IFLA_IPTUN_MAX = 34,
};

enum {
    IFLA_NETKIT_UNSPEC = 0,
    IFLA_NETKIT_PEER_INFO = 1,
    IFLA_NETKIT_PRIMARY = 2,
    IFLA_NETKIT_POLICY = 3,
    IFLA_NETKIT_PEER_POLICY = 4,
    IFLA_NETKIT_MODE = 5,
    IFLA_NETKIT_SCRUB = 6,
    IFLA_NETKIT_PEER_SCRUB = 7,
    IFLA_NETKIT_HEADROOM = 8,
    IFLA_NETKIT_TAILROOM = 9,
    __IFLA_NETKIT_MAX = 10,
};

enum {
    IFLA_OFFLOAD_XSTATS_HW_S_INFO_UNSPEC = 0,
    IFLA_OFFLOAD_XSTATS_HW_S_INFO_REQUEST = 1,
    IFLA_OFFLOAD_XSTATS_HW_S_INFO_USED = 2,
    __IFLA_OFFLOAD_XSTATS_HW_S_INFO_MAX = 3,
};

enum {
    IFLA_OFFLOAD_XSTATS_UNSPEC = 0,
    IFLA_OFFLOAD_XSTATS_CPU_HIT = 1,
    IFLA_OFFLOAD_XSTATS_HW_S_INFO = 2,
    IFLA_OFFLOAD_XSTATS_L3_STATS = 3,
    __IFLA_OFFLOAD_XSTATS_MAX = 4,
};

enum {
    IFLA_PORT_UNSPEC = 0,
    IFLA_PORT_VF = 1,
    IFLA_PORT_PROFILE = 2,
    IFLA_PORT_VSI_TYPE = 3,
    IFLA_PORT_INSTANCE_UUID = 4,
    IFLA_PORT_HOST_UUID = 5,
    IFLA_PORT_REQUEST = 6,
    IFLA_PORT_RESPONSE = 7,
    __IFLA_PORT_MAX = 8,
};

enum {
    IFLA_PROTO_DOWN_REASON_UNSPEC = 0,
    IFLA_PROTO_DOWN_REASON_MASK = 1,
    IFLA_PROTO_DOWN_REASON_VALUE = 2,
    __IFLA_PROTO_DOWN_REASON_CNT = 3,
    IFLA_PROTO_DOWN_REASON_MAX = 2,
};

enum {
    IFLA_STATS_GETSET_UNSPEC = 0,
    IFLA_STATS_GET_FILTERS = 1,
    IFLA_STATS_SET_OFFLOAD_XSTATS_L3_STATS = 2,
    __IFLA_STATS_GETSET_MAX = 3,
};

enum {
    IFLA_STATS_UNSPEC = 0,
    IFLA_STATS_LINK_64 = 1,
    IFLA_STATS_LINK_XSTATS = 2,
    IFLA_STATS_LINK_XSTATS_SLAVE = 3,
    IFLA_STATS_LINK_OFFLOAD_XSTATS = 4,
    IFLA_STATS_AF_SPEC = 5,
    __IFLA_STATS_MAX = 6,
};

enum {
    IFLA_UNSPEC = 0,
    IFLA_ADDRESS = 1,
    IFLA_BROADCAST = 2,
    IFLA_IFNAME = 3,
    IFLA_MTU = 4,
    IFLA_LINK = 5,
    IFLA_QDISC = 6,
    IFLA_STATS = 7,
    IFLA_COST = 8,
    IFLA_PRIORITY = 9,
    IFLA_MASTER = 10,
    IFLA_WIRELESS = 11,
    IFLA_PROTINFO = 12,
    IFLA_TXQLEN = 13,
    IFLA_MAP = 14,
    IFLA_WEIGHT = 15,
    IFLA_OPERSTATE = 16,
    IFLA_LINKMODE = 17,
    IFLA_LINKINFO = 18,
    IFLA_NET_NS_PID = 19,
    IFLA_IFALIAS = 20,
    IFLA_NUM_VF = 21,
    IFLA_VFINFO_LIST = 22,
    IFLA_STATS64 = 23,
    IFLA_VF_PORTS = 24,
    IFLA_PORT_SELF = 25,
    IFLA_AF_SPEC = 26,
    IFLA_GROUP = 27,
    IFLA_NET_NS_FD = 28,
    IFLA_EXT_MASK = 29,
    IFLA_PROMISCUITY = 30,
    IFLA_NUM_TX_QUEUES = 31,
    IFLA_NUM_RX_QUEUES = 32,
    IFLA_CARRIER = 33,
    IFLA_PHYS_PORT_ID = 34,
    IFLA_CARRIER_CHANGES = 35,
    IFLA_PHYS_SWITCH_ID = 36,
    IFLA_LINK_NETNSID = 37,
    IFLA_PHYS_PORT_NAME = 38,
    IFLA_PROTO_DOWN = 39,
    IFLA_GSO_MAX_SEGS = 40,
    IFLA_GSO_MAX_SIZE = 41,
    IFLA_PAD = 42,
    IFLA_XDP = 43,
    IFLA_EVENT = 44,
    IFLA_NEW_NETNSID = 45,
    IFLA_IF_NETNSID = 46,
    IFLA_TARGET_NETNSID = 46,
    IFLA_CARRIER_UP_COUNT = 47,
    IFLA_CARRIER_DOWN_COUNT = 48,
    IFLA_NEW_IFINDEX = 49,
    IFLA_MIN_MTU = 50,
    IFLA_MAX_MTU = 51,
    IFLA_PROP_LIST = 52,
    IFLA_ALT_IFNAME = 53,
    IFLA_PERM_ADDRESS = 54,
    IFLA_PROTO_DOWN_REASON = 55,
    IFLA_PARENT_DEV_NAME = 56,
    IFLA_PARENT_DEV_BUS_NAME = 57,
    IFLA_GRO_MAX_SIZE = 58,
    IFLA_TSO_MAX_SIZE = 59,
    IFLA_TSO_MAX_SEGS = 60,
    IFLA_ALLMULTI = 61,
    IFLA_DEVLINK_PORT = 62,
    IFLA_GSO_IPV4_MAX_SIZE = 63,
    IFLA_GRO_IPV4_MAX_SIZE = 64,
    IFLA_DPLL_PIN = 65,
    IFLA_MAX_PACING_OFFLOAD_HORIZON = 66,
    __IFLA_MAX = 67,
};

enum {
    IFLA_VF_INFO_UNSPEC = 0,
    IFLA_VF_INFO = 1,
    __IFLA_VF_INFO_MAX = 2,
};

enum {
    IFLA_VF_PORT_UNSPEC = 0,
    IFLA_VF_PORT = 1,
    __IFLA_VF_PORT_MAX = 2,
};

enum {
    IFLA_VF_STATS_RX_PACKETS = 0,
    IFLA_VF_STATS_TX_PACKETS = 1,
    IFLA_VF_STATS_RX_BYTES = 2,
    IFLA_VF_STATS_TX_BYTES = 3,
    IFLA_VF_STATS_BROADCAST = 4,
    IFLA_VF_STATS_MULTICAST = 5,
    IFLA_VF_STATS_PAD = 6,
    IFLA_VF_STATS_RX_DROPPED = 7,
    IFLA_VF_STATS_TX_DROPPED = 8,
    __IFLA_VF_STATS_MAX = 9,
};

enum {
    IFLA_VF_UNSPEC = 0,
    IFLA_VF_MAC = 1,
    IFLA_VF_VLAN = 2,
    IFLA_VF_TX_RATE = 3,
    IFLA_VF_SPOOFCHK = 4,
    IFLA_VF_LINK_STATE = 5,
    IFLA_VF_RATE = 6,
    IFLA_VF_RSS_QUERY_EN = 7,
    IFLA_VF_STATS = 8,
    IFLA_VF_TRUST = 9,
    IFLA_VF_IB_NODE_GUID = 10,
    IFLA_VF_IB_PORT_GUID = 11,
    IFLA_VF_VLAN_LIST = 12,
    IFLA_VF_BROADCAST = 13,
    __IFLA_VF_MAX = 14,
};

enum {
    IFLA_VF_VLAN_INFO_UNSPEC = 0,
    IFLA_VF_VLAN_INFO = 1,
    __IFLA_VF_VLAN_INFO_MAX = 2,
};

enum {
    IFLA_XDP_UNSPEC = 0,
    IFLA_XDP_FD = 1,
    IFLA_XDP_ATTACHED = 2,
    IFLA_XDP_FLAGS = 3,
    IFLA_XDP_PROG_ID = 4,
    IFLA_XDP_DRV_PROG_ID = 5,
    IFLA_XDP_SKB_PROG_ID = 6,
    IFLA_XDP_HW_PROG_ID = 7,
    IFLA_XDP_EXPECTED_FD = 8,
    __IFLA_XDP_MAX = 9,
};

enum {
    IF_ACT_NONE = -1,
    IF_ACT_FILTER = 0,
    IF_ACT_START = 1,
    IF_ACT_STOP = 2,
    IF_SRC_FILE = 3,
    IF_SRC_KERNEL = 4,
    IF_SRC_FILEADDR = 5,
    IF_SRC_KERNELADDR = 6,
};

enum {
    IF_LINK_MODE_DEFAULT = 0,
    IF_LINK_MODE_DORMANT = 1,
    IF_LINK_MODE_TESTING = 2,
};

enum {
    IF_OPER_UNKNOWN = 0,
    IF_OPER_NOTPRESENT = 1,
    IF_OPER_DOWN = 2,
    IF_OPER_LOWERLAYERDOWN = 3,
    IF_OPER_TESTING = 4,
    IF_OPER_DORMANT = 5,
    IF_OPER_UP = 6,
};

enum {
    IF_STATE_ACTION = 0,
    IF_STATE_SOURCE = 1,
    IF_STATE_END = 2,
};

enum {
    INET6_IFADDR_STATE_PREDAD = 0,
    INET6_IFADDR_STATE_DAD = 1,
    INET6_IFADDR_STATE_POSTDAD = 2,
    INET6_IFADDR_STATE_ERRDAD = 3,
    INET6_IFADDR_STATE_DEAD = 4,
};

enum {
    INET_DIAG_REQ_NONE = 0,
    INET_DIAG_REQ_BYTECODE = 1,
    INET_DIAG_REQ_SK_BPF_STORAGES = 2,
    INET_DIAG_REQ_PROTOCOL = 3,
    __INET_DIAG_REQ_MAX = 4,
};

enum {
    INET_ECN_NOT_ECT = 0,
    INET_ECN_ECT_1 = 1,
    INET_ECN_ECT_0 = 2,
    INET_ECN_CE = 3,
    INET_ECN_MASK = 3,
};

enum {
    INET_FLAGS_PKTINFO = 0,
    INET_FLAGS_TTL = 1,
    INET_FLAGS_TOS = 2,
    INET_FLAGS_RECVOPTS = 3,
    INET_FLAGS_RETOPTS = 4,
    INET_FLAGS_PASSSEC = 5,
    INET_FLAGS_ORIGDSTADDR = 6,
    INET_FLAGS_CHECKSUM = 7,
    INET_FLAGS_RECVFRAGSIZE = 8,
    INET_FLAGS_RECVERR = 9,
    INET_FLAGS_RECVERR_RFC4884 = 10,
    INET_FLAGS_FREEBIND = 11,
    INET_FLAGS_HDRINCL = 12,
    INET_FLAGS_MC_LOOP = 13,
    INET_FLAGS_MC_ALL = 14,
    INET_FLAGS_TRANSPARENT = 15,
    INET_FLAGS_IS_ICSK = 16,
    INET_FLAGS_NODEFRAG = 17,
    INET_FLAGS_BIND_ADDRESS_NO_PORT = 18,
    INET_FLAGS_DEFER_CONNECT = 19,
    INET_FLAGS_MC6_LOOP = 20,
    INET_FLAGS_RECVERR6_RFC4884 = 21,
    INET_FLAGS_MC6_ALL = 22,
    INET_FLAGS_AUTOFLOWLABEL_SET = 23,
    INET_FLAGS_AUTOFLOWLABEL = 24,
    INET_FLAGS_DONTFRAG = 25,
    INET_FLAGS_RECVERR6 = 26,
    INET_FLAGS_REPFLOW = 27,
    INET_FLAGS_RTALERT_ISOLATE = 28,
    INET_FLAGS_SNDFLOW = 29,
    INET_FLAGS_RTALERT = 30,
};

enum {
    INET_FRAG_FIRST_IN = 1,
    INET_FRAG_LAST_IN = 2,
    INET_FRAG_COMPLETE = 4,
    INET_FRAG_HASH_DEAD = 8,
    INET_FRAG_DROP = 16,
};

enum {
    INET_ULP_INFO_UNSPEC = 0,
    INET_ULP_INFO_NAME = 1,
    INET_ULP_INFO_TLS = 2,
    INET_ULP_INFO_MPTCP = 3,
    __INET_ULP_INFO_MAX = 4,
};

enum {
    INSN_F_FRAMENO_MASK = 7,
    INSN_F_SPI_MASK = 63,
    INSN_F_SPI_SHIFT = 3,
    INSN_F_STACK_ACCESS = 512,
};

enum {
    INVERT = 1,
    PROCESS_AND = 2,
    PROCESS_OR = 4,
};

enum {
    IOAM6_ATTR_UNSPEC = 0,
    IOAM6_ATTR_NS_ID = 1,
    IOAM6_ATTR_NS_DATA = 2,
    IOAM6_ATTR_NS_DATA_WIDE = 3,
    IOAM6_ATTR_SC_ID = 4,
    IOAM6_ATTR_SC_DATA = 5,
    IOAM6_ATTR_SC_NONE = 6,
    IOAM6_ATTR_PAD = 7,
    __IOAM6_ATTR_MAX = 8,
};

enum {
    IOAM6_CMD_UNSPEC = 0,
    IOAM6_CMD_ADD_NAMESPACE = 1,
    IOAM6_CMD_DEL_NAMESPACE = 2,
    IOAM6_CMD_DUMP_NAMESPACES = 3,
    IOAM6_CMD_ADD_SCHEMA = 4,
    IOAM6_CMD_DEL_SCHEMA = 5,
    IOAM6_CMD_DUMP_SCHEMAS = 6,
    IOAM6_CMD_NS_SET_SCHEMA = 7,
    __IOAM6_CMD_MAX = 8,
};

enum {
    IOAM6_IPTUNNEL_UNSPEC = 0,
    IOAM6_IPTUNNEL_MODE = 1,
    IOAM6_IPTUNNEL_DST = 2,
    IOAM6_IPTUNNEL_TRACE = 3,
    IOAM6_IPTUNNEL_FREQ_K = 4,
    IOAM6_IPTUNNEL_FREQ_N = 5,
    IOAM6_IPTUNNEL_SRC = 6,
    __IOAM6_IPTUNNEL_MAX = 7,
};

enum {
    IOBL_BUF_RING = 1,
    IOBL_INC = 2,
};

enum {
    IOCB_CMD_PREAD = 0,
    IOCB_CMD_PWRITE = 1,
    IOCB_CMD_FSYNC = 2,
    IOCB_CMD_FDSYNC = 3,
    IOCB_CMD_POLL = 5,
    IOCB_CMD_NOOP = 6,
    IOCB_CMD_PREADV = 7,
    IOCB_CMD_PWRITEV = 8,
};

enum {
    IOMMU_SET_DOMAIN_MUST_SUCCEED = 1,
};

enum {
    IOPRIO_CLASS_NONE = 0,
    IOPRIO_CLASS_RT = 1,
    IOPRIO_CLASS_BE = 2,
    IOPRIO_CLASS_IDLE = 3,
    IOPRIO_CLASS_INVALID = 7,
};

enum {
    IOPRIO_HINT_NONE = 0,
    IOPRIO_HINT_DEV_DURATION_LIMIT_1 = 1,
    IOPRIO_HINT_DEV_DURATION_LIMIT_2 = 2,
    IOPRIO_HINT_DEV_DURATION_LIMIT_3 = 3,
    IOPRIO_HINT_DEV_DURATION_LIMIT_4 = 4,
    IOPRIO_HINT_DEV_DURATION_LIMIT_5 = 5,
    IOPRIO_HINT_DEV_DURATION_LIMIT_6 = 6,
    IOPRIO_HINT_DEV_DURATION_LIMIT_7 = 7,
};

enum {
    IOPRIO_WHO_PROCESS = 1,
    IOPRIO_WHO_PGRP = 2,
    IOPRIO_WHO_USER = 3,
};

enum {
    IORES_DESC_NONE = 0,
    IORES_DESC_CRASH_KERNEL = 1,
    IORES_DESC_ACPI_TABLES = 2,
    IORES_DESC_ACPI_NV_STORAGE = 3,
    IORES_DESC_PERSISTENT_MEMORY = 4,
    IORES_DESC_PERSISTENT_MEMORY_LEGACY = 5,
    IORES_DESC_DEVICE_PRIVATE_MEMORY = 6,
    IORES_DESC_RESERVED = 7,
    IORES_DESC_SOFT_RESERVED = 8,
    IORES_DESC_CXL = 9,
};

enum {
    IORING_MEM_REGION_REG_WAIT_ARG = 1,
};

enum {
    IORING_MEM_REGION_TYPE_USER = 1,
};

enum {
    IORING_REGISTER_SRC_REGISTERED = 1,
    IORING_REGISTER_DST_REPLACE = 2,
};

enum {
    IORING_REG_WAIT_TS = 1,
};

enum {
    IORING_RSRC_FILE = 0,
    IORING_RSRC_BUFFER = 1,
};

enum {
    IOU_F_TWQ_LAZY_WAKE = 1,
};

enum {
    IOU_OK = 0,
    IOU_ISSUE_SKIP_COMPLETE = -529,
    IOU_REQUEUE = -3072,
    IOU_STOP_MULTISHOT = -125,
};

enum {
    IOU_POLL_DONE = 0,
    IOU_POLL_NO_ACTION = 1,
    IOU_POLL_REMOVE_POLL_USE_RES = 2,
    IOU_POLL_REISSUE = 3,
    IOU_POLL_REQUEUE = 4,
};

enum {
    IO_ACCT_STALLED_BIT = 0,
};

enum {
    IO_APOLL_OK = 0,
    IO_APOLL_ABORTED = 1,
    IO_APOLL_READY = 2,
};

enum {
    IO_CHECK_CQ_OVERFLOW_BIT = 0,
    IO_CHECK_CQ_DROPPED_BIT = 1,
};

enum {
    IO_EVENTFD_OP_SIGNAL_BIT = 0,
};

enum {
    IO_REGION_F_VMAP = 1,
    IO_REGION_F_USER_PROVIDED = 2,
    IO_REGION_F_SINGLE_REF = 4,
};

enum {
    IO_SQ_THREAD_SHOULD_STOP = 0,
    IO_SQ_THREAD_SHOULD_PARK = 1,
};

enum {
    IO_WORKER_F_UP = 0,
    IO_WORKER_F_RUNNING = 1,
    IO_WORKER_F_FREE = 2,
    IO_WORKER_F_BOUND = 3,
};

enum {
    IO_WQ_ACCT_BOUND = 0,
    IO_WQ_ACCT_UNBOUND = 1,
    IO_WQ_ACCT_NR = 2,
};

enum {
    IO_WQ_BIT_EXIT = 0,
};

enum {
    IO_WQ_WORK_CANCEL = 1,
    IO_WQ_WORK_HASHED = 2,
    IO_WQ_WORK_UNBOUND = 4,
    IO_WQ_WORK_CONCURRENT = 16,
    IO_WQ_HASH_SHIFT = 24,
};

enum {
    IP6MRA_CREPORT_UNSPEC = 0,
    IP6MRA_CREPORT_MSGTYPE = 1,
    IP6MRA_CREPORT_MIF_ID = 2,
    IP6MRA_CREPORT_SRC_ADDR = 3,
    IP6MRA_CREPORT_DST_ADDR = 4,
    IP6MRA_CREPORT_PKT = 5,
    __IP6MRA_CREPORT_MAX = 6,
};

enum {
    IP6_FH_F_FRAG = 1,
    IP6_FH_F_AUTH = 2,
    IP6_FH_F_SKIP_RH = 4,
};

enum {
    IPMRA_CREPORT_UNSPEC = 0,
    IPMRA_CREPORT_MSGTYPE = 1,
    IPMRA_CREPORT_VIF_ID = 2,
    IPMRA_CREPORT_SRC_ADDR = 3,
    IPMRA_CREPORT_DST_ADDR = 4,
    IPMRA_CREPORT_PKT = 5,
    IPMRA_CREPORT_TABLE = 6,
    __IPMRA_CREPORT_MAX = 7,
};

enum {
    IPMRA_TABLE_UNSPEC = 0,
    IPMRA_TABLE_ID = 1,
    IPMRA_TABLE_CACHE_RES_QUEUE_LEN = 2,
    IPMRA_TABLE_MROUTE_REG_VIF_NUM = 3,
    IPMRA_TABLE_MROUTE_DO_ASSERT = 4,
    IPMRA_TABLE_MROUTE_DO_PIM = 5,
    IPMRA_TABLE_VIFS = 6,
    IPMRA_TABLE_MROUTE_DO_WRVIFWHOLE = 7,
    __IPMRA_TABLE_MAX = 8,
};

enum {
    IPMRA_VIFA_UNSPEC = 0,
    IPMRA_VIFA_IFINDEX = 1,
    IPMRA_VIFA_VIF_ID = 2,
    IPMRA_VIFA_FLAGS = 3,
    IPMRA_VIFA_BYTES_IN = 4,
    IPMRA_VIFA_BYTES_OUT = 5,
    IPMRA_VIFA_PACKETS_IN = 6,
    IPMRA_VIFA_PACKETS_OUT = 7,
    IPMRA_VIFA_LOCAL_ADDR = 8,
    IPMRA_VIFA_REMOTE_ADDR = 9,
    IPMRA_VIFA_PAD = 10,
    __IPMRA_VIFA_MAX = 11,
};

enum {
    IPMRA_VIF_UNSPEC = 0,
    IPMRA_VIF = 1,
    __IPMRA_VIF_MAX = 2,
};

enum {
    IPPROTO_IP = 0,
    IPPROTO_ICMP = 1,
    IPPROTO_IGMP = 2,
    IPPROTO_IPIP = 4,
    IPPROTO_TCP = 6,
    IPPROTO_EGP = 8,
    IPPROTO_PUP = 12,
    IPPROTO_UDP = 17,
    IPPROTO_IDP = 22,
    IPPROTO_TP = 29,
    IPPROTO_DCCP = 33,
    IPPROTO_IPV6 = 41,
    IPPROTO_RSVP = 46,
    IPPROTO_GRE = 47,
    IPPROTO_ESP = 50,
    IPPROTO_AH = 51,
    IPPROTO_MTP = 92,
    IPPROTO_BEETPH = 94,
    IPPROTO_ENCAP = 98,
    IPPROTO_PIM = 103,
    IPPROTO_COMP = 108,
    IPPROTO_L2TP = 115,
    IPPROTO_SCTP = 132,
    IPPROTO_UDPLITE = 136,
    IPPROTO_MPLS = 137,
    IPPROTO_ETHERNET = 143,
    IPPROTO_AGGFRAG = 144,
    IPPROTO_RAW = 255,
    IPPROTO_SMC = 256,
    IPPROTO_MPTCP = 262,
    IPPROTO_MAX = 263,
};

enum {
    IPSTATS_MIB_NUM = 0,
    IPSTATS_MIB_INPKTS = 1,
    IPSTATS_MIB_INOCTETS = 2,
    IPSTATS_MIB_INDELIVERS = 3,
    IPSTATS_MIB_OUTFORWDATAGRAMS = 4,
    IPSTATS_MIB_OUTREQUESTS = 5,
    IPSTATS_MIB_OUTOCTETS = 6,
    IPSTATS_MIB_INHDRERRORS = 7,
    IPSTATS_MIB_INTOOBIGERRORS = 8,
    IPSTATS_MIB_INNOROUTES = 9,
    IPSTATS_MIB_INADDRERRORS = 10,
    IPSTATS_MIB_INUNKNOWNPROTOS = 11,
    IPSTATS_MIB_INTRUNCATEDPKTS = 12,
    IPSTATS_MIB_INDISCARDS = 13,
    IPSTATS_MIB_OUTDISCARDS = 14,
    IPSTATS_MIB_OUTNOROUTES = 15,
    IPSTATS_MIB_REASMTIMEOUT = 16,
    IPSTATS_MIB_REASMREQDS = 17,
    IPSTATS_MIB_REASMOKS = 18,
    IPSTATS_MIB_REASMFAILS = 19,
    IPSTATS_MIB_FRAGOKS = 20,
    IPSTATS_MIB_FRAGFAILS = 21,
    IPSTATS_MIB_FRAGCREATES = 22,
    IPSTATS_MIB_INMCASTPKTS = 23,
    IPSTATS_MIB_OUTMCASTPKTS = 24,
    IPSTATS_MIB_INBCASTPKTS = 25,
    IPSTATS_MIB_OUTBCASTPKTS = 26,
    IPSTATS_MIB_INMCASTOCTETS = 27,
    IPSTATS_MIB_OUTMCASTOCTETS = 28,
    IPSTATS_MIB_INBCASTOCTETS = 29,
    IPSTATS_MIB_OUTBCASTOCTETS = 30,
    IPSTATS_MIB_CSUMERRORS = 31,
    IPSTATS_MIB_NOECTPKTS = 32,
    IPSTATS_MIB_ECT1PKTS = 33,
    IPSTATS_MIB_ECT0PKTS = 34,
    IPSTATS_MIB_CEPKTS = 35,
    IPSTATS_MIB_REASM_OVERLAPS = 36,
    IPSTATS_MIB_OUTPKTS = 37,
    __IPSTATS_MIB_MAX = 38,
};

enum {
    IPV4_DEVCONF_FORWARDING = 1,
    IPV4_DEVCONF_MC_FORWARDING = 2,
    IPV4_DEVCONF_PROXY_ARP = 3,
    IPV4_DEVCONF_ACCEPT_REDIRECTS = 4,
    IPV4_DEVCONF_SECURE_REDIRECTS = 5,
    IPV4_DEVCONF_SEND_REDIRECTS = 6,
    IPV4_DEVCONF_SHARED_MEDIA = 7,
    IPV4_DEVCONF_RP_FILTER = 8,
    IPV4_DEVCONF_ACCEPT_SOURCE_ROUTE = 9,
    IPV4_DEVCONF_BOOTP_RELAY = 10,
    IPV4_DEVCONF_LOG_MARTIANS = 11,
    IPV4_DEVCONF_TAG = 12,
    IPV4_DEVCONF_ARPFILTER = 13,
    IPV4_DEVCONF_MEDIUM_ID = 14,
    IPV4_DEVCONF_NOXFRM = 15,
    IPV4_DEVCONF_NOPOLICY = 16,
    IPV4_DEVCONF_FORCE_IGMP_VERSION = 17,
    IPV4_DEVCONF_ARP_ANNOUNCE = 18,
    IPV4_DEVCONF_ARP_IGNORE = 19,
    IPV4_DEVCONF_PROMOTE_SECONDARIES = 20,
    IPV4_DEVCONF_ARP_ACCEPT = 21,
    IPV4_DEVCONF_ARP_NOTIFY = 22,
    IPV4_DEVCONF_ACCEPT_LOCAL = 23,
    IPV4_DEVCONF_SRC_VMARK = 24,
    IPV4_DEVCONF_PROXY_ARP_PVLAN = 25,
    IPV4_DEVCONF_ROUTE_LOCALNET = 26,
    IPV4_DEVCONF_IGMPV2_UNSOLICITED_REPORT_INTERVAL = 27,
    IPV4_DEVCONF_IGMPV3_UNSOLICITED_REPORT_INTERVAL = 28,
    IPV4_DEVCONF_IGNORE_ROUTES_WITH_LINKDOWN = 29,
    IPV4_DEVCONF_DROP_UNICAST_IN_L2_MULTICAST = 30,
    IPV4_DEVCONF_DROP_GRATUITOUS_ARP = 31,
    IPV4_DEVCONF_BC_FORWARDING = 32,
    IPV4_DEVCONF_ARP_EVICT_NOCARRIER = 33,
    __IPV4_DEVCONF_MAX = 34,
};

enum {
    IPV6_SADDR_RULE_INIT = 0,
    IPV6_SADDR_RULE_LOCAL = 1,
    IPV6_SADDR_RULE_SCOPE = 2,
    IPV6_SADDR_RULE_PREFERRED = 3,
    IPV6_SADDR_RULE_OIF = 4,
    IPV6_SADDR_RULE_LABEL = 5,
    IPV6_SADDR_RULE_PRIVACY = 6,
    IPV6_SADDR_RULE_ORCHID = 7,
    IPV6_SADDR_RULE_PREFIX = 8,
    IPV6_SADDR_RULE_MAX = 9,
};

enum {
    IP_TUNNEL_CSUM_BIT = 0,
    IP_TUNNEL_ROUTING_BIT = 1,
    IP_TUNNEL_KEY_BIT = 2,
    IP_TUNNEL_SEQ_BIT = 3,
    IP_TUNNEL_STRICT_BIT = 4,
    IP_TUNNEL_REC_BIT = 5,
    IP_TUNNEL_VERSION_BIT = 6,
    IP_TUNNEL_NO_KEY_BIT = 7,
    IP_TUNNEL_DONT_FRAGMENT_BIT = 8,
    IP_TUNNEL_OAM_BIT = 9,
    IP_TUNNEL_CRIT_OPT_BIT = 10,
    IP_TUNNEL_GENEVE_OPT_BIT = 11,
    IP_TUNNEL_VXLAN_OPT_BIT = 12,
    IP_TUNNEL_NOCACHE_BIT = 13,
    IP_TUNNEL_ERSPAN_OPT_BIT = 14,
    IP_TUNNEL_GTP_OPT_BIT = 15,
    IP_TUNNEL_VTI_BIT = 16,
    IP_TUNNEL_SIT_ISATAP_BIT = 16,
    IP_TUNNEL_PFCP_OPT_BIT = 17,
    __IP_TUNNEL_FLAG_NUM = 18,
};

enum {
    IRQCHIP_FWNODE_REAL = 0,
    IRQCHIP_FWNODE_NAMED = 1,
    IRQCHIP_FWNODE_NAMED_ID = 2,
};

enum {
    IRQCHIP_SET_TYPE_MASKED = 1,
    IRQCHIP_EOI_IF_HANDLED = 2,
    IRQCHIP_MASK_ON_SUSPEND = 4,
    IRQCHIP_ONOFFLINE_ENABLED = 8,
    IRQCHIP_SKIP_SET_WAKE = 16,
    IRQCHIP_ONESHOT_SAFE = 32,
    IRQCHIP_EOI_THREADED = 64,
    IRQCHIP_SUPPORTS_LEVEL_MSI = 128,
    IRQCHIP_SUPPORTS_NMI = 256,
    IRQCHIP_ENABLE_WAKEUP_ON_SUSPEND = 512,
    IRQCHIP_AFFINITY_PRE_STARTUP = 1024,
    IRQCHIP_IMMUTABLE = 2048,
    IRQCHIP_MOVE_DEFERRED = 4096,
};

enum {
    IRQC_IS_HARDIRQ = 0,
    IRQC_IS_NESTED = 1,
};

enum {
    IRQD_TRIGGER_MASK = 15,
    IRQD_SETAFFINITY_PENDING = 256,
    IRQD_ACTIVATED = 512,
    IRQD_NO_BALANCING = 1024,
    IRQD_PER_CPU = 2048,
    IRQD_AFFINITY_SET = 4096,
    IRQD_LEVEL = 8192,
    IRQD_WAKEUP_STATE = 16384,
    IRQD_IRQ_DISABLED = 65536,
    IRQD_IRQ_MASKED = 131072,
    IRQD_IRQ_INPROGRESS = 262144,
    IRQD_WAKEUP_ARMED = 524288,
    IRQD_FORWARDED_TO_VCPU = 1048576,
    IRQD_AFFINITY_MANAGED = 2097152,
    IRQD_IRQ_STARTED = 4194304,
    IRQD_MANAGED_SHUTDOWN = 8388608,
    IRQD_SINGLE_TARGET = 16777216,
    IRQD_DEFAULT_TRIGGER_SET = 33554432,
    IRQD_CAN_RESERVE = 67108864,
    IRQD_HANDLE_ENFORCE_IRQCTX = 134217728,
    IRQD_AFFINITY_ON_ACTIVATE = 268435456,
    IRQD_IRQ_ENABLED_ON_SUSPEND = 536870912,
    IRQD_RESEND_WHEN_IN_PROGRESS = 1073741824,
};

enum {
    IRQS_AUTODETECT = 1,
    IRQS_SPURIOUS_DISABLED = 2,
    IRQS_POLL_INPROGRESS = 8,
    IRQS_ONESHOT = 32,
    IRQS_REPLAY = 64,
    IRQS_WAITING = 128,
    IRQS_PENDING = 512,
    IRQS_SUSPENDED = 2048,
    IRQS_TIMINGS = 4096,
    IRQS_NMI = 8192,
    IRQS_SYSFS = 16384,
};

enum {
    IRQTF_RUNTHREAD = 0,
    IRQTF_WARNED = 1,
    IRQTF_AFFINITY = 2,
    IRQTF_FORCED_THREAD = 3,
    IRQTF_READY = 4,
};

enum {
    IRQ_DOMAIN_FLAG_HIERARCHY = 1,
    IRQ_DOMAIN_NAME_ALLOCATED = 2,
    IRQ_DOMAIN_FLAG_IPI_PER_CPU = 4,
    IRQ_DOMAIN_FLAG_IPI_SINGLE = 8,
    IRQ_DOMAIN_FLAG_MSI = 16,
    IRQ_DOMAIN_FLAG_ISOLATED_MSI = 32,
    IRQ_DOMAIN_FLAG_NO_MAP = 64,
    IRQ_DOMAIN_FLAG_MSI_PARENT = 256,
    IRQ_DOMAIN_FLAG_MSI_DEVICE = 512,
    IRQ_DOMAIN_FLAG_DESTROY_GC = 1024,
    IRQ_DOMAIN_FLAG_NONCORE = 65536,
};

enum {
    IRQ_POLL_F_SCHED = 0,
    IRQ_POLL_F_DISABLE = 1,
};

enum {
    IRQ_SET_MASK_OK = 0,
    IRQ_SET_MASK_OK_NOCOPY = 1,
    IRQ_SET_MASK_OK_DONE = 2,
};

enum {
    IRQ_STARTUP_NORMAL = 0,
    IRQ_STARTUP_MANAGED = 1,
    IRQ_STARTUP_ABORT = 2,
};

enum {
    IRQ_TYPE_NONE = 0,
    IRQ_TYPE_EDGE_RISING = 1,
    IRQ_TYPE_EDGE_FALLING = 2,
    IRQ_TYPE_EDGE_BOTH = 3,
    IRQ_TYPE_LEVEL_HIGH = 4,
    IRQ_TYPE_LEVEL_LOW = 8,
    IRQ_TYPE_LEVEL_MASK = 12,
    IRQ_TYPE_SENSE_MASK = 15,
    IRQ_TYPE_DEFAULT = 15,
    IRQ_TYPE_PROBE = 16,
    IRQ_LEVEL = 256,
    IRQ_PER_CPU = 512,
    IRQ_NOPROBE = 1024,
    IRQ_NOREQUEST = 2048,
    IRQ_NOAUTOEN = 4096,
    IRQ_NO_BALANCING = 8192,
    IRQ_NESTED_THREAD = 32768,
    IRQ_NOTHREAD = 65536,
    IRQ_PER_CPU_DEVID = 131072,
    IRQ_IS_POLLED = 262144,
    IRQ_DISABLE_UNLAZY = 524288,
    IRQ_HIDDEN = 1048576,
    IRQ_NO_DEBUG = 2097152,
};

enum {
    I_DATA_SEM_NORMAL = 0,
    I_DATA_SEM_OTHER = 1,
    I_DATA_SEM_QUOTA = 2,
    I_DATA_SEM_EA = 3,
};

enum {
    KBUF_MODE_EXPAND = 1,
    KBUF_MODE_FREE = 2,
};

enum {
    KDB_NOT_INITIALIZED = 0,
    KDB_INIT_EARLY = 1,
    KDB_INIT_FULL = 2,
};

enum {
    KERNEL_PARAM_FL_UNSAFE = 1,
    KERNEL_PARAM_FL_HWPARAM = 2,
};

enum {
    KERNEL_PARAM_OPS_FL_NOARG = 1,
};

enum {
    KF_ARG_DYNPTR_ID = 0,
    KF_ARG_LIST_HEAD_ID = 1,
    KF_ARG_LIST_NODE_ID = 2,
    KF_ARG_RB_ROOT_ID = 3,
    KF_ARG_RB_NODE_ID = 4,
    KF_ARG_WORKQUEUE_ID = 5,
};

enum {
    KTW_FREEZABLE = 1,
};

enum {
    KVM_REG_ARM_STD_BIT_TRNG_V1_0 = 0,
    KVM_REG_ARM_STD_BMAP_BIT_COUNT = 1,
};

enum {
    KVM_REG_ARM_STD_HYP_BIT_PV_TIME = 0,
    KVM_REG_ARM_STD_HYP_BMAP_BIT_COUNT = 1,
};

enum {
    KVM_REG_ARM_VENDOR_HYP_BIT_FUNC_FEAT = 0,
    KVM_REG_ARM_VENDOR_HYP_BIT_PTP = 1,
    KVM_REG_ARM_VENDOR_HYP_BMAP_BIT_COUNT = 2,
};

enum {
    LAST_NORM = 0,
    LAST_ROOT = 1,
    LAST_DOT = 2,
    LAST_DOTDOT = 3,
};

enum {
    LAT_OK = 1,
    LAT_UNKNOWN = 2,
    LAT_UNKNOWN_WRITES = 3,
    LAT_EXCEEDED = 4,
};

enum {
    LINUX_MIB_NUM = 0,
    LINUX_MIB_SYNCOOKIESSENT = 1,
    LINUX_MIB_SYNCOOKIESRECV = 2,
    LINUX_MIB_SYNCOOKIESFAILED = 3,
    LINUX_MIB_EMBRYONICRSTS = 4,
    LINUX_MIB_PRUNECALLED = 5,
    LINUX_MIB_RCVPRUNED = 6,
    LINUX_MIB_OFOPRUNED = 7,
    LINUX_MIB_OUTOFWINDOWICMPS = 8,
    LINUX_MIB_LOCKDROPPEDICMPS = 9,
    LINUX_MIB_ARPFILTER = 10,
    LINUX_MIB_TIMEWAITED = 11,
    LINUX_MIB_TIMEWAITRECYCLED = 12,
    LINUX_MIB_TIMEWAITKILLED = 13,
    LINUX_MIB_PAWSACTIVEREJECTED = 14,
    LINUX_MIB_PAWSESTABREJECTED = 15,
    LINUX_MIB_PAWS_OLD_ACK = 16,
    LINUX_MIB_DELAYEDACKS = 17,
    LINUX_MIB_DELAYEDACKLOCKED = 18,
    LINUX_MIB_DELAYEDACKLOST = 19,
    LINUX_MIB_LISTENOVERFLOWS = 20,
    LINUX_MIB_LISTENDROPS = 21,
    LINUX_MIB_TCPHPHITS = 22,
    LINUX_MIB_TCPPUREACKS = 23,
    LINUX_MIB_TCPHPACKS = 24,
    LINUX_MIB_TCPRENORECOVERY = 25,
    LINUX_MIB_TCPSACKRECOVERY = 26,
    LINUX_MIB_TCPSACKRENEGING = 27,
    LINUX_MIB_TCPSACKREORDER = 28,
    LINUX_MIB_TCPRENOREORDER = 29,
    LINUX_MIB_TCPTSREORDER = 30,
    LINUX_MIB_TCPFULLUNDO = 31,
    LINUX_MIB_TCPPARTIALUNDO = 32,
    LINUX_MIB_TCPDSACKUNDO = 33,
    LINUX_MIB_TCPLOSSUNDO = 34,
    LINUX_MIB_TCPLOSTRETRANSMIT = 35,
    LINUX_MIB_TCPRENOFAILURES = 36,
    LINUX_MIB_TCPSACKFAILURES = 37,
    LINUX_MIB_TCPLOSSFAILURES = 38,
    LINUX_MIB_TCPFASTRETRANS = 39,
    LINUX_MIB_TCPSLOWSTARTRETRANS = 40,
    LINUX_MIB_TCPTIMEOUTS = 41,
    LINUX_MIB_TCPLOSSPROBES = 42,
    LINUX_MIB_TCPLOSSPROBERECOVERY = 43,
    LINUX_MIB_TCPRENORECOVERYFAIL = 44,
    LINUX_MIB_TCPSACKRECOVERYFAIL = 45,
    LINUX_MIB_TCPRCVCOLLAPSED = 46,
    LINUX_MIB_TCPDSACKOLDSENT = 47,
    LINUX_MIB_TCPDSACKOFOSENT = 48,
    LINUX_MIB_TCPDSACKRECV = 49,
    LINUX_MIB_TCPDSACKOFORECV = 50,
    LINUX_MIB_TCPABORTONDATA = 51,
    LINUX_MIB_TCPABORTONCLOSE = 52,
    LINUX_MIB_TCPABORTONMEMORY = 53,
    LINUX_MIB_TCPABORTONTIMEOUT = 54,
    LINUX_MIB_TCPABORTONLINGER = 55,
    LINUX_MIB_TCPABORTFAILED = 56,
    LINUX_MIB_TCPMEMORYPRESSURES = 57,
    LINUX_MIB_TCPMEMORYPRESSURESCHRONO = 58,
    LINUX_MIB_TCPSACKDISCARD = 59,
    LINUX_MIB_TCPDSACKIGNOREDOLD = 60,
    LINUX_MIB_TCPDSACKIGNOREDNOUNDO = 61,
    LINUX_MIB_TCPSPURIOUSRTOS = 62,
    LINUX_MIB_TCPMD5NOTFOUND = 63,
    LINUX_MIB_TCPMD5UNEXPECTED = 64,
    LINUX_MIB_TCPMD5FAILURE = 65,
    LINUX_MIB_SACKSHIFTED = 66,
    LINUX_MIB_SACKMERGED = 67,
    LINUX_MIB_SACKSHIFTFALLBACK = 68,
    LINUX_MIB_TCPBACKLOGDROP = 69,
    LINUX_MIB_PFMEMALLOCDROP = 70,
    LINUX_MIB_TCPMINTTLDROP = 71,
    LINUX_MIB_TCPDEFERACCEPTDROP = 72,
    LINUX_MIB_IPRPFILTER = 73,
    LINUX_MIB_TCPTIMEWAITOVERFLOW = 74,
    LINUX_MIB_TCPREQQFULLDOCOOKIES = 75,
    LINUX_MIB_TCPREQQFULLDROP = 76,
    LINUX_MIB_TCPRETRANSFAIL = 77,
    LINUX_MIB_TCPRCVCOALESCE = 78,
    LINUX_MIB_TCPBACKLOGCOALESCE = 79,
    LINUX_MIB_TCPOFOQUEUE = 80,
    LINUX_MIB_TCPOFODROP = 81,
    LINUX_MIB_TCPOFOMERGE = 82,
    LINUX_MIB_TCPCHALLENGEACK = 83,
    LINUX_MIB_TCPSYNCHALLENGE = 84,
    LINUX_MIB_TCPFASTOPENACTIVE = 85,
    LINUX_MIB_TCPFASTOPENACTIVEFAIL = 86,
    LINUX_MIB_TCPFASTOPENPASSIVE = 87,
    LINUX_MIB_TCPFASTOPENPASSIVEFAIL = 88,
    LINUX_MIB_TCPFASTOPENLISTENOVERFLOW = 89,
    LINUX_MIB_TCPFASTOPENCOOKIEREQD = 90,
    LINUX_MIB_TCPFASTOPENBLACKHOLE = 91,
    LINUX_MIB_TCPSPURIOUS_RTX_HOSTQUEUES = 92,
    LINUX_MIB_BUSYPOLLRXPACKETS = 93,
    LINUX_MIB_TCPAUTOCORKING = 94,
    LINUX_MIB_TCPFROMZEROWINDOWADV = 95,
    LINUX_MIB_TCPTOZEROWINDOWADV = 96,
    LINUX_MIB_TCPWANTZEROWINDOWADV = 97,
    LINUX_MIB_TCPSYNRETRANS = 98,
    LINUX_MIB_TCPORIGDATASENT = 99,
    LINUX_MIB_TCPHYSTARTTRAINDETECT = 100,
    LINUX_MIB_TCPHYSTARTTRAINCWND = 101,
    LINUX_MIB_TCPHYSTARTDELAYDETECT = 102,
    LINUX_MIB_TCPHYSTARTDELAYCWND = 103,
    LINUX_MIB_TCPACKSKIPPEDSYNRECV = 104,
    LINUX_MIB_TCPACKSKIPPEDPAWS = 105,
    LINUX_MIB_TCPACKSKIPPEDSEQ = 106,
    LINUX_MIB_TCPACKSKIPPEDFINWAIT2 = 107,
    LINUX_MIB_TCPACKSKIPPEDTIMEWAIT = 108,
    LINUX_MIB_TCPACKSKIPPEDCHALLENGE = 109,
    LINUX_MIB_TCPWINPROBE = 110,
    LINUX_MIB_TCPKEEPALIVE = 111,
    LINUX_MIB_TCPMTUPFAIL = 112,
    LINUX_MIB_TCPMTUPSUCCESS = 113,
    LINUX_MIB_TCPDELIVERED = 114,
    LINUX_MIB_TCPDELIVEREDCE = 115,
    LINUX_MIB_TCPACKCOMPRESSED = 116,
    LINUX_MIB_TCPZEROWINDOWDROP = 117,
    LINUX_MIB_TCPRCVQDROP = 118,
    LINUX_MIB_TCPWQUEUETOOBIG = 119,
    LINUX_MIB_TCPFASTOPENPASSIVEALTKEY = 120,
    LINUX_MIB_TCPTIMEOUTREHASH = 121,
    LINUX_MIB_TCPDUPLICATEDATAREHASH = 122,
    LINUX_MIB_TCPDSACKRECVSEGS = 123,
    LINUX_MIB_TCPDSACKIGNOREDDUBIOUS = 124,
    LINUX_MIB_TCPMIGRATEREQSUCCESS = 125,
    LINUX_MIB_TCPMIGRATEREQFAILURE = 126,
    LINUX_MIB_TCPPLBREHASH = 127,
    LINUX_MIB_TCPAOREQUIRED = 128,
    LINUX_MIB_TCPAOBAD = 129,
    LINUX_MIB_TCPAOKEYNOTFOUND = 130,
    LINUX_MIB_TCPAOGOOD = 131,
    LINUX_MIB_TCPAODROPPEDICMPS = 132,
    __LINUX_MIB_MAX = 133,
};

enum {
    LINUX_MIB_TLSNUM = 0,
    LINUX_MIB_TLSCURRTXSW = 1,
    LINUX_MIB_TLSCURRRXSW = 2,
    LINUX_MIB_TLSCURRTXDEVICE = 3,
    LINUX_MIB_TLSCURRRXDEVICE = 4,
    LINUX_MIB_TLSTXSW = 5,
    LINUX_MIB_TLSRXSW = 6,
    LINUX_MIB_TLSTXDEVICE = 7,
    LINUX_MIB_TLSRXDEVICE = 8,
    LINUX_MIB_TLSDECRYPTERROR = 9,
    LINUX_MIB_TLSRXDEVICERESYNC = 10,
    LINUX_MIB_TLSDECRYPTRETRY = 11,
    LINUX_MIB_TLSRXNOPADVIOL = 12,
    LINUX_MIB_TLSRXREKEYOK = 13,
    LINUX_MIB_TLSRXREKEYERROR = 14,
    LINUX_MIB_TLSTXREKEYOK = 15,
    LINUX_MIB_TLSTXREKEYERROR = 16,
    LINUX_MIB_TLSRXREKEYRECEIVED = 17,
    __LINUX_MIB_TLSMAX = 18,
};

enum {
    LINUX_MIB_XFRMNUM = 0,
    LINUX_MIB_XFRMINERROR = 1,
    LINUX_MIB_XFRMINBUFFERERROR = 2,
    LINUX_MIB_XFRMINHDRERROR = 3,
    LINUX_MIB_XFRMINNOSTATES = 4,
    LINUX_MIB_XFRMINSTATEPROTOERROR = 5,
    LINUX_MIB_XFRMINSTATEMODEERROR = 6,
    LINUX_MIB_XFRMINSTATESEQERROR = 7,
    LINUX_MIB_XFRMINSTATEEXPIRED = 8,
    LINUX_MIB_XFRMINSTATEMISMATCH = 9,
    LINUX_MIB_XFRMINSTATEINVALID = 10,
    LINUX_MIB_XFRMINTMPLMISMATCH = 11,
    LINUX_MIB_XFRMINNOPOLS = 12,
    LINUX_MIB_XFRMINPOLBLOCK = 13,
    LINUX_MIB_XFRMINPOLERROR = 14,
    LINUX_MIB_XFRMOUTERROR = 15,
    LINUX_MIB_XFRMOUTBUNDLEGENERROR = 16,
    LINUX_MIB_XFRMOUTBUNDLECHECKERROR = 17,
    LINUX_MIB_XFRMOUTNOSTATES = 18,
    LINUX_MIB_XFRMOUTSTATEPROTOERROR = 19,
    LINUX_MIB_XFRMOUTSTATEMODEERROR = 20,
    LINUX_MIB_XFRMOUTSTATESEQERROR = 21,
    LINUX_MIB_XFRMOUTSTATEEXPIRED = 22,
    LINUX_MIB_XFRMOUTPOLBLOCK = 23,
    LINUX_MIB_XFRMOUTPOLDEAD = 24,
    LINUX_MIB_XFRMOUTPOLERROR = 25,
    LINUX_MIB_XFRMFWDHDRERROR = 26,
    LINUX_MIB_XFRMOUTSTATEINVALID = 27,
    LINUX_MIB_XFRMACQUIREERROR = 28,
    LINUX_MIB_XFRMOUTSTATEDIRERROR = 29,
    LINUX_MIB_XFRMINSTATEDIRERROR = 30,
    LINUX_MIB_XFRMINIPTFSERROR = 31,
    LINUX_MIB_XFRMOUTNOQSPACE = 32,
    __LINUX_MIB_XFRMMAX = 33,
};

enum {
    LOGIC_PIO_INDIRECT = 0,
    LOGIC_PIO_CPU_MMIO = 1,
};

enum {
    LO_FLAGS_READ_ONLY = 1,
    LO_FLAGS_AUTOCLEAR = 4,
    LO_FLAGS_PARTSCAN = 8,
    LO_FLAGS_DIRECT_IO = 16,
};

enum {
    LRU_GEN_ANON = 0,
    LRU_GEN_FILE = 1,
};

enum {
    LRU_GEN_CORE = 0,
    LRU_GEN_MM_WALK = 1,
    LRU_GEN_NONLEAF_YOUNG = 2,
    NR_LRU_GEN_CAPS = 3,
};

enum {
    LWTUNNEL_IP_OPTS_UNSPEC = 0,
    LWTUNNEL_IP_OPTS_GENEVE = 1,
    LWTUNNEL_IP_OPTS_VXLAN = 2,
    LWTUNNEL_IP_OPTS_ERSPAN = 3,
    __LWTUNNEL_IP_OPTS_MAX = 4,
};

enum {
    LWTUNNEL_IP_OPT_ERSPAN_UNSPEC = 0,
    LWTUNNEL_IP_OPT_ERSPAN_VER = 1,
    LWTUNNEL_IP_OPT_ERSPAN_INDEX = 2,
    LWTUNNEL_IP_OPT_ERSPAN_DIR = 3,
    LWTUNNEL_IP_OPT_ERSPAN_HWID = 4,
    __LWTUNNEL_IP_OPT_ERSPAN_MAX = 5,
};

enum {
    LWTUNNEL_IP_OPT_GENEVE_UNSPEC = 0,
    LWTUNNEL_IP_OPT_GENEVE_CLASS = 1,
    LWTUNNEL_IP_OPT_GENEVE_TYPE = 2,
    LWTUNNEL_IP_OPT_GENEVE_DATA = 3,
    __LWTUNNEL_IP_OPT_GENEVE_MAX = 4,
};

enum {
    LWTUNNEL_IP_OPT_VXLAN_UNSPEC = 0,
    LWTUNNEL_IP_OPT_VXLAN_GBP = 1,
    __LWTUNNEL_IP_OPT_VXLAN_MAX = 2,
};

enum {
    LWTUNNEL_XMIT_DONE = 0,
    LWTUNNEL_XMIT_CONTINUE = 256,
};

enum {
    LWT_BPF_PROG_UNSPEC = 0,
    LWT_BPF_PROG_FD = 1,
    LWT_BPF_PROG_NAME = 2,
    __LWT_BPF_PROG_MAX = 3,
};

enum {
    LWT_BPF_UNSPEC = 0,
    LWT_BPF_IN = 1,
    LWT_BPF_OUT = 2,
    LWT_BPF_XMIT = 3,
    LWT_BPF_XMIT_HEADROOM = 4,
    __LWT_BPF_MAX = 5,
};

enum {
    Lo_unbound = 0,
    Lo_bound = 1,
    Lo_rundown = 2,
    Lo_deleting = 3,
};

enum {
    MAX_IORES_LEVEL = 5,
};

enum {
    MAX_OPT_ARGS = 3,
};

enum {
    MBE_REFERENCED_B = 0,
    MBE_REUSABLE_B = 1,
};

enum {
    MB_INODE_PA = 0,
    MB_GROUP_PA = 1,
};

enum {
    MDBA_GET_ENTRY_UNSPEC = 0,
    MDBA_GET_ENTRY = 1,
    MDBA_GET_ENTRY_ATTRS = 2,
    __MDBA_GET_ENTRY_MAX = 3,
};

enum {
    MDBA_SET_ENTRY_UNSPEC = 0,
    MDBA_SET_ENTRY = 1,
    MDBA_SET_ENTRY_ATTRS = 2,
    __MDBA_SET_ENTRY_MAX = 3,
};

enum {
    MEMBARRIER_FLAG_SYNC_CORE = 1,
    MEMBARRIER_FLAG_RSEQ = 2,
};

enum {
    MEMBARRIER_STATE_PRIVATE_EXPEDITED_READY = 1,
    MEMBARRIER_STATE_PRIVATE_EXPEDITED = 2,
    MEMBARRIER_STATE_GLOBAL_EXPEDITED_READY = 4,
    MEMBARRIER_STATE_GLOBAL_EXPEDITED = 8,
    MEMBARRIER_STATE_PRIVATE_EXPEDITED_SYNC_CORE_READY = 16,
    MEMBARRIER_STATE_PRIVATE_EXPEDITED_SYNC_CORE = 32,
    MEMBARRIER_STATE_PRIVATE_EXPEDITED_RSEQ_READY = 64,
    MEMBARRIER_STATE_PRIVATE_EXPEDITED_RSEQ = 128,
};

enum {
    MEMCG_LRU_NOP = 0,
    MEMCG_LRU_HEAD = 1,
    MEMCG_LRU_TAIL = 2,
    MEMCG_LRU_OLD = 3,
    MEMCG_LRU_YOUNG = 4,
};

enum {
    MEMORY_RECLAIM_SWAPPINESS = 0,
    MEMORY_RECLAIM_NULL = 1,
};

enum {
    MEMREMAP_WB = 1,
    MEMREMAP_WT = 2,
    MEMREMAP_WC = 4,
    MEMREMAP_ENC = 8,
    MEMREMAP_DEC = 16,
};

enum {
    MFC_STATIC = 1,
    MFC_OFFLOAD = 2,
};

enum {
    MIPI_DCS_NOP = 0,
    MIPI_DCS_SOFT_RESET = 1,
    MIPI_DCS_GET_COMPRESSION_MODE = 3,
    MIPI_DCS_GET_DISPLAY_ID = 4,
    MIPI_DCS_GET_ERROR_COUNT_ON_DSI = 5,
    MIPI_DCS_GET_RED_CHANNEL = 6,
    MIPI_DCS_GET_GREEN_CHANNEL = 7,
    MIPI_DCS_GET_BLUE_CHANNEL = 8,
    MIPI_DCS_GET_DISPLAY_STATUS = 9,
    MIPI_DCS_GET_POWER_MODE = 10,
    MIPI_DCS_GET_ADDRESS_MODE = 11,
    MIPI_DCS_GET_PIXEL_FORMAT = 12,
    MIPI_DCS_GET_DISPLAY_MODE = 13,
    MIPI_DCS_GET_SIGNAL_MODE = 14,
    MIPI_DCS_GET_DIAGNOSTIC_RESULT = 15,
    MIPI_DCS_ENTER_SLEEP_MODE = 16,
    MIPI_DCS_EXIT_SLEEP_MODE = 17,
    MIPI_DCS_ENTER_PARTIAL_MODE = 18,
    MIPI_DCS_ENTER_NORMAL_MODE = 19,
    MIPI_DCS_GET_IMAGE_CHECKSUM_RGB = 20,
    MIPI_DCS_GET_IMAGE_CHECKSUM_CT = 21,
    MIPI_DCS_EXIT_INVERT_MODE = 32,
    MIPI_DCS_ENTER_INVERT_MODE = 33,
    MIPI_DCS_SET_GAMMA_CURVE = 38,
    MIPI_DCS_SET_DISPLAY_OFF = 40,
    MIPI_DCS_SET_DISPLAY_ON = 41,
    MIPI_DCS_SET_COLUMN_ADDRESS = 42,
    MIPI_DCS_SET_PAGE_ADDRESS = 43,
    MIPI_DCS_WRITE_MEMORY_START = 44,
    MIPI_DCS_WRITE_LUT = 45,
    MIPI_DCS_READ_MEMORY_START = 46,
    MIPI_DCS_SET_PARTIAL_ROWS = 48,
    MIPI_DCS_SET_PARTIAL_COLUMNS = 49,
    MIPI_DCS_SET_SCROLL_AREA = 51,
    MIPI_DCS_SET_TEAR_OFF = 52,
    MIPI_DCS_SET_TEAR_ON = 53,
    MIPI_DCS_SET_ADDRESS_MODE = 54,
    MIPI_DCS_SET_SCROLL_START = 55,
    MIPI_DCS_EXIT_IDLE_MODE = 56,
    MIPI_DCS_ENTER_IDLE_MODE = 57,
    MIPI_DCS_SET_PIXEL_FORMAT = 58,
    MIPI_DCS_WRITE_MEMORY_CONTINUE = 60,
    MIPI_DCS_SET_3D_CONTROL = 61,
    MIPI_DCS_READ_MEMORY_CONTINUE = 62,
    MIPI_DCS_GET_3D_CONTROL = 63,
    MIPI_DCS_SET_VSYNC_TIMING = 64,
    MIPI_DCS_SET_TEAR_SCANLINE = 68,
    MIPI_DCS_GET_SCANLINE = 69,
    MIPI_DCS_SET_DISPLAY_BRIGHTNESS = 81,
    MIPI_DCS_GET_DISPLAY_BRIGHTNESS = 82,
    MIPI_DCS_WRITE_CONTROL_DISPLAY = 83,
    MIPI_DCS_GET_CONTROL_DISPLAY = 84,
    MIPI_DCS_WRITE_POWER_SAVE = 85,
    MIPI_DCS_GET_POWER_SAVE = 86,
    MIPI_DCS_SET_CABC_MIN_BRIGHTNESS = 94,
    MIPI_DCS_GET_CABC_MIN_BRIGHTNESS = 95,
    MIPI_DCS_READ_DDB_START = 161,
    MIPI_DCS_READ_PPS_START = 162,
    MIPI_DCS_READ_DDB_CONTINUE = 168,
    MIPI_DCS_READ_PPS_CONTINUE = 169,
};

enum {
    MIPI_DSI_V_SYNC_START = 1,
    MIPI_DSI_V_SYNC_END = 17,
    MIPI_DSI_H_SYNC_START = 33,
    MIPI_DSI_H_SYNC_END = 49,
    MIPI_DSI_COMPRESSION_MODE = 7,
    MIPI_DSI_END_OF_TRANSMISSION = 8,
    MIPI_DSI_COLOR_MODE_OFF = 2,
    MIPI_DSI_COLOR_MODE_ON = 18,
    MIPI_DSI_SHUTDOWN_PERIPHERAL = 34,
    MIPI_DSI_TURN_ON_PERIPHERAL = 50,
    MIPI_DSI_GENERIC_SHORT_WRITE_0_PARAM = 3,
    MIPI_DSI_GENERIC_SHORT_WRITE_1_PARAM = 19,
    MIPI_DSI_GENERIC_SHORT_WRITE_2_PARAM = 35,
    MIPI_DSI_GENERIC_READ_REQUEST_0_PARAM = 4,
    MIPI_DSI_GENERIC_READ_REQUEST_1_PARAM = 20,
    MIPI_DSI_GENERIC_READ_REQUEST_2_PARAM = 36,
    MIPI_DSI_DCS_SHORT_WRITE = 5,
    MIPI_DSI_DCS_SHORT_WRITE_PARAM = 21,
    MIPI_DSI_DCS_READ = 6,
    MIPI_DSI_EXECUTE_QUEUE = 22,
    MIPI_DSI_SET_MAXIMUM_RETURN_PACKET_SIZE = 55,
    MIPI_DSI_NULL_PACKET = 9,
    MIPI_DSI_BLANKING_PACKET = 25,
    MIPI_DSI_GENERIC_LONG_WRITE = 41,
    MIPI_DSI_DCS_LONG_WRITE = 57,
    MIPI_DSI_PICTURE_PARAMETER_SET = 10,
    MIPI_DSI_COMPRESSED_PIXEL_STREAM = 11,
    MIPI_DSI_LOOSELY_PACKED_PIXEL_STREAM_YCBCR20 = 12,
    MIPI_DSI_PACKED_PIXEL_STREAM_YCBCR24 = 28,
    MIPI_DSI_PACKED_PIXEL_STREAM_YCBCR16 = 44,
    MIPI_DSI_PACKED_PIXEL_STREAM_30 = 13,
    MIPI_DSI_PACKED_PIXEL_STREAM_36 = 29,
    MIPI_DSI_PACKED_PIXEL_STREAM_YCBCR12 = 61,
    MIPI_DSI_PACKED_PIXEL_STREAM_16 = 14,
    MIPI_DSI_PACKED_PIXEL_STREAM_18 = 30,
    MIPI_DSI_PIXEL_STREAM_3BYTE_18 = 46,
    MIPI_DSI_PACKED_PIXEL_STREAM_24 = 62,
};

enum {
    MIX_INFLIGHT = 2147483648,
};

enum {
    MM_FILEPAGES = 0,
    MM_ANONPAGES = 1,
    MM_SWAPENTS = 2,
    MM_SHMEMPAGES = 3,
    NR_MM_COUNTERS = 4,
};

enum {
    MM_LEAF_TOTAL = 0,
    MM_LEAF_YOUNG = 1,
    MM_NONLEAF_FOUND = 2,
    MM_NONLEAF_ADDED = 3,
    NR_MM_STATS = 4,
};

enum {
    MODE_NONE = 0,
    MODE_ROUND_ROBIN = 1,
    MODE_PER_CPU = 2,
    MODE_MAX = 3,
};

enum {
    MPTCP_CMSG_TS = 1,
    MPTCP_CMSG_INQ = 2,
};

enum {
    MPTCP_PM_ADDR_ATTR_UNSPEC = 0,
    MPTCP_PM_ADDR_ATTR_FAMILY = 1,
    MPTCP_PM_ADDR_ATTR_ID = 2,
    MPTCP_PM_ADDR_ATTR_ADDR4 = 3,
    MPTCP_PM_ADDR_ATTR_ADDR6 = 4,
    MPTCP_PM_ADDR_ATTR_PORT = 5,
    MPTCP_PM_ADDR_ATTR_FLAGS = 6,
    MPTCP_PM_ADDR_ATTR_IF_IDX = 7,
    __MPTCP_PM_ADDR_ATTR_MAX = 8,
};

enum {
    MPTCP_PM_ATTR_UNSPEC = 0,
    MPTCP_PM_ATTR_ADDR = 1,
    MPTCP_PM_ATTR_RCV_ADD_ADDRS = 2,
    MPTCP_PM_ATTR_SUBFLOWS = 3,
    MPTCP_PM_ATTR_TOKEN = 4,
    MPTCP_PM_ATTR_LOC_ID = 5,
    MPTCP_PM_ATTR_ADDR_REMOTE = 6,
    __MPTCP_ATTR_AFTER_LAST = 7,
};

enum {
    MPTCP_PM_CMD_UNSPEC = 0,
    MPTCP_PM_CMD_ADD_ADDR = 1,
    MPTCP_PM_CMD_DEL_ADDR = 2,
    MPTCP_PM_CMD_GET_ADDR = 3,
    MPTCP_PM_CMD_FLUSH_ADDRS = 4,
    MPTCP_PM_CMD_SET_LIMITS = 5,
    MPTCP_PM_CMD_GET_LIMITS = 6,
    MPTCP_PM_CMD_SET_FLAGS = 7,
    MPTCP_PM_CMD_ANNOUNCE = 8,
    MPTCP_PM_CMD_REMOVE = 9,
    MPTCP_PM_CMD_SUBFLOW_CREATE = 10,
    MPTCP_PM_CMD_SUBFLOW_DESTROY = 11,
    __MPTCP_PM_CMD_AFTER_LAST = 12,
};

enum {
    MPTCP_PM_ENDPOINT_ADDR = 1,
    __MPTCP_PM_ENDPOINT_MAX = 2,
};

enum {
    MPTCP_SUBFLOW_ATTR_UNSPEC = 0,
    MPTCP_SUBFLOW_ATTR_TOKEN_REM = 1,
    MPTCP_SUBFLOW_ATTR_TOKEN_LOC = 2,
    MPTCP_SUBFLOW_ATTR_RELWRITE_SEQ = 3,
    MPTCP_SUBFLOW_ATTR_MAP_SEQ = 4,
    MPTCP_SUBFLOW_ATTR_MAP_SFSEQ = 5,
    MPTCP_SUBFLOW_ATTR_SSN_OFFSET = 6,
    MPTCP_SUBFLOW_ATTR_MAP_DATALEN = 7,
    MPTCP_SUBFLOW_ATTR_FLAGS = 8,
    MPTCP_SUBFLOW_ATTR_ID_REM = 9,
    MPTCP_SUBFLOW_ATTR_ID_LOC = 10,
    MPTCP_SUBFLOW_ATTR_PAD = 11,
    __MPTCP_SUBFLOW_ATTR_MAX = 12,
};

enum {
    MSI_FLAG_USE_DEF_DOM_OPS = 1,
    MSI_FLAG_USE_DEF_CHIP_OPS = 2,
    MSI_FLAG_ACTIVATE_EARLY = 4,
    MSI_FLAG_MUST_REACTIVATE = 8,
    MSI_FLAG_DEV_SYSFS = 16,
    MSI_FLAG_ALLOC_SIMPLE_MSI_DESCS = 32,
    MSI_FLAG_FREE_MSI_DESCS = 64,
    MSI_FLAG_USE_DEV_FWNODE = 128,
    MSI_FLAG_PARENT_PM_DEV = 256,
    MSI_FLAG_PCI_MSI_MASK_PARENT = 512,
    MSI_GENERIC_FLAGS_MASK = 65535,
    MSI_DOMAIN_FLAGS_MASK = 4294901760,
    MSI_FLAG_MULTI_PCI_MSI = 65536,
    MSI_FLAG_PCI_MSIX = 131072,
    MSI_FLAG_LEVEL_CAPABLE = 262144,
    MSI_FLAG_MSIX_CONTIGUOUS = 524288,
    MSI_FLAG_PCI_MSIX_ALLOC_DYN = 1048576,
    MSI_FLAG_NO_AFFINITY = 2097152,
    MSI_FLAG_NO_MASK = 4194304,
};

enum {
    NAPIF_STATE_SCHED = 1,
    NAPIF_STATE_MISSED = 2,
    NAPIF_STATE_DISABLE = 4,
    NAPIF_STATE_NPSVC = 8,
    NAPIF_STATE_LISTED = 16,
    NAPIF_STATE_NO_BUSY_POLL = 32,
    NAPIF_STATE_IN_BUSY_POLL = 64,
    NAPIF_STATE_PREFER_BUSY_POLL = 128,
    NAPIF_STATE_THREADED = 256,
    NAPIF_STATE_SCHED_THREADED = 512,
};

enum {
    NAPI_F_PREFER_BUSY_POLL = 1,
    NAPI_F_END_ON_RESCHED = 2,
};

enum {
    NAPI_STATE_SCHED = 0,
    NAPI_STATE_MISSED = 1,
    NAPI_STATE_DISABLE = 2,
    NAPI_STATE_NPSVC = 3,
    NAPI_STATE_LISTED = 4,
    NAPI_STATE_NO_BUSY_POLL = 5,
    NAPI_STATE_IN_BUSY_POLL = 6,
    NAPI_STATE_PREFER_BUSY_POLL = 7,
    NAPI_STATE_THREADED = 8,
    NAPI_STATE_SCHED_THREADED = 9,
};

enum {
    NDA_UNSPEC = 0,
    NDA_DST = 1,
    NDA_LLADDR = 2,
    NDA_CACHEINFO = 3,
    NDA_PROBES = 4,
    NDA_VLAN = 5,
    NDA_PORT = 6,
    NDA_VNI = 7,
    NDA_IFINDEX = 8,
    NDA_MASTER = 9,
    NDA_LINK_NETNSID = 10,
    NDA_SRC_VNI = 11,
    NDA_PROTOCOL = 12,
    NDA_NH_ID = 13,
    NDA_FDB_EXT_ATTRS = 14,
    NDA_FLAGS_EXT = 15,
    NDA_NDM_STATE_MASK = 16,
    NDA_NDM_FLAGS_MASK = 17,
    __NDA_MAX = 18,
};

enum {
    NDD_UNARMED = 1,
    NDD_LOCKED = 2,
    NDD_SECURITY_OVERWRITE = 3,
    NDD_WORK_PENDING = 4,
    NDD_LABELING = 6,
    NDD_INCOHERENT = 7,
    NDD_REGISTER_SYNC = 8,
    ND_IOCTL_MAX_BUFLEN = 4194304,
    ND_CMD_MAX_ELEM = 5,
    ND_CMD_MAX_ENVELOPE = 256,
    ND_MAX_MAPPINGS = 32,
    ND_REGION_PAGEMAP = 0,
    ND_REGION_PERSIST_CACHE = 1,
    ND_REGION_PERSIST_MEMCTRL = 2,
    ND_REGION_ASYNC = 3,
    ND_REGION_CXL = 4,
    DPA_RESOURCE_ADJUSTED = 1,
};

enum {
    NDTA_UNSPEC = 0,
    NDTA_NAME = 1,
    NDTA_THRESH1 = 2,
    NDTA_THRESH2 = 3,
    NDTA_THRESH3 = 4,
    NDTA_CONFIG = 5,
    NDTA_PARMS = 6,
    NDTA_STATS = 7,
    NDTA_GC_INTERVAL = 8,
    NDTA_PAD = 9,
    __NDTA_MAX = 10,
};

enum {
    NDTPA_UNSPEC = 0,
    NDTPA_IFINDEX = 1,
    NDTPA_REFCNT = 2,
    NDTPA_REACHABLE_TIME = 3,
    NDTPA_BASE_REACHABLE_TIME = 4,
    NDTPA_RETRANS_TIME = 5,
    NDTPA_GC_STALETIME = 6,
    NDTPA_DELAY_PROBE_TIME = 7,
    NDTPA_QUEUE_LEN = 8,
    NDTPA_APP_PROBES = 9,
    NDTPA_UCAST_PROBES = 10,
    NDTPA_MCAST_PROBES = 11,
    NDTPA_ANYCAST_DELAY = 12,
    NDTPA_PROXY_DELAY = 13,
    NDTPA_PROXY_QLEN = 14,
    NDTPA_LOCKTIME = 15,
    NDTPA_QUEUE_LENBYTES = 16,
    NDTPA_MCAST_REPROBES = 17,
    NDTPA_PAD = 18,
    NDTPA_INTERVAL_PROBE_TIME_MS = 19,
    __NDTPA_MAX = 20,
};

enum {
    NDUSEROPT_UNSPEC = 0,
    NDUSEROPT_SRCADDR = 1,
    __NDUSEROPT_MAX = 2,
};

enum {
    NEIGH_ARP_TABLE = 0,
    NEIGH_ND_TABLE = 1,
    NEIGH_NR_TABLES = 2,
    NEIGH_LINK_TABLE = 2,
};

enum {
    NEIGH_VAR_MCAST_PROBES = 0,
    NEIGH_VAR_UCAST_PROBES = 1,
    NEIGH_VAR_APP_PROBES = 2,
    NEIGH_VAR_MCAST_REPROBES = 3,
    NEIGH_VAR_RETRANS_TIME = 4,
    NEIGH_VAR_BASE_REACHABLE_TIME = 5,
    NEIGH_VAR_DELAY_PROBE_TIME = 6,
    NEIGH_VAR_INTERVAL_PROBE_TIME_MS = 7,
    NEIGH_VAR_GC_STALETIME = 8,
    NEIGH_VAR_QUEUE_LEN_BYTES = 9,
    NEIGH_VAR_PROXY_QLEN = 10,
    NEIGH_VAR_ANYCAST_DELAY = 11,
    NEIGH_VAR_PROXY_DELAY = 12,
    NEIGH_VAR_LOCKTIME = 13,
    NEIGH_VAR_QUEUE_LEN = 14,
    NEIGH_VAR_RETRANS_TIME_MS = 15,
    NEIGH_VAR_BASE_REACHABLE_TIME_MS = 16,
    NEIGH_VAR_GC_INTERVAL = 17,
    NEIGH_VAR_GC_THRESH1 = 18,
    NEIGH_VAR_GC_THRESH2 = 19,
    NEIGH_VAR_GC_THRESH3 = 20,
    NEIGH_VAR_MAX = 21,
};

enum {
    NESTED_SYNC_IMM_BIT = 0,
    NESTED_SYNC_TODO_BIT = 1,
};

enum {
    NETCONFA_UNSPEC = 0,
    NETCONFA_IFINDEX = 1,
    NETCONFA_FORWARDING = 2,
    NETCONFA_RP_FILTER = 3,
    NETCONFA_MC_FORWARDING = 4,
    NETCONFA_PROXY_NEIGH = 5,
    NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN = 6,
    NETCONFA_INPUT = 7,
    NETCONFA_BC_FORWARDING = 8,
    __NETCONFA_MAX = 9,
};

enum {
    NETDEV_A_DEV_IFINDEX = 1,
    NETDEV_A_DEV_PAD = 2,
    NETDEV_A_DEV_XDP_FEATURES = 3,
    NETDEV_A_DEV_XDP_ZC_MAX_SEGS = 4,
    NETDEV_A_DEV_XDP_RX_METADATA_FEATURES = 5,
    NETDEV_A_DEV_XSK_FEATURES = 6,
    __NETDEV_A_DEV_MAX = 7,
    NETDEV_A_DEV_MAX = 6,
};

enum {
    NETDEV_A_DMABUF_IFINDEX = 1,
    NETDEV_A_DMABUF_QUEUES = 2,
    NETDEV_A_DMABUF_FD = 3,
    NETDEV_A_DMABUF_ID = 4,
    __NETDEV_A_DMABUF_MAX = 5,
    NETDEV_A_DMABUF_MAX = 4,
};

enum {
    NETDEV_A_NAPI_IFINDEX = 1,
    NETDEV_A_NAPI_ID = 2,
    NETDEV_A_NAPI_IRQ = 3,
    NETDEV_A_NAPI_PID = 4,
    NETDEV_A_NAPI_DEFER_HARD_IRQS = 5,
    NETDEV_A_NAPI_GRO_FLUSH_TIMEOUT = 6,
    NETDEV_A_NAPI_IRQ_SUSPEND_TIMEOUT = 7,
    __NETDEV_A_NAPI_MAX = 8,
    NETDEV_A_NAPI_MAX = 7,
};

enum {
    NETDEV_A_PAGE_POOL_ID = 1,
    NETDEV_A_PAGE_POOL_IFINDEX = 2,
    NETDEV_A_PAGE_POOL_NAPI_ID = 3,
    NETDEV_A_PAGE_POOL_INFLIGHT = 4,
    NETDEV_A_PAGE_POOL_INFLIGHT_MEM = 5,
    NETDEV_A_PAGE_POOL_DETACH_TIME = 6,
    NETDEV_A_PAGE_POOL_DMABUF = 7,
    __NETDEV_A_PAGE_POOL_MAX = 8,
    NETDEV_A_PAGE_POOL_MAX = 7,
};

enum {
    NETDEV_A_PAGE_POOL_STATS_INFO = 1,
    NETDEV_A_PAGE_POOL_STATS_ALLOC_FAST = 8,
    NETDEV_A_PAGE_POOL_STATS_ALLOC_SLOW = 9,
    NETDEV_A_PAGE_POOL_STATS_ALLOC_SLOW_HIGH_ORDER = 10,
    NETDEV_A_PAGE_POOL_STATS_ALLOC_EMPTY = 11,
    NETDEV_A_PAGE_POOL_STATS_ALLOC_REFILL = 12,
    NETDEV_A_PAGE_POOL_STATS_ALLOC_WAIVE = 13,
    NETDEV_A_PAGE_POOL_STATS_RECYCLE_CACHED = 14,
    NETDEV_A_PAGE_POOL_STATS_RECYCLE_CACHE_FULL = 15,
    NETDEV_A_PAGE_POOL_STATS_RECYCLE_RING = 16,
    NETDEV_A_PAGE_POOL_STATS_RECYCLE_RING_FULL = 17,
    NETDEV_A_PAGE_POOL_STATS_RECYCLE_RELEASED_REFCNT = 18,
    __NETDEV_A_PAGE_POOL_STATS_MAX = 19,
    NETDEV_A_PAGE_POOL_STATS_MAX = 18,
};

enum {
    NETDEV_A_QSTATS_IFINDEX = 1,
    NETDEV_A_QSTATS_QUEUE_TYPE = 2,
    NETDEV_A_QSTATS_QUEUE_ID = 3,
    NETDEV_A_QSTATS_SCOPE = 4,
    NETDEV_A_QSTATS_RX_PACKETS = 8,
    NETDEV_A_QSTATS_RX_BYTES = 9,
    NETDEV_A_QSTATS_TX_PACKETS = 10,
    NETDEV_A_QSTATS_TX_BYTES = 11,
    NETDEV_A_QSTATS_RX_ALLOC_FAIL = 12,
    NETDEV_A_QSTATS_RX_HW_DROPS = 13,
    NETDEV_A_QSTATS_RX_HW_DROP_OVERRUNS = 14,
    NETDEV_A_QSTATS_RX_CSUM_COMPLETE = 15,
    NETDEV_A_QSTATS_RX_CSUM_UNNECESSARY = 16,
    NETDEV_A_QSTATS_RX_CSUM_NONE = 17,
    NETDEV_A_QSTATS_RX_CSUM_BAD = 18,
    NETDEV_A_QSTATS_RX_HW_GRO_PACKETS = 19,
    NETDEV_A_QSTATS_RX_HW_GRO_BYTES = 20,
    NETDEV_A_QSTATS_RX_HW_GRO_WIRE_PACKETS = 21,
    NETDEV_A_QSTATS_RX_HW_GRO_WIRE_BYTES = 22,
    NETDEV_A_QSTATS_RX_HW_DROP_RATELIMITS = 23,
    NETDEV_A_QSTATS_TX_HW_DROPS = 24,
    NETDEV_A_QSTATS_TX_HW_DROP_ERRORS = 25,
    NETDEV_A_QSTATS_TX_CSUM_NONE = 26,
    NETDEV_A_QSTATS_TX_NEEDS_CSUM = 27,
    NETDEV_A_QSTATS_TX_HW_GSO_PACKETS = 28,
    NETDEV_A_QSTATS_TX_HW_GSO_BYTES = 29,
    NETDEV_A_QSTATS_TX_HW_GSO_WIRE_PACKETS = 30,
    NETDEV_A_QSTATS_TX_HW_GSO_WIRE_BYTES = 31,
    NETDEV_A_QSTATS_TX_HW_DROP_RATELIMITS = 32,
    NETDEV_A_QSTATS_TX_STOP = 33,
    NETDEV_A_QSTATS_TX_WAKE = 34,
    __NETDEV_A_QSTATS_MAX = 35,
    NETDEV_A_QSTATS_MAX = 34,
};

enum {
    NETDEV_A_QUEUE_ID = 1,
    NETDEV_A_QUEUE_IFINDEX = 2,
    NETDEV_A_QUEUE_TYPE = 3,
    NETDEV_A_QUEUE_NAPI_ID = 4,
    NETDEV_A_QUEUE_DMABUF = 5,
    __NETDEV_A_QUEUE_MAX = 6,
    NETDEV_A_QUEUE_MAX = 5,
};

enum {
    NETDEV_CMD_DEV_GET = 1,
    NETDEV_CMD_DEV_ADD_NTF = 2,
    NETDEV_CMD_DEV_DEL_NTF = 3,
    NETDEV_CMD_DEV_CHANGE_NTF = 4,
    NETDEV_CMD_PAGE_POOL_GET = 5,
    NETDEV_CMD_PAGE_POOL_ADD_NTF = 6,
    NETDEV_CMD_PAGE_POOL_DEL_NTF = 7,
    NETDEV_CMD_PAGE_POOL_CHANGE_NTF = 8,
    NETDEV_CMD_PAGE_POOL_STATS_GET = 9,
    NETDEV_CMD_QUEUE_GET = 10,
    NETDEV_CMD_NAPI_GET = 11,
    NETDEV_CMD_QSTATS_GET = 12,
    NETDEV_CMD_BIND_RX = 13,
    NETDEV_CMD_NAPI_SET = 14,
    __NETDEV_CMD_MAX = 15,
    NETDEV_CMD_MAX = 14,
};

enum {
    NETDEV_NLGRP_MGMT = 0,
    NETDEV_NLGRP_PAGE_POOL = 1,
};

enum {
    NETIF_F_SG_BIT = 0,
    NETIF_F_IP_CSUM_BIT = 1,
    __UNUSED_NETIF_F_1 = 2,
    NETIF_F_HW_CSUM_BIT = 3,
    NETIF_F_IPV6_CSUM_BIT = 4,
    NETIF_F_HIGHDMA_BIT = 5,
    NETIF_F_FRAGLIST_BIT = 6,
    NETIF_F_HW_VLAN_CTAG_TX_BIT = 7,
    NETIF_F_HW_VLAN_CTAG_RX_BIT = 8,
    NETIF_F_HW_VLAN_CTAG_FILTER_BIT = 9,
    NETIF_F_VLAN_CHALLENGED_BIT = 10,
    NETIF_F_GSO_BIT = 11,
    __UNUSED_NETIF_F_12 = 12,
    __UNUSED_NETIF_F_13 = 13,
    NETIF_F_GRO_BIT = 14,
    NETIF_F_LRO_BIT = 15,
    NETIF_F_GSO_SHIFT = 16,
    NETIF_F_TSO_BIT = 16,
    NETIF_F_GSO_ROBUST_BIT = 17,
    NETIF_F_TSO_ECN_BIT = 18,
    NETIF_F_TSO_MANGLEID_BIT = 19,
    NETIF_F_TSO6_BIT = 20,
    NETIF_F_FSO_BIT = 21,
    NETIF_F_GSO_GRE_BIT = 22,
    NETIF_F_GSO_GRE_CSUM_BIT = 23,
    NETIF_F_GSO_IPXIP4_BIT = 24,
    NETIF_F_GSO_IPXIP6_BIT = 25,
    NETIF_F_GSO_UDP_TUNNEL_BIT = 26,
    NETIF_F_GSO_UDP_TUNNEL_CSUM_BIT = 27,
    NETIF_F_GSO_PARTIAL_BIT = 28,
    NETIF_F_GSO_TUNNEL_REMCSUM_BIT = 29,
    NETIF_F_GSO_SCTP_BIT = 30,
    NETIF_F_GSO_ESP_BIT = 31,
    NETIF_F_GSO_UDP_BIT = 32,
    NETIF_F_GSO_UDP_L4_BIT = 33,
    NETIF_F_GSO_FRAGLIST_BIT = 34,
    NETIF_F_GSO_LAST = 34,
    NETIF_F_FCOE_CRC_BIT = 35,
    NETIF_F_SCTP_CRC_BIT = 36,
    __UNUSED_NETIF_F_37 = 37,
    NETIF_F_NTUPLE_BIT = 38,
    NETIF_F_RXHASH_BIT = 39,
    NETIF_F_RXCSUM_BIT = 40,
    NETIF_F_NOCACHE_COPY_BIT = 41,
    NETIF_F_LOOPBACK_BIT = 42,
    NETIF_F_RXFCS_BIT = 43,
    NETIF_F_RXALL_BIT = 44,
    NETIF_F_HW_VLAN_STAG_TX_BIT = 45,
    NETIF_F_HW_VLAN_STAG_RX_BIT = 46,
    NETIF_F_HW_VLAN_STAG_FILTER_BIT = 47,
    NETIF_F_HW_L2FW_DOFFLOAD_BIT = 48,
    NETIF_F_HW_TC_BIT = 49,
    NETIF_F_HW_ESP_BIT = 50,
    NETIF_F_HW_ESP_TX_CSUM_BIT = 51,
    NETIF_F_RX_UDP_TUNNEL_PORT_BIT = 52,
    NETIF_F_HW_TLS_TX_BIT = 53,
    NETIF_F_HW_TLS_RX_BIT = 54,
    NETIF_F_GRO_HW_BIT = 55,
    NETIF_F_HW_TLS_RECORD_BIT = 56,
    NETIF_F_GRO_FRAGLIST_BIT = 57,
    NETIF_F_HW_MACSEC_BIT = 58,
    NETIF_F_GRO_UDP_FWD_BIT = 59,
    NETIF_F_HW_HSR_TAG_INS_BIT = 60,
    NETIF_F_HW_HSR_TAG_RM_BIT = 61,
    NETIF_F_HW_HSR_FWD_BIT = 62,
    NETIF_F_HW_HSR_DUP_BIT = 63,
    NETDEV_FEATURE_COUNT = 64,
};

enum {
    NETIF_MSG_DRV_BIT = 0,
    NETIF_MSG_PROBE_BIT = 1,
    NETIF_MSG_LINK_BIT = 2,
    NETIF_MSG_TIMER_BIT = 3,
    NETIF_MSG_IFDOWN_BIT = 4,
    NETIF_MSG_IFUP_BIT = 5,
    NETIF_MSG_RX_ERR_BIT = 6,
    NETIF_MSG_TX_ERR_BIT = 7,
    NETIF_MSG_TX_QUEUED_BIT = 8,
    NETIF_MSG_INTR_BIT = 9,
    NETIF_MSG_TX_DONE_BIT = 10,
    NETIF_MSG_RX_STATUS_BIT = 11,
    NETIF_MSG_PKTDATA_BIT = 12,
    NETIF_MSG_HW_BIT = 13,
    NETIF_MSG_WOL_BIT = 14,
    NETIF_MSG_CLASS_COUNT = 15,
};

enum {
    NETLINK_F_KERNEL_SOCKET = 0,
    NETLINK_F_RECV_PKTINFO = 1,
    NETLINK_F_BROADCAST_SEND_ERROR = 2,
    NETLINK_F_RECV_NO_ENOBUFS = 3,
    NETLINK_F_LISTEN_ALL_NSID = 4,
    NETLINK_F_CAP_ACK = 5,
    NETLINK_F_EXT_ACK = 6,
    NETLINK_F_STRICT_CHK = 7,
};

enum {
    NETLINK_UNCONNECTED = 0,
    NETLINK_CONNECTED = 1,
};

enum {
    NETNSA_NONE = 0,
    NETNSA_NSID = 1,
    NETNSA_PID = 2,
    NETNSA_FD = 3,
    NETNSA_TARGET_NSID = 4,
    NETNSA_CURRENT_NSID = 5,
    __NETNSA_MAX = 6,
};

enum {
    NET_NS_INDEX = 0,
    UTS_NS_INDEX = 1,
    IPC_NS_INDEX = 2,
    PID_NS_INDEX = 3,
    USER_NS_INDEX = 4,
    MNT_NS_INDEX = 5,
    CGROUP_NS_INDEX = 6,
    NR_NAMESPACES = 7,
};

enum {
    NET_SHAPER_A_CAPS_IFINDEX = 1,
    NET_SHAPER_A_CAPS_SCOPE = 2,
    NET_SHAPER_A_CAPS_SUPPORT_METRIC_BPS = 3,
    NET_SHAPER_A_CAPS_SUPPORT_METRIC_PPS = 4,
    NET_SHAPER_A_CAPS_SUPPORT_NESTING = 5,
    NET_SHAPER_A_CAPS_SUPPORT_BW_MIN = 6,
    NET_SHAPER_A_CAPS_SUPPORT_BW_MAX = 7,
    NET_SHAPER_A_CAPS_SUPPORT_BURST = 8,
    NET_SHAPER_A_CAPS_SUPPORT_PRIORITY = 9,
    NET_SHAPER_A_CAPS_SUPPORT_WEIGHT = 10,
    __NET_SHAPER_A_CAPS_MAX = 11,
    NET_SHAPER_A_CAPS_MAX = 10,
};

enum {
    NET_SHAPER_A_HANDLE = 1,
    NET_SHAPER_A_METRIC = 2,
    NET_SHAPER_A_BW_MIN = 3,
    NET_SHAPER_A_BW_MAX = 4,
    NET_SHAPER_A_BURST = 5,
    NET_SHAPER_A_PRIORITY = 6,
    NET_SHAPER_A_WEIGHT = 7,
    NET_SHAPER_A_IFINDEX = 8,
    NET_SHAPER_A_PARENT = 9,
    NET_SHAPER_A_LEAVES = 10,
    __NET_SHAPER_A_MAX = 11,
    NET_SHAPER_A_MAX = 10,
};

enum {
    NET_SHAPER_A_HANDLE_SCOPE = 1,
    NET_SHAPER_A_HANDLE_ID = 2,
    __NET_SHAPER_A_HANDLE_MAX = 3,
    NET_SHAPER_A_HANDLE_MAX = 2,
};

enum {
    NET_SHAPER_CMD_GET = 1,
    NET_SHAPER_CMD_SET = 2,
    NET_SHAPER_CMD_DELETE = 3,
    NET_SHAPER_CMD_GROUP = 4,
    NET_SHAPER_CMD_CAP_GET = 5,
    __NET_SHAPER_CMD_MAX = 6,
    NET_SHAPER_CMD_MAX = 5,
};

enum {
    NEXTHOP_GRP_TYPE_MPATH = 0,
    NEXTHOP_GRP_TYPE_RES = 1,
    __NEXTHOP_GRP_TYPE_MAX = 2,
};

enum {
    NFPROTO_UNSPEC = 0,
    NFPROTO_INET = 1,
    NFPROTO_IPV4 = 2,
    NFPROTO_ARP = 3,
    NFPROTO_NETDEV = 5,
    NFPROTO_BRIDGE = 7,
    NFPROTO_IPV6 = 10,
    NFPROTO_NUMPROTO = 11,
};

enum {
    NHA_GROUP_STATS_ENTRY_UNSPEC = 0,
    NHA_GROUP_STATS_ENTRY_ID = 1,
    NHA_GROUP_STATS_ENTRY_PACKETS = 2,
    NHA_GROUP_STATS_ENTRY_PACKETS_HW = 3,
    __NHA_GROUP_STATS_ENTRY_MAX = 4,
};

enum {
    NHA_GROUP_STATS_UNSPEC = 0,
    NHA_GROUP_STATS_ENTRY = 1,
    __NHA_GROUP_STATS_MAX = 2,
};

enum {
    NHA_RES_BUCKET_UNSPEC = 0,
    NHA_RES_BUCKET_PAD = 0,
    NHA_RES_BUCKET_INDEX = 1,
    NHA_RES_BUCKET_IDLE_TIME = 2,
    NHA_RES_BUCKET_NH_ID = 3,
    __NHA_RES_BUCKET_MAX = 4,
};

enum {
    NHA_RES_GROUP_UNSPEC = 0,
    NHA_RES_GROUP_PAD = 0,
    NHA_RES_GROUP_BUCKETS = 1,
    NHA_RES_GROUP_IDLE_TIMER = 2,
    NHA_RES_GROUP_UNBALANCED_TIMER = 3,
    NHA_RES_GROUP_UNBALANCED_TIME = 4,
    __NHA_RES_GROUP_MAX = 5,
};

enum {
    NHA_UNSPEC = 0,
    NHA_ID = 1,
    NHA_GROUP = 2,
    NHA_GROUP_TYPE = 3,
    NHA_BLACKHOLE = 4,
    NHA_OIF = 5,
    NHA_GATEWAY = 6,
    NHA_ENCAP_TYPE = 7,
    NHA_ENCAP = 8,
    NHA_GROUPS = 9,
    NHA_MASTER = 10,
    NHA_FDB = 11,
    NHA_RES_GROUP = 12,
    NHA_RES_BUCKET = 13,
    NHA_OP_FLAGS = 14,
    NHA_GROUP_STATS = 15,
    NHA_HW_STATS_ENABLE = 16,
    NHA_HW_STATS_USED = 17,
    __NHA_MAX = 18,
};

enum {
    NLA_UNSPEC = 0,
    NLA_U8 = 1,
    NLA_U16 = 2,
    NLA_U32 = 3,
    NLA_U64 = 4,
    NLA_STRING = 5,
    NLA_FLAG = 6,
    NLA_MSECS = 7,
    NLA_NESTED = 8,
    NLA_NESTED_ARRAY = 9,
    NLA_NUL_STRING = 10,
    NLA_BINARY = 11,
    NLA_S8 = 12,
    NLA_S16 = 13,
    NLA_S32 = 14,
    NLA_S64 = 15,
    NLA_BITFIELD32 = 16,
    NLA_REJECT = 17,
    NLA_BE16 = 18,
    NLA_BE32 = 19,
    NLA_SINT = 20,
    NLA_UINT = 21,
    __NLA_TYPE_MAX = 22,
};

enum {
    NLBL_CALIPSO_A_UNSPEC = 0,
    NLBL_CALIPSO_A_DOI = 1,
    NLBL_CALIPSO_A_MTYPE = 2,
    __NLBL_CALIPSO_A_MAX = 3,
};

enum {
    NLBL_CALIPSO_C_UNSPEC = 0,
    NLBL_CALIPSO_C_ADD = 1,
    NLBL_CALIPSO_C_REMOVE = 2,
    NLBL_CALIPSO_C_LIST = 3,
    NLBL_CALIPSO_C_LISTALL = 4,
    __NLBL_CALIPSO_C_MAX = 5,
};

enum {
    NLBL_CIPSOV4_A_UNSPEC = 0,
    NLBL_CIPSOV4_A_DOI = 1,
    NLBL_CIPSOV4_A_MTYPE = 2,
    NLBL_CIPSOV4_A_TAG = 3,
    NLBL_CIPSOV4_A_TAGLST = 4,
    NLBL_CIPSOV4_A_MLSLVLLOC = 5,
    NLBL_CIPSOV4_A_MLSLVLREM = 6,
    NLBL_CIPSOV4_A_MLSLVL = 7,
    NLBL_CIPSOV4_A_MLSLVLLST = 8,
    NLBL_CIPSOV4_A_MLSCATLOC = 9,
    NLBL_CIPSOV4_A_MLSCATREM = 10,
    NLBL_CIPSOV4_A_MLSCAT = 11,
    NLBL_CIPSOV4_A_MLSCATLST = 12,
    __NLBL_CIPSOV4_A_MAX = 13,
};

enum {
    NLBL_CIPSOV4_C_UNSPEC = 0,
    NLBL_CIPSOV4_C_ADD = 1,
    NLBL_CIPSOV4_C_REMOVE = 2,
    NLBL_CIPSOV4_C_LIST = 3,
    NLBL_CIPSOV4_C_LISTALL = 4,
    __NLBL_CIPSOV4_C_MAX = 5,
};

enum {
    NLBL_MGMT_A_UNSPEC = 0,
    NLBL_MGMT_A_DOMAIN = 1,
    NLBL_MGMT_A_PROTOCOL = 2,
    NLBL_MGMT_A_VERSION = 3,
    NLBL_MGMT_A_CV4DOI = 4,
    NLBL_MGMT_A_IPV6ADDR = 5,
    NLBL_MGMT_A_IPV6MASK = 6,
    NLBL_MGMT_A_IPV4ADDR = 7,
    NLBL_MGMT_A_IPV4MASK = 8,
    NLBL_MGMT_A_ADDRSELECTOR = 9,
    NLBL_MGMT_A_SELECTORLIST = 10,
    NLBL_MGMT_A_FAMILY = 11,
    NLBL_MGMT_A_CLPDOI = 12,
    __NLBL_MGMT_A_MAX = 13,
};

enum {
    NLBL_MGMT_C_UNSPEC = 0,
    NLBL_MGMT_C_ADD = 1,
    NLBL_MGMT_C_REMOVE = 2,
    NLBL_MGMT_C_LISTALL = 3,
    NLBL_MGMT_C_ADDDEF = 4,
    NLBL_MGMT_C_REMOVEDEF = 5,
    NLBL_MGMT_C_LISTDEF = 6,
    NLBL_MGMT_C_PROTOCOLS = 7,
    NLBL_MGMT_C_VERSION = 8,
    __NLBL_MGMT_C_MAX = 9,
};

enum {
    NLBL_UNLABEL_A_UNSPEC = 0,
    NLBL_UNLABEL_A_ACPTFLG = 1,
    NLBL_UNLABEL_A_IPV6ADDR = 2,
    NLBL_UNLABEL_A_IPV6MASK = 3,
    NLBL_UNLABEL_A_IPV4ADDR = 4,
    NLBL_UNLABEL_A_IPV4MASK = 5,
    NLBL_UNLABEL_A_IFACE = 6,
    NLBL_UNLABEL_A_SECCTX = 7,
    __NLBL_UNLABEL_A_MAX = 8,
};

enum {
    NLBL_UNLABEL_C_UNSPEC = 0,
    NLBL_UNLABEL_C_ACCEPT = 1,
    NLBL_UNLABEL_C_LIST = 2,
    NLBL_UNLABEL_C_STATICADD = 3,
    NLBL_UNLABEL_C_STATICREMOVE = 4,
    NLBL_UNLABEL_C_STATICLIST = 5,
    NLBL_UNLABEL_C_STATICADDDEF = 6,
    NLBL_UNLABEL_C_STATICREMOVEDEF = 7,
    NLBL_UNLABEL_C_STATICLISTDEF = 8,
    __NLBL_UNLABEL_C_MAX = 9,
};

enum {
    NUM_TRIAL_SAMPLES = 8192,
    MAX_SAMPLES_PER_BIT = 66,
};

enum {
    NVMEM_ADD = 1,
    NVMEM_REMOVE = 2,
    NVMEM_CELL_ADD = 3,
    NVMEM_CELL_REMOVE = 4,
    NVMEM_LAYOUT_ADD = 5,
    NVMEM_LAYOUT_REMOVE = 6,
};

enum {
    NVME_AEN_BIT_NS_ATTR = 8,
    NVME_AEN_BIT_FW_ACT = 9,
    NVME_AEN_BIT_ANA_CHANGE = 11,
    NVME_AEN_BIT_DISC_CHANGE = 31,
};

enum {
    NVME_CC_ENABLE = 1,
    NVME_CC_EN_SHIFT = 0,
    NVME_CC_CSS_SHIFT = 4,
    NVME_CC_CSS_MASK = 112,
    NVME_CC_CSS_NVM = 0,
    NVME_CC_CSS_CSI = 96,
    NVME_CC_MPS_SHIFT = 7,
    NVME_CC_MPS_MASK = 1920,
    NVME_CC_AMS_SHIFT = 11,
    NVME_CC_AMS_MASK = 14336,
    NVME_CC_AMS_RR = 0,
    NVME_CC_AMS_WRRU = 2048,
    NVME_CC_AMS_VS = 14336,
    NVME_CC_SHN_SHIFT = 14,
    NVME_CC_SHN_MASK = 49152,
    NVME_CC_SHN_NONE = 0,
    NVME_CC_SHN_NORMAL = 16384,
    NVME_CC_SHN_ABRUPT = 32768,
    NVME_CC_IOSQES_SHIFT = 16,
    NVME_CC_IOSQES_MASK = 983040,
    NVME_CC_IOSQES = 393216,
    NVME_CC_IOCQES_SHIFT = 20,
    NVME_CC_IOCQES_MASK = 15728640,
    NVME_CC_IOCQES = 4194304,
    NVME_CC_CRIME = 16777216,
};

enum {
    NVME_CSTS_RDY = 1,
    NVME_CSTS_CFS = 2,
    NVME_CSTS_NSSRO = 16,
    NVME_CSTS_PP = 32,
    NVME_CSTS_SHST_NORMAL = 0,
    NVME_CSTS_SHST_OCCUR = 4,
    NVME_CSTS_SHST_CMPLT = 8,
    NVME_CSTS_SHST_MASK = 12,
};

enum {
    NVME_REG_CAP = 0,
    NVME_REG_VS = 8,
    NVME_REG_INTMS = 12,
    NVME_REG_INTMC = 16,
    NVME_REG_CC = 20,
    NVME_REG_CSTS = 28,
    NVME_REG_NSSR = 32,
    NVME_REG_AQA = 36,
    NVME_REG_ASQ = 40,
    NVME_REG_ACQ = 48,
    NVME_REG_CMBLOC = 56,
    NVME_REG_CMBSZ = 60,
    NVME_REG_BPINFO = 64,
    NVME_REG_BPRSEL = 68,
    NVME_REG_BPMBL = 72,
    NVME_REG_CMBMSC = 80,
    NVME_REG_CRTO = 104,
    NVME_REG_PMRCAP = 3584,
    NVME_REG_PMRCTL = 3588,
    NVME_REG_PMRSTS = 3592,
    NVME_REG_PMREBS = 3596,
    NVME_REG_PMRSWTP = 3600,
    NVME_REG_DBS = 4096,
};

enum {
    OD_NORMAL_SAMPLE = 0,
    OD_SUB_SAMPLE = 1,
};

enum {
    OPT_UID = 0,
    OPT_GID = 1,
    OPT_MODE = 2,
    OPT_DELEGATE_CMDS = 3,
    OPT_DELEGATE_MAPS = 4,
    OPT_DELEGATE_PROGS = 5,
    OPT_DELEGATE_ATTACHS = 6,
};

enum {
    OUTSIDE_GUEST_MODE = 0,
    IN_GUEST_MODE = 1,
    EXITING_GUEST_MODE = 2,
    READING_SHADOW_PAGE_TABLES = 3,
};

enum {
    Opt_bsd_df = 0,
    Opt_minix_df = 1,
    Opt_grpid = 2,
    Opt_nogrpid = 3,
    Opt_resgid = 4,
    Opt_resuid = 5,
    Opt_sb = 6,
    Opt_nouid32 = 7,
    Opt_debug = 8,
    Opt_removed = 9,
    Opt_user_xattr = 10,
    Opt_acl = 11,
    Opt_auto_da_alloc = 12,
    Opt_noauto_da_alloc = 13,
    Opt_noload = 14,
    Opt_commit = 15,
    Opt_min_batch_time = 16,
    Opt_max_batch_time = 17,
    Opt_journal_dev = 18,
    Opt_journal_path = 19,
    Opt_journal_checksum = 20,
    Opt_journal_async_commit = 21,
    Opt_abort = 22,
    Opt_data_journal = 23,
    Opt_data_ordered = 24,
    Opt_data_writeback = 25,
    Opt_data_err_abort = 26,
    Opt_data_err_ignore = 27,
    Opt_test_dummy_encryption = 28,
    Opt_inlinecrypt = 29,
    Opt_usrjquota = 30,
    Opt_grpjquota = 31,
    Opt_quota = 32,
    Opt_noquota = 33,
    Opt_barrier = 34,
    Opt_nobarrier = 35,
    Opt_err = 36,
    Opt_usrquota = 37,
    Opt_grpquota = 38,
    Opt_prjquota = 39,
    Opt_dax = 40,
    Opt_dax_always = 41,
    Opt_dax_inode = 42,
    Opt_dax_never = 43,
    Opt_stripe = 44,
    Opt_delalloc = 45,
    Opt_nodelalloc = 46,
    Opt_warn_on_error = 47,
    Opt_nowarn_on_error = 48,
    Opt_mblk_io_submit = 49,
    Opt_debug_want_extra_isize = 50,
    Opt_nomblk_io_submit = 51,
    Opt_block_validity = 52,
    Opt_noblock_validity = 53,
    Opt_inode_readahead_blks = 54,
    Opt_journal_ioprio = 55,
    Opt_dioread_nolock = 56,
    Opt_dioread_lock = 57,
    Opt_discard = 58,
    Opt_nodiscard = 59,
    Opt_init_itable = 60,
    Opt_noinit_itable = 61,
    Opt_max_dir_size_kb = 62,
    Opt_nojournal_checksum = 63,
    Opt_nombcache = 64,
    Opt_no_prefetch_block_bitmaps = 65,
    Opt_mb_optimize_scan = 66,
    Opt_errors = 67,
    Opt_data = 68,
    Opt_data_err = 69,
    Opt_jqfmt = 70,
    Opt_dax_type = 71,
};

enum {
    Opt_check = 0,
    Opt_uid = 1,
    Opt_gid = 2,
    Opt_umask = 3,
    Opt_dmask = 4,
    Opt_fmask = 5,
    Opt_allow_utime = 6,
    Opt_codepage = 7,
    Opt_usefree = 8,
    Opt_nocase = 9,
    Opt_quiet = 10,
    Opt_showexec = 11,
    Opt_debug___2 = 12,
    Opt_immutable = 13,
    Opt_dots = 14,
    Opt_dotsOK = 15,
    Opt_charset = 16,
    Opt_shortname = 17,
    Opt_utf8 = 18,
    Opt_utf8_bool = 19,
    Opt_uni_xl = 20,
    Opt_uni_xl_bool = 21,
    Opt_nonumtail = 22,
    Opt_nonumtail_bool = 23,
    Opt_obsolete = 24,
    Opt_flush = 25,
    Opt_tz = 26,
    Opt_rodir = 27,
    Opt_errors___2 = 28,
    Opt_discard___2 = 29,
    Opt_nfs = 30,
    Opt_nfs_enum = 31,
    Opt_time_offset = 32,
    Opt_dos1xfloppy = 33,
};

enum {
    Opt_default = 0,
    Opt_ecryptfs = 1,
    Opt_enc32 = 2,
    Opt_error = 3,
};

enum {
    Opt_err___2 = 0,
    Opt_enc = 1,
    Opt_hash = 2,
};

enum {
    Opt_err___3 = 0,
    Opt_new = 1,
    Opt_load = 2,
    Opt_update = 3,
};

enum {
    Opt_err___4 = 0,
    Opt_keyhandle = 1,
    Opt_keyauth = 2,
    Opt_blobauth = 3,
    Opt_pcrinfo = 4,
    Opt_pcrlock = 5,
    Opt_migratable = 6,
    Opt_hash___2 = 7,
    Opt_policydigest = 8,
    Opt_policyhandle = 9,
};

enum {
    Opt_error___2 = -1,
    Opt_fsdefault = 0,
    Opt_fsfloor = 1,
    Opt_fshat = 2,
    Opt_fsroot = 3,
    Opt_fstransmute = 4,
};

enum {
    Opt_error___3 = -1,
    Opt_context = 0,
    Opt_defcontext = 1,
    Opt_fscontext = 2,
    Opt_rootcontext = 3,
    Opt_seclabel = 4,
};

enum {
    Opt_kmsg_bytes = 0,
    Opt_err___5 = 1,
};

enum {
    Opt_new___2 = 0,
    Opt_load___2 = 1,
    Opt_update___2 = 2,
    Opt_err___6 = 3,
};

enum {
    Opt_uid___2 = 0,
    Opt_gid___2 = 1,
    Opt_mode = 2,
};

enum {
    Opt_uid___3 = 0,
    Opt_gid___3 = 1,
    Opt_mode___2 = 2,
    Opt_source = 3,
};

enum {
    Opt_uid___4 = 0,
    Opt_gid___4 = 1,
    Opt_mode___3 = 2,
    Opt_ptmxmode = 3,
    Opt_newinstance = 4,
    Opt_max = 5,
    Opt_err___7 = 6,
};

enum {
    PAGE_REPORTING_IDLE = 0,
    PAGE_REPORTING_REQUESTED = 1,
    PAGE_REPORTING_ACTIVE = 2,
};

enum {
    PAGE_WAS_MAPPED = 1,
    PAGE_WAS_MLOCKED = 2,
    PAGE_OLD_STATES = 3,
};

enum {
    PARSE_INVALID = 1,
    PARSE_NOT_LONGNAME = 2,
    PARSE_EOF = 3,
};

enum {
    PCI_REASSIGN_ALL_RSRC = 1,
    PCI_REASSIGN_ALL_BUS = 2,
    PCI_PROBE_ONLY = 4,
    PCI_CAN_SKIP_ISA_ALIGN = 8,
    PCI_ENABLE_PROC_DOMAINS = 16,
    PCI_COMPAT_DOMAIN_0 = 32,
    PCI_SCAN_ALL_PCIE_DEVS = 64,
};

enum {
    PCI_STD_RESOURCES = 0,
    PCI_STD_RESOURCE_END = 5,
    PCI_ROM_RESOURCE = 6,
    PCI_IOV_RESOURCES = 7,
    PCI_IOV_RESOURCE_END = 12,
    PCI_BRIDGE_RESOURCES = 13,
    PCI_BRIDGE_RESOURCE_END = 16,
    PCI_NUM_RESOURCES = 17,
    DEVICE_COUNT_RESOURCE = 17,
};

enum {
    PERCPU_REF_INIT_ATOMIC = 1,
    PERCPU_REF_INIT_DEAD = 2,
    PERCPU_REF_ALLOW_REINIT = 4,
};

enum {
    PER_LINUX = 0,
    PER_LINUX_32BIT = 8388608,
    PER_LINUX_FDPIC = 524288,
    PER_SVR4 = 68157441,
    PER_SVR3 = 83886082,
    PER_SCOSVR3 = 117440515,
    PER_OSR5 = 100663299,
    PER_WYSEV386 = 83886084,
    PER_ISCR4 = 67108869,
    PER_BSD = 6,
    PER_SUNOS = 67108870,
    PER_XENIX = 83886087,
    PER_LINUX32 = 8,
    PER_LINUX32_3GB = 134217736,
    PER_IRIX32 = 67108873,
    PER_IRIXN32 = 67108874,
    PER_IRIX64 = 67108875,
    PER_RISCOS = 12,
    PER_SOLARIS = 67108877,
    PER_UW7 = 68157454,
    PER_OSF4 = 15,
    PER_HPUX = 16,
    PER_MASK = 255,
};

enum {
    PIM_TYPE_HELLO = 0,
    PIM_TYPE_REGISTER = 1,
    PIM_TYPE_REGISTER_STOP = 2,
    PIM_TYPE_JOIN_PRUNE = 3,
    PIM_TYPE_BOOTSTRAP = 4,
    PIM_TYPE_ASSERT = 5,
    PIM_TYPE_GRAFT = 6,
    PIM_TYPE_GRAFT_ACK = 7,
    PIM_TYPE_CANDIDATE_RP_ADV = 8,
};

enum {
    PINCTRL_PIN_REG_MODE = 0,
    PINCTRL_PIN_REG_DIR = 1,
    PINCTRL_PIN_REG_DI = 2,
    PINCTRL_PIN_REG_DO = 3,
    PINCTRL_PIN_REG_SR = 4,
    PINCTRL_PIN_REG_SMT = 5,
    PINCTRL_PIN_REG_PD = 6,
    PINCTRL_PIN_REG_PU = 7,
    PINCTRL_PIN_REG_E4 = 8,
    PINCTRL_PIN_REG_E8 = 9,
    PINCTRL_PIN_REG_TDSEL = 10,
    PINCTRL_PIN_REG_RDSEL = 11,
    PINCTRL_PIN_REG_DRV = 12,
    PINCTRL_PIN_REG_PUPD = 13,
    PINCTRL_PIN_REG_R0 = 14,
    PINCTRL_PIN_REG_R1 = 15,
    PINCTRL_PIN_REG_IES = 16,
    PINCTRL_PIN_REG_PULLEN = 17,
    PINCTRL_PIN_REG_PULLSEL = 18,
    PINCTRL_PIN_REG_DRV_EN = 19,
    PINCTRL_PIN_REG_DRV_E0 = 20,
    PINCTRL_PIN_REG_DRV_E1 = 21,
    PINCTRL_PIN_REG_DRV_ADV = 22,
    PINCTRL_PIN_REG_RSEL = 23,
    PINCTRL_PIN_REG_MAX = 24,
};

enum {
    PLAT8250_DEV_LEGACY = -1,
    PLAT8250_DEV_PLATFORM = 0,
    PLAT8250_DEV_PLATFORM1 = 1,
    PLAT8250_DEV_PLATFORM2 = 2,
    PLAT8250_DEV_FOURPORT = 3,
    PLAT8250_DEV_ACCENT = 4,
    PLAT8250_DEV_BOCA = 5,
    PLAT8250_DEV_EXAR_ST16C554 = 6,
    PLAT8250_DEV_HUB6 = 7,
    PLAT8250_DEV_AU1X00 = 8,
    PLAT8250_DEV_SM501 = 9,
};

enum {
    POLICYDB_CAP_NETPEER = 0,
    POLICYDB_CAP_OPENPERM = 1,
    POLICYDB_CAP_EXTSOCKCLASS = 2,
    POLICYDB_CAP_ALWAYSNETWORK = 3,
    POLICYDB_CAP_CGROUPSECLABEL = 4,
    POLICYDB_CAP_NNP_NOSUID_TRANSITION = 5,
    POLICYDB_CAP_GENFS_SECLABEL_SYMLINKS = 6,
    POLICYDB_CAP_IOCTL_SKIP_CLOEXEC = 7,
    POLICYDB_CAP_USERSPACE_INITIAL_CONTEXT = 8,
    POLICYDB_CAP_NETLINK_XPERM = 9,
    __POLICYDB_CAP_MAX = 10,
};

enum {
    POOL_BITS = 256,
    POOL_READY_BITS = 256,
    POOL_EARLY_BITS = 128,
};

enum {
    POWER_SUPPLY_CAPACITY_LEVEL_UNKNOWN = 0,
    POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL = 1,
    POWER_SUPPLY_CAPACITY_LEVEL_LOW = 2,
    POWER_SUPPLY_CAPACITY_LEVEL_NORMAL = 3,
    POWER_SUPPLY_CAPACITY_LEVEL_HIGH = 4,
    POWER_SUPPLY_CAPACITY_LEVEL_FULL = 5,
};

enum {
    POWER_SUPPLY_HEALTH_UNKNOWN = 0,
    POWER_SUPPLY_HEALTH_GOOD = 1,
    POWER_SUPPLY_HEALTH_OVERHEAT = 2,
    POWER_SUPPLY_HEALTH_DEAD = 3,
    POWER_SUPPLY_HEALTH_OVERVOLTAGE = 4,
    POWER_SUPPLY_HEALTH_UNDERVOLTAGE = 5,
    POWER_SUPPLY_HEALTH_UNSPEC_FAILURE = 6,
    POWER_SUPPLY_HEALTH_COLD = 7,
    POWER_SUPPLY_HEALTH_WATCHDOG_TIMER_EXPIRE = 8,
    POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE = 9,
    POWER_SUPPLY_HEALTH_OVERCURRENT = 10,
    POWER_SUPPLY_HEALTH_CALIBRATION_REQUIRED = 11,
    POWER_SUPPLY_HEALTH_WARM = 12,
    POWER_SUPPLY_HEALTH_COOL = 13,
    POWER_SUPPLY_HEALTH_HOT = 14,
    POWER_SUPPLY_HEALTH_NO_BATTERY = 15,
};

enum {
    POWER_SUPPLY_SCOPE_UNKNOWN = 0,
    POWER_SUPPLY_SCOPE_SYSTEM = 1,
    POWER_SUPPLY_SCOPE_DEVICE = 2,
};

enum {
    POWER_SUPPLY_STATUS_UNKNOWN = 0,
    POWER_SUPPLY_STATUS_CHARGING = 1,
    POWER_SUPPLY_STATUS_DISCHARGING = 2,
    POWER_SUPPLY_STATUS_NOT_CHARGING = 3,
    POWER_SUPPLY_STATUS_FULL = 4,
};

enum {
    POWER_SUPPLY_TECHNOLOGY_UNKNOWN = 0,
    POWER_SUPPLY_TECHNOLOGY_NiMH = 1,
    POWER_SUPPLY_TECHNOLOGY_LION = 2,
    POWER_SUPPLY_TECHNOLOGY_LIPO = 3,
    POWER_SUPPLY_TECHNOLOGY_LiFe = 4,
    POWER_SUPPLY_TECHNOLOGY_NiCd = 5,
    POWER_SUPPLY_TECHNOLOGY_LiMn = 6,
};

enum {
    PREFIX_UNSPEC = 0,
    PREFIX_ADDRESS = 1,
    PREFIX_CACHEINFO = 2,
    __PREFIX_MAX = 3,
};

enum {
    PROC_ENTRY_PERMANENT = 1,
    PROC_ENTRY_proc_read_iter = 2,
    PROC_ENTRY_proc_compat_ioctl = 4,
};

enum {
    PROC_ROOT_INO = 1,
    PROC_IPC_INIT_INO = 4026531839,
    PROC_UTS_INIT_INO = 4026531838,
    PROC_USER_INIT_INO = 4026531837,
    PROC_PID_INIT_INO = 4026531836,
    PROC_CGROUP_INIT_INO = 4026531835,
    PROC_TIME_INIT_INO = 4026531834,
};

enum {
    PWMF_REQUESTED = 0,
    PWMF_EXPORTED = 1,
};

enum {
    QIF_BLIMITS_B = 0,
    QIF_SPACE_B = 1,
    QIF_ILIMITS_B = 2,
    QIF_INODES_B = 3,
    QIF_BTIME_B = 4,
    QIF_ITIME_B = 5,
};

enum {
    QMFLAGS_IS_BLOCKING = 1,
    QMFLAGS_NO_MUTEX_LOCK = 2,
    QMFLAGS_NO_MUTEX_UNLOCK = 4,
};

enum {
    QUEUE_FLAG_DYING = 0,
    QUEUE_FLAG_NOMERGES = 1,
    QUEUE_FLAG_SAME_COMP = 2,
    QUEUE_FLAG_FAIL_IO = 3,
    QUEUE_FLAG_NOXMERGES = 4,
    QUEUE_FLAG_SAME_FORCE = 5,
    QUEUE_FLAG_INIT_DONE = 6,
    QUEUE_FLAG_STATS = 7,
    QUEUE_FLAG_REGISTERED = 8,
    QUEUE_FLAG_QUIESCED = 9,
    QUEUE_FLAG_RQ_ALLOC_TIME = 10,
    QUEUE_FLAG_HCTX_ACTIVE = 11,
    QUEUE_FLAG_SQ_SCHED = 12,
    QUEUE_FLAG_MAX = 13,
};

enum {
    QUOTA_NL_A_UNSPEC = 0,
    QUOTA_NL_A_QTYPE = 1,
    QUOTA_NL_A_EXCESS_ID = 2,
    QUOTA_NL_A_WARNING = 3,
    QUOTA_NL_A_DEV_MAJOR = 4,
    QUOTA_NL_A_DEV_MINOR = 5,
    QUOTA_NL_A_CAUSED_ID = 6,
    QUOTA_NL_A_PAD = 7,
    __QUOTA_NL_A_MAX = 8,
};

enum {
    QUOTA_NL_C_UNSPEC = 0,
    QUOTA_NL_C_WARNING = 1,
    __QUOTA_NL_C_MAX = 2,
};

enum {
    Q_REQUEUE_PI_NONE = 0,
    Q_REQUEUE_PI_IGNORE = 1,
    Q_REQUEUE_PI_IN_PROGRESS = 2,
    Q_REQUEUE_PI_WAIT = 3,
    Q_REQUEUE_PI_DONE = 4,
    Q_REQUEUE_PI_LOCKED = 5,
};

enum {
    RADIX_TREE_ITER_TAG_MASK = 15,
    RADIX_TREE_ITER_TAGGED = 16,
    RADIX_TREE_ITER_CONTIG = 32,
};

enum {
    RB_ADD_STAMP_NONE = 0,
    RB_ADD_STAMP_EXTEND = 2,
    RB_ADD_STAMP_ABSOLUTE = 4,
    RB_ADD_STAMP_FORCE = 8,
};

enum {
    RB_CTX_TRANSITION = 0,
    RB_CTX_NMI = 1,
    RB_CTX_IRQ = 2,
    RB_CTX_SOFTIRQ = 3,
    RB_CTX_NORMAL = 4,
    RB_CTX_MAX = 5,
};

enum {
    RB_LEN_TIME_EXTEND = 8,
    RB_LEN_TIME_STAMP = 8,
};

enum {
    REASON_BOUNDS = -1,
    REASON_TYPE = -2,
    REASON_PATHS = -3,
    REASON_LIMIT = -4,
    REASON_STACK = -5,
};

enum {
    REGION_INTERSECTS = 0,
    REGION_DISJOINT = 1,
    REGION_MIXED = 2,
};

enum {
    REGULATOR_ERROR_CLEARED = 0,
    REGULATOR_FAILED_RETRY = 1,
    REGULATOR_ERROR_ON = 2,
};

enum {
    REG_DR = 0,
    REG_ST_DMAWM = 1,
    REG_ST_TIMEOUT = 2,
    REG_FR = 3,
    REG_LCRH_RX = 4,
    REG_LCRH_TX = 5,
    REG_IBRD = 6,
    REG_FBRD = 7,
    REG_CR = 8,
    REG_IFLS = 9,
    REG_IMSC = 10,
    REG_RIS = 11,
    REG_MIS = 12,
    REG_ICR = 13,
    REG_DMACR = 14,
    REG_ST_XFCR = 15,
    REG_ST_XON1 = 16,
    REG_ST_XON2 = 17,
    REG_ST_XOFF1 = 18,
    REG_ST_XOFF2 = 19,
    REG_ST_ITCR = 20,
    REG_ST_ITIP = 21,
    REG_ST_ABCR = 22,
    REG_ST_ABIMSC = 23,
    REG_ARRAY_SIZE = 24,
};

enum {
    REG_GENL_ATTR_UNSPEC = 0,
    REG_GENL_ATTR_EVENT = 1,
    __REG_GENL_ATTR_MAX = 2,
};

enum {
    REG_GENL_CMD_UNSPEC = 0,
    REG_GENL_CMD_EVENT = 1,
    __REG_GENL_CMD_MAX = 2,
};

enum {
    REQ_FSEQ_PREFLUSH = 1,
    REQ_FSEQ_DATA = 2,
    REQ_FSEQ_POSTFLUSH = 4,
    REQ_FSEQ_DONE = 8,
    REQ_FSEQ_ACTIONS = 7,
    FLUSH_PENDING_TIMEOUT = 5000,
};

enum {
    REQ_F_FIXED_FILE = 1ULL,
    REQ_F_IO_DRAIN = 2ULL,
    REQ_F_LINK = 4ULL,
    REQ_F_HARDLINK = 8ULL,
    REQ_F_FORCE_ASYNC = 16ULL,
    REQ_F_BUFFER_SELECT = 32ULL,
    REQ_F_CQE_SKIP = 64ULL,
    REQ_F_FAIL = 256ULL,
    REQ_F_INFLIGHT = 512ULL,
    REQ_F_CUR_POS = 1024ULL,
    REQ_F_NOWAIT = 2048ULL,
    REQ_F_LINK_TIMEOUT = 4096ULL,
    REQ_F_NEED_CLEANUP = 8192ULL,
    REQ_F_POLLED = 16384ULL,
    REQ_F_IOPOLL_STATE = 32768ULL,
    REQ_F_BUFFER_SELECTED = 65536ULL,
    REQ_F_BUFFER_RING = 131072ULL,
    REQ_F_REISSUE = 262144ULL,
    REQ_F_SUPPORT_NOWAIT = 536870912ULL,
    REQ_F_ISREG = 1073741824ULL,
    REQ_F_CREDS = 524288ULL,
    REQ_F_REFCOUNT = 1048576ULL,
    REQ_F_ARM_LTIMEOUT = 2097152ULL,
    REQ_F_ASYNC_DATA = 4194304ULL,
    REQ_F_SKIP_LINK_CQES = 8388608ULL,
    REQ_F_SINGLE_POLL = 16777216ULL,
    REQ_F_DOUBLE_POLL = 33554432ULL,
    REQ_F_MULTISHOT = 67108864ULL,
    REQ_F_APOLL_MULTISHOT = 134217728ULL,
    REQ_F_CLEAR_POLLIN = 268435456ULL,
    REQ_F_POLL_NO_LAZY = 2147483648ULL,
    REQ_F_CAN_POLL = 4294967296ULL,
    REQ_F_BL_EMPTY = 8589934592ULL,
    REQ_F_BL_NO_RECYCLE = 17179869184ULL,
    REQ_F_BUFFERS_COMMIT = 34359738368ULL,
    REQ_F_BUF_NODE = 68719476736ULL,
    REQ_F_HAS_METADATA = 137438953472ULL,
};

enum {
    REQ_F_FIXED_FILE_BIT = 0,
    REQ_F_IO_DRAIN_BIT = 1,
    REQ_F_LINK_BIT = 2,
    REQ_F_HARDLINK_BIT = 3,
    REQ_F_FORCE_ASYNC_BIT = 4,
    REQ_F_BUFFER_SELECT_BIT = 5,
    REQ_F_CQE_SKIP_BIT = 6,
    REQ_F_FAIL_BIT = 8,
    REQ_F_INFLIGHT_BIT = 9,
    REQ_F_CUR_POS_BIT = 10,
    REQ_F_NOWAIT_BIT = 11,
    REQ_F_LINK_TIMEOUT_BIT = 12,
    REQ_F_NEED_CLEANUP_BIT = 13,
    REQ_F_POLLED_BIT = 14,
    REQ_F_HYBRID_IOPOLL_STATE_BIT = 15,
    REQ_F_BUFFER_SELECTED_BIT = 16,
    REQ_F_BUFFER_RING_BIT = 17,
    REQ_F_REISSUE_BIT = 18,
    REQ_F_CREDS_BIT = 19,
    REQ_F_REFCOUNT_BIT = 20,
    REQ_F_ARM_LTIMEOUT_BIT = 21,
    REQ_F_ASYNC_DATA_BIT = 22,
    REQ_F_SKIP_LINK_CQES_BIT = 23,
    REQ_F_SINGLE_POLL_BIT = 24,
    REQ_F_DOUBLE_POLL_BIT = 25,
    REQ_F_MULTISHOT_BIT = 26,
    REQ_F_APOLL_MULTISHOT_BIT = 27,
    REQ_F_CLEAR_POLLIN_BIT = 28,
    REQ_F_SUPPORT_NOWAIT_BIT = 29,
    REQ_F_ISREG_BIT = 30,
    REQ_F_POLL_NO_LAZY_BIT = 31,
    REQ_F_CAN_POLL_BIT = 32,
    REQ_F_BL_EMPTY_BIT = 33,
    REQ_F_BL_NO_RECYCLE_BIT = 34,
    REQ_F_BUFFERS_COMMIT_BIT = 35,
    REQ_F_BUF_NODE_BIT = 36,
    REQ_F_HAS_METADATA_BIT = 37,
    __REQ_F_LAST_BIT = 38,
};

enum {
    RES_USAGE = 0,
    RES_RSVD_USAGE = 1,
    RES_LIMIT = 2,
    RES_RSVD_LIMIT = 3,
    RES_MAX_USAGE = 4,
    RES_RSVD_MAX_USAGE = 5,
    RES_FAILCNT = 6,
    RES_RSVD_FAILCNT = 7,
};

enum {
    RGR1_SW_INIT_1 = 0,
    EXT_CFG_INDEX = 1,
    EXT_CFG_DATA = 2,
    PCIE_HARD_DEBUG = 3,
    PCIE_INTR2_CPU_BASE = 4,
};

enum {
    RTAX_UNSPEC = 0,
    RTAX_LOCK = 1,
    RTAX_MTU = 2,
    RTAX_WINDOW = 3,
    RTAX_RTT = 4,
    RTAX_RTTVAR = 5,
    RTAX_SSTHRESH = 6,
    RTAX_CWND = 7,
    RTAX_ADVMSS = 8,
    RTAX_REORDERING = 9,
    RTAX_HOPLIMIT = 10,
    RTAX_INITCWND = 11,
    RTAX_FEATURES = 12,
    RTAX_RTO_MIN = 13,
    RTAX_INITRWND = 14,
    RTAX_QUICKACK = 15,
    RTAX_CC_ALGO = 16,
    RTAX_FASTOPEN_NO_COOKIE = 17,
    __RTAX_MAX = 18,
};

enum {
    RTM_BASE = 16,
    RTM_NEWLINK = 16,
    RTM_DELLINK = 17,
    RTM_GETLINK = 18,
    RTM_SETLINK = 19,
    RTM_NEWADDR = 20,
    RTM_DELADDR = 21,
    RTM_GETADDR = 22,
    RTM_NEWROUTE = 24,
    RTM_DELROUTE = 25,
    RTM_GETROUTE = 26,
    RTM_NEWNEIGH = 28,
    RTM_DELNEIGH = 29,
    RTM_GETNEIGH = 30,
    RTM_NEWRULE = 32,
    RTM_DELRULE = 33,
    RTM_GETRULE = 34,
    RTM_NEWQDISC = 36,
    RTM_DELQDISC = 37,
    RTM_GETQDISC = 38,
    RTM_NEWTCLASS = 40,
    RTM_DELTCLASS = 41,
    RTM_GETTCLASS = 42,
    RTM_NEWTFILTER = 44,
    RTM_DELTFILTER = 45,
    RTM_GETTFILTER = 46,
    RTM_NEWACTION = 48,
    RTM_DELACTION = 49,
    RTM_GETACTION = 50,
    RTM_NEWPREFIX = 52,
    RTM_NEWMULTICAST = 56,
    RTM_DELMULTICAST = 57,
    RTM_GETMULTICAST = 58,
    RTM_NEWANYCAST = 60,
    RTM_DELANYCAST = 61,
    RTM_GETANYCAST = 62,
    RTM_NEWNEIGHTBL = 64,
    RTM_GETNEIGHTBL = 66,
    RTM_SETNEIGHTBL = 67,
    RTM_NEWNDUSEROPT = 68,
    RTM_NEWADDRLABEL = 72,
    RTM_DELADDRLABEL = 73,
    RTM_GETADDRLABEL = 74,
    RTM_GETDCB = 78,
    RTM_SETDCB = 79,
    RTM_NEWNETCONF = 80,
    RTM_DELNETCONF = 81,
    RTM_GETNETCONF = 82,
    RTM_NEWMDB = 84,
    RTM_DELMDB = 85,
    RTM_GETMDB = 86,
    RTM_NEWNSID = 88,
    RTM_DELNSID = 89,
    RTM_GETNSID = 90,
    RTM_NEWSTATS = 92,
    RTM_GETSTATS = 94,
    RTM_SETSTATS = 95,
    RTM_NEWCACHEREPORT = 96,
    RTM_NEWCHAIN = 100,
    RTM_DELCHAIN = 101,
    RTM_GETCHAIN = 102,
    RTM_NEWNEXTHOP = 104,
    RTM_DELNEXTHOP = 105,
    RTM_GETNEXTHOP = 106,
    RTM_NEWLINKPROP = 108,
    RTM_DELLINKPROP = 109,
    RTM_GETLINKPROP = 110,
    RTM_NEWVLAN = 112,
    RTM_DELVLAN = 113,
    RTM_GETVLAN = 114,
    RTM_NEWNEXTHOPBUCKET = 116,
    RTM_DELNEXTHOPBUCKET = 117,
    RTM_GETNEXTHOPBUCKET = 118,
    RTM_NEWTUNNEL = 120,
    RTM_DELTUNNEL = 121,
    RTM_GETTUNNEL = 122,
    __RTM_MAX = 123,
};

enum {
    RTN_UNSPEC = 0,
    RTN_UNICAST = 1,
    RTN_LOCAL = 2,
    RTN_BROADCAST = 3,
    RTN_ANYCAST = 4,
    RTN_MULTICAST = 5,
    RTN_BLACKHOLE = 6,
    RTN_UNREACHABLE = 7,
    RTN_PROHIBIT = 8,
    RTN_THROW = 9,
    RTN_NAT = 10,
    RTN_XRESOLVE = 11,
    __RTN_MAX = 12,
};

enum {
    RWB_DEF_DEPTH = 16,
    RWB_WINDOW_NSEC = 100000000,
    RWB_MIN_WRITE_SAMPLES = 3,
    RWB_UNKNOWN_BUMP = 5,
};

enum {
    Root_NFS = 255,
    Root_CIFS = 254,
    Root_Generic = 253,
    Root_RAM0 = 1048576,
};

enum {
    SB_UNFROZEN = 0,
    SB_FREEZE_WRITE = 1,
    SB_FREEZE_PAGEFAULT = 2,
    SB_FREEZE_FS = 3,
    SB_FREEZE_COMPLETE = 4,
};

enum {
    SCM_TSTAMP_SND = 0,
    SCM_TSTAMP_SCHED = 1,
    SCM_TSTAMP_ACK = 2,
};

enum {
    SCSI_DH_OK = 0,
    SCSI_DH_DEV_FAILED = 1,
    SCSI_DH_DEV_TEMP_BUSY = 2,
    SCSI_DH_DEV_UNSUPP = 3,
    SCSI_DH_DEVICE_MAX = 4,
    SCSI_DH_NOTCONN = 5,
    SCSI_DH_CONN_FAILURE = 6,
    SCSI_DH_TRANSPORT_MAX = 7,
    SCSI_DH_IO = 8,
    SCSI_DH_INVALID_IO = 9,
    SCSI_DH_RETRY = 10,
    SCSI_DH_IMM_RETRY = 11,
    SCSI_DH_TIMED_OUT = 12,
    SCSI_DH_RES_TEMP_UNAVAIL = 13,
    SCSI_DH_DEV_OFFLINED = 14,
    SCSI_DH_NOMEM = 15,
    SCSI_DH_NOSYS = 16,
    SCSI_DH_DRIVER_MAX = 17,
};

enum {
    SCTP_AUTH_HMAC_ID_RESERVED_0 = 0,
    SCTP_AUTH_HMAC_ID_SHA1 = 1,
    SCTP_AUTH_HMAC_ID_RESERVED_2 = 2,
    SCTP_AUTH_HMAC_ID_SHA256 = 3,
    __SCTP_AUTH_HMAC_MAX = 4,
};

enum {
    SCTP_MAX_DUP_TSNS = 16,
};

enum {
    SCTP_MAX_STREAM = 65535,
};

enum {
    SD_BALANCE_NEWIDLE = 1,
    SD_BALANCE_EXEC = 2,
    SD_BALANCE_FORK = 4,
    SD_BALANCE_WAKE = 8,
    SD_WAKE_AFFINE = 16,
    SD_ASYM_CPUCAPACITY = 32,
    SD_ASYM_CPUCAPACITY_FULL = 64,
    SD_SHARE_CPUCAPACITY = 128,
    SD_CLUSTER = 256,
    SD_SHARE_LLC = 512,
    SD_SERIALIZE = 1024,
    SD_ASYM_PACKING = 2048,
    SD_PREFER_SIBLING = 4096,
    SD_OVERLAP = 8192,
    SD_NUMA = 16384,
};

enum {
    SD_DEF_XFER_BLOCKS = 65535,
    SD_MAX_XFER_BLOCKS = 4294967295,
    SD_MAX_WS10_BLOCKS = 65535,
    SD_MAX_WS16_BLOCKS = 8388607,
};

enum {
    SD_EXT_CDB_SIZE = 32,
    SD_MEMPOOL_SIZE = 2,
};

enum {
    SD_LBP_FULL = 0,
    SD_LBP_UNMAP = 1,
    SD_LBP_WS16 = 2,
    SD_LBP_WS10 = 3,
    SD_LBP_ZERO = 4,
    SD_LBP_DISABLE = 5,
};

enum {
    SD_ZERO_WRITE = 0,
    SD_ZERO_WS = 1,
    SD_ZERO_WS16_UNMAP = 2,
    SD_ZERO_WS10_UNMAP = 3,
};

enum {
    SEAL_keytype = 1,
    SRK_keytype = 4,
};

enum {
    SECTION_MARKED_PRESENT_BIT = 0,
    SECTION_HAS_MEM_MAP_BIT = 1,
    SECTION_IS_ONLINE_BIT = 2,
    SECTION_IS_EARLY_BIT = 3,
    SECTION_MAP_LAST_BIT = 4,
};

enum {
    SEG6_ATTR_UNSPEC = 0,
    SEG6_ATTR_DST = 1,
    SEG6_ATTR_DSTLEN = 2,
    SEG6_ATTR_HMACKEYID = 3,
    SEG6_ATTR_SECRET = 4,
    SEG6_ATTR_SECRETLEN = 5,
    SEG6_ATTR_ALGID = 6,
    SEG6_ATTR_HMACINFO = 7,
    __SEG6_ATTR_MAX = 8,
};

enum {
    SEG6_CMD_UNSPEC = 0,
    SEG6_CMD_SETHMAC = 1,
    SEG6_CMD_DUMPHMAC = 2,
    SEG6_CMD_SET_TUNSRC = 3,
    SEG6_CMD_GET_TUNSRC = 4,
    __SEG6_CMD_MAX = 5,
};

enum {
    SEG6_HMAC_ALGO_SHA1 = 1,
    SEG6_HMAC_ALGO_SHA256 = 2,
};

enum {
    SEG6_IPTUNNEL_UNSPEC = 0,
    SEG6_IPTUNNEL_SRH = 1,
    __SEG6_IPTUNNEL_MAX = 2,
};

enum {
    SEG6_IPTUN_MODE_INLINE = 0,
    SEG6_IPTUN_MODE_ENCAP = 1,
    SEG6_IPTUN_MODE_L2ENCAP = 2,
    SEG6_IPTUN_MODE_ENCAP_RED = 3,
    SEG6_IPTUN_MODE_L2ENCAP_RED = 4,
};

enum {
    SEG6_LOCAL_ACTION_UNSPEC = 0,
    SEG6_LOCAL_ACTION_END = 1,
    SEG6_LOCAL_ACTION_END_X = 2,
    SEG6_LOCAL_ACTION_END_T = 3,
    SEG6_LOCAL_ACTION_END_DX2 = 4,
    SEG6_LOCAL_ACTION_END_DX6 = 5,
    SEG6_LOCAL_ACTION_END_DX4 = 6,
    SEG6_LOCAL_ACTION_END_DT6 = 7,
    SEG6_LOCAL_ACTION_END_DT4 = 8,
    SEG6_LOCAL_ACTION_END_B6 = 9,
    SEG6_LOCAL_ACTION_END_B6_ENCAP = 10,
    SEG6_LOCAL_ACTION_END_BM = 11,
    SEG6_LOCAL_ACTION_END_S = 12,
    SEG6_LOCAL_ACTION_END_AS = 13,
    SEG6_LOCAL_ACTION_END_AM = 14,
    SEG6_LOCAL_ACTION_END_BPF = 15,
    SEG6_LOCAL_ACTION_END_DT46 = 16,
    __SEG6_LOCAL_ACTION_MAX = 17,
};

enum {
    SEG6_LOCAL_BPF_PROG_UNSPEC = 0,
    SEG6_LOCAL_BPF_PROG = 1,
    SEG6_LOCAL_BPF_PROG_NAME = 2,
    __SEG6_LOCAL_BPF_PROG_MAX = 3,
};

enum {
    SEG6_LOCAL_CNT_UNSPEC = 0,
    SEG6_LOCAL_CNT_PAD = 1,
    SEG6_LOCAL_CNT_PACKETS = 2,
    SEG6_LOCAL_CNT_BYTES = 3,
    SEG6_LOCAL_CNT_ERRORS = 4,
    __SEG6_LOCAL_CNT_MAX = 5,
};

enum {
    SEG6_LOCAL_FLV_OP_UNSPEC = 0,
    SEG6_LOCAL_FLV_OP_PSP = 1,
    SEG6_LOCAL_FLV_OP_USP = 2,
    SEG6_LOCAL_FLV_OP_USD = 3,
    SEG6_LOCAL_FLV_OP_NEXT_CSID = 4,
    __SEG6_LOCAL_FLV_OP_MAX = 5,
};

enum {
    SEG6_LOCAL_FLV_UNSPEC = 0,
    SEG6_LOCAL_FLV_OPERATION = 1,
    SEG6_LOCAL_FLV_LCBLOCK_BITS = 2,
    SEG6_LOCAL_FLV_LCNODE_FN_BITS = 3,
    __SEG6_LOCAL_FLV_MAX = 4,
};

enum {
    SEG6_LOCAL_UNSPEC = 0,
    SEG6_LOCAL_ACTION = 1,
    SEG6_LOCAL_SRH = 2,
    SEG6_LOCAL_TABLE = 3,
    SEG6_LOCAL_NH4 = 4,
    SEG6_LOCAL_NH6 = 5,
    SEG6_LOCAL_IIF = 6,
    SEG6_LOCAL_OIF = 7,
    SEG6_LOCAL_BPF = 8,
    SEG6_LOCAL_VRFTABLE = 9,
    SEG6_LOCAL_COUNTERS = 10,
    SEG6_LOCAL_FLAVORS = 11,
    __SEG6_LOCAL_MAX = 12,
};

enum {
    SELNL_MSG_SETENFORCE = 16,
    SELNL_MSG_POLICYLOAD = 17,
    SELNL_MSG_MAX = 18,
};

enum {
    SFF8024_ID_UNK = 0,
    SFF8024_ID_SFF_8472 = 2,
    SFF8024_ID_SFP = 3,
    SFF8024_ID_DWDM_SFP = 11,
    SFF8024_ID_QSFP_8438 = 12,
    SFF8024_ID_QSFP_8436_8636 = 13,
    SFF8024_ID_QSFP28_8636 = 17,
    SFF8024_ID_QSFP_DD = 24,
    SFF8024_ID_OSFP = 25,
    SFF8024_ID_DSFP = 27,
    SFF8024_ID_QSFP_PLUS_CMIS = 30,
    SFF8024_ID_SFP_DD_CMIS = 31,
    SFF8024_ID_SFP_PLUS_CMIS = 32,
    SFF8024_ENCODING_UNSPEC = 0,
    SFF8024_ENCODING_8B10B = 1,
    SFF8024_ENCODING_4B5B = 2,
    SFF8024_ENCODING_NRZ = 3,
    SFF8024_ENCODING_8472_MANCHESTER = 4,
    SFF8024_ENCODING_8472_SONET = 5,
    SFF8024_ENCODING_8472_64B66B = 6,
    SFF8024_ENCODING_8436_MANCHESTER = 6,
    SFF8024_ENCODING_8436_SONET = 4,
    SFF8024_ENCODING_8436_64B66B = 5,
    SFF8024_ENCODING_256B257B = 7,
    SFF8024_ENCODING_PAM4 = 8,
    SFF8024_CONNECTOR_UNSPEC = 0,
    SFF8024_CONNECTOR_SC = 1,
    SFF8024_CONNECTOR_FIBERJACK = 6,
    SFF8024_CONNECTOR_LC = 7,
    SFF8024_CONNECTOR_MT_RJ = 8,
    SFF8024_CONNECTOR_MU = 9,
    SFF8024_CONNECTOR_SG = 10,
    SFF8024_CONNECTOR_OPTICAL_PIGTAIL = 11,
    SFF8024_CONNECTOR_MPO_1X12 = 12,
    SFF8024_CONNECTOR_MPO_2X16 = 13,
    SFF8024_CONNECTOR_HSSDC_II = 32,
    SFF8024_CONNECTOR_COPPER_PIGTAIL = 33,
    SFF8024_CONNECTOR_RJ45 = 34,
    SFF8024_CONNECTOR_NOSEPARATE = 35,
    SFF8024_CONNECTOR_MXC_2X16 = 36,
    SFF8024_ECC_UNSPEC = 0,
    SFF8024_ECC_100G_25GAUI_C2M_AOC = 1,
    SFF8024_ECC_100GBASE_SR4_25GBASE_SR = 2,
    SFF8024_ECC_100GBASE_LR4_25GBASE_LR = 3,
    SFF8024_ECC_100GBASE_ER4_25GBASE_ER = 4,
    SFF8024_ECC_100GBASE_SR10 = 5,
    SFF8024_ECC_100GBASE_CR4 = 11,
    SFF8024_ECC_25GBASE_CR_S = 12,
    SFF8024_ECC_25GBASE_CR_N = 13,
    SFF8024_ECC_10GBASE_T_SFI = 22,
    SFF8024_ECC_10GBASE_T_SR = 28,
    SFF8024_ECC_5GBASE_T = 29,
    SFF8024_ECC_2_5GBASE_T = 30,
};

enum {
    SFP_PHYS_ID = 0,
    SFP_PHYS_EXT_ID = 1,
    SFP_PHYS_EXT_ID_SFP = 4,
    SFP_CONNECTOR = 2,
    SFP_COMPLIANCE = 3,
    SFP_ENCODING = 11,
    SFP_BR_NOMINAL = 12,
    SFP_RATE_ID = 13,
    SFF_RID_8079 = 1,
    SFF_RID_8431_RX_ONLY = 2,
    SFF_RID_8431_TX_ONLY = 4,
    SFF_RID_8431 = 6,
    SFF_RID_10G8G = 14,
    SFP_LINK_LEN_SM_KM = 14,
    SFP_LINK_LEN_SM_100M = 15,
    SFP_LINK_LEN_50UM_OM2_10M = 16,
    SFP_LINK_LEN_62_5UM_OM1_10M = 17,
    SFP_LINK_LEN_COPPER_1M = 18,
    SFP_LINK_LEN_50UM_OM4_10M = 18,
    SFP_LINK_LEN_50UM_OM3_10M = 19,
    SFP_VENDOR_NAME = 20,
    SFP_VENDOR_OUI = 37,
    SFP_VENDOR_PN = 40,
    SFP_VENDOR_REV = 56,
    SFP_OPTICAL_WAVELENGTH_MSB = 60,
    SFP_OPTICAL_WAVELENGTH_LSB = 61,
    SFP_CABLE_SPEC = 60,
    SFP_CC_BASE = 63,
    SFP_OPTIONS = 64,
    SFP_OPTIONS_HIGH_POWER_LEVEL = 8192,
    SFP_OPTIONS_PAGING_A2 = 4096,
    SFP_OPTIONS_RETIMER = 2048,
    SFP_OPTIONS_COOLED_XCVR = 1024,
    SFP_OPTIONS_POWER_DECL = 512,
    SFP_OPTIONS_RX_LINEAR_OUT = 256,
    SFP_OPTIONS_RX_DECISION_THRESH = 128,
    SFP_OPTIONS_TUNABLE_TX = 64,
    SFP_OPTIONS_RATE_SELECT = 32,
    SFP_OPTIONS_TX_DISABLE = 16,
    SFP_OPTIONS_TX_FAULT = 8,
    SFP_OPTIONS_LOS_INVERTED = 4,
    SFP_OPTIONS_LOS_NORMAL = 2,
    SFP_BR_MAX = 66,
    SFP_BR_MIN = 67,
    SFP_VENDOR_SN = 68,
    SFP_DATECODE = 84,
    SFP_DIAGMON = 92,
    SFP_DIAGMON_DDM = 64,
    SFP_DIAGMON_INT_CAL = 32,
    SFP_DIAGMON_EXT_CAL = 16,
    SFP_DIAGMON_RXPWR_AVG = 8,
    SFP_DIAGMON_ADDRMODE = 4,
    SFP_ENHOPTS = 93,
    SFP_ENHOPTS_ALARMWARN = 128,
    SFP_ENHOPTS_SOFT_TX_DISABLE = 64,
    SFP_ENHOPTS_SOFT_TX_FAULT = 32,
    SFP_ENHOPTS_SOFT_RX_LOS = 16,
    SFP_ENHOPTS_SOFT_RATE_SELECT = 8,
    SFP_ENHOPTS_APP_SELECT_SFF8079 = 4,
    SFP_ENHOPTS_SOFT_RATE_SFF8431 = 2,
    SFP_SFF8472_COMPLIANCE = 94,
    SFP_SFF8472_COMPLIANCE_NONE = 0,
    SFP_SFF8472_COMPLIANCE_REV9_3 = 1,
    SFP_SFF8472_COMPLIANCE_REV9_5 = 2,
    SFP_SFF8472_COMPLIANCE_REV10_2 = 3,
    SFP_SFF8472_COMPLIANCE_REV10_4 = 4,
    SFP_SFF8472_COMPLIANCE_REV11_0 = 5,
    SFP_SFF8472_COMPLIANCE_REV11_3 = 6,
    SFP_SFF8472_COMPLIANCE_REV11_4 = 7,
    SFP_SFF8472_COMPLIANCE_REV12_0 = 8,
    SFP_CC_EXT = 95,
};

enum {
    SKBFL_ZEROCOPY_ENABLE = 1,
    SKBFL_SHARED_FRAG = 2,
    SKBFL_PURE_ZEROCOPY = 4,
    SKBFL_DONT_ORPHAN = 8,
    SKBFL_MANAGED_FRAG_REFS = 16,
};

enum {
    SKBTX_HW_TSTAMP = 1,
    SKBTX_SW_TSTAMP = 2,
    SKBTX_IN_PROGRESS = 4,
    SKBTX_HW_TSTAMP_USE_CYCLES = 8,
    SKBTX_WIFI_STATUS = 16,
    SKBTX_HW_TSTAMP_NETDEV = 32,
    SKBTX_SCHED_TSTAMP = 64,
};

enum {
    SKB_FCLONE_UNAVAILABLE = 0,
    SKB_FCLONE_ORIG = 1,
    SKB_FCLONE_CLONE = 2,
};

enum {
    SKB_GSO_TCPV4 = 1,
    SKB_GSO_DODGY = 2,
    SKB_GSO_TCP_ECN = 4,
    SKB_GSO_TCP_FIXEDID = 8,
    SKB_GSO_TCPV6 = 16,
    SKB_GSO_FCOE = 32,
    SKB_GSO_GRE = 64,
    SKB_GSO_GRE_CSUM = 128,
    SKB_GSO_IPXIP4 = 256,
    SKB_GSO_IPXIP6 = 512,
    SKB_GSO_UDP_TUNNEL = 1024,
    SKB_GSO_UDP_TUNNEL_CSUM = 2048,
    SKB_GSO_PARTIAL = 4096,
    SKB_GSO_TUNNEL_REMCSUM = 8192,
    SKB_GSO_SCTP = 16384,
    SKB_GSO_ESP = 32768,
    SKB_GSO_UDP = 65536,
    SKB_GSO_UDP_L4 = 131072,
    SKB_GSO_FRAGLIST = 262144,
};

enum {
    SKCIPHER_WALK_SLOW = 1,
    SKCIPHER_WALK_COPY = 2,
    SKCIPHER_WALK_DIFF = 4,
    SKCIPHER_WALK_SLEEP = 8,
};

enum {
    SK_DIAG_BPF_STORAGE_NONE = 0,
    SK_DIAG_BPF_STORAGE_PAD = 1,
    SK_DIAG_BPF_STORAGE_MAP_ID = 2,
    SK_DIAG_BPF_STORAGE_MAP_VALUE = 3,
    __SK_DIAG_BPF_STORAGE_MAX = 4,
};

enum {
    SK_DIAG_BPF_STORAGE_REP_NONE = 0,
    SK_DIAG_BPF_STORAGE = 1,
    __SK_DIAG_BPF_STORAGE_REP_MAX = 2,
};

enum {
    SK_DIAG_BPF_STORAGE_REQ_NONE = 0,
    SK_DIAG_BPF_STORAGE_REQ_MAP_FD = 1,
    __SK_DIAG_BPF_STORAGE_REQ_MAX = 2,
};

enum {
    SK_MEMINFO_RMEM_ALLOC = 0,
    SK_MEMINFO_RCVBUF = 1,
    SK_MEMINFO_WMEM_ALLOC = 2,
    SK_MEMINFO_SNDBUF = 3,
    SK_MEMINFO_FWD_ALLOC = 4,
    SK_MEMINFO_WMEM_QUEUED = 5,
    SK_MEMINFO_OPTMEM = 6,
    SK_MEMINFO_BACKLOG = 7,
    SK_MEMINFO_DROPS = 8,
    SK_MEMINFO_VARS = 9,
};

enum {
    SOCK_WAKE_IO = 0,
    SOCK_WAKE_WAITD = 1,
    SOCK_WAKE_SPACE = 2,
    SOCK_WAKE_URG = 3,
};

enum {
    SOF_TIMESTAMPING_TX_HARDWARE = 1,
    SOF_TIMESTAMPING_TX_SOFTWARE = 2,
    SOF_TIMESTAMPING_RX_HARDWARE = 4,
    SOF_TIMESTAMPING_RX_SOFTWARE = 8,
    SOF_TIMESTAMPING_SOFTWARE = 16,
    SOF_TIMESTAMPING_SYS_HARDWARE = 32,
    SOF_TIMESTAMPING_RAW_HARDWARE = 64,
    SOF_TIMESTAMPING_OPT_ID = 128,
    SOF_TIMESTAMPING_TX_SCHED = 256,
    SOF_TIMESTAMPING_TX_ACK = 512,
    SOF_TIMESTAMPING_OPT_CMSG = 1024,
    SOF_TIMESTAMPING_OPT_TSONLY = 2048,
    SOF_TIMESTAMPING_OPT_STATS = 4096,
    SOF_TIMESTAMPING_OPT_PKTINFO = 8192,
    SOF_TIMESTAMPING_OPT_TX_SWHW = 16384,
    SOF_TIMESTAMPING_BIND_PHC = 32768,
    SOF_TIMESTAMPING_OPT_ID_TCP = 65536,
    SOF_TIMESTAMPING_OPT_RX_FILTER = 131072,
    SOF_TIMESTAMPING_LAST = 131072,
    SOF_TIMESTAMPING_MASK = 262143,
};

enum {
    STMPE_IDX_CHIP_ID = 0,
    STMPE_IDX_SYS_CTRL = 1,
    STMPE_IDX_SYS_CTRL2 = 2,
    STMPE_IDX_ICR_LSB = 3,
    STMPE_IDX_IER_LSB = 4,
    STMPE_IDX_IER_MSB = 5,
    STMPE_IDX_ISR_LSB = 6,
    STMPE_IDX_ISR_MSB = 7,
    STMPE_IDX_GPMR_LSB = 8,
    STMPE_IDX_GPMR_CSB = 9,
    STMPE_IDX_GPMR_MSB = 10,
    STMPE_IDX_GPSR_LSB = 11,
    STMPE_IDX_GPSR_CSB = 12,
    STMPE_IDX_GPSR_MSB = 13,
    STMPE_IDX_GPCR_LSB = 14,
    STMPE_IDX_GPCR_CSB = 15,
    STMPE_IDX_GPCR_MSB = 16,
    STMPE_IDX_GPDR_LSB = 17,
    STMPE_IDX_GPDR_CSB = 18,
    STMPE_IDX_GPDR_MSB = 19,
    STMPE_IDX_GPEDR_LSB = 20,
    STMPE_IDX_GPEDR_CSB = 21,
    STMPE_IDX_GPEDR_MSB = 22,
    STMPE_IDX_GPRER_LSB = 23,
    STMPE_IDX_GPRER_CSB = 24,
    STMPE_IDX_GPRER_MSB = 25,
    STMPE_IDX_GPFER_LSB = 26,
    STMPE_IDX_GPFER_CSB = 27,
    STMPE_IDX_GPFER_MSB = 28,
    STMPE_IDX_GPPUR_LSB = 29,
    STMPE_IDX_GPPDR_LSB = 30,
    STMPE_IDX_GPAFR_U_MSB = 31,
    STMPE_IDX_IEGPIOR_LSB = 32,
    STMPE_IDX_IEGPIOR_CSB = 33,
    STMPE_IDX_IEGPIOR_MSB = 34,
    STMPE_IDX_ISGPIOR_LSB = 35,
    STMPE_IDX_ISGPIOR_CSB = 36,
    STMPE_IDX_ISGPIOR_MSB = 37,
    STMPE_IDX_MAX = 38,
};

enum {
    SWITCHTEC_GAS_MRPC_OFFSET = 0,
    SWITCHTEC_GAS_TOP_CFG_OFFSET = 4096,
    SWITCHTEC_GAS_SW_EVENT_OFFSET = 6144,
    SWITCHTEC_GAS_SYS_INFO_OFFSET = 8192,
    SWITCHTEC_GAS_FLASH_INFO_OFFSET = 8704,
    SWITCHTEC_GAS_PART_CFG_OFFSET = 16384,
    SWITCHTEC_GAS_NTB_OFFSET = 65536,
    SWITCHTEC_GAS_PFF_CSR_OFFSET = 1261568,
};

enum {
    SWITCHTEC_NTB_REG_INFO_OFFSET = 0,
    SWITCHTEC_NTB_REG_CTRL_OFFSET = 16384,
    SWITCHTEC_NTB_REG_DBMSG_OFFSET = 409600,
};

enum {
    SWMII_SPEED_10 = 0,
    SWMII_SPEED_100 = 1,
    SWMII_SPEED_1000 = 2,
    SWMII_DUPLEX_HALF = 0,
    SWMII_DUPLEX_FULL = 1,
};

enum {
    SWP_USED = 1,
    SWP_WRITEOK = 2,
    SWP_DISCARDABLE = 4,
    SWP_DISCARDING = 8,
    SWP_SOLIDSTATE = 16,
    SWP_CONTINUED = 32,
    SWP_BLKDEV = 64,
    SWP_ACTIVATED = 128,
    SWP_FS_OPS = 256,
    SWP_AREA_DISCARD = 512,
    SWP_PAGE_DISCARD = 1024,
    SWP_STABLE_WRITES = 2048,
    SWP_SYNCHRONOUS_IO = 4096,
};

enum {
    SYNTH_ERR_BAD_NAME = 0,
    SYNTH_ERR_INVALID_CMD = 1,
    SYNTH_ERR_INVALID_DYN_CMD = 2,
    SYNTH_ERR_EVENT_EXISTS = 3,
    SYNTH_ERR_TOO_MANY_FIELDS = 4,
    SYNTH_ERR_INCOMPLETE_TYPE = 5,
    SYNTH_ERR_INVALID_TYPE = 6,
    SYNTH_ERR_INVALID_FIELD = 7,
    SYNTH_ERR_INVALID_ARRAY_SPEC = 8,
};

enum {
    SYSTAB = 0,
    MMBASE = 1,
    MMSIZE = 2,
    DCSIZE = 3,
    DCVERS = 4,
    SCBOOT = 5,
    PARAMCOUNT = 6,
};

enum {
    TASKLET_STATE_SCHED = 0,
    TASKLET_STATE_RUN = 1,
};

enum {
    TASKSTATS_CMD_ATTR_UNSPEC = 0,
    TASKSTATS_CMD_ATTR_PID = 1,
    TASKSTATS_CMD_ATTR_TGID = 2,
    TASKSTATS_CMD_ATTR_REGISTER_CPUMASK = 3,
    TASKSTATS_CMD_ATTR_DEREGISTER_CPUMASK = 4,
    __TASKSTATS_CMD_ATTR_MAX = 5,
};

enum {
    TASKSTATS_CMD_UNSPEC = 0,
    TASKSTATS_CMD_GET = 1,
    TASKSTATS_CMD_NEW = 2,
    __TASKSTATS_CMD_MAX = 3,
};

enum {
    TASKSTATS_TYPE_UNSPEC = 0,
    TASKSTATS_TYPE_PID = 1,
    TASKSTATS_TYPE_TGID = 2,
    TASKSTATS_TYPE_STATS = 3,
    TASKSTATS_TYPE_AGGR_PID = 4,
    TASKSTATS_TYPE_AGGR_TGID = 5,
    TASKSTATS_TYPE_NULL = 6,
    __TASKSTATS_TYPE_MAX = 7,
};

enum {
    TASK_COMM_LEN = 16,
};

enum {
    TCA_ACT_UNSPEC = 0,
    TCA_ACT_KIND = 1,
    TCA_ACT_OPTIONS = 2,
    TCA_ACT_INDEX = 3,
    TCA_ACT_STATS = 4,
    TCA_ACT_PAD = 5,
    TCA_ACT_COOKIE = 6,
    TCA_ACT_FLAGS = 7,
    TCA_ACT_HW_STATS = 8,
    TCA_ACT_USED_HW_STATS = 9,
    TCA_ACT_IN_HW_COUNT = 10,
    __TCA_ACT_MAX = 11,
};

enum {
    TCA_EMATCH_TREE_UNSPEC = 0,
    TCA_EMATCH_TREE_HDR = 1,
    TCA_EMATCH_TREE_LIST = 2,
    __TCA_EMATCH_TREE_MAX = 3,
};

enum {
    TCA_FLOWER_KEY_CT_FLAGS_NEW = 1,
    TCA_FLOWER_KEY_CT_FLAGS_ESTABLISHED = 2,
    TCA_FLOWER_KEY_CT_FLAGS_RELATED = 4,
    TCA_FLOWER_KEY_CT_FLAGS_TRACKED = 8,
    TCA_FLOWER_KEY_CT_FLAGS_INVALID = 16,
    TCA_FLOWER_KEY_CT_FLAGS_REPLY = 32,
    __TCA_FLOWER_KEY_CT_FLAGS_MAX = 33,
};

enum {
    TCA_FLOWER_KEY_FLAGS_IS_FRAGMENT = 1,
    TCA_FLOWER_KEY_FLAGS_FRAG_IS_FIRST = 2,
    TCA_FLOWER_KEY_FLAGS_TUNNEL_CSUM = 4,
    TCA_FLOWER_KEY_FLAGS_TUNNEL_DONT_FRAGMENT = 8,
    TCA_FLOWER_KEY_FLAGS_TUNNEL_OAM = 16,
    TCA_FLOWER_KEY_FLAGS_TUNNEL_CRIT_OPT = 32,
    __TCA_FLOWER_KEY_FLAGS_MAX = 33,
};

enum {
    TCA_ROOT_UNSPEC = 0,
    TCA_ROOT_TAB = 1,
    TCA_ROOT_FLAGS = 2,
    TCA_ROOT_COUNT = 3,
    TCA_ROOT_TIME_DELTA = 4,
    TCA_ROOT_EXT_WARN_MSG = 5,
    __TCA_ROOT_MAX = 6,
};

enum {
    TCA_STAB_UNSPEC = 0,
    TCA_STAB_BASE = 1,
    TCA_STAB_DATA = 2,
    __TCA_STAB_MAX = 3,
};

enum {
    TCA_STATS_UNSPEC = 0,
    TCA_STATS_BASIC = 1,
    TCA_STATS_RATE_EST = 2,
    TCA_STATS_QUEUE = 3,
    TCA_STATS_APP = 4,
    TCA_STATS_RATE_EST64 = 5,
    TCA_STATS_PAD = 6,
    TCA_STATS_BASIC_HW = 7,
    TCA_STATS_PKT64 = 8,
    __TCA_STATS_MAX = 9,
};

enum {
    TCA_UNSPEC = 0,
    TCA_KIND = 1,
    TCA_OPTIONS = 2,
    TCA_STATS = 3,
    TCA_XSTATS = 4,
    TCA_RATE = 5,
    TCA_FCNT = 6,
    TCA_STATS2 = 7,
    TCA_STAB = 8,
    TCA_PAD = 9,
    TCA_DUMP_INVISIBLE = 10,
    TCA_CHAIN = 11,
    TCA_HW_OFFLOAD = 12,
    TCA_INGRESS_BLOCK = 13,
    TCA_EGRESS_BLOCK = 14,
    TCA_DUMP_FLAGS = 15,
    TCA_EXT_WARN_MSG = 16,
    __TCA_MAX = 17,
};

enum {
    TCG_SECP_00 = 0,
    TCG_SECP_01 = 1,
};

enum {
    TCPF_ESTABLISHED = 2,
    TCPF_SYN_SENT = 4,
    TCPF_SYN_RECV = 8,
    TCPF_FIN_WAIT1 = 16,
    TCPF_FIN_WAIT2 = 32,
    TCPF_TIME_WAIT = 64,
    TCPF_CLOSE = 128,
    TCPF_CLOSE_WAIT = 256,
    TCPF_LAST_ACK = 512,
    TCPF_LISTEN = 1024,
    TCPF_CLOSING = 2048,
    TCPF_NEW_SYN_RECV = 4096,
    TCPF_BOUND_INACTIVE = 8192,
};

enum {
    TCP_BPF_BASE = 0,
    TCP_BPF_TX = 1,
    TCP_BPF_RX = 2,
    TCP_BPF_TXRX = 3,
    TCP_BPF_NUM_CFGS = 4,
};

enum {
    TCP_BPF_IPV4 = 0,
    TCP_BPF_IPV6 = 1,
    TCP_BPF_NUM_PROTS = 2,
};

enum {
    TCP_BPF_IW = 1001,
    TCP_BPF_SNDCWND_CLAMP = 1002,
    TCP_BPF_DELACK_MAX = 1003,
    TCP_BPF_RTO_MIN = 1004,
    TCP_BPF_SYN = 1005,
    TCP_BPF_SYN_IP = 1006,
    TCP_BPF_SYN_MAC = 1007,
    TCP_BPF_SOCK_OPS_CB_FLAGS = 1008,
};

enum {
    TCP_CMSG_INQ = 1,
    TCP_CMSG_TS = 2,
};

enum {
    TCP_ESTABLISHED = 1,
    TCP_SYN_SENT = 2,
    TCP_SYN_RECV = 3,
    TCP_FIN_WAIT1 = 4,
    TCP_FIN_WAIT2 = 5,
    TCP_TIME_WAIT = 6,
    TCP_CLOSE = 7,
    TCP_CLOSE_WAIT = 8,
    TCP_LAST_ACK = 9,
    TCP_LISTEN = 10,
    TCP_CLOSING = 11,
    TCP_NEW_SYN_RECV = 12,
    TCP_BOUND_INACTIVE = 13,
    TCP_MAX_STATES = 14,
};

enum {
    TCP_FLAG_CWR = 32768,
    TCP_FLAG_ECE = 16384,
    TCP_FLAG_URG = 8192,
    TCP_FLAG_ACK = 4096,
    TCP_FLAG_PSH = 2048,
    TCP_FLAG_RST = 1024,
    TCP_FLAG_SYN = 512,
    TCP_FLAG_FIN = 256,
    TCP_RESERVED_BITS = 15,
    TCP_DATA_OFFSET = 240,
};

enum {
    TCP_METRICS_ATTR_UNSPEC = 0,
    TCP_METRICS_ATTR_ADDR_IPV4 = 1,
    TCP_METRICS_ATTR_ADDR_IPV6 = 2,
    TCP_METRICS_ATTR_AGE = 3,
    TCP_METRICS_ATTR_TW_TSVAL = 4,
    TCP_METRICS_ATTR_TW_TS_STAMP = 5,
    TCP_METRICS_ATTR_VALS = 6,
    TCP_METRICS_ATTR_FOPEN_MSS = 7,
    TCP_METRICS_ATTR_FOPEN_SYN_DROPS = 8,
    TCP_METRICS_ATTR_FOPEN_SYN_DROP_TS = 9,
    TCP_METRICS_ATTR_FOPEN_COOKIE = 10,
    TCP_METRICS_ATTR_SADDR_IPV4 = 11,
    TCP_METRICS_ATTR_SADDR_IPV6 = 12,
    TCP_METRICS_ATTR_PAD = 13,
    __TCP_METRICS_ATTR_MAX = 14,
};

enum {
    TCP_METRICS_CMD_UNSPEC = 0,
    TCP_METRICS_CMD_GET = 1,
    TCP_METRICS_CMD_DEL = 2,
    __TCP_METRICS_CMD_MAX = 3,
};

enum {
    TCP_MIB_NUM = 0,
    TCP_MIB_RTOALGORITHM = 1,
    TCP_MIB_RTOMIN = 2,
    TCP_MIB_RTOMAX = 3,
    TCP_MIB_MAXCONN = 4,
    TCP_MIB_ACTIVEOPENS = 5,
    TCP_MIB_PASSIVEOPENS = 6,
    TCP_MIB_ATTEMPTFAILS = 7,
    TCP_MIB_ESTABRESETS = 8,
    TCP_MIB_CURRESTAB = 9,
    TCP_MIB_INSEGS = 10,
    TCP_MIB_OUTSEGS = 11,
    TCP_MIB_RETRANSSEGS = 12,
    TCP_MIB_INERRS = 13,
    TCP_MIB_OUTRSTS = 14,
    TCP_MIB_CSUMERRORS = 15,
    __TCP_MIB_MAX = 16,
};

enum {
    TCP_NLA_PAD = 0,
    TCP_NLA_BUSY = 1,
    TCP_NLA_RWND_LIMITED = 2,
    TCP_NLA_SNDBUF_LIMITED = 3,
    TCP_NLA_DATA_SEGS_OUT = 4,
    TCP_NLA_TOTAL_RETRANS = 5,
    TCP_NLA_PACING_RATE = 6,
    TCP_NLA_DELIVERY_RATE = 7,
    TCP_NLA_SND_CWND = 8,
    TCP_NLA_REORDERING = 9,
    TCP_NLA_MIN_RTT = 10,
    TCP_NLA_RECUR_RETRANS = 11,
    TCP_NLA_DELIVERY_RATE_APP_LMT = 12,
    TCP_NLA_SNDQ_SIZE = 13,
    TCP_NLA_CA_STATE = 14,
    TCP_NLA_SND_SSTHRESH = 15,
    TCP_NLA_DELIVERED = 16,
    TCP_NLA_DELIVERED_CE = 17,
    TCP_NLA_BYTES_SENT = 18,
    TCP_NLA_BYTES_RETRANS = 19,
    TCP_NLA_DSACK_DUPS = 20,
    TCP_NLA_REORD_SEEN = 21,
    TCP_NLA_SRTT = 22,
    TCP_NLA_TIMEOUT_REHASH = 23,
    TCP_NLA_BYTES_NOTSENT = 24,
    TCP_NLA_EDT = 25,
    TCP_NLA_TTL = 26,
    TCP_NLA_REHASH = 27,
};

enum {
    TCP_NO_QUEUE = 0,
    TCP_RECV_QUEUE = 1,
    TCP_SEND_QUEUE = 2,
    TCP_QUEUES_NR = 3,
};

enum {
    TLS_ALERT_DESC_CLOSE_NOTIFY = 0,
    TLS_ALERT_DESC_UNEXPECTED_MESSAGE = 10,
    TLS_ALERT_DESC_BAD_RECORD_MAC = 20,
    TLS_ALERT_DESC_RECORD_OVERFLOW = 22,
    TLS_ALERT_DESC_HANDSHAKE_FAILURE = 40,
    TLS_ALERT_DESC_BAD_CERTIFICATE = 42,
    TLS_ALERT_DESC_UNSUPPORTED_CERTIFICATE = 43,
    TLS_ALERT_DESC_CERTIFICATE_REVOKED = 44,
    TLS_ALERT_DESC_CERTIFICATE_EXPIRED = 45,
    TLS_ALERT_DESC_CERTIFICATE_UNKNOWN = 46,
    TLS_ALERT_DESC_ILLEGAL_PARAMETER = 47,
    TLS_ALERT_DESC_UNKNOWN_CA = 48,
    TLS_ALERT_DESC_ACCESS_DENIED = 49,
    TLS_ALERT_DESC_DECODE_ERROR = 50,
    TLS_ALERT_DESC_DECRYPT_ERROR = 51,
    TLS_ALERT_DESC_TOO_MANY_CIDS_REQUESTED = 52,
    TLS_ALERT_DESC_PROTOCOL_VERSION = 70,
    TLS_ALERT_DESC_INSUFFICIENT_SECURITY = 71,
    TLS_ALERT_DESC_INTERNAL_ERROR = 80,
    TLS_ALERT_DESC_INAPPROPRIATE_FALLBACK = 86,
    TLS_ALERT_DESC_USER_CANCELED = 90,
    TLS_ALERT_DESC_MISSING_EXTENSION = 109,
    TLS_ALERT_DESC_UNSUPPORTED_EXTENSION = 110,
    TLS_ALERT_DESC_UNRECOGNIZED_NAME = 112,
    TLS_ALERT_DESC_BAD_CERTIFICATE_STATUS_RESPONSE = 113,
    TLS_ALERT_DESC_UNKNOWN_PSK_IDENTITY = 115,
    TLS_ALERT_DESC_CERTIFICATE_REQUIRED = 116,
    TLS_ALERT_DESC_NO_APPLICATION_PROTOCOL = 120,
};

enum {
    TLS_ALERT_LEVEL_WARNING = 1,
    TLS_ALERT_LEVEL_FATAL = 2,
};

enum {
    TLS_NO_KEYRING = 0,
    TLS_NO_PEERID = 0,
    TLS_NO_CERT = 0,
    TLS_NO_PRIVKEY = 0,
};

enum {
    TLS_RECORD_TYPE_CHANGE_CIPHER_SPEC = 20,
    TLS_RECORD_TYPE_ALERT = 21,
    TLS_RECORD_TYPE_HANDSHAKE = 22,
    TLS_RECORD_TYPE_DATA = 23,
    TLS_RECORD_TYPE_HEARTBEAT = 24,
    TLS_RECORD_TYPE_TLS12_CID = 25,
    TLS_RECORD_TYPE_ACK = 26,
};

enum {
    TOO_MANY_CLOSE = -1,
    TOO_MANY_OPEN = -2,
    MISSING_QUOTE = -3,
};

enum {
    TP_ERR_FILE_NOT_FOUND = 0,
    TP_ERR_NO_REGULAR_FILE = 1,
    TP_ERR_BAD_REFCNT = 2,
    TP_ERR_REFCNT_OPEN_BRACE = 3,
    TP_ERR_BAD_REFCNT_SUFFIX = 4,
    TP_ERR_BAD_UPROBE_OFFS = 5,
    TP_ERR_BAD_MAXACT_TYPE = 6,
    TP_ERR_BAD_MAXACT = 7,
    TP_ERR_MAXACT_TOO_BIG = 8,
    TP_ERR_BAD_PROBE_ADDR = 9,
    TP_ERR_NON_UNIQ_SYMBOL = 10,
    TP_ERR_BAD_RETPROBE = 11,
    TP_ERR_NO_TRACEPOINT = 12,
    TP_ERR_BAD_TP_NAME = 13,
    TP_ERR_BAD_ADDR_SUFFIX = 14,
    TP_ERR_NO_GROUP_NAME = 15,
    TP_ERR_GROUP_TOO_LONG = 16,
    TP_ERR_BAD_GROUP_NAME = 17,
    TP_ERR_NO_EVENT_NAME = 18,
    TP_ERR_EVENT_TOO_LONG = 19,
    TP_ERR_BAD_EVENT_NAME = 20,
    TP_ERR_EVENT_EXIST = 21,
    TP_ERR_RETVAL_ON_PROBE = 22,
    TP_ERR_NO_RETVAL = 23,
    TP_ERR_BAD_STACK_NUM = 24,
    TP_ERR_BAD_ARG_NUM = 25,
    TP_ERR_BAD_VAR = 26,
    TP_ERR_BAD_REG_NAME = 27,
    TP_ERR_BAD_MEM_ADDR = 28,
    TP_ERR_BAD_IMM = 29,
    TP_ERR_IMMSTR_NO_CLOSE = 30,
    TP_ERR_FILE_ON_KPROBE = 31,
    TP_ERR_BAD_FILE_OFFS = 32,
    TP_ERR_SYM_ON_UPROBE = 33,
    TP_ERR_TOO_MANY_OPS = 34,
    TP_ERR_DEREF_NEED_BRACE = 35,
    TP_ERR_BAD_DEREF_OFFS = 36,
    TP_ERR_DEREF_OPEN_BRACE = 37,
    TP_ERR_COMM_CANT_DEREF = 38,
    TP_ERR_BAD_FETCH_ARG = 39,
    TP_ERR_ARRAY_NO_CLOSE = 40,
    TP_ERR_BAD_ARRAY_SUFFIX = 41,
    TP_ERR_BAD_ARRAY_NUM = 42,
    TP_ERR_ARRAY_TOO_BIG = 43,
    TP_ERR_BAD_TYPE = 44,
    TP_ERR_BAD_STRING = 45,
    TP_ERR_BAD_SYMSTRING = 46,
    TP_ERR_BAD_BITFIELD = 47,
    TP_ERR_ARG_NAME_TOO_LONG = 48,
    TP_ERR_NO_ARG_NAME = 49,
    TP_ERR_BAD_ARG_NAME = 50,
    TP_ERR_USED_ARG_NAME = 51,
    TP_ERR_ARG_TOO_LONG = 52,
    TP_ERR_NO_ARG_BODY = 53,
    TP_ERR_BAD_INSN_BNDRY = 54,
    TP_ERR_FAIL_REG_PROBE = 55,
    TP_ERR_DIFF_PROBE_TYPE = 56,
    TP_ERR_DIFF_ARG_TYPE = 57,
    TP_ERR_SAME_PROBE = 58,
    TP_ERR_NO_EVENT_INFO = 59,
    TP_ERR_BAD_ATTACH_EVENT = 60,
    TP_ERR_BAD_ATTACH_ARG = 61,
    TP_ERR_NO_EP_FILTER = 62,
    TP_ERR_NOSUP_BTFARG = 63,
    TP_ERR_NO_BTFARG = 64,
    TP_ERR_NO_BTF_ENTRY = 65,
    TP_ERR_BAD_VAR_ARGS = 66,
    TP_ERR_NOFENTRY_ARGS = 67,
    TP_ERR_DOUBLE_ARGS = 68,
    TP_ERR_ARGS_2LONG = 69,
    TP_ERR_ARGIDX_2BIG = 70,
    TP_ERR_NO_PTR_STRCT = 71,
    TP_ERR_NOSUP_DAT_ARG = 72,
    TP_ERR_BAD_HYPHEN = 73,
    TP_ERR_NO_BTF_FIELD = 74,
    TP_ERR_BAD_BTF_TID = 75,
    TP_ERR_BAD_TYPE4STR = 76,
    TP_ERR_NEED_STRING_TYPE = 77,
    TP_ERR_TOO_MANY_ARGS = 78,
    TP_ERR_TOO_MANY_EARGS = 79,
};

enum {
    TRACEFS_EVENT_INODE = 2,
    TRACEFS_GID_PERM_SET = 4,
    TRACEFS_UID_PERM_SET = 8,
    TRACEFS_INSTANCE_INODE = 16,
};

enum {
    TRACER_IRQS_OFF = 2,
    TRACER_PREEMPT_OFF = 4,
};

enum {
    TRACE_ARRAY_FL_GLOBAL = 1,
    TRACE_ARRAY_FL_BOOT = 2,
    TRACE_ARRAY_FL_MOD_INIT = 4,
};

enum {
    TRACE_CTX_NMI = 0,
    TRACE_CTX_IRQ = 1,
    TRACE_CTX_SOFTIRQ = 2,
    TRACE_CTX_NORMAL = 3,
    TRACE_CTX_TRANSITION = 4,
};

enum {
    TRACE_EVENT_FL_CAP_ANY = 1,
    TRACE_EVENT_FL_NO_SET_FILTER = 2,
    TRACE_EVENT_FL_IGNORE_ENABLE = 4,
    TRACE_EVENT_FL_TRACEPOINT = 8,
    TRACE_EVENT_FL_DYNAMIC = 16,
    TRACE_EVENT_FL_KPROBE = 32,
    TRACE_EVENT_FL_UPROBE = 64,
    TRACE_EVENT_FL_EPROBE = 128,
    TRACE_EVENT_FL_FPROBE = 256,
    TRACE_EVENT_FL_CUSTOM = 512,
    TRACE_EVENT_FL_TEST_STR = 1024,
};

enum {
    TRACE_EVENT_FL_CAP_ANY_BIT = 0,
    TRACE_EVENT_FL_NO_SET_FILTER_BIT = 1,
    TRACE_EVENT_FL_IGNORE_ENABLE_BIT = 2,
    TRACE_EVENT_FL_TRACEPOINT_BIT = 3,
    TRACE_EVENT_FL_DYNAMIC_BIT = 4,
    TRACE_EVENT_FL_KPROBE_BIT = 5,
    TRACE_EVENT_FL_UPROBE_BIT = 6,
    TRACE_EVENT_FL_EPROBE_BIT = 7,
    TRACE_EVENT_FL_FPROBE_BIT = 8,
    TRACE_EVENT_FL_CUSTOM_BIT = 9,
    TRACE_EVENT_FL_TEST_STR_BIT = 10,
};

enum {
    TRACE_FTRACE_BIT = 0,
    TRACE_FTRACE_NMI_BIT = 1,
    TRACE_FTRACE_IRQ_BIT = 2,
    TRACE_FTRACE_SIRQ_BIT = 3,
    TRACE_FTRACE_TRANSITION_BIT = 4,
    TRACE_INTERNAL_BIT = 5,
    TRACE_INTERNAL_NMI_BIT = 6,
    TRACE_INTERNAL_IRQ_BIT = 7,
    TRACE_INTERNAL_SIRQ_BIT = 8,
    TRACE_INTERNAL_TRANSITION_BIT = 9,
    TRACE_BRANCH_BIT = 10,
    TRACE_IRQ_BIT = 11,
    TRACE_RECORD_RECURSION_BIT = 12,
};

enum {
    TRACE_FUNC_NO_OPTS = 0,
    TRACE_FUNC_OPT_STACK = 1,
    TRACE_FUNC_OPT_NO_REPEATS = 2,
    TRACE_FUNC_OPT_HIGHEST_BIT = 4,
};

enum {
    TRACE_GRAPH_FL = 1,
    TRACE_GRAPH_DEPTH_START_BIT = 2,
    TRACE_GRAPH_DEPTH_END_BIT = 3,
    TRACE_GRAPH_NOTRACE_BIT = 4,
};

enum {
    TRACE_NOP_OPT_ACCEPT = 1,
    TRACE_NOP_OPT_REFUSE = 2,
};

enum {
    TRACE_PIDS = 1,
    TRACE_NO_PIDS = 2,
};

enum {
    TRACE_SIGNAL_DELIVERED = 0,
    TRACE_SIGNAL_IGNORED = 1,
    TRACE_SIGNAL_ALREADY_PENDING = 2,
    TRACE_SIGNAL_OVERFLOW_FAIL = 3,
    TRACE_SIGNAL_LOSE_INFO = 4,
};

enum {
    UDP_BPF_IPV4 = 0,
    UDP_BPF_IPV6 = 1,
    UDP_BPF_NUM_PROTS = 2,
};

enum {
    UDP_FLAGS_CORK = 0,
    UDP_FLAGS_NO_CHECK6_TX = 1,
    UDP_FLAGS_NO_CHECK6_RX = 2,
    UDP_FLAGS_GRO_ENABLED = 3,
    UDP_FLAGS_ACCEPT_FRAGLIST = 4,
    UDP_FLAGS_ACCEPT_L4 = 5,
    UDP_FLAGS_ENCAP_ENABLED = 6,
    UDP_FLAGS_UDPLITE_SEND_CC = 7,
    UDP_FLAGS_UDPLITE_RECV_CC = 8,
};

enum {
    UDP_MIB_NUM = 0,
    UDP_MIB_INDATAGRAMS = 1,
    UDP_MIB_NOPORTS = 2,
    UDP_MIB_INERRORS = 3,
    UDP_MIB_OUTDATAGRAMS = 4,
    UDP_MIB_RCVBUFERRORS = 5,
    UDP_MIB_SNDBUFERRORS = 6,
    UDP_MIB_CSUMERRORS = 7,
    UDP_MIB_IGNOREDMULTI = 8,
    UDP_MIB_MEMERRORS = 9,
    __UDP_MIB_MAX = 10,
};

enum {
    UNAME26 = 131072,
    ADDR_NO_RANDOMIZE = 262144,
    FDPIC_FUNCPTRS = 524288,
    MMAP_PAGE_ZERO = 1048576,
    ADDR_COMPAT_LAYOUT = 2097152,
    READ_IMPLIES_EXEC = 4194304,
    ADDR_LIMIT_32BIT = 8388608,
    SHORT_INODE = 16777216,
    WHOLE_SECONDS = 33554432,
    STICKY_TIMEOUTS = 67108864,
    ADDR_LIMIT_3GB = 134217728,
};

enum {
    VCHIQ_POLL_TERMINATE = 0,
    VCHIQ_POLL_REMOVE = 1,
    VCHIQ_POLL_TXNOTIFY = 2,
    VCHIQ_POLL_RXNOTIFY = 3,
    VCHIQ_POLL_COUNT = 4,
};

enum {
    VCHIQ_SRVSTATE_FREE = 0,
    VCHIQ_SRVSTATE_HIDDEN = 1,
    VCHIQ_SRVSTATE_LISTENING = 2,
    VCHIQ_SRVSTATE_OPENING = 3,
    VCHIQ_SRVSTATE_OPEN = 4,
    VCHIQ_SRVSTATE_OPENSYNC = 5,
    VCHIQ_SRVSTATE_CLOSESENT = 6,
    VCHIQ_SRVSTATE_CLOSERECVD = 7,
    VCHIQ_SRVSTATE_CLOSEWAIT = 8,
    VCHIQ_SRVSTATE_CLOSED = 9,
};

enum {
    WALK_TRAILING = 1,
    WALK_MORE = 2,
    WALK_NOFOLLOW = 4,
};

enum {
    WBT_RWQ_BG = 0,
    WBT_RWQ_SWAP = 1,
    WBT_RWQ_DISCARD = 2,
    WBT_NUM_RWQ = 3,
};

enum {
    WBT_STATE_ON_DEFAULT = 1,
    WBT_STATE_ON_MANUAL = 2,
    WBT_STATE_OFF_DEFAULT = 3,
    WBT_STATE_OFF_MANUAL = 4,
};

enum {
    XA_CHECK_SCHED = 4096,
};

enum {
    XDP_ATTACHED_NONE = 0,
    XDP_ATTACHED_DRV = 1,
    XDP_ATTACHED_SKB = 2,
    XDP_ATTACHED_HW = 3,
    XDP_ATTACHED_MULTI = 4,
};

enum {
    XFRM_DEV_OFFLOAD_FLAG_ACQ = 1,
};

enum {
    XFRM_DEV_OFFLOAD_IN = 1,
    XFRM_DEV_OFFLOAD_OUT = 2,
    XFRM_DEV_OFFLOAD_FWD = 3,
};

enum {
    XFRM_DEV_OFFLOAD_UNSPECIFIED = 0,
    XFRM_DEV_OFFLOAD_CRYPTO = 1,
    XFRM_DEV_OFFLOAD_PACKET = 2,
};

enum {
    XFRM_LOOKUP_ICMP = 1,
    XFRM_LOOKUP_QUEUE = 2,
    XFRM_LOOKUP_KEEP_DST_REF = 4,
};

enum {
    XFRM_MODE_FLAG_TUNNEL = 1,
};

enum {
    XFRM_MSG_BASE = 16,
    XFRM_MSG_NEWSA = 16,
    XFRM_MSG_DELSA = 17,
    XFRM_MSG_GETSA = 18,
    XFRM_MSG_NEWPOLICY = 19,
    XFRM_MSG_DELPOLICY = 20,
    XFRM_MSG_GETPOLICY = 21,
    XFRM_MSG_ALLOCSPI = 22,
    XFRM_MSG_ACQUIRE = 23,
    XFRM_MSG_EXPIRE = 24,
    XFRM_MSG_UPDPOLICY = 25,
    XFRM_MSG_UPDSA = 26,
    XFRM_MSG_POLEXPIRE = 27,
    XFRM_MSG_FLUSHSA = 28,
    XFRM_MSG_FLUSHPOLICY = 29,
    XFRM_MSG_NEWAE = 30,
    XFRM_MSG_GETAE = 31,
    XFRM_MSG_REPORT = 32,
    XFRM_MSG_MIGRATE = 33,
    XFRM_MSG_NEWSADINFO = 34,
    XFRM_MSG_GETSADINFO = 35,
    XFRM_MSG_NEWSPDINFO = 36,
    XFRM_MSG_GETSPDINFO = 37,
    XFRM_MSG_MAPPING = 38,
    XFRM_MSG_SETDEFAULT = 39,
    XFRM_MSG_GETDEFAULT = 40,
    __XFRM_MSG_MAX = 41,
};

enum {
    XFRM_POLICY_IN = 0,
    XFRM_POLICY_OUT = 1,
    XFRM_POLICY_FWD = 2,
    XFRM_POLICY_MASK = 3,
    XFRM_POLICY_MAX = 3,
};

enum {
    XFRM_POLICY_TYPE_MAIN = 0,
    XFRM_POLICY_TYPE_SUB = 1,
    XFRM_POLICY_TYPE_MAX = 2,
    XFRM_POLICY_TYPE_ANY = 255,
};

enum {
    XFRM_STATE_VOID = 0,
    XFRM_STATE_ACQ = 1,
    XFRM_STATE_VALID = 2,
    XFRM_STATE_ERROR = 3,
    XFRM_STATE_EXPIRED = 4,
    XFRM_STATE_DEAD = 5,
};

enum {
    ZONELIST_FALLBACK = 0,
    MAX_ZONELISTS = 1,
};

enum {
    ZSTDbss_compress = 0,
    ZSTDbss_noCompress = 1,
};

enum {
    _DQUOT_USAGE_ENABLED = 0,
    _DQUOT_LIMITS_ENABLED = 1,
    _DQUOT_SUSPENDED = 2,
    _DQUOT_STATE_FLAGS = 3,
};

enum {
    _IRQ_DEFAULT_INIT_FLAGS = 0,
    _IRQ_PER_CPU = 512,
    _IRQ_LEVEL = 256,
    _IRQ_NOPROBE = 1024,
    _IRQ_NOREQUEST = 2048,
    _IRQ_NOTHREAD = 65536,
    _IRQ_NOAUTOEN = 4096,
    _IRQ_NO_BALANCING = 8192,
    _IRQ_NESTED_THREAD = 32768,
    _IRQ_PER_CPU_DEVID = 131072,
    _IRQ_IS_POLLED = 262144,
    _IRQ_DISABLE_UNLAZY = 524288,
    _IRQ_HIDDEN = 1048576,
    _IRQ_NO_DEBUG = 2097152,
    _IRQF_MODIFY_MASK = 2080527,
};

enum {
    __IOAM6_IPTUNNEL_MODE_MIN = 0,
    IOAM6_IPTUNNEL_MODE_INLINE = 1,
    IOAM6_IPTUNNEL_MODE_ENCAP = 2,
    IOAM6_IPTUNNEL_MODE_AUTO = 3,
    __IOAM6_IPTUNNEL_MODE_MAX = 4,
};

enum {
    __ND_OPT_PREFIX_INFO_END = 0,
    ND_OPT_SOURCE_LL_ADDR = 1,
    ND_OPT_TARGET_LL_ADDR = 2,
    ND_OPT_PREFIX_INFO = 3,
    ND_OPT_REDIRECT_HDR = 4,
    ND_OPT_MTU = 5,
    ND_OPT_NONCE = 14,
    __ND_OPT_ARRAY_MAX = 15,
    ND_OPT_ROUTE_INFO = 24,
    ND_OPT_RDNSS = 25,
    ND_OPT_DNSSL = 31,
    ND_OPT_6CO = 34,
    ND_OPT_CAPTIVE_PORTAL = 37,
    ND_OPT_PREF64 = 38,
    __ND_OPT_MAX = 39,
};

enum {
    __PERCPU_REF_ATOMIC = 1,
    __PERCPU_REF_DEAD = 2,
    __PERCPU_REF_ATOMIC_DEAD = 3,
    __PERCPU_REF_FLAG_BITS = 2,
};

enum {
    __SCHED_FEAT_PLACE_LAG = 0,
    __SCHED_FEAT_PLACE_DEADLINE_INITIAL = 1,
    __SCHED_FEAT_PLACE_REL_DEADLINE = 2,
    __SCHED_FEAT_RUN_TO_PARITY = 3,
    __SCHED_FEAT_PREEMPT_SHORT = 4,
    __SCHED_FEAT_NEXT_BUDDY = 5,
    __SCHED_FEAT_PICK_BUDDY = 6,
    __SCHED_FEAT_CACHE_HOT_BUDDY = 7,
    __SCHED_FEAT_DELAY_DEQUEUE = 8,
    __SCHED_FEAT_DELAY_ZERO = 9,
    __SCHED_FEAT_WAKEUP_PREEMPTION = 10,
    __SCHED_FEAT_HRTICK = 11,
    __SCHED_FEAT_HRTICK_DL = 12,
    __SCHED_FEAT_NONTASK_CAPACITY = 13,
    __SCHED_FEAT_TTWU_QUEUE = 14,
    __SCHED_FEAT_SIS_UTIL = 15,
    __SCHED_FEAT_WARN_DOUBLE_CLOCK = 16,
    __SCHED_FEAT_RT_PUSH_IPI = 17,
    __SCHED_FEAT_RT_RUNTIME_SHARE = 18,
    __SCHED_FEAT_LB_MIN = 19,
    __SCHED_FEAT_ATTACH_AGE_LOAD = 20,
    __SCHED_FEAT_WA_IDLE = 21,
    __SCHED_FEAT_WA_WEIGHT = 22,
    __SCHED_FEAT_WA_BIAS = 23,
    __SCHED_FEAT_UTIL_EST = 24,
    __SCHED_FEAT_LATENCY_WARN = 25,
    __SCHED_FEAT_NR = 26,
};

enum {
    __SD_BALANCE_NEWIDLE = 0,
    __SD_BALANCE_EXEC = 1,
    __SD_BALANCE_FORK = 2,
    __SD_BALANCE_WAKE = 3,
    __SD_WAKE_AFFINE = 4,
    __SD_ASYM_CPUCAPACITY = 5,
    __SD_ASYM_CPUCAPACITY_FULL = 6,
    __SD_SHARE_CPUCAPACITY = 7,
    __SD_CLUSTER = 8,
    __SD_SHARE_LLC = 9,
    __SD_SERIALIZE = 10,
    __SD_ASYM_PACKING = 11,
    __SD_PREFER_SIBLING = 12,
    __SD_OVERLAP = 13,
    __SD_NUMA = 14,
    __SD_FLAG_CNT = 15,
};

enum {
    ___GFP_DMA_BIT = 0,
    ___GFP_HIGHMEM_BIT = 1,
    ___GFP_DMA32_BIT = 2,
    ___GFP_MOVABLE_BIT = 3,
    ___GFP_RECLAIMABLE_BIT = 4,
    ___GFP_HIGH_BIT = 5,
    ___GFP_IO_BIT = 6,
    ___GFP_FS_BIT = 7,
    ___GFP_ZERO_BIT = 8,
    ___GFP_UNUSED_BIT = 9,
    ___GFP_DIRECT_RECLAIM_BIT = 10,
    ___GFP_KSWAPD_RECLAIM_BIT = 11,
    ___GFP_WRITE_BIT = 12,
    ___GFP_NOWARN_BIT = 13,
    ___GFP_RETRY_MAYFAIL_BIT = 14,
    ___GFP_NOFAIL_BIT = 15,
    ___GFP_NORETRY_BIT = 16,
    ___GFP_MEMALLOC_BIT = 17,
    ___GFP_COMP_BIT = 18,
    ___GFP_NOMEMALLOC_BIT = 19,
    ___GFP_HARDWALL_BIT = 20,
    ___GFP_THISNODE_BIT = 21,
    ___GFP_ACCOUNT_BIT = 22,
    ___GFP_ZEROTAGS_BIT = 23,
    ___GFP_NO_OBJ_EXT_BIT = 24,
    ___GFP_LAST_BIT = 25,
};

enum {
    __ctx_convertBPF_PROG_TYPE_SOCKET_FILTER = 0,
    __ctx_convertBPF_PROG_TYPE_SCHED_CLS = 1,
    __ctx_convertBPF_PROG_TYPE_SCHED_ACT = 2,
    __ctx_convertBPF_PROG_TYPE_XDP = 3,
    __ctx_convertBPF_PROG_TYPE_CGROUP_SKB = 4,
    __ctx_convertBPF_PROG_TYPE_CGROUP_SOCK = 5,
    __ctx_convertBPF_PROG_TYPE_CGROUP_SOCK_ADDR = 6,
    __ctx_convertBPF_PROG_TYPE_LWT_IN = 7,
    __ctx_convertBPF_PROG_TYPE_LWT_OUT = 8,
    __ctx_convertBPF_PROG_TYPE_LWT_XMIT = 9,
    __ctx_convertBPF_PROG_TYPE_LWT_SEG6LOCAL = 10,
    __ctx_convertBPF_PROG_TYPE_SOCK_OPS = 11,
    __ctx_convertBPF_PROG_TYPE_SK_SKB = 12,
    __ctx_convertBPF_PROG_TYPE_SK_MSG = 13,
    __ctx_convertBPF_PROG_TYPE_FLOW_DISSECTOR = 14,
    __ctx_convertBPF_PROG_TYPE_KPROBE = 15,
    __ctx_convertBPF_PROG_TYPE_TRACEPOINT = 16,
    __ctx_convertBPF_PROG_TYPE_PERF_EVENT = 17,
    __ctx_convertBPF_PROG_TYPE_RAW_TRACEPOINT = 18,
    __ctx_convertBPF_PROG_TYPE_RAW_TRACEPOINT_WRITABLE = 19,
    __ctx_convertBPF_PROG_TYPE_TRACING = 20,
    __ctx_convertBPF_PROG_TYPE_CGROUP_DEVICE = 21,
    __ctx_convertBPF_PROG_TYPE_CGROUP_SYSCTL = 22,
    __ctx_convertBPF_PROG_TYPE_CGROUP_SOCKOPT = 23,
    __ctx_convertBPF_PROG_TYPE_SK_REUSEPORT = 24,
    __ctx_convertBPF_PROG_TYPE_SK_LOOKUP = 25,
    __ctx_convertBPF_PROG_TYPE_STRUCT_OPS = 26,
    __ctx_convertBPF_PROG_TYPE_EXT = 27,
    __ctx_convertBPF_PROG_TYPE_SYSCALL = 28,
    __ctx_convertBPF_PROG_TYPE_NETFILTER = 29,
    __ctx_convert_unused = 30,
};

enum {
    attr_noop = 0,
    attr_delayed_allocation_blocks = 1,
    attr_session_write_kbytes = 2,
    attr_lifetime_write_kbytes = 3,
    attr_reserved_clusters = 4,
    attr_sra_exceeded_retry_limit = 5,
    attr_inode_readahead = 6,
    attr_trigger_test_error = 7,
    attr_first_error_time = 8,
    attr_last_error_time = 9,
    attr_clusters_in_group = 10,
    attr_mb_order = 11,
    attr_feature = 12,
    attr_pointer_pi = 13,
    attr_pointer_ui = 14,
    attr_pointer_ul = 15,
    attr_pointer_u64 = 16,
    attr_pointer_u8 = 17,
    attr_pointer_string = 18,
    attr_pointer_atomic = 19,
    attr_journal_task = 20,
};

enum {
    blank_off = 0,
    blank_normal_wait = 1,
    blank_vesa_wait = 2,
};

enum {
    cpuset = 0,
    possible = 1,
    fail = 2,
};

enum {
    dns_key_data = 0,
    dns_key_error = 1,
};

enum {
    false = 0,
    true = 1,
};

enum {
    kvm_ioeventfd_flag_nr_datamatch = 0,
    kvm_ioeventfd_flag_nr_pio = 1,
    kvm_ioeventfd_flag_nr_deassign = 2,
    kvm_ioeventfd_flag_nr_virtio_ccw_notify = 3,
    kvm_ioeventfd_flag_nr_fast_mmio = 4,
    kvm_ioeventfd_flag_nr_max = 5,
};

enum {
    none = 0,
    day = 1,
    month = 2,
    year = 3,
};

enum {
    pci_channel_io_normal = 1,
    pci_channel_io_frozen = 2,
    pci_channel_io_perm_failure = 3,
};

enum {
    preempt_dynamic_undefined = -1,
    preempt_dynamic_none = 0,
    preempt_dynamic_voluntary = 1,
    preempt_dynamic_full = 2,
    preempt_dynamic_lazy = 3,
};

enum {
    ptr_explicit = 0,
    ptr_ext4_sb_info_offset = 1,
    ptr_ext4_super_block_offset = 2,
};

enum {
    type_kind_int = 0,
    type_kind_float = 1,
    type_unknown = 65535,
};

typedef enum {
    BIT_DStream_unfinished = 0,
    BIT_DStream_endOfBuffer = 1,
    BIT_DStream_completed = 2,
    BIT_DStream_overflow = 3,
} BIT_DStream_status;

typedef enum {
    EfiPciIoWidthUint8 = 0,
    EfiPciIoWidthUint16 = 1,
    EfiPciIoWidthUint32 = 2,
    EfiPciIoWidthUint64 = 3,
    EfiPciIoWidthFifoUint8 = 4,
    EfiPciIoWidthFifoUint16 = 5,
    EfiPciIoWidthFifoUint32 = 6,
    EfiPciIoWidthFifoUint64 = 7,
    EfiPciIoWidthFillUint8 = 8,
    EfiPciIoWidthFillUint16 = 9,
    EfiPciIoWidthFillUint32 = 10,
    EfiPciIoWidthFillUint64 = 11,
    EfiPciIoWidthMaximum = 12,
} EFI_PCI_IO_PROTOCOL_WIDTH;

typedef enum {
    EfiTimerCancel = 0,
    EfiTimerPeriodic = 1,
    EfiTimerRelative = 2,
} EFI_TIMER_DELAY;

typedef enum {
    ZSTD_error_no_error = 0,
    ZSTD_error_GENERIC = 1,
    ZSTD_error_prefix_unknown = 10,
    ZSTD_error_version_unsupported = 12,
    ZSTD_error_frameParameter_unsupported = 14,
    ZSTD_error_frameParameter_windowTooLarge = 16,
    ZSTD_error_corruption_detected = 20,
    ZSTD_error_checksum_wrong = 22,
    ZSTD_error_dictionary_corrupted = 30,
    ZSTD_error_dictionary_wrong = 32,
    ZSTD_error_dictionaryCreation_failed = 34,
    ZSTD_error_parameter_unsupported = 40,
    ZSTD_error_parameter_outOfBound = 42,
    ZSTD_error_tableLog_tooLarge = 44,
    ZSTD_error_maxSymbolValue_tooLarge = 46,
    ZSTD_error_maxSymbolValue_tooSmall = 48,
    ZSTD_error_stage_wrong = 60,
    ZSTD_error_init_missing = 62,
    ZSTD_error_memory_allocation = 64,
    ZSTD_error_workSpace_tooSmall = 66,
    ZSTD_error_dstSize_tooSmall = 70,
    ZSTD_error_srcSize_wrong = 72,
    ZSTD_error_dstBuffer_null = 74,
    ZSTD_error_frameIndex_tooLarge = 100,
    ZSTD_error_seekableIO = 102,
    ZSTD_error_dstBuffer_wrong = 104,
    ZSTD_error_srcBuffer_wrong = 105,
    ZSTD_error_maxCode = 120,
} ZSTD_ErrorCode;

typedef ZSTD_ErrorCode ERR_enum;

typedef enum {
    FSE_repeat_none = 0,
    FSE_repeat_check = 1,
    FSE_repeat_valid = 2,
} FSE_repeat;

typedef enum {
    trustInput = 0,
    checkMaxSymbolValue = 1,
} HIST_checkInput_e;

typedef enum {
    HUF_singleStream = 0,
    HUF_fourStreams = 1,
} HUF_nbStreams_e;

typedef enum {
    HUF_repeat_none = 0,
    HUF_repeat_check = 1,
    HUF_repeat_valid = 2,
} HUF_repeat;

typedef enum {
    ZSTD_e_continue = 0,
    ZSTD_e_flush = 1,
    ZSTD_e_end = 2,
} ZSTD_EndDirective;

typedef enum {
    zop_dynamic = 0,
    zop_predef = 1,
} ZSTD_OptPrice_e;

typedef enum {
    ZSTD_reset_session_only = 1,
    ZSTD_reset_parameters = 2,
    ZSTD_reset_session_and_parameters = 3,
} ZSTD_ResetDirective;

typedef enum {
    ZSTD_bm_buffered = 0,
    ZSTD_bm_stable = 1,
} ZSTD_bufferMode_e;

typedef enum {
    ZSTDb_not_buffered = 0,
    ZSTDb_buffered = 1,
} ZSTD_buffered_policy_e;

typedef enum {
    ZSTD_cpm_noAttachDict = 0,
    ZSTD_cpm_attachDict = 1,
    ZSTD_cpm_createCDict = 2,
    ZSTD_cpm_unknown = 3,
} ZSTD_cParamMode_e;

typedef enum {
    ZSTD_c_compressionLevel = 100,
    ZSTD_c_windowLog = 101,
    ZSTD_c_hashLog = 102,
    ZSTD_c_chainLog = 103,
    ZSTD_c_searchLog = 104,
    ZSTD_c_minMatch = 105,
    ZSTD_c_targetLength = 106,
    ZSTD_c_strategy = 107,
    ZSTD_c_enableLongDistanceMatching = 160,
    ZSTD_c_ldmHashLog = 161,
    ZSTD_c_ldmMinMatch = 162,
    ZSTD_c_ldmBucketSizeLog = 163,
    ZSTD_c_ldmHashRateLog = 164,
    ZSTD_c_contentSizeFlag = 200,
    ZSTD_c_checksumFlag = 201,
    ZSTD_c_dictIDFlag = 202,
    ZSTD_c_nbWorkers = 400,
    ZSTD_c_jobSize = 401,
    ZSTD_c_overlapLog = 402,
    ZSTD_c_experimentalParam1 = 500,
    ZSTD_c_experimentalParam2 = 10,
    ZSTD_c_experimentalParam3 = 1000,
    ZSTD_c_experimentalParam4 = 1001,
    ZSTD_c_experimentalParam5 = 1002,
    ZSTD_c_experimentalParam6 = 1003,
    ZSTD_c_experimentalParam7 = 1004,
    ZSTD_c_experimentalParam8 = 1005,
    ZSTD_c_experimentalParam9 = 1006,
    ZSTD_c_experimentalParam10 = 1007,
    ZSTD_c_experimentalParam11 = 1008,
    ZSTD_c_experimentalParam12 = 1009,
    ZSTD_c_experimentalParam13 = 1010,
    ZSTD_c_experimentalParam14 = 1011,
    ZSTD_c_experimentalParam15 = 1012,
} ZSTD_cParameter;

typedef enum {
    zcss_init = 0,
    zcss_load = 1,
    zcss_flush = 2,
} ZSTD_cStreamStage;

typedef enum {
    ZSTDcrp_makeClean = 0,
    ZSTDcrp_leaveDirty = 1,
} ZSTD_compResetPolicy_e;

typedef enum {
    ZSTDcs_created = 0,
    ZSTDcs_init = 1,
    ZSTDcs_ongoing = 2,
    ZSTDcs_ending = 3,
} ZSTD_compressionStage_e;

typedef enum {
    ZSTD_cwksp_alloc_objects = 0,
    ZSTD_cwksp_alloc_buffers = 1,
    ZSTD_cwksp_alloc_aligned = 2,
} ZSTD_cwksp_alloc_phase_e;

typedef enum {
    ZSTD_cwksp_dynamic_alloc = 0,
    ZSTD_cwksp_static_alloc = 1,
} ZSTD_cwksp_static_alloc_e;

typedef enum {
    ZSTD_d_windowLogMax = 100,
    ZSTD_d_experimentalParam1 = 1000,
    ZSTD_d_experimentalParam2 = 1001,
    ZSTD_d_experimentalParam3 = 1002,
    ZSTD_d_experimentalParam4 = 1003,
} ZSTD_dParameter;

typedef enum {
    ZSTDds_getFrameHeaderSize = 0,
    ZSTDds_decodeFrameHeader = 1,
    ZSTDds_decodeBlockHeader = 2,
    ZSTDds_decompressBlock = 3,
    ZSTDds_decompressLastBlock = 4,
    ZSTDds_checkChecksum = 5,
    ZSTDds_decodeSkippableHeader = 6,
    ZSTDds_skipFrame = 7,
} ZSTD_dStage;

typedef enum {
    zdss_init = 0,
    zdss_loadHeader = 1,
    zdss_read = 2,
    zdss_load = 3,
    zdss_flush = 4,
} ZSTD_dStreamStage;

typedef enum {
    ZSTD_defaultDisallowed = 0,
    ZSTD_defaultAllowed = 1,
} ZSTD_defaultPolicy_e;

typedef enum {
    ZSTD_dictDefaultAttach = 0,
    ZSTD_dictForceAttach = 1,
    ZSTD_dictForceCopy = 2,
    ZSTD_dictForceLoad = 3,
} ZSTD_dictAttachPref_e;

typedef enum {
    ZSTD_dct_auto = 0,
    ZSTD_dct_rawContent = 1,
    ZSTD_dct_fullDict = 2,
} ZSTD_dictContentType_e;

typedef enum {
    ZSTD_dlm_byCopy = 0,
    ZSTD_dlm_byRef = 1,
} ZSTD_dictLoadMethod_e;

typedef enum {
    ZSTD_noDict = 0,
    ZSTD_extDict = 1,
    ZSTD_dictMatchState = 2,
    ZSTD_dedicatedDictSearch = 3,
} ZSTD_dictMode_e;

typedef enum {
    ZSTD_dtlm_fast = 0,
    ZSTD_dtlm_full = 1,
} ZSTD_dictTableLoadMethod_e;

typedef enum {
    ZSTD_use_indefinitely = -1,
    ZSTD_dont_use = 0,
    ZSTD_use_once = 1,
} ZSTD_dictUses_e;

typedef enum {
    ZSTD_d_validateChecksum = 0,
    ZSTD_d_ignoreChecksum = 1,
} ZSTD_forceIgnoreChecksum_e;

typedef enum {
    ZSTD_f_zstd1 = 0,
    ZSTD_f_zstd1_magicless = 1,
} ZSTD_format_e;

typedef enum {
    ZSTD_frame = 0,
    ZSTD_skippableFrame = 1,
} ZSTD_frameType_e;

typedef enum {
    ZSTDirp_continue = 0,
    ZSTDirp_reset = 1,
} ZSTD_indexResetPolicy_e;

typedef enum {
    ZSTD_not_in_dst = 0,
    ZSTD_in_dst = 1,
    ZSTD_split = 2,
} ZSTD_litLocation_e;

typedef enum {
    ZSTD_llt_none = 0,
    ZSTD_llt_literalLength = 1,
    ZSTD_llt_matchLength = 2,
} ZSTD_longLengthType_e;

typedef enum {
    ZSTD_lo_isRegularOffset = 0,
    ZSTD_lo_isLongOffset = 1,
} ZSTD_longOffset_e;

typedef enum {
    ZSTDnit_frameHeader = 0,
    ZSTDnit_blockHeader = 1,
    ZSTDnit_block = 2,
    ZSTDnit_lastBlock = 3,
    ZSTDnit_checksum = 4,
    ZSTDnit_skippableFrame = 5,
} ZSTD_nextInputType_e;

typedef enum {
    ZSTD_no_overlap = 0,
    ZSTD_overlap_src_before_dst = 1,
} ZSTD_overlap_e;

typedef enum {
    ZSTD_ps_auto = 0,
    ZSTD_ps_enable = 1,
    ZSTD_ps_disable = 2,
} ZSTD_paramSwitch_e;

typedef enum {
    ZSTD_rmd_refSingleDDict = 0,
    ZSTD_rmd_refMultipleDDicts = 1,
} ZSTD_refMultipleDDicts_e;

typedef enum {
    ZSTD_resetTarget_CDict = 0,
    ZSTD_resetTarget_CCtx = 1,
} ZSTD_resetTarget_e;

typedef enum {
    ZSTD_sf_noBlockDelimiters = 0,
    ZSTD_sf_explicitBlockDelimiters = 1,
} ZSTD_sequenceFormat_e;

typedef enum {
    ZSTD_fast = 1,
    ZSTD_dfast = 2,
    ZSTD_greedy = 3,
    ZSTD_lazy = 4,
    ZSTD_lazy2 = 5,
    ZSTD_btlazy2 = 6,
    ZSTD_btopt = 7,
    ZSTD_btultra = 8,
    ZSTD_btultra2 = 9,
} ZSTD_strategy;

typedef enum {
    bt_raw = 0,
    bt_rle = 1,
    bt_compressed = 2,
    bt_reserved = 3,
} blockType_e;

typedef enum {
    need_more = 0,
    block_done = 1,
    finish_started = 2,
    finish_done = 3,
} block_state;

typedef enum {
    CODES = 0,
    LENS = 1,
    DISTS = 2,
} codetype;

typedef enum {
    FILE_MEMORY_MIGRATE = 0,
    FILE_CPULIST = 1,
    FILE_MEMLIST = 2,
    FILE_EFFECTIVE_CPULIST = 3,
    FILE_EFFECTIVE_MEMLIST = 4,
    FILE_SUBPARTS_CPULIST = 5,
    FILE_EXCLUSIVE_CPULIST = 6,
    FILE_EFFECTIVE_XCPULIST = 7,
    FILE_ISOLATED_CPULIST = 8,
    FILE_CPU_EXCLUSIVE = 9,
    FILE_MEM_EXCLUSIVE = 10,
    FILE_MEM_HARDWALL = 11,
    FILE_SCHED_LOAD_BALANCE = 12,
    FILE_PARTITION_ROOT = 13,
    FILE_SCHED_RELAX_DOMAIN_LEVEL = 14,
    FILE_MEMORY_PRESSURE_ENABLED = 15,
    FILE_MEMORY_PRESSURE = 16,
    FILE_SPREAD_PAGE = 17,
    FILE_SPREAD_SLAB = 18,
} cpuset_filetype_t;

typedef enum {
    CS_ONLINE = 0,
    CS_CPU_EXCLUSIVE = 1,
    CS_MEM_EXCLUSIVE = 2,
    CS_MEM_HARDWALL = 3,
    CS_MEMORY_MIGRATE = 4,
    CS_SCHED_LOAD_BALANCE = 5,
    CS_SPREAD_PAGE = 6,
    CS_SPREAD_SLAB = 7,
} cpuset_flagbits_t;

typedef enum {
    noDict = 0,
    withPrefix64k = 1,
    usingExtDict = 2,
} dict_directive;

typedef enum {
    EITHER = 0,
    INDEX = 1,
    DIRENT = 2,
    DIRENT_HTREE = 3,
} dirblock_type_t;

typedef enum {
    decode_full_block = 0,
    partial_decode = 1,
} earlyEnd_directive;

typedef enum {
    endOnOutputSize = 0,
    endOnInputSize = 1,
} endCondition_directive;

typedef enum {
    EXT4_IGET_NORMAL = 0,
    EXT4_IGET_SPECIAL = 1,
    EXT4_IGET_HANDLE = 2,
    EXT4_IGET_BAD = 4,
    EXT4_IGET_EA_INODE = 8,
} ext4_iget_flags;

typedef enum {
    FS_DECRYPT = 0,
    FS_ENCRYPT = 1,
} fscrypt_direction_t;

typedef enum {
    HEAD = 0,
    FLAGS = 1,
    TIME = 2,
    OS = 3,
    EXLEN = 4,
    EXTRA = 5,
    NAME = 6,
    COMMENT = 7,
    HCRC = 8,
    DICTID = 9,
    DICT = 10,
    TYPE = 11,
    TYPEDO = 12,
    STORED = 13,
    COPY = 14,
    TABLE = 15,
    LENLENS = 16,
    CODELENS = 17,
    LEN = 18,
    LENEXT = 19,
    DIST = 20,
    DISTEXT = 21,
    MATCH = 22,
    LIT = 23,
    CHECK = 24,
    LENGTH = 25,
    DONE = 26,
    BAD = 27,
    MEM = 28,
    SYNC = 29,
} inflate_mode;

typedef enum {
    ISOLATE_ABORT = 0,
    ISOLATE_NONE = 1,
    ISOLATE_SUCCESS = 2,
} isolate_migrate_t;

typedef enum {
    KDB_ENABLE_ALL = 1,
    KDB_ENABLE_MEM_READ = 2,
    KDB_ENABLE_MEM_WRITE = 4,
    KDB_ENABLE_REG_READ = 8,
    KDB_ENABLE_REG_WRITE = 16,
    KDB_ENABLE_INSPECT = 32,
    KDB_ENABLE_FLOW_CTRL = 64,
    KDB_ENABLE_SIGNAL = 128,
    KDB_ENABLE_REBOOT = 256,
    KDB_ENABLE_ALWAYS_SAFE = 512,
    KDB_ENABLE_MASK = 1023,
    KDB_ENABLE_ALL_NO_ARGS = 1024,
    KDB_ENABLE_MEM_READ_NO_ARGS = 2048,
    KDB_ENABLE_MEM_WRITE_NO_ARGS = 4096,
    KDB_ENABLE_REG_READ_NO_ARGS = 8192,
    KDB_ENABLE_REG_WRITE_NO_ARGS = 16384,
    KDB_ENABLE_INSPECT_NO_ARGS = 32768,
    KDB_ENABLE_FLOW_CTRL_NO_ARGS = 65536,
    KDB_ENABLE_SIGNAL_NO_ARGS = 131072,
    KDB_ENABLE_REBOOT_NO_ARGS = 262144,
    KDB_ENABLE_ALWAYS_SAFE_NO_ARGS = 524288,
    KDB_ENABLE_MASK_NO_ARGS = 1047552,
    KDB_REPEAT_NO_ARGS = 1073741824,
    KDB_REPEAT_WITH_ARGS = 2147483648,
} kdb_cmdflags_t;

typedef enum {
    KDB_DB_BPT = 0,
    KDB_DB_SS = 1,
    KDB_DB_SSBPT = 2,
    KDB_DB_NOBPT = 3,
} kdb_dbtrap_t;

typedef enum {
    KDB_REASON_ENTER = 1,
    KDB_REASON_ENTER_SLAVE = 2,
    KDB_REASON_BREAK = 3,
    KDB_REASON_DEBUG = 4,
    KDB_REASON_OOPS = 5,
    KDB_REASON_SWITCH = 6,
    KDB_REASON_KEYBOARD = 7,
    KDB_REASON_NMI = 8,
    KDB_REASON_RECURSE = 9,
    KDB_REASON_SSTEP = 10,
    KDB_REASON_SYSTEM_NMI = 11,
} kdb_reason_t;

typedef enum {
    MAP_CHG_REUSE = 0,
    MAP_CHG_NEEDED = 1,
    MAP_CHG_ENFORCED = 2,
} map_chg_state;

typedef enum {
    PAGE_KEEP = 0,
    PAGE_ACTIVATE = 1,
    PAGE_SUCCESS = 2,
    PAGE_CLEAN = 3,
} pageout_t;

typedef enum {
    PHY_INTERFACE_MODE_NA = 0,
    PHY_INTERFACE_MODE_INTERNAL = 1,
    PHY_INTERFACE_MODE_MII = 2,
    PHY_INTERFACE_MODE_GMII = 3,
    PHY_INTERFACE_MODE_SGMII = 4,
    PHY_INTERFACE_MODE_TBI = 5,
    PHY_INTERFACE_MODE_REVMII = 6,
    PHY_INTERFACE_MODE_RMII = 7,
    PHY_INTERFACE_MODE_REVRMII = 8,
    PHY_INTERFACE_MODE_RGMII = 9,
    PHY_INTERFACE_MODE_RGMII_ID = 10,
    PHY_INTERFACE_MODE_RGMII_RXID = 11,
    PHY_INTERFACE_MODE_RGMII_TXID = 12,
    PHY_INTERFACE_MODE_RTBI = 13,
    PHY_INTERFACE_MODE_SMII = 14,
    PHY_INTERFACE_MODE_XGMII = 15,
    PHY_INTERFACE_MODE_XLGMII = 16,
    PHY_INTERFACE_MODE_MOCA = 17,
    PHY_INTERFACE_MODE_PSGMII = 18,
    PHY_INTERFACE_MODE_QSGMII = 19,
    PHY_INTERFACE_MODE_TRGMII = 20,
    PHY_INTERFACE_MODE_100BASEX = 21,
    PHY_INTERFACE_MODE_1000BASEX = 22,
    PHY_INTERFACE_MODE_2500BASEX = 23,
    PHY_INTERFACE_MODE_5GBASER = 24,
    PHY_INTERFACE_MODE_RXAUI = 25,
    PHY_INTERFACE_MODE_XAUI = 26,
    PHY_INTERFACE_MODE_10GBASER = 27,
    PHY_INTERFACE_MODE_25GBASER = 28,
    PHY_INTERFACE_MODE_USXGMII = 29,
    PHY_INTERFACE_MODE_10GKR = 30,
    PHY_INTERFACE_MODE_QUSGMII = 31,
    PHY_INTERFACE_MODE_1000BASEKX = 32,
    PHY_INTERFACE_MODE_10G_QXGMII = 33,
    PHY_INTERFACE_MODE_MAX = 34,
} phy_interface_t;

typedef enum {
    search_hashChain = 0,
    search_binaryTree = 1,
    search_rowHash = 2,
} searchMethod_e;

typedef enum {
    SS_FREE = 0,
    SS_UNCONNECTED = 1,
    SS_CONNECTING = 2,
    SS_CONNECTED = 3,
    SS_DISCONNECTING = 4,
} socket_state;

typedef enum {
    not_streaming = 0,
    is_streaming = 1,
} streaming_operation;

typedef enum {
    set_basic = 0,
    set_rle = 1,
    set_compressed = 2,
    set_repeat = 3,
} symbolEncodingType_e;

typedef ZSTD_ErrorCode zstd_error_code;

enum CSI_J {
    CSI_J_CURSOR_TO_END = 0,
    CSI_J_START_TO_CURSOR = 1,
    CSI_J_VISIBLE = 2,
    CSI_J_FULL = 3,
};

enum CSI_right_square_bracket {
    CSI_RSB_COLOR_FOR_UNDERLINE = 1,
    CSI_RSB_COLOR_FOR_HALF_BRIGHT = 2,
    CSI_RSB_MAKE_CUR_COLOR_DEFAULT = 8,
    CSI_RSB_BLANKING_INTERVAL = 9,
    CSI_RSB_BELL_FREQUENCY = 10,
    CSI_RSB_BELL_DURATION = 11,
    CSI_RSB_BRING_CONSOLE_TO_FRONT = 12,
    CSI_RSB_UNBLANK = 13,
    CSI_RSB_VESA_OFF_INTERVAL = 14,
    CSI_RSB_BRING_PREV_CONSOLE_TO_FRONT = 15,
    CSI_RSB_CURSOR_BLINK_INTERVAL = 16,
};

enum KTHREAD_BITS {
    KTHREAD_IS_PER_CPU = 0,
    KTHREAD_SHOULD_STOP = 1,
    KTHREAD_SHOULD_PARK = 2,
};

enum OID {
    OID_id_dsa_with_sha1 = 0,
    OID_id_dsa = 1,
    OID_id_ecPublicKey = 2,
    OID_id_prime192v1 = 3,
    OID_id_prime256v1 = 4,
    OID_id_ecdsa_with_sha1 = 5,
    OID_id_ecdsa_with_sha224 = 6,
    OID_id_ecdsa_with_sha256 = 7,
    OID_id_ecdsa_with_sha384 = 8,
    OID_id_ecdsa_with_sha512 = 9,
    OID_rsaEncryption = 10,
    OID_sha1WithRSAEncryption = 11,
    OID_sha256WithRSAEncryption = 12,
    OID_sha384WithRSAEncryption = 13,
    OID_sha512WithRSAEncryption = 14,
    OID_sha224WithRSAEncryption = 15,
    OID_data = 16,
    OID_signed_data = 17,
    OID_email_address = 18,
    OID_contentType = 19,
    OID_messageDigest = 20,
    OID_signingTime = 21,
    OID_smimeCapabilites = 22,
    OID_smimeAuthenticatedAttrs = 23,
    OID_mskrb5 = 24,
    OID_krb5 = 25,
    OID_krb5u2u = 26,
    OID_msIndirectData = 27,
    OID_msStatementType = 28,
    OID_msSpOpusInfo = 29,
    OID_msPeImageDataObjId = 30,
    OID_msIndividualSPKeyPurpose = 31,
    OID_msOutlookExpress = 32,
    OID_ntlmssp = 33,
    OID_negoex = 34,
    OID_spnego = 35,
    OID_IAKerb = 36,
    OID_PKU2U = 37,
    OID_Scram = 38,
    OID_certAuthInfoAccess = 39,
    OID_sha1 = 40,
    OID_id_ansip384r1 = 41,
    OID_id_ansip521r1 = 42,
    OID_sha256 = 43,
    OID_sha384 = 44,
    OID_sha512 = 45,
    OID_sha224 = 46,
    OID_commonName = 47,
    OID_surname = 48,
    OID_countryName = 49,
    OID_locality = 50,
    OID_stateOrProvinceName = 51,
    OID_organizationName = 52,
    OID_organizationUnitName = 53,
    OID_title = 54,
    OID_description = 55,
    OID_name = 56,
    OID_givenName = 57,
    OID_initials = 58,
    OID_generationalQualifier = 59,
    OID_subjectKeyIdentifier = 60,
    OID_keyUsage = 61,
    OID_subjectAltName = 62,
    OID_issuerAltName = 63,
    OID_basicConstraints = 64,
    OID_crlDistributionPoints = 65,
    OID_certPolicies = 66,
    OID_authorityKeyIdentifier = 67,
    OID_extKeyUsage = 68,
    OID_NetlogonMechanism = 69,
    OID_appleLocalKdcSupported = 70,
    OID_gostCPSignA = 71,
    OID_gostCPSignB = 72,
    OID_gostCPSignC = 73,
    OID_gost2012PKey256 = 74,
    OID_gost2012PKey512 = 75,
    OID_gost2012Digest256 = 76,
    OID_gost2012Digest512 = 77,
    OID_gost2012Signature256 = 78,
    OID_gost2012Signature512 = 79,
    OID_gostTC26Sign256A = 80,
    OID_gostTC26Sign256B = 81,
    OID_gostTC26Sign256C = 82,
    OID_gostTC26Sign256D = 83,
    OID_gostTC26Sign512A = 84,
    OID_gostTC26Sign512B = 85,
    OID_gostTC26Sign512C = 86,
    OID_sm2 = 87,
    OID_sm3 = 88,
    OID_SM2_with_SM3 = 89,
    OID_sm3WithRSAEncryption = 90,
    OID_TPMLoadableKey = 91,
    OID_TPMImportableKey = 92,
    OID_TPMSealedData = 93,
    OID_sha3_256 = 94,
    OID_sha3_384 = 95,
    OID_sha3_512 = 96,
    OID_id_ecdsa_with_sha3_256 = 97,
    OID_id_ecdsa_with_sha3_384 = 98,
    OID_id_ecdsa_with_sha3_512 = 99,
    OID_id_rsassa_pkcs1_v1_5_with_sha3_256 = 100,
    OID_id_rsassa_pkcs1_v1_5_with_sha3_384 = 101,
    OID_id_rsassa_pkcs1_v1_5_with_sha3_512 = 102,
    OID__NR = 103,
};

enum Opt_errors {
    Opt_errors_continue = 0,
    Opt_errors_panic = 1,
};

enum SHIFT_DIRECTION {
    SHIFT_LEFT = 0,
    SHIFT_RIGHT = 1,
};

enum TPM_OPS_FLAGS {
    TPM_OPS_AUTO_STARTUP = 1,
};

enum USE_TYPE_E {
    USE_TYPE_SERVICE = 0,
    USE_TYPE_VCHIQ = 1,
};

enum __kvm_host_smccc_func {
    __KVM_HOST_SMCCC_FUNC___pkvm_init = 1,
    __KVM_HOST_SMCCC_FUNC___pkvm_create_private_mapping = 2,
    __KVM_HOST_SMCCC_FUNC___pkvm_cpu_set_vector = 3,
    __KVM_HOST_SMCCC_FUNC___kvm_enable_ssbs = 4,
    __KVM_HOST_SMCCC_FUNC___vgic_v3_init_lrs = 5,
    __KVM_HOST_SMCCC_FUNC___vgic_v3_get_gic_config = 6,
    __KVM_HOST_SMCCC_FUNC___pkvm_prot_finalize = 7,
    __KVM_HOST_SMCCC_FUNC___pkvm_host_share_hyp = 8,
    __KVM_HOST_SMCCC_FUNC___pkvm_host_unshare_hyp = 9,
    __KVM_HOST_SMCCC_FUNC___pkvm_host_share_guest = 10,
    __KVM_HOST_SMCCC_FUNC___pkvm_host_unshare_guest = 11,
    __KVM_HOST_SMCCC_FUNC___pkvm_host_relax_perms_guest = 12,
    __KVM_HOST_SMCCC_FUNC___pkvm_host_wrprotect_guest = 13,
    __KVM_HOST_SMCCC_FUNC___pkvm_host_test_clear_young_guest = 14,
    __KVM_HOST_SMCCC_FUNC___pkvm_host_mkyoung_guest = 15,
    __KVM_HOST_SMCCC_FUNC___kvm_adjust_pc = 16,
    __KVM_HOST_SMCCC_FUNC___kvm_vcpu_run = 17,
    __KVM_HOST_SMCCC_FUNC___kvm_flush_vm_context = 18,
    __KVM_HOST_SMCCC_FUNC___kvm_tlb_flush_vmid_ipa = 19,
    __KVM_HOST_SMCCC_FUNC___kvm_tlb_flush_vmid_ipa_nsh = 20,
    __KVM_HOST_SMCCC_FUNC___kvm_tlb_flush_vmid = 21,
    __KVM_HOST_SMCCC_FUNC___kvm_tlb_flush_vmid_range = 22,
    __KVM_HOST_SMCCC_FUNC___kvm_flush_cpu_context = 23,
    __KVM_HOST_SMCCC_FUNC___kvm_timer_set_cntvoff = 24,
    __KVM_HOST_SMCCC_FUNC___vgic_v3_save_vmcr_aprs = 25,
    __KVM_HOST_SMCCC_FUNC___vgic_v3_restore_vmcr_aprs = 26,
    __KVM_HOST_SMCCC_FUNC___pkvm_init_vm = 27,
    __KVM_HOST_SMCCC_FUNC___pkvm_init_vcpu = 28,
    __KVM_HOST_SMCCC_FUNC___pkvm_teardown_vm = 29,
    __KVM_HOST_SMCCC_FUNC___pkvm_vcpu_load = 30,
    __KVM_HOST_SMCCC_FUNC___pkvm_vcpu_put = 31,
    __KVM_HOST_SMCCC_FUNC___pkvm_tlb_flush_vmid = 32,
};

enum __sk_action {
    __SK_DROP = 0,
    __SK_PASS = 1,
    __SK_REDIRECT = 2,
    __SK_NONE = 3,
};

enum _slab_flag_bits {
    _SLAB_CONSISTENCY_CHECKS = 0,
    _SLAB_RED_ZONE = 1,
    _SLAB_POISON = 2,
    _SLAB_KMALLOC = 3,
    _SLAB_HWCACHE_ALIGN = 4,
    _SLAB_CACHE_DMA = 5,
    _SLAB_CACHE_DMA32 = 6,
    _SLAB_STORE_USER = 7,
    _SLAB_PANIC = 8,
    _SLAB_TYPESAFE_BY_RCU = 9,
    _SLAB_TRACE = 10,
    _SLAB_NOLEAKTRACE = 11,
    _SLAB_NO_MERGE = 12,
    _SLAB_ACCOUNT = 13,
    _SLAB_NO_USER_FLAGS = 14,
    _SLAB_RECLAIM_ACCOUNT = 15,
    _SLAB_OBJECT_POISON = 16,
    _SLAB_CMPXCHG_DOUBLE = 17,
    _SLAB_NO_OBJ_EXT = 18,
    _SLAB_FLAGS_LAST_BIT = 19,
};

enum aa_code {
    AA_U8 = 0,
    AA_U16 = 1,
    AA_U32 = 2,
    AA_U64 = 3,
    AA_NAME = 4,
    AA_STRING = 5,
    AA_BLOB = 6,
    AA_STRUCT = 7,
    AA_STRUCTEND = 8,
    AA_LIST = 9,
    AA_LISTEND = 10,
    AA_ARRAY = 11,
    AA_ARRAYEND = 12,
};

enum aa_sfs_type {
    AA_SFS_TYPE_BOOLEAN = 0,
    AA_SFS_TYPE_BOOLEAN_INTPRINT = 1,
    AA_SFS_TYPE_STRING = 2,
    AA_SFS_TYPE_U64 = 3,
    AA_SFS_TYPE_FOPS = 4,
    AA_SFS_TYPE_DIR = 5,
};

enum aafs_ns_type {
    AAFS_NS_DIR = 0,
    AAFS_NS_PROFS = 1,
    AAFS_NS_NS = 2,
    AAFS_NS_RAW_DATA = 3,
    AAFS_NS_LOAD = 4,
    AAFS_NS_REPLACE = 5,
    AAFS_NS_REMOVE = 6,
    AAFS_NS_REVISION = 7,
    AAFS_NS_COUNT = 8,
    AAFS_NS_MAX_COUNT = 9,
    AAFS_NS_SIZE = 10,
    AAFS_NS_MAX_SIZE = 11,
    AAFS_NS_OWNER = 12,
    AAFS_NS_SIZEOF = 13,
};

enum aafs_prof_type {
    AAFS_PROF_DIR = 0,
    AAFS_PROF_PROFS = 1,
    AAFS_PROF_NAME = 2,
    AAFS_PROF_MODE = 3,
    AAFS_PROF_ATTACH = 4,
    AAFS_PROF_HASH = 5,
    AAFS_PROF_RAW_DATA = 6,
    AAFS_PROF_RAW_HASH = 7,
    AAFS_PROF_RAW_ABI = 8,
    AAFS_PROF_LEARNING_COUNT = 9,
    AAFS_PROF_SIZEOF = 10,
};

enum aarch32_map {
    AA32_MAP_VECTORS = 0,
    AA32_MAP_SIGPAGE = 1,
    AA32_MAP_VDSO = 2,
};

enum aarch64_insn_adr_type {
    AARCH64_INSN_ADR_TYPE_ADRP = 0,
    AARCH64_INSN_ADR_TYPE_ADR = 1,
};

enum aarch64_insn_adsb_type {
    AARCH64_INSN_ADSB_ADD = 0,
    AARCH64_INSN_ADSB_SUB = 1,
    AARCH64_INSN_ADSB_ADD_SETFLAGS = 2,
    AARCH64_INSN_ADSB_SUB_SETFLAGS = 3,
};

enum aarch64_insn_bitfield_type {
    AARCH64_INSN_BITFIELD_MOVE = 0,
    AARCH64_INSN_BITFIELD_MOVE_UNSIGNED = 1,
    AARCH64_INSN_BITFIELD_MOVE_SIGNED = 2,
};

enum aarch64_insn_branch_type {
    AARCH64_INSN_BRANCH_NOLINK = 0,
    AARCH64_INSN_BRANCH_LINK = 1,
    AARCH64_INSN_BRANCH_RETURN = 2,
    AARCH64_INSN_BRANCH_COMP_ZERO = 3,
    AARCH64_INSN_BRANCH_COMP_NONZERO = 4,
};

enum aarch64_insn_condition {
    AARCH64_INSN_COND_EQ = 0,
    AARCH64_INSN_COND_NE = 1,
    AARCH64_INSN_COND_CS = 2,
    AARCH64_INSN_COND_CC = 3,
    AARCH64_INSN_COND_MI = 4,
    AARCH64_INSN_COND_PL = 5,
    AARCH64_INSN_COND_VS = 6,
    AARCH64_INSN_COND_VC = 7,
    AARCH64_INSN_COND_HI = 8,
    AARCH64_INSN_COND_LS = 9,
    AARCH64_INSN_COND_GE = 10,
    AARCH64_INSN_COND_LT = 11,
    AARCH64_INSN_COND_GT = 12,
    AARCH64_INSN_COND_LE = 13,
    AARCH64_INSN_COND_AL = 14,
};

enum aarch64_insn_data1_type {
    AARCH64_INSN_DATA1_REVERSE_16 = 0,
    AARCH64_INSN_DATA1_REVERSE_32 = 1,
    AARCH64_INSN_DATA1_REVERSE_64 = 2,
};

enum aarch64_insn_data2_type {
    AARCH64_INSN_DATA2_UDIV = 0,
    AARCH64_INSN_DATA2_SDIV = 1,
    AARCH64_INSN_DATA2_LSLV = 2,
    AARCH64_INSN_DATA2_LSRV = 3,
    AARCH64_INSN_DATA2_ASRV = 4,
    AARCH64_INSN_DATA2_RORV = 5,
};

enum aarch64_insn_data3_type {
    AARCH64_INSN_DATA3_MADD = 0,
    AARCH64_INSN_DATA3_MSUB = 1,
};

enum aarch64_insn_hint_cr_op {
    AARCH64_INSN_HINT_NOP = 0,
    AARCH64_INSN_HINT_YIELD = 32,
    AARCH64_INSN_HINT_WFE = 64,
    AARCH64_INSN_HINT_WFI = 96,
    AARCH64_INSN_HINT_SEV = 128,
    AARCH64_INSN_HINT_SEVL = 160,
    AARCH64_INSN_HINT_XPACLRI = 224,
    AARCH64_INSN_HINT_PACIA_1716 = 256,
    AARCH64_INSN_HINT_PACIB_1716 = 320,
    AARCH64_INSN_HINT_AUTIA_1716 = 384,
    AARCH64_INSN_HINT_AUTIB_1716 = 448,
    AARCH64_INSN_HINT_PACIAZ = 768,
    AARCH64_INSN_HINT_PACIASP = 800,
    AARCH64_INSN_HINT_PACIBZ = 832,
    AARCH64_INSN_HINT_PACIBSP = 864,
    AARCH64_INSN_HINT_AUTIAZ = 896,
    AARCH64_INSN_HINT_AUTIASP = 928,
    AARCH64_INSN_HINT_AUTIBZ = 960,
    AARCH64_INSN_HINT_AUTIBSP = 992,
    AARCH64_INSN_HINT_ESB = 512,
    AARCH64_INSN_HINT_PSB = 544,
    AARCH64_INSN_HINT_TSB = 576,
    AARCH64_INSN_HINT_CSDB = 640,
    AARCH64_INSN_HINT_CLEARBHB = 704,
    AARCH64_INSN_HINT_BTI = 1024,
    AARCH64_INSN_HINT_BTIC = 1088,
    AARCH64_INSN_HINT_BTIJ = 1152,
    AARCH64_INSN_HINT_BTIJC = 1216,
};

enum aarch64_insn_imm_type {
    AARCH64_INSN_IMM_ADR = 0,
    AARCH64_INSN_IMM_26 = 1,
    AARCH64_INSN_IMM_19 = 2,
    AARCH64_INSN_IMM_16 = 3,
    AARCH64_INSN_IMM_14 = 4,
    AARCH64_INSN_IMM_12 = 5,
    AARCH64_INSN_IMM_9 = 6,
    AARCH64_INSN_IMM_7 = 7,
    AARCH64_INSN_IMM_6 = 8,
    AARCH64_INSN_IMM_S = 9,
    AARCH64_INSN_IMM_R = 10,
    AARCH64_INSN_IMM_N = 11,
    AARCH64_INSN_IMM_MAX = 12,
};

enum aarch64_insn_ldst_type {
    AARCH64_INSN_LDST_LOAD_REG_OFFSET = 0,
    AARCH64_INSN_LDST_STORE_REG_OFFSET = 1,
    AARCH64_INSN_LDST_LOAD_IMM_OFFSET = 2,
    AARCH64_INSN_LDST_STORE_IMM_OFFSET = 3,
    AARCH64_INSN_LDST_LOAD_PAIR_PRE_INDEX = 4,
    AARCH64_INSN_LDST_STORE_PAIR_PRE_INDEX = 5,
    AARCH64_INSN_LDST_LOAD_PAIR_POST_INDEX = 6,
    AARCH64_INSN_LDST_STORE_PAIR_POST_INDEX = 7,
    AARCH64_INSN_LDST_LOAD_EX = 8,
    AARCH64_INSN_LDST_LOAD_ACQ_EX = 9,
    AARCH64_INSN_LDST_STORE_EX = 10,
    AARCH64_INSN_LDST_STORE_REL_EX = 11,
    AARCH64_INSN_LDST_SIGNED_LOAD_IMM_OFFSET = 12,
    AARCH64_INSN_LDST_SIGNED_LOAD_REG_OFFSET = 13,
};

enum aarch64_insn_logic_type {
    AARCH64_INSN_LOGIC_AND = 0,
    AARCH64_INSN_LOGIC_BIC = 1,
    AARCH64_INSN_LOGIC_ORR = 2,
    AARCH64_INSN_LOGIC_ORN = 3,
    AARCH64_INSN_LOGIC_EOR = 4,
    AARCH64_INSN_LOGIC_EON = 5,
    AARCH64_INSN_LOGIC_AND_SETFLAGS = 6,
    AARCH64_INSN_LOGIC_BIC_SETFLAGS = 7,
};

enum aarch64_insn_mb_type {
    AARCH64_INSN_MB_SY = 0,
    AARCH64_INSN_MB_ST = 1,
    AARCH64_INSN_MB_LD = 2,
    AARCH64_INSN_MB_ISH = 3,
    AARCH64_INSN_MB_ISHST = 4,
    AARCH64_INSN_MB_ISHLD = 5,
    AARCH64_INSN_MB_NSH = 6,
    AARCH64_INSN_MB_NSHST = 7,
    AARCH64_INSN_MB_NSHLD = 8,
    AARCH64_INSN_MB_OSH = 9,
    AARCH64_INSN_MB_OSHST = 10,
    AARCH64_INSN_MB_OSHLD = 11,
};

enum aarch64_insn_mem_atomic_op {
    AARCH64_INSN_MEM_ATOMIC_ADD = 0,
    AARCH64_INSN_MEM_ATOMIC_CLR = 1,
    AARCH64_INSN_MEM_ATOMIC_EOR = 2,
    AARCH64_INSN_MEM_ATOMIC_SET = 3,
    AARCH64_INSN_MEM_ATOMIC_SWP = 4,
};

enum aarch64_insn_mem_order_type {
    AARCH64_INSN_MEM_ORDER_NONE = 0,
    AARCH64_INSN_MEM_ORDER_ACQ = 1,
    AARCH64_INSN_MEM_ORDER_REL = 2,
    AARCH64_INSN_MEM_ORDER_ACQREL = 3,
};

enum aarch64_insn_movewide_type {
    AARCH64_INSN_MOVEWIDE_ZERO = 0,
    AARCH64_INSN_MOVEWIDE_KEEP = 1,
    AARCH64_INSN_MOVEWIDE_INVERSE = 2,
};

enum aarch64_insn_movw_imm_type {
    AARCH64_INSN_IMM_MOVNZ = 0,
    AARCH64_INSN_IMM_MOVKZ = 1,
};

enum aarch64_insn_register {
    AARCH64_INSN_REG_0 = 0,
    AARCH64_INSN_REG_1 = 1,
    AARCH64_INSN_REG_2 = 2,
    AARCH64_INSN_REG_3 = 3,
    AARCH64_INSN_REG_4 = 4,
    AARCH64_INSN_REG_5 = 5,
    AARCH64_INSN_REG_6 = 6,
    AARCH64_INSN_REG_7 = 7,
    AARCH64_INSN_REG_8 = 8,
    AARCH64_INSN_REG_9 = 9,
    AARCH64_INSN_REG_10 = 10,
    AARCH64_INSN_REG_11 = 11,
    AARCH64_INSN_REG_12 = 12,
    AARCH64_INSN_REG_13 = 13,
    AARCH64_INSN_REG_14 = 14,
    AARCH64_INSN_REG_15 = 15,
    AARCH64_INSN_REG_16 = 16,
    AARCH64_INSN_REG_17 = 17,
    AARCH64_INSN_REG_18 = 18,
    AARCH64_INSN_REG_19 = 19,
    AARCH64_INSN_REG_20 = 20,
    AARCH64_INSN_REG_21 = 21,
    AARCH64_INSN_REG_22 = 22,
    AARCH64_INSN_REG_23 = 23,
    AARCH64_INSN_REG_24 = 24,
    AARCH64_INSN_REG_25 = 25,
    AARCH64_INSN_REG_26 = 26,
    AARCH64_INSN_REG_27 = 27,
    AARCH64_INSN_REG_28 = 28,
    AARCH64_INSN_REG_29 = 29,
    AARCH64_INSN_REG_FP = 29,
    AARCH64_INSN_REG_30 = 30,
    AARCH64_INSN_REG_LR = 30,
    AARCH64_INSN_REG_ZR = 31,
    AARCH64_INSN_REG_SP = 31,
};

enum aarch64_insn_register_type {
    AARCH64_INSN_REGTYPE_RT = 0,
    AARCH64_INSN_REGTYPE_RN = 1,
    AARCH64_INSN_REGTYPE_RT2 = 2,
    AARCH64_INSN_REGTYPE_RM = 3,
    AARCH64_INSN_REGTYPE_RD = 4,
    AARCH64_INSN_REGTYPE_RA = 5,
    AARCH64_INSN_REGTYPE_RS = 6,
};

enum aarch64_insn_size_type {
    AARCH64_INSN_SIZE_8 = 0,
    AARCH64_INSN_SIZE_16 = 1,
    AARCH64_INSN_SIZE_32 = 2,
    AARCH64_INSN_SIZE_64 = 3,
};

enum aarch64_insn_special_register {
    AARCH64_INSN_SPCLREG_SPSR_EL1 = 49664,
    AARCH64_INSN_SPCLREG_ELR_EL1 = 49665,
    AARCH64_INSN_SPCLREG_SP_EL0 = 49672,
    AARCH64_INSN_SPCLREG_SPSEL = 49680,
    AARCH64_INSN_SPCLREG_CURRENTEL = 49682,
    AARCH64_INSN_SPCLREG_DAIF = 55825,
    AARCH64_INSN_SPCLREG_NZCV = 55824,
    AARCH64_INSN_SPCLREG_FPCR = 55840,
    AARCH64_INSN_SPCLREG_DSPSR_EL0 = 55848,
    AARCH64_INSN_SPCLREG_DLR_EL0 = 55849,
    AARCH64_INSN_SPCLREG_SPSR_EL2 = 57856,
    AARCH64_INSN_SPCLREG_ELR_EL2 = 57857,
    AARCH64_INSN_SPCLREG_SP_EL1 = 57864,
    AARCH64_INSN_SPCLREG_SPSR_INQ = 57880,
    AARCH64_INSN_SPCLREG_SPSR_ABT = 57881,
    AARCH64_INSN_SPCLREG_SPSR_UND = 57882,
    AARCH64_INSN_SPCLREG_SPSR_FIQ = 57883,
    AARCH64_INSN_SPCLREG_SPSR_EL3 = 61952,
    AARCH64_INSN_SPCLREG_ELR_EL3 = 61953,
    AARCH64_INSN_SPCLREG_SP_EL2 = 61968,
};

enum aarch64_insn_system_register {
    AARCH64_INSN_SYSREG_TPIDR_EL1 = 18052,
    AARCH64_INSN_SYSREG_TPIDR_EL2 = 26242,
    AARCH64_INSN_SYSREG_SP_EL0 = 16904,
};

enum aarch64_insn_variant {
    AARCH64_INSN_VARIANT_32BIT = 0,
    AARCH64_INSN_VARIANT_64BIT = 1,
};

enum aarch64_regset {
    REGSET_GPR = 0,
    REGSET_FPR = 1,
    REGSET_TLS = 2,
    REGSET_HW_BREAK = 3,
    REGSET_HW_WATCH = 4,
    REGSET_FPMR = 5,
    REGSET_SYSTEM_CALL = 6,
    REGSET_SVE = 7,
    REGSET_PAC_MASK = 8,
    REGSET_PAC_ENABLED_KEYS = 9,
    REGSET_PACA_KEYS = 10,
    REGSET_PACG_KEYS = 11,
    REGSET_TAGGED_ADDR_CTRL = 12,
    REGSET_POE = 13,
};

enum aarch64_reloc_op {
    RELOC_OP_NONE = 0,
    RELOC_OP_ABS = 1,
    RELOC_OP_PREL = 2,
    RELOC_OP_PAGE = 3,
};

enum action_id {
    ACTION_SAVE = 1,
    ACTION_TRACE = 2,
    ACTION_SNAPSHOT = 3,
};

enum actions {
    REGISTER = 0,
    DEREGISTER = 1,
    CPU_DONT_CARE = 2,
};

enum addr_type {
    ADDR_LOCAL = 0,
    ADDR_LOCAL_PRIV = 1,
    ADDR_REMOTE = 2,
};

enum addr_type_t {
    UNICAST_ADDR = 0,
    MULTICAST_ADDR = 1,
    ANYCAST_ADDR = 2,
};

enum alarmtimer_type {
    ALARM_REALTIME = 0,
    ALARM_BOOTTIME = 1,
    ALARM_NUMTYPE = 2,
    ALARM_REALTIME_FREEZER = 3,
    ALARM_BOOTTIME_FREEZER = 4,
};

enum amd_chipset_gen {
    NOT_AMD_CHIPSET = 0,
    AMD_CHIPSET_SB600 = 1,
    AMD_CHIPSET_SB700 = 2,
    AMD_CHIPSET_SB800 = 3,
    AMD_CHIPSET_HUDSON2 = 4,
    AMD_CHIPSET_BOLTON = 5,
    AMD_CHIPSET_YANGTZE = 6,
    AMD_CHIPSET_TAISHAN = 7,
    AMD_CHIPSET_UNKNOWN = 8,
};

enum apparmor_notif_type {
    APPARMOR_NOTIF_RESP_PERM = 0,
    APPARMOR_NOTIF_CANCEL = 1,
    APPARMOR_NOTIF_INTERUPT = 2,
    APPARMOR_NOTIF_ALIVE = 3,
    APPARMOR_NOTIF_OP = 4,
    APPARMOR_NOTIF_RESP_NAME = 5,
};

enum arch_timer_erratum_match_type {
    ate_match_dt = 0,
    ate_match_local_cap_id = 1,
    ate_match_acpi_oem_info = 2,
};

enum arch_timer_ppi_nr {
    ARCH_TIMER_PHYS_SECURE_PPI = 0,
    ARCH_TIMER_PHYS_NONSECURE_PPI = 1,
    ARCH_TIMER_VIRT_PPI = 2,
    ARCH_TIMER_HYP_PPI = 3,
    ARCH_TIMER_HYP_VIRT_PPI = 4,
    ARCH_TIMER_MAX_TIMER_PPI = 5,
};

enum arch_timer_reg {
    ARCH_TIMER_REG_CTRL = 0,
    ARCH_TIMER_REG_CVAL = 1,
};

enum arch_timer_spi_nr {
    ARCH_TIMER_PHYS_SPI = 0,
    ARCH_TIMER_VIRT_SPI = 1,
    ARCH_TIMER_MAX_TIMER_SPI = 2,
};

enum arm64_bp_harden_el1_vectors {
    EL1_VECTOR_BHB_LOOP = 0,
    EL1_VECTOR_BHB_FW = 1,
    EL1_VECTOR_BHB_CLEAR_INSN = 2,
    EL1_VECTOR_KPTI = 3,
};

enum arm64_hyp_spectre_vector {
    HYP_VECTOR_DIRECT = 0,
    HYP_VECTOR_SPECTRE_DIRECT = 1,
    HYP_VECTOR_INDIRECT = 2,
    HYP_VECTOR_SPECTRE_INDIRECT = 3,
};

enum arm_smccc_conduit {
    SMCCC_CONDUIT_NONE = 0,
    SMCCC_CONDUIT_SMC = 1,
    SMCCC_CONDUIT_HVC = 2,
};

enum armpmu_attr_groups {
    ARMPMU_ATTR_GROUP_COMMON = 0,
    ARMPMU_ATTR_GROUP_EVENTS = 1,
    ARMPMU_ATTR_GROUP_FORMATS = 2,
    ARMPMU_ATTR_GROUP_CAPS = 3,
    ARMPMU_NR_ATTR_GROUPS = 4,
};

enum asn1_class {
    ASN1_UNIV = 0,
    ASN1_APPL = 1,
    ASN1_CONT = 2,
    ASN1_PRIV = 3,
};

enum asn1_method {
    ASN1_PRIM = 0,
    ASN1_CONS = 1,
};

enum asn1_opcode {
    ASN1_OP_MATCH = 0,
    ASN1_OP_MATCH_OR_SKIP = 1,
    ASN1_OP_MATCH_ACT = 2,
    ASN1_OP_MATCH_ACT_OR_SKIP = 3,
    ASN1_OP_MATCH_JUMP = 4,
    ASN1_OP_MATCH_JUMP_OR_SKIP = 5,
    ASN1_OP_MATCH_ANY = 8,
    ASN1_OP_MATCH_ANY_OR_SKIP = 9,
    ASN1_OP_MATCH_ANY_ACT = 10,
    ASN1_OP_MATCH_ANY_ACT_OR_SKIP = 11,
    ASN1_OP_COND_MATCH_OR_SKIP = 17,
    ASN1_OP_COND_MATCH_ACT_OR_SKIP = 19,
    ASN1_OP_COND_MATCH_JUMP_OR_SKIP = 21,
    ASN1_OP_COND_MATCH_ANY = 24,
    ASN1_OP_COND_MATCH_ANY_OR_SKIP = 25,
    ASN1_OP_COND_MATCH_ANY_ACT = 26,
    ASN1_OP_COND_MATCH_ANY_ACT_OR_SKIP = 27,
    ASN1_OP_COND_FAIL = 28,
    ASN1_OP_COMPLETE = 29,
    ASN1_OP_ACT = 30,
    ASN1_OP_MAYBE_ACT = 31,
    ASN1_OP_END_SEQ = 32,
    ASN1_OP_END_SET = 33,
    ASN1_OP_END_SEQ_OF = 34,
    ASN1_OP_END_SET_OF = 35,
    ASN1_OP_END_SEQ_ACT = 36,
    ASN1_OP_END_SET_ACT = 37,
    ASN1_OP_END_SEQ_OF_ACT = 38,
    ASN1_OP_END_SET_OF_ACT = 39,
    ASN1_OP_RETURN = 40,
    ASN1_OP__NR = 41,
};

enum asn1_tag {
    ASN1_EOC = 0,
    ASN1_BOOL = 1,
    ASN1_INT = 2,
    ASN1_BTS = 3,
    ASN1_OTS = 4,
    ASN1_NULL = 5,
    ASN1_OID = 6,
    ASN1_ODE = 7,
    ASN1_EXT = 8,
    ASN1_REAL = 9,
    ASN1_ENUM = 10,
    ASN1_EPDV = 11,
    ASN1_UTF8STR = 12,
    ASN1_RELOID = 13,
    ASN1_SEQ = 16,
    ASN1_SET = 17,
    ASN1_NUMSTR = 18,
    ASN1_PRNSTR = 19,
    ASN1_TEXSTR = 20,
    ASN1_VIDSTR = 21,
    ASN1_IA5STR = 22,
    ASN1_UNITIM = 23,
    ASN1_GENTIM = 24,
    ASN1_GRASTR = 25,
    ASN1_VISSTR = 26,
    ASN1_GENSTR = 27,
    ASN1_UNISTR = 28,
    ASN1_CHRSTR = 29,
    ASN1_BMPSTR = 30,
    ASN1_LONG_TAG = 31,
};

enum assoc_array_walk_status {
    assoc_array_walk_tree_empty = 0,
    assoc_array_walk_found_terminal_node = 1,
    assoc_array_walk_found_wrong_shortcut = 2,
};

enum asymmetric_payload_bits {
    asym_crypto = 0,
    asym_subtype = 1,
    asym_key_ids = 2,
    asym_auth = 3,
};

enum audit_mode {
    AUDIT_NORMAL = 0,
    AUDIT_QUIET_DENIED = 1,
    AUDIT_QUIET = 2,
    AUDIT_NOQUIET = 3,
    AUDIT_ALL = 4,
};

enum audit_nfcfgop {
    AUDIT_XT_OP_REGISTER = 0,
    AUDIT_XT_OP_REPLACE = 1,
    AUDIT_XT_OP_UNREGISTER = 2,
    AUDIT_NFT_OP_TABLE_REGISTER = 3,
    AUDIT_NFT_OP_TABLE_UNREGISTER = 4,
    AUDIT_NFT_OP_CHAIN_REGISTER = 5,
    AUDIT_NFT_OP_CHAIN_UNREGISTER = 6,
    AUDIT_NFT_OP_RULE_REGISTER = 7,
    AUDIT_NFT_OP_RULE_UNREGISTER = 8,
    AUDIT_NFT_OP_SET_REGISTER = 9,
    AUDIT_NFT_OP_SET_UNREGISTER = 10,
    AUDIT_NFT_OP_SETELEM_REGISTER = 11,
    AUDIT_NFT_OP_SETELEM_UNREGISTER = 12,
    AUDIT_NFT_OP_GEN_REGISTER = 13,
    AUDIT_NFT_OP_OBJ_REGISTER = 14,
    AUDIT_NFT_OP_OBJ_UNREGISTER = 15,
    AUDIT_NFT_OP_OBJ_RESET = 16,
    AUDIT_NFT_OP_FLOWTABLE_REGISTER = 17,
    AUDIT_NFT_OP_FLOWTABLE_UNREGISTER = 18,
    AUDIT_NFT_OP_SETELEM_RESET = 19,
    AUDIT_NFT_OP_RULE_RESET = 20,
    AUDIT_NFT_OP_INVALID = 21,
};

enum audit_nlgrps {
    AUDIT_NLGRP_NONE = 0,
    AUDIT_NLGRP_READLOG = 1,
    __AUDIT_NLGRP_MAX = 2,
};

enum audit_ntp_type {
    AUDIT_NTP_OFFSET = 0,
    AUDIT_NTP_FREQ = 1,
    AUDIT_NTP_STATUS = 2,
    AUDIT_NTP_TAI = 3,
    AUDIT_NTP_TICK = 4,
    AUDIT_NTP_ADJUST = 5,
    AUDIT_NTP_NVALS = 6,
};

enum audit_state {
    AUDIT_STATE_DISABLED = 0,
    AUDIT_STATE_BUILD = 1,
    AUDIT_STATE_RECORD = 2,
};

enum audit_type {
    AUDIT_APPARMOR_AUDIT = 0,
    AUDIT_APPARMOR_ALLOWED = 1,
    AUDIT_APPARMOR_DENIED = 2,
    AUDIT_APPARMOR_HINT = 3,
    AUDIT_APPARMOR_STATUS = 4,
    AUDIT_APPARMOR_ERROR = 5,
    AUDIT_APPARMOR_KILL = 6,
    AUDIT_APPARMOR_USER = 7,
    AUDIT_APPARMOR_AUTO = 8,
};

enum auditsc_class_t {
    AUDITSC_NATIVE = 0,
    AUDITSC_COMPAT = 1,
    AUDITSC_OPEN = 2,
    AUDITSC_OPENAT = 3,
    AUDITSC_SOCKETCALL = 4,
    AUDITSC_EXECVE = 5,
    AUDITSC_OPENAT2 = 6,
    AUDITSC_NVALS = 7,
};

enum backlight_scale {
    BACKLIGHT_SCALE_UNKNOWN = 0,
    BACKLIGHT_SCALE_LINEAR = 1,
    BACKLIGHT_SCALE_NON_LINEAR = 2,
};

enum backlight_type {
    BACKLIGHT_RAW = 1,
    BACKLIGHT_PLATFORM = 2,
    BACKLIGHT_FIRMWARE = 3,
    BACKLIGHT_TYPE_MAX = 4,
};

enum batadv_packettype {
    BATADV_IV_OGM = 0,
    BATADV_BCAST = 1,
    BATADV_CODED = 2,
    BATADV_ELP = 3,
    BATADV_OGM2 = 4,
    BATADV_MCAST = 5,
    BATADV_UNICAST = 64,
    BATADV_UNICAST_FRAG = 65,
    BATADV_UNICAST_4ADDR = 66,
    BATADV_ICMP = 67,
    BATADV_UNICAST_TVLV = 68,
};

enum bcm2712_funcs {
    func_gpio = 0,
    func_alt1 = 1,
    func_alt2 = 2,
    func_alt3 = 3,
    func_alt4 = 4,
    func_alt5 = 5,
    func_alt6 = 6,
    func_alt7 = 7,
    func_alt8 = 8,
    func_aon_cpu_standbyb = 9,
    func_aon_fp_4sec_resetb = 10,
    func_aon_gpclk = 11,
    func_aon_pwm = 12,
    func_arm_jtag = 13,
    func_aud_fs_clk0 = 14,
    func_avs_pmu_bsc = 15,
    func_bsc_m0 = 16,
    func_bsc_m1 = 17,
    func_bsc_m2 = 18,
    func_bsc_m3 = 19,
    func_clk_observe = 20,
    func_ctl_hdmi_5v = 21,
    func_enet0 = 22,
    func_enet0_mii = 23,
    func_enet0_rgmii = 24,
    func_ext_sc_clk = 25,
    func_fl0 = 26,
    func_fl1 = 27,
    func_gpclk0 = 28,
    func_gpclk1 = 29,
    func_gpclk2 = 30,
    func_hdmi_tx0_auto_i2c = 31,
    func_hdmi_tx0_bsc = 32,
    func_hdmi_tx1_auto_i2c = 33,
    func_hdmi_tx1_bsc = 34,
    func_i2s_in = 35,
    func_i2s_out = 36,
    func_ir_in = 37,
    func_mtsif = 38,
    func_mtsif_alt = 39,
    func_mtsif_alt1 = 40,
    func_pdm = 41,
    func_pkt = 42,
    func_pm_led_out = 43,
    func_sc0 = 44,
    func_sd0 = 45,
    func_sd2 = 46,
    func_sd_card_a = 47,
    func_sd_card_b = 48,
    func_sd_card_c = 49,
    func_sd_card_d = 50,
    func_sd_card_e = 51,
    func_sd_card_f = 52,
    func_sd_card_g = 53,
    func_spdif_out = 54,
    func_spi_m = 55,
    func_spi_s = 56,
    func_sr_edm_sense = 57,
    func_te0 = 58,
    func_te1 = 59,
    func_tsio = 60,
    func_uart0 = 61,
    func_uart1 = 62,
    func_uart2 = 63,
    func_usb_pwr = 64,
    func_usb_vbus = 65,
    func_uui = 66,
    func_vc_i2c0 = 67,
    func_vc_i2c3 = 68,
    func_vc_i2c4 = 69,
    func_vc_i2c5 = 70,
    func_vc_i2csl = 71,
    func_vc_pcm = 72,
    func_vc_pwm0 = 73,
    func_vc_pwm1 = 74,
    func_vc_spi0 = 75,
    func_vc_spi3 = 76,
    func_vc_spi4 = 77,
    func_vc_spi5 = 78,
    func_vc_uart0 = 79,
    func_vc_uart2 = 80,
    func_vc_uart3 = 81,
    func_vc_uart4 = 82,
    func__ = 83,
    func_count = 83,
};

enum bcm2835_fsel {
    BCM2835_FSEL_COUNT = 8,
    BCM2835_FSEL_MASK = 7,
};

enum bcmgenet_power_mode {
    GENET_POWER_CABLE_SENSE = 0,
    GENET_POWER_PASSIVE = 1,
    GENET_POWER_WOL_MAGIC = 2,
};

enum bcmgenet_rxnfc_state {
    BCMGENET_RXNFC_STATE_UNUSED = 0,
    BCMGENET_RXNFC_STATE_DISABLED = 1,
    BCMGENET_RXNFC_STATE_ENABLED = 2,
};

enum bcmgenet_stat_type {
    BCMGENET_STAT_NETDEV = -1,
    BCMGENET_STAT_MIB_RX = 0,
    BCMGENET_STAT_MIB_TX = 1,
    BCMGENET_STAT_RUNT = 2,
    BCMGENET_STAT_MISC = 3,
    BCMGENET_STAT_SOFT = 4,
};

enum bcmgenet_version {
    GENET_V1 = 1,
    GENET_V2 = 2,
    GENET_V3 = 3,
    GENET_V4 = 4,
    GENET_V5 = 5,
};

enum behavior {
    EXCLUSIVE = 0,
    SHARED = 1,
    DROP = 2,
};

enum bh_state_bits {
    BH_Uptodate = 0,
    BH_Dirty = 1,
    BH_Lock = 2,
    BH_Req = 3,
    BH_Mapped = 4,
    BH_New = 5,
    BH_Async_Read = 6,
    BH_Async_Write = 7,
    BH_Delay = 8,
    BH_Boundary = 9,
    BH_Write_EIO = 10,
    BH_Unwritten = 11,
    BH_Quiet = 12,
    BH_Meta = 13,
    BH_Prio = 14,
    BH_Defer_Completion = 15,
    BH_PrivateStart = 16,
};

enum bhb_mitigation_bits {
    BHB_LOOP = 0,
    BHB_FW = 1,
    BHB_HW = 2,
    BHB_INSN = 3,
};

enum bio_merge_status {
    BIO_MERGE_OK = 0,
    BIO_MERGE_NONE = 1,
    BIO_MERGE_FAILED = 2,
};

enum bio_post_read_step {
    STEP_INITIAL = 0,
    STEP_DECRYPT = 1,
    STEP_VERITY = 2,
    STEP_MAX = 3,
};

enum bip_flags {
    BIP_BLOCK_INTEGRITY = 1,
    BIP_MAPPED_INTEGRITY = 2,
    BIP_DISK_NOCHECK = 4,
    BIP_IP_CHECKSUM = 8,
    BIP_COPY_USER = 16,
    BIP_CHECK_GUARD = 32,
    BIP_CHECK_REFTAG = 64,
    BIP_CHECK_APPTAG = 128,
};

enum blacklist_hash_type {
    BLACKLIST_HASH_X509_TBS = 1,
    BLACKLIST_HASH_BINARY = 2,
};

enum blake2s_iv {
    BLAKE2S_IV0 = 1779033703,
    BLAKE2S_IV1 = 3144134277,
    BLAKE2S_IV2 = 1013904242,
    BLAKE2S_IV3 = 2773480762,
    BLAKE2S_IV4 = 1359893119,
    BLAKE2S_IV5 = 2600822924,
    BLAKE2S_IV6 = 528734635,
    BLAKE2S_IV7 = 1541459225,
};

enum blake2s_lengths {
    BLAKE2S_BLOCK_SIZE = 64,
    BLAKE2S_HASH_SIZE = 32,
    BLAKE2S_KEY_SIZE = 32,
    BLAKE2S_128_HASH_SIZE = 16,
    BLAKE2S_160_HASH_SIZE = 20,
    BLAKE2S_224_HASH_SIZE = 28,
    BLAKE2S_256_HASH_SIZE = 32,
};

enum blk_crypto_mode_num {
    BLK_ENCRYPTION_MODE_INVALID = 0,
    BLK_ENCRYPTION_MODE_AES_256_XTS = 1,
    BLK_ENCRYPTION_MODE_AES_128_CBC_ESSIV = 2,
    BLK_ENCRYPTION_MODE_ADIANTUM = 3,
    BLK_ENCRYPTION_MODE_SM4_XTS = 4,
    BLK_ENCRYPTION_MODE_MAX = 5,
};

enum blk_default_limits {
    BLK_MAX_SEGMENTS = 128,
    BLK_SAFE_MAX_SECTORS = 255,
    BLK_MAX_SEGMENT_SIZE = 65536,
    BLK_SEG_BOUNDARY_MASK = 4294967295,
};

enum blk_eh_timer_return {
    BLK_EH_DONE = 0,
    BLK_EH_RESET_TIMER = 1,
};

enum blk_integrity_checksum {
    BLK_INTEGRITY_CSUM_NONE = 0,
    BLK_INTEGRITY_CSUM_IP = 1,
    BLK_INTEGRITY_CSUM_CRC = 2,
    BLK_INTEGRITY_CSUM_CRC64 = 3,
} __attribute__((mode(byte)));

enum blk_integrity_flags {
    BLK_INTEGRITY_NOVERIFY = 1,
    BLK_INTEGRITY_NOGENERATE = 2,
    BLK_INTEGRITY_DEVICE_CAPABLE = 4,
    BLK_INTEGRITY_REF_TAG = 8,
    BLK_INTEGRITY_STACKED = 16,
};

enum blk_unique_id {
    BLK_UID_T10 = 1,
    BLK_UID_EUI64 = 2,
    BLK_UID_NAA = 3,
};

enum blk_zone_cond {
    BLK_ZONE_COND_NOT_WP = 0,
    BLK_ZONE_COND_EMPTY = 1,
    BLK_ZONE_COND_IMP_OPEN = 2,
    BLK_ZONE_COND_EXP_OPEN = 3,
    BLK_ZONE_COND_CLOSED = 4,
    BLK_ZONE_COND_READONLY = 13,
    BLK_ZONE_COND_FULL = 14,
    BLK_ZONE_COND_OFFLINE = 15,
};

enum blk_zone_report_flags {
    BLK_ZONE_REP_CAPACITY = 1,
};

enum blk_zone_type {
    BLK_ZONE_TYPE_CONVENTIONAL = 1,
    BLK_ZONE_TYPE_SEQWRITE_REQ = 2,
    BLK_ZONE_TYPE_SEQWRITE_PREF = 3,
};

enum blkg_iostat_type {
    BLKG_IOSTAT_READ = 0,
    BLKG_IOSTAT_WRITE = 1,
    BLKG_IOSTAT_DISCARD = 2,
    BLKG_IOSTAT_NR = 3,
};

enum blkg_rwstat_type {
    BLKG_RWSTAT_READ = 0,
    BLKG_RWSTAT_WRITE = 1,
    BLKG_RWSTAT_SYNC = 2,
    BLKG_RWSTAT_ASYNC = 3,
    BLKG_RWSTAT_DISCARD = 4,
    BLKG_RWSTAT_NR = 5,
    BLKG_RWSTAT_TOTAL = 5,
};

enum blktrace_act {
    __BLK_TA_QUEUE = 1,
    __BLK_TA_BACKMERGE = 2,
    __BLK_TA_FRONTMERGE = 3,
    __BLK_TA_GETRQ = 4,
    __BLK_TA_SLEEPRQ = 5,
    __BLK_TA_REQUEUE = 6,
    __BLK_TA_ISSUE = 7,
    __BLK_TA_COMPLETE = 8,
    __BLK_TA_PLUG = 9,
    __BLK_TA_UNPLUG_IO = 10,
    __BLK_TA_UNPLUG_TIMER = 11,
    __BLK_TA_INSERT = 12,
    __BLK_TA_SPLIT = 13,
    __BLK_TA_BOUNCE = 14,
    __BLK_TA_REMAP = 15,
    __BLK_TA_ABORT = 16,
    __BLK_TA_DRV_DATA = 17,
    __BLK_TA_CGROUP = 256,
};

enum blktrace_cat {
    BLK_TC_READ = 1,
    BLK_TC_WRITE = 2,
    BLK_TC_FLUSH = 4,
    BLK_TC_SYNC = 8,
    BLK_TC_SYNCIO = 8,
    BLK_TC_QUEUE = 16,
    BLK_TC_REQUEUE = 32,
    BLK_TC_ISSUE = 64,
    BLK_TC_COMPLETE = 128,
    BLK_TC_FS = 256,
    BLK_TC_PC = 512,
    BLK_TC_NOTIFY = 1024,
    BLK_TC_AHEAD = 2048,
    BLK_TC_META = 4096,
    BLK_TC_DISCARD = 8192,
    BLK_TC_DRV_DATA = 16384,
    BLK_TC_FUA = 32768,
    BLK_TC_END = 32768,
};

enum blktrace_notify {
    __BLK_TN_PROCESS = 0,
    __BLK_TN_TIMESTAMP = 1,
    __BLK_TN_MESSAGE = 2,
    __BLK_TN_CGROUP = 256,
};

enum bp_type_idx {
    TYPE_INST = 0,
    TYPE_DATA = 1,
    TYPE_MAX = 2,
};

enum bpf_access_src {
    ACCESS_DIRECT = 1,
    ACCESS_HELPER = 2,
};

enum bpf_access_type {
    BPF_READ = 1,
    BPF_WRITE = 2,
};

enum bpf_addr_space_cast {
    BPF_ADDR_SPACE_CAST = 1,
};

enum bpf_adj_room_mode {
    BPF_ADJ_ROOM_NET = 0,
    BPF_ADJ_ROOM_MAC = 1,
};

enum bpf_arg_type {
    ARG_DONTCARE = 0,
    ARG_CONST_MAP_PTR = 1,
    ARG_PTR_TO_MAP_KEY = 2,
    ARG_PTR_TO_MAP_VALUE = 3,
    ARG_PTR_TO_MEM = 4,
    ARG_PTR_TO_ARENA = 5,
    ARG_CONST_SIZE = 6,
    ARG_CONST_SIZE_OR_ZERO = 7,
    ARG_PTR_TO_CTX = 8,
    ARG_ANYTHING = 9,
    ARG_PTR_TO_SPIN_LOCK = 10,
    ARG_PTR_TO_SOCK_COMMON = 11,
    ARG_PTR_TO_SOCKET = 12,
    ARG_PTR_TO_BTF_ID = 13,
    ARG_PTR_TO_RINGBUF_MEM = 14,
    ARG_CONST_ALLOC_SIZE_OR_ZERO = 15,
    ARG_PTR_TO_BTF_ID_SOCK_COMMON = 16,
    ARG_PTR_TO_PERCPU_BTF_ID = 17,
    ARG_PTR_TO_FUNC = 18,
    ARG_PTR_TO_STACK = 19,
    ARG_PTR_TO_CONST_STR = 20,
    ARG_PTR_TO_TIMER = 21,
    ARG_KPTR_XCHG_DEST = 22,
    ARG_PTR_TO_DYNPTR = 23,
    __BPF_ARG_TYPE_MAX = 24,
    ARG_PTR_TO_MAP_VALUE_OR_NULL = 259,
    ARG_PTR_TO_MEM_OR_NULL = 260,
    ARG_PTR_TO_CTX_OR_NULL = 264,
    ARG_PTR_TO_SOCKET_OR_NULL = 268,
    ARG_PTR_TO_STACK_OR_NULL = 275,
    ARG_PTR_TO_BTF_ID_OR_NULL = 269,
    ARG_PTR_TO_UNINIT_MEM = 67141636,
    ARG_PTR_TO_FIXED_SIZE_MEM = 262148,
    __BPF_ARG_TYPE_LIMIT = 134217727,
};

enum bpf_async_type {
    BPF_ASYNC_TYPE_TIMER = 0,
    BPF_ASYNC_TYPE_WQ = 1,
};

enum bpf_attach_type {
    BPF_CGROUP_INET_INGRESS = 0,
    BPF_CGROUP_INET_EGRESS = 1,
    BPF_CGROUP_INET_SOCK_CREATE = 2,
    BPF_CGROUP_SOCK_OPS = 3,
    BPF_SK_SKB_STREAM_PARSER = 4,
    BPF_SK_SKB_STREAM_VERDICT = 5,
    BPF_CGROUP_DEVICE = 6,
    BPF_SK_MSG_VERDICT = 7,
    BPF_CGROUP_INET4_BIND = 8,
    BPF_CGROUP_INET6_BIND = 9,
    BPF_CGROUP_INET4_CONNECT = 10,
    BPF_CGROUP_INET6_CONNECT = 11,
    BPF_CGROUP_INET4_POST_BIND = 12,
    BPF_CGROUP_INET6_POST_BIND = 13,
    BPF_CGROUP_UDP4_SENDMSG = 14,
    BPF_CGROUP_UDP6_SENDMSG = 15,
    BPF_LIRC_MODE2 = 16,
    BPF_FLOW_DISSECTOR = 17,
    BPF_CGROUP_SYSCTL = 18,
    BPF_CGROUP_UDP4_RECVMSG = 19,
    BPF_CGROUP_UDP6_RECVMSG = 20,
    BPF_CGROUP_GETSOCKOPT = 21,
    BPF_CGROUP_SETSOCKOPT = 22,
    BPF_TRACE_RAW_TP = 23,
    BPF_TRACE_FENTRY = 24,
    BPF_TRACE_FEXIT = 25,
    BPF_MODIFY_RETURN = 26,
    BPF_LSM_MAC = 27,
    BPF_TRACE_ITER = 28,
    BPF_CGROUP_INET4_GETPEERNAME = 29,
    BPF_CGROUP_INET6_GETPEERNAME = 30,
    BPF_CGROUP_INET4_GETSOCKNAME = 31,
    BPF_CGROUP_INET6_GETSOCKNAME = 32,
    BPF_XDP_DEVMAP = 33,
    BPF_CGROUP_INET_SOCK_RELEASE = 34,
    BPF_XDP_CPUMAP = 35,
    BPF_SK_LOOKUP = 36,
    BPF_XDP = 37,
    BPF_SK_SKB_VERDICT = 38,
    BPF_SK_REUSEPORT_SELECT = 39,
    BPF_SK_REUSEPORT_SELECT_OR_MIGRATE = 40,
    BPF_PERF_EVENT = 41,
    BPF_TRACE_KPROBE_MULTI = 42,
    BPF_LSM_CGROUP = 43,
    BPF_STRUCT_OPS = 44,
    BPF_NETFILTER = 45,
    BPF_TCX_INGRESS = 46,
    BPF_TCX_EGRESS = 47,
    BPF_TRACE_UPROBE_MULTI = 48,
    BPF_CGROUP_UNIX_CONNECT = 49,
    BPF_CGROUP_UNIX_SENDMSG = 50,
    BPF_CGROUP_UNIX_RECVMSG = 51,
    BPF_CGROUP_UNIX_GETPEERNAME = 52,
    BPF_CGROUP_UNIX_GETSOCKNAME = 53,
    BPF_NETKIT_PRIMARY = 54,
    BPF_NETKIT_PEER = 55,
    BPF_TRACE_KPROBE_SESSION = 56,
    BPF_TRACE_UPROBE_SESSION = 57,
    __MAX_BPF_ATTACH_TYPE = 58,
};

enum bpf_audit {
    BPF_AUDIT_LOAD = 0,
    BPF_AUDIT_UNLOAD = 1,
    BPF_AUDIT_MAX = 2,
};

enum bpf_cgroup_iter_order {
    BPF_CGROUP_ITER_ORDER_UNSPEC = 0,
    BPF_CGROUP_ITER_SELF_ONLY = 1,
    BPF_CGROUP_ITER_DESCENDANTS_PRE = 2,
    BPF_CGROUP_ITER_DESCENDANTS_POST = 3,
    BPF_CGROUP_ITER_ANCESTORS_UP = 4,
};

enum bpf_cgroup_storage_type {
    BPF_CGROUP_STORAGE_SHARED = 0,
    BPF_CGROUP_STORAGE_PERCPU = 1,
    __BPF_CGROUP_STORAGE_MAX = 2,
};

enum bpf_check_mtu_flags {
    BPF_MTU_CHK_SEGS = 1,
};

enum bpf_check_mtu_ret {
    BPF_MTU_CHK_RET_SUCCESS = 0,
    BPF_MTU_CHK_RET_FRAG_NEEDED = 1,
    BPF_MTU_CHK_RET_SEGS_TOOBIG = 2,
};

enum bpf_cmd {
    BPF_MAP_CREATE = 0,
    BPF_MAP_LOOKUP_ELEM = 1,
    BPF_MAP_UPDATE_ELEM = 2,
    BPF_MAP_DELETE_ELEM = 3,
    BPF_MAP_GET_NEXT_KEY = 4,
    BPF_PROG_LOAD = 5,
    BPF_OBJ_PIN = 6,
    BPF_OBJ_GET = 7,
    BPF_PROG_ATTACH = 8,
    BPF_PROG_DETACH = 9,
    BPF_PROG_TEST_RUN = 10,
    BPF_PROG_RUN = 10,
    BPF_PROG_GET_NEXT_ID = 11,
    BPF_MAP_GET_NEXT_ID = 12,
    BPF_PROG_GET_FD_BY_ID = 13,
    BPF_MAP_GET_FD_BY_ID = 14,
    BPF_OBJ_GET_INFO_BY_FD = 15,
    BPF_PROG_QUERY = 16,
    BPF_RAW_TRACEPOINT_OPEN = 17,
    BPF_BTF_LOAD = 18,
    BPF_BTF_GET_FD_BY_ID = 19,
    BPF_TASK_FD_QUERY = 20,
    BPF_MAP_LOOKUP_AND_DELETE_ELEM = 21,
    BPF_MAP_FREEZE = 22,
    BPF_BTF_GET_NEXT_ID = 23,
    BPF_MAP_LOOKUP_BATCH = 24,
    BPF_MAP_LOOKUP_AND_DELETE_BATCH = 25,
    BPF_MAP_UPDATE_BATCH = 26,
    BPF_MAP_DELETE_BATCH = 27,
    BPF_LINK_CREATE = 28,
    BPF_LINK_UPDATE = 29,
    BPF_LINK_GET_FD_BY_ID = 30,
    BPF_LINK_GET_NEXT_ID = 31,
    BPF_ENABLE_STATS = 32,
    BPF_ITER_CREATE = 33,
    BPF_LINK_DETACH = 34,
    BPF_PROG_BIND_MAP = 35,
    BPF_TOKEN_CREATE = 36,
    __MAX_BPF_CMD = 37,
};

enum bpf_cond_pseudo_jmp {
    BPF_MAY_GOTO = 0,
};

enum bpf_core_relo_kind {
    BPF_CORE_FIELD_BYTE_OFFSET = 0,
    BPF_CORE_FIELD_BYTE_SIZE = 1,
    BPF_CORE_FIELD_EXISTS = 2,
    BPF_CORE_FIELD_SIGNED = 3,
    BPF_CORE_FIELD_LSHIFT_U64 = 4,
    BPF_CORE_FIELD_RSHIFT_U64 = 5,
    BPF_CORE_TYPE_ID_LOCAL = 6,
    BPF_CORE_TYPE_ID_TARGET = 7,
    BPF_CORE_TYPE_EXISTS = 8,
    BPF_CORE_TYPE_SIZE = 9,
    BPF_CORE_ENUMVAL_EXISTS = 10,
    BPF_CORE_ENUMVAL_VALUE = 11,
    BPF_CORE_TYPE_MATCHES = 12,
};

enum bpf_dynptr_type {
    BPF_DYNPTR_TYPE_INVALID = 0,
    BPF_DYNPTR_TYPE_LOCAL = 1,
    BPF_DYNPTR_TYPE_RINGBUF = 2,
    BPF_DYNPTR_TYPE_SKB = 3,
    BPF_DYNPTR_TYPE_XDP = 4,
};

enum bpf_func_id {
    BPF_FUNC_unspec = 0,
    BPF_FUNC_map_lookup_elem = 1,
    BPF_FUNC_map_update_elem = 2,
    BPF_FUNC_map_delete_elem = 3,
    BPF_FUNC_probe_read = 4,
    BPF_FUNC_ktime_get_ns = 5,
    BPF_FUNC_trace_printk = 6,
    BPF_FUNC_get_prandom_u32 = 7,
    BPF_FUNC_get_smp_processor_id = 8,
    BPF_FUNC_skb_store_bytes = 9,
    BPF_FUNC_l3_csum_replace = 10,
    BPF_FUNC_l4_csum_replace = 11,
    BPF_FUNC_tail_call = 12,
    BPF_FUNC_clone_redirect = 13,
    BPF_FUNC_get_current_pid_tgid = 14,
    BPF_FUNC_get_current_uid_gid = 15,
    BPF_FUNC_get_current_comm = 16,
    BPF_FUNC_get_cgroup_classid = 17,
    BPF_FUNC_skb_vlan_push = 18,
    BPF_FUNC_skb_vlan_pop = 19,
    BPF_FUNC_skb_get_tunnel_key = 20,
    BPF_FUNC_skb_set_tunnel_key = 21,
    BPF_FUNC_perf_event_read = 22,
    BPF_FUNC_redirect = 23,
    BPF_FUNC_get_route_realm = 24,
    BPF_FUNC_perf_event_output = 25,
    BPF_FUNC_skb_load_bytes = 26,
    BPF_FUNC_get_stackid = 27,
    BPF_FUNC_csum_diff = 28,
    BPF_FUNC_skb_get_tunnel_opt = 29,
    BPF_FUNC_skb_set_tunnel_opt = 30,
    BPF_FUNC_skb_change_proto = 31,
    BPF_FUNC_skb_change_type = 32,
    BPF_FUNC_skb_under_cgroup = 33,
    BPF_FUNC_get_hash_recalc = 34,
    BPF_FUNC_get_current_task = 35,
    BPF_FUNC_probe_write_user = 36,
    BPF_FUNC_current_task_under_cgroup = 37,
    BPF_FUNC_skb_change_tail = 38,
    BPF_FUNC_skb_pull_data = 39,
    BPF_FUNC_csum_update = 40,
    BPF_FUNC_set_hash_invalid = 41,
    BPF_FUNC_get_numa_node_id = 42,
    BPF_FUNC_skb_change_head = 43,
    BPF_FUNC_xdp_adjust_head = 44,
    BPF_FUNC_probe_read_str = 45,
    BPF_FUNC_get_socket_cookie = 46,
    BPF_FUNC_get_socket_uid = 47,
    BPF_FUNC_set_hash = 48,
    BPF_FUNC_setsockopt = 49,
    BPF_FUNC_skb_adjust_room = 50,
    BPF_FUNC_redirect_map = 51,
    BPF_FUNC_sk_redirect_map = 52,
    BPF_FUNC_sock_map_update = 53,
    BPF_FUNC_xdp_adjust_meta = 54,
    BPF_FUNC_perf_event_read_value = 55,
    BPF_FUNC_perf_prog_read_value = 56,
    BPF_FUNC_getsockopt = 57,
    BPF_FUNC_override_return = 58,
    BPF_FUNC_sock_ops_cb_flags_set = 59,
    BPF_FUNC_msg_redirect_map = 60,
    BPF_FUNC_msg_apply_bytes = 61,
    BPF_FUNC_msg_cork_bytes = 62,
    BPF_FUNC_msg_pull_data = 63,
    BPF_FUNC_bind = 64,
    BPF_FUNC_xdp_adjust_tail = 65,
    BPF_FUNC_skb_get_xfrm_state = 66,
    BPF_FUNC_get_stack = 67,
    BPF_FUNC_skb_load_bytes_relative = 68,
    BPF_FUNC_fib_lookup = 69,
    BPF_FUNC_sock_hash_update = 70,
    BPF_FUNC_msg_redirect_hash = 71,
    BPF_FUNC_sk_redirect_hash = 72,
    BPF_FUNC_lwt_push_encap = 73,
    BPF_FUNC_lwt_seg6_store_bytes = 74,
    BPF_FUNC_lwt_seg6_adjust_srh = 75,
    BPF_FUNC_lwt_seg6_action = 76,
    BPF_FUNC_rc_repeat = 77,
    BPF_FUNC_rc_keydown = 78,
    BPF_FUNC_skb_cgroup_id = 79,
    BPF_FUNC_get_current_cgroup_id = 80,
    BPF_FUNC_get_local_storage = 81,
    BPF_FUNC_sk_select_reuseport = 82,
    BPF_FUNC_skb_ancestor_cgroup_id = 83,
    BPF_FUNC_sk_lookup_tcp = 84,
    BPF_FUNC_sk_lookup_udp = 85,
    BPF_FUNC_sk_release = 86,
    BPF_FUNC_map_push_elem = 87,
    BPF_FUNC_map_pop_elem = 88,
    BPF_FUNC_map_peek_elem = 89,
    BPF_FUNC_msg_push_data = 90,
    BPF_FUNC_msg_pop_data = 91,
    BPF_FUNC_rc_pointer_rel = 92,
    BPF_FUNC_spin_lock = 93,
    BPF_FUNC_spin_unlock = 94,
    BPF_FUNC_sk_fullsock = 95,
    BPF_FUNC_tcp_sock = 96,
    BPF_FUNC_skb_ecn_set_ce = 97,
    BPF_FUNC_get_listener_sock = 98,
    BPF_FUNC_skc_lookup_tcp = 99,
    BPF_FUNC_tcp_check_syncookie = 100,
    BPF_FUNC_sysctl_get_name = 101,
    BPF_FUNC_sysctl_get_current_value = 102,
    BPF_FUNC_sysctl_get_new_value = 103,
    BPF_FUNC_sysctl_set_new_value = 104,
    BPF_FUNC_strtol = 105,
    BPF_FUNC_strtoul = 106,
    BPF_FUNC_sk_storage_get = 107,
    BPF_FUNC_sk_storage_delete = 108,
    BPF_FUNC_send_signal = 109,
    BPF_FUNC_tcp_gen_syncookie = 110,
    BPF_FUNC_skb_output = 111,
    BPF_FUNC_probe_read_user = 112,
    BPF_FUNC_probe_read_kernel = 113,
    BPF_FUNC_probe_read_user_str = 114,
    BPF_FUNC_probe_read_kernel_str = 115,
    BPF_FUNC_tcp_send_ack = 116,
    BPF_FUNC_send_signal_thread = 117,
    BPF_FUNC_jiffies64 = 118,
    BPF_FUNC_read_branch_records = 119,
    BPF_FUNC_get_ns_current_pid_tgid = 120,
    BPF_FUNC_xdp_output = 121,
    BPF_FUNC_get_netns_cookie = 122,
    BPF_FUNC_get_current_ancestor_cgroup_id = 123,
    BPF_FUNC_sk_assign = 124,
    BPF_FUNC_ktime_get_boot_ns = 125,
    BPF_FUNC_seq_printf = 126,
    BPF_FUNC_seq_write = 127,
    BPF_FUNC_sk_cgroup_id = 128,
    BPF_FUNC_sk_ancestor_cgroup_id = 129,
    BPF_FUNC_ringbuf_output = 130,
    BPF_FUNC_ringbuf_reserve = 131,
    BPF_FUNC_ringbuf_submit = 132,
    BPF_FUNC_ringbuf_discard = 133,
    BPF_FUNC_ringbuf_query = 134,
    BPF_FUNC_csum_level = 135,
    BPF_FUNC_skc_to_tcp6_sock = 136,
    BPF_FUNC_skc_to_tcp_sock = 137,
    BPF_FUNC_skc_to_tcp_timewait_sock = 138,
    BPF_FUNC_skc_to_tcp_request_sock = 139,
    BPF_FUNC_skc_to_udp6_sock = 140,
    BPF_FUNC_get_task_stack = 141,
    BPF_FUNC_load_hdr_opt = 142,
    BPF_FUNC_store_hdr_opt = 143,
    BPF_FUNC_reserve_hdr_opt = 144,
    BPF_FUNC_inode_storage_get = 145,
    BPF_FUNC_inode_storage_delete = 146,
    BPF_FUNC_d_path = 147,
    BPF_FUNC_copy_from_user = 148,
    BPF_FUNC_snprintf_btf = 149,
    BPF_FUNC_seq_printf_btf = 150,
    BPF_FUNC_skb_cgroup_classid = 151,
    BPF_FUNC_redirect_neigh = 152,
    BPF_FUNC_per_cpu_ptr = 153,
    BPF_FUNC_this_cpu_ptr = 154,
    BPF_FUNC_redirect_peer = 155,
    BPF_FUNC_task_storage_get = 156,
    BPF_FUNC_task_storage_delete = 157,
    BPF_FUNC_get_current_task_btf = 158,
    BPF_FUNC_bprm_opts_set = 159,
    BPF_FUNC_ktime_get_coarse_ns = 160,
    BPF_FUNC_ima_inode_hash = 161,
    BPF_FUNC_sock_from_file = 162,
    BPF_FUNC_check_mtu = 163,
    BPF_FUNC_for_each_map_elem = 164,
    BPF_FUNC_snprintf = 165,
    BPF_FUNC_sys_bpf = 166,
    BPF_FUNC_btf_find_by_name_kind = 167,
    BPF_FUNC_sys_close = 168,
    BPF_FUNC_timer_init = 169,
    BPF_FUNC_timer_set_callback = 170,
    BPF_FUNC_timer_start = 171,
    BPF_FUNC_timer_cancel = 172,
    BPF_FUNC_get_func_ip = 173,
    BPF_FUNC_get_attach_cookie = 174,
    BPF_FUNC_task_pt_regs = 175,
    BPF_FUNC_get_branch_snapshot = 176,
    BPF_FUNC_trace_vprintk = 177,
    BPF_FUNC_skc_to_unix_sock = 178,
    BPF_FUNC_kallsyms_lookup_name = 179,
    BPF_FUNC_find_vma = 180,
    BPF_FUNC_loop = 181,
    BPF_FUNC_strncmp = 182,
    BPF_FUNC_get_func_arg = 183,
    BPF_FUNC_get_func_ret = 184,
    BPF_FUNC_get_func_arg_cnt = 185,
    BPF_FUNC_get_retval = 186,
    BPF_FUNC_set_retval = 187,
    BPF_FUNC_xdp_get_buff_len = 188,
    BPF_FUNC_xdp_load_bytes = 189,
    BPF_FUNC_xdp_store_bytes = 190,
    BPF_FUNC_copy_from_user_task = 191,
    BPF_FUNC_skb_set_tstamp = 192,
    BPF_FUNC_ima_file_hash = 193,
    BPF_FUNC_kptr_xchg = 194,
    BPF_FUNC_map_lookup_percpu_elem = 195,
    BPF_FUNC_skc_to_mptcp_sock = 196,
    BPF_FUNC_dynptr_from_mem = 197,
    BPF_FUNC_ringbuf_reserve_dynptr = 198,
    BPF_FUNC_ringbuf_submit_dynptr = 199,
    BPF_FUNC_ringbuf_discard_dynptr = 200,
    BPF_FUNC_dynptr_read = 201,
    BPF_FUNC_dynptr_write = 202,
    BPF_FUNC_dynptr_data = 203,
    BPF_FUNC_tcp_raw_gen_syncookie_ipv4 = 204,
    BPF_FUNC_tcp_raw_gen_syncookie_ipv6 = 205,
    BPF_FUNC_tcp_raw_check_syncookie_ipv4 = 206,
    BPF_FUNC_tcp_raw_check_syncookie_ipv6 = 207,
    BPF_FUNC_ktime_get_tai_ns = 208,
    BPF_FUNC_user_ringbuf_drain = 209,
    BPF_FUNC_cgrp_storage_get = 210,
    BPF_FUNC_cgrp_storage_delete = 211,
    __BPF_FUNC_MAX_ID = 212,
};

enum bpf_hdr_start_off {
    BPF_HDR_START_MAC = 0,
    BPF_HDR_START_NET = 1,
};

enum bpf_iter_feature {
    BPF_ITER_RESCHED = 1,
};

enum bpf_iter_state {
    BPF_ITER_STATE_INVALID = 0,
    BPF_ITER_STATE_ACTIVE = 1,
    BPF_ITER_STATE_DRAINED = 2,
};

enum bpf_iter_task_type {
    BPF_TASK_ITER_ALL = 0,
    BPF_TASK_ITER_TID = 1,
    BPF_TASK_ITER_TGID = 2,
};

enum bpf_jit_poke_reason {
    BPF_POKE_REASON_TAIL_CALL = 0,
};

enum bpf_kfunc_flags {
    BPF_F_PAD_ZEROS = 1,
};

enum bpf_link_type {
    BPF_LINK_TYPE_UNSPEC = 0,
    BPF_LINK_TYPE_RAW_TRACEPOINT = 1,
    BPF_LINK_TYPE_TRACING = 2,
    BPF_LINK_TYPE_CGROUP = 3,
    BPF_LINK_TYPE_ITER = 4,
    BPF_LINK_TYPE_NETNS = 5,
    BPF_LINK_TYPE_XDP = 6,
    BPF_LINK_TYPE_PERF_EVENT = 7,
    BPF_LINK_TYPE_KPROBE_MULTI = 8,
    BPF_LINK_TYPE_STRUCT_OPS = 9,
    BPF_LINK_TYPE_NETFILTER = 10,
    BPF_LINK_TYPE_TCX = 11,
    BPF_LINK_TYPE_UPROBE_MULTI = 12,
    BPF_LINK_TYPE_NETKIT = 13,
    BPF_LINK_TYPE_SOCKMAP = 14,
    __MAX_BPF_LINK_TYPE = 15,
};

enum bpf_lru_list_type {
    BPF_LRU_LIST_T_ACTIVE = 0,
    BPF_LRU_LIST_T_INACTIVE = 1,
    BPF_LRU_LIST_T_FREE = 2,
    BPF_LRU_LOCAL_LIST_T_FREE = 3,
    BPF_LRU_LOCAL_LIST_T_PENDING = 4,
};

enum bpf_lwt_encap_mode {
    BPF_LWT_ENCAP_SEG6 = 0,
    BPF_LWT_ENCAP_SEG6_INLINE = 1,
    BPF_LWT_ENCAP_IP = 2,
};

enum bpf_map_type {
    BPF_MAP_TYPE_UNSPEC = 0,
    BPF_MAP_TYPE_HASH = 1,
    BPF_MAP_TYPE_ARRAY = 2,
    BPF_MAP_TYPE_PROG_ARRAY = 3,
    BPF_MAP_TYPE_PERF_EVENT_ARRAY = 4,
    BPF_MAP_TYPE_PERCPU_HASH = 5,
    BPF_MAP_TYPE_PERCPU_ARRAY = 6,
    BPF_MAP_TYPE_STACK_TRACE = 7,
    BPF_MAP_TYPE_CGROUP_ARRAY = 8,
    BPF_MAP_TYPE_LRU_HASH = 9,
    BPF_MAP_TYPE_LRU_PERCPU_HASH = 10,
    BPF_MAP_TYPE_LPM_TRIE = 11,
    BPF_MAP_TYPE_ARRAY_OF_MAPS = 12,
    BPF_MAP_TYPE_HASH_OF_MAPS = 13,
    BPF_MAP_TYPE_DEVMAP = 14,
    BPF_MAP_TYPE_SOCKMAP = 15,
    BPF_MAP_TYPE_CPUMAP = 16,
    BPF_MAP_TYPE_XSKMAP = 17,
    BPF_MAP_TYPE_SOCKHASH = 18,
    BPF_MAP_TYPE_CGROUP_STORAGE_DEPRECATED = 19,
    BPF_MAP_TYPE_CGROUP_STORAGE = 19,
    BPF_MAP_TYPE_REUSEPORT_SOCKARRAY = 20,
    BPF_MAP_TYPE_PERCPU_CGROUP_STORAGE_DEPRECATED = 21,
    BPF_MAP_TYPE_PERCPU_CGROUP_STORAGE = 21,
    BPF_MAP_TYPE_QUEUE = 22,
    BPF_MAP_TYPE_STACK = 23,
    BPF_MAP_TYPE_SK_STORAGE = 24,
    BPF_MAP_TYPE_DEVMAP_HASH = 25,
    BPF_MAP_TYPE_STRUCT_OPS = 26,
    BPF_MAP_TYPE_RINGBUF = 27,
    BPF_MAP_TYPE_INODE_STORAGE = 28,
    BPF_MAP_TYPE_TASK_STORAGE = 29,
    BPF_MAP_TYPE_BLOOM_FILTER = 30,
    BPF_MAP_TYPE_USER_RINGBUF = 31,
    BPF_MAP_TYPE_CGRP_STORAGE = 32,
    BPF_MAP_TYPE_ARENA = 33,
    __MAX_BPF_MAP_TYPE = 34,
};

enum bpf_netdev_command {
    XDP_SETUP_PROG = 0,
    XDP_SETUP_PROG_HW = 1,
    BPF_OFFLOAD_MAP_ALLOC = 2,
    BPF_OFFLOAD_MAP_FREE = 3,
    XDP_SETUP_XSK_POOL = 4,
};

enum bpf_perf_event_type {
    BPF_PERF_EVENT_UNSPEC = 0,
    BPF_PERF_EVENT_UPROBE = 1,
    BPF_PERF_EVENT_URETPROBE = 2,
    BPF_PERF_EVENT_KPROBE = 3,
    BPF_PERF_EVENT_KRETPROBE = 4,
    BPF_PERF_EVENT_TRACEPOINT = 5,
    BPF_PERF_EVENT_EVENT = 6,
};

enum bpf_prog_type {
    BPF_PROG_TYPE_UNSPEC = 0,
    BPF_PROG_TYPE_SOCKET_FILTER = 1,
    BPF_PROG_TYPE_KPROBE = 2,
    BPF_PROG_TYPE_SCHED_CLS = 3,
    BPF_PROG_TYPE_SCHED_ACT = 4,
    BPF_PROG_TYPE_TRACEPOINT = 5,
    BPF_PROG_TYPE_XDP = 6,
    BPF_PROG_TYPE_PERF_EVENT = 7,
    BPF_PROG_TYPE_CGROUP_SKB = 8,
    BPF_PROG_TYPE_CGROUP_SOCK = 9,
    BPF_PROG_TYPE_LWT_IN = 10,
    BPF_PROG_TYPE_LWT_OUT = 11,
    BPF_PROG_TYPE_LWT_XMIT = 12,
    BPF_PROG_TYPE_SOCK_OPS = 13,
    BPF_PROG_TYPE_SK_SKB = 14,
    BPF_PROG_TYPE_CGROUP_DEVICE = 15,
    BPF_PROG_TYPE_SK_MSG = 16,
    BPF_PROG_TYPE_RAW_TRACEPOINT = 17,
    BPF_PROG_TYPE_CGROUP_SOCK_ADDR = 18,
    BPF_PROG_TYPE_LWT_SEG6LOCAL = 19,
    BPF_PROG_TYPE_LIRC_MODE2 = 20,
    BPF_PROG_TYPE_SK_REUSEPORT = 21,
    BPF_PROG_TYPE_FLOW_DISSECTOR = 22,
    BPF_PROG_TYPE_CGROUP_SYSCTL = 23,
    BPF_PROG_TYPE_RAW_TRACEPOINT_WRITABLE = 24,
    BPF_PROG_TYPE_CGROUP_SOCKOPT = 25,
    BPF_PROG_TYPE_TRACING = 26,
    BPF_PROG_TYPE_STRUCT_OPS = 27,
    BPF_PROG_TYPE_EXT = 28,
    BPF_PROG_TYPE_LSM = 29,
    BPF_PROG_TYPE_SK_LOOKUP = 30,
    BPF_PROG_TYPE_SYSCALL = 31,
    BPF_PROG_TYPE_NETFILTER = 32,
    __MAX_BPF_PROG_TYPE = 33,
};

enum bpf_reg_liveness {
    REG_LIVE_NONE = 0,
    REG_LIVE_READ32 = 1,
    REG_LIVE_READ64 = 2,
    REG_LIVE_READ = 3,
    REG_LIVE_WRITTEN = 4,
    REG_LIVE_DONE = 8,
};

enum bpf_reg_type {
    NOT_INIT = 0,
    SCALAR_VALUE = 1,
    PTR_TO_CTX = 2,
    CONST_PTR_TO_MAP = 3,
    PTR_TO_MAP_VALUE = 4,
    PTR_TO_MAP_KEY = 5,
    PTR_TO_STACK = 6,
    PTR_TO_PACKET_META = 7,
    PTR_TO_PACKET = 8,
    PTR_TO_PACKET_END = 9,
    PTR_TO_FLOW_KEYS = 10,
    PTR_TO_SOCKET = 11,
    PTR_TO_SOCK_COMMON = 12,
    PTR_TO_TCP_SOCK = 13,
    PTR_TO_TP_BUFFER = 14,
    PTR_TO_XDP_SOCK = 15,
    PTR_TO_BTF_ID = 16,
    PTR_TO_MEM = 17,
    PTR_TO_ARENA = 18,
    PTR_TO_BUF = 19,
    PTR_TO_FUNC = 20,
    CONST_PTR_TO_DYNPTR = 21,
    __BPF_REG_TYPE_MAX = 22,
    PTR_TO_MAP_VALUE_OR_NULL = 260,
    PTR_TO_SOCKET_OR_NULL = 267,
    PTR_TO_SOCK_COMMON_OR_NULL = 268,
    PTR_TO_TCP_SOCK_OR_NULL = 269,
    PTR_TO_BTF_ID_OR_NULL = 272,
    __BPF_REG_TYPE_LIMIT = 134217727,
};

enum bpf_ret_code {
    BPF_OK = 0,
    BPF_DROP = 2,
    BPF_REDIRECT = 7,
    BPF_LWT_REROUTE = 128,
    BPF_FLOW_DISSECTOR_CONTINUE = 129,
};

enum bpf_return_type {
    RET_INTEGER = 0,
    RET_VOID = 1,
    RET_PTR_TO_MAP_VALUE = 2,
    RET_PTR_TO_SOCKET = 3,
    RET_PTR_TO_TCP_SOCK = 4,
    RET_PTR_TO_SOCK_COMMON = 5,
    RET_PTR_TO_MEM = 6,
    RET_PTR_TO_MEM_OR_BTF_ID = 7,
    RET_PTR_TO_BTF_ID = 8,
    __BPF_RET_TYPE_MAX = 9,
    RET_PTR_TO_MAP_VALUE_OR_NULL = 258,
    RET_PTR_TO_SOCKET_OR_NULL = 259,
    RET_PTR_TO_TCP_SOCK_OR_NULL = 260,
    RET_PTR_TO_SOCK_COMMON_OR_NULL = 261,
    RET_PTR_TO_RINGBUF_MEM_OR_NULL = 1286,
    RET_PTR_TO_DYNPTR_MEM_OR_NULL = 262,
    RET_PTR_TO_BTF_ID_OR_NULL = 264,
    RET_PTR_TO_BTF_ID_TRUSTED = 1048584,
    __BPF_RET_TYPE_LIMIT = 134217727,
};

enum bpf_stack_build_id_status {
    BPF_STACK_BUILD_ID_EMPTY = 0,
    BPF_STACK_BUILD_ID_VALID = 1,
    BPF_STACK_BUILD_ID_IP = 2,
};

enum bpf_stack_slot_type {
    STACK_INVALID = 0,
    STACK_SPILL = 1,
    STACK_MISC = 2,
    STACK_ZERO = 3,
    STACK_DYNPTR = 4,
    STACK_ITER = 5,
    STACK_IRQ_FLAG = 6,
};

enum bpf_stats_type {
    BPF_STATS_RUN_TIME = 0,
};

enum bpf_struct_ops_state {
    BPF_STRUCT_OPS_STATE_INIT = 0,
    BPF_STRUCT_OPS_STATE_INUSE = 1,
    BPF_STRUCT_OPS_STATE_TOBEFREE = 2,
    BPF_STRUCT_OPS_STATE_READY = 3,
};

enum bpf_struct_walk_result {
    WALK_SCALAR = 0,
    WALK_PTR = 1,
    WALK_STRUCT = 2,
};

enum bpf_task_fd_type {
    BPF_FD_TYPE_RAW_TRACEPOINT = 0,
    BPF_FD_TYPE_TRACEPOINT = 1,
    BPF_FD_TYPE_KPROBE = 2,
    BPF_FD_TYPE_KRETPROBE = 3,
    BPF_FD_TYPE_UPROBE = 4,
    BPF_FD_TYPE_URETPROBE = 5,
};

enum bpf_task_vma_iter_find_op {
    task_vma_iter_first_vma = 0,
    task_vma_iter_next_vma = 1,
    task_vma_iter_find_vma = 2,
};

enum bpf_text_poke_type {
    BPF_MOD_CALL = 0,
    BPF_MOD_JUMP = 1,
};

enum bpf_tramp_prog_type {
    BPF_TRAMP_FENTRY = 0,
    BPF_TRAMP_FEXIT = 1,
    BPF_TRAMP_MODIFY_RETURN = 2,
    BPF_TRAMP_MAX = 3,
    BPF_TRAMP_REPLACE = 4,
};

enum bpf_type {
    BPF_TYPE_UNSPEC = 0,
    BPF_TYPE_PROG = 1,
    BPF_TYPE_MAP = 2,
    BPF_TYPE_LINK = 3,
};

enum bpf_type_flag {
    PTR_MAYBE_NULL = 256,
    MEM_RDONLY = 512,
    MEM_RINGBUF = 1024,
    MEM_USER = 2048,
    MEM_PERCPU = 4096,
    OBJ_RELEASE = 8192,
    PTR_UNTRUSTED = 16384,
    MEM_UNINIT = 32768,
    DYNPTR_TYPE_LOCAL = 65536,
    DYNPTR_TYPE_RINGBUF = 131072,
    MEM_FIXED_SIZE = 262144,
    MEM_ALLOC = 524288,
    PTR_TRUSTED = 1048576,
    MEM_RCU = 2097152,
    NON_OWN_REF = 4194304,
    DYNPTR_TYPE_SKB = 8388608,
    DYNPTR_TYPE_XDP = 16777216,
    MEM_ALIGNED = 33554432,
    MEM_WRITE = 67108864,
    __BPF_TYPE_FLAG_MAX = 67108865,
    __BPF_TYPE_LAST_FLAG = 67108864,
};

enum bpf_xdp_mode {
    XDP_MODE_SKB = 0,
    XDP_MODE_DRV = 1,
    XDP_MODE_HW = 2,
    __MAX_XDP_MODE = 3,
};

enum btf_arg_tag {
    ARG_TAG_CTX = 1,
    ARG_TAG_NONNULL = 2,
    ARG_TAG_TRUSTED = 4,
    ARG_TAG_NULLABLE = 8,
    ARG_TAG_ARENA = 16,
};

enum btf_field_iter_kind {
    BTF_FIELD_ITER_IDS = 0,
    BTF_FIELD_ITER_STRS = 1,
};

enum btf_field_type {
    BPF_SPIN_LOCK = 1,
    BPF_TIMER = 2,
    BPF_KPTR_UNREF = 4,
    BPF_KPTR_REF = 8,
    BPF_KPTR_PERCPU = 16,
    BPF_KPTR = 28,
    BPF_LIST_HEAD = 32,
    BPF_LIST_NODE = 64,
    BPF_RB_ROOT = 128,
    BPF_RB_NODE = 256,
    BPF_GRAPH_NODE = 320,
    BPF_GRAPH_ROOT = 160,
    BPF_REFCOUNT = 512,
    BPF_WORKQUEUE = 1024,
    BPF_UPTR = 2048,
};

enum btf_func_linkage {
    BTF_FUNC_STATIC = 0,
    BTF_FUNC_GLOBAL = 1,
    BTF_FUNC_EXTERN = 2,
};

enum btf_kfunc_hook {
    BTF_KFUNC_HOOK_COMMON = 0,
    BTF_KFUNC_HOOK_XDP = 1,
    BTF_KFUNC_HOOK_TC = 2,
    BTF_KFUNC_HOOK_STRUCT_OPS = 3,
    BTF_KFUNC_HOOK_TRACING = 4,
    BTF_KFUNC_HOOK_SYSCALL = 5,
    BTF_KFUNC_HOOK_FMODRET = 6,
    BTF_KFUNC_HOOK_CGROUP = 7,
    BTF_KFUNC_HOOK_SCHED_ACT = 8,
    BTF_KFUNC_HOOK_SK_SKB = 9,
    BTF_KFUNC_HOOK_SOCKET_FILTER = 10,
    BTF_KFUNC_HOOK_LWT = 11,
    BTF_KFUNC_HOOK_NETFILTER = 12,
    BTF_KFUNC_HOOK_KPROBE = 13,
    BTF_KFUNC_HOOK_MAX = 14,
};

enum buddy {
    FIRST = 0,
    LAST = 1,
};

enum bug_trap_type {
    BUG_TRAP_TYPE_NONE = 0,
    BUG_TRAP_TYPE_WARN = 1,
    BUG_TRAP_TYPE_BUG = 2,
};

enum bus_notifier_event {
    BUS_NOTIFY_ADD_DEVICE = 0,
    BUS_NOTIFY_DEL_DEVICE = 1,
    BUS_NOTIFY_REMOVED_DEVICE = 2,
    BUS_NOTIFY_BIND_DRIVER = 3,
    BUS_NOTIFY_BOUND_DRIVER = 4,
    BUS_NOTIFY_UNBIND_DRIVER = 5,
    BUS_NOTIFY_UNBOUND_DRIVER = 6,
    BUS_NOTIFY_DRIVER_NOT_BOUND = 7,
};

enum cache_type {
    CACHE_TYPE_NOCACHE = 0,
    CACHE_TYPE_INST = 1,
    CACHE_TYPE_DATA = 2,
    CACHE_TYPE_SEPARATE = 3,
    CACHE_TYPE_UNIFIED = 4,
};

enum cc_attr {
    CC_ATTR_MEM_ENCRYPT = 0,
    CC_ATTR_HOST_MEM_ENCRYPT = 1,
    CC_ATTR_GUEST_MEM_ENCRYPT = 2,
    CC_ATTR_GUEST_STATE_ENCRYPT = 3,
    CC_ATTR_GUEST_UNROLL_STRING_IO = 4,
    CC_ATTR_GUEST_SEV_SNP = 5,
    CC_ATTR_GUEST_SNP_SECURE_TSC = 6,
    CC_ATTR_HOST_SEV_SNP = 7,
};

enum cee_attrs {
    DCB_ATTR_CEE_UNSPEC = 0,
    DCB_ATTR_CEE_PEER_PG = 1,
    DCB_ATTR_CEE_PEER_PFC = 2,
    DCB_ATTR_CEE_PEER_APP_TABLE = 3,
    DCB_ATTR_CEE_TX_PG = 4,
    DCB_ATTR_CEE_RX_PG = 5,
    DCB_ATTR_CEE_PFC = 6,
    DCB_ATTR_CEE_APP_TABLE = 7,
    DCB_ATTR_CEE_FEAT = 8,
    __DCB_ATTR_CEE_MAX = 9,
};

enum cfg80211_signal_type {
    CFG80211_SIGNAL_TYPE_NONE = 0,
    CFG80211_SIGNAL_TYPE_MBM = 1,
    CFG80211_SIGNAL_TYPE_UNSPEC = 2,
};

enum cgroup1_param {
    Opt_all = 0,
    Opt_clone_children = 1,
    Opt_cpuset_v2_mode = 2,
    Opt_name = 3,
    Opt_none = 4,
    Opt_noprefix = 5,
    Opt_release_agent = 6,
    Opt_xattr = 7,
    Opt_favordynmods = 8,
    Opt_nofavordynmods = 9,
};

enum cgroup2_param {
    Opt_nsdelegate = 0,
    Opt_favordynmods___2 = 1,
    Opt_memory_localevents = 2,
    Opt_memory_recursiveprot = 3,
    Opt_memory_hugetlb_accounting = 4,
    Opt_pids_localevents = 5,
    nr__cgroup2_params = 6,
};

enum cgroup_bpf_attach_type {
    CGROUP_BPF_ATTACH_TYPE_INVALID = -1,
    CGROUP_INET_INGRESS = 0,
    CGROUP_INET_EGRESS = 1,
    CGROUP_INET_SOCK_CREATE = 2,
    CGROUP_SOCK_OPS = 3,
    CGROUP_DEVICE = 4,
    CGROUP_INET4_BIND = 5,
    CGROUP_INET6_BIND = 6,
    CGROUP_INET4_CONNECT = 7,
    CGROUP_INET6_CONNECT = 8,
    CGROUP_UNIX_CONNECT = 9,
    CGROUP_INET4_POST_BIND = 10,
    CGROUP_INET6_POST_BIND = 11,
    CGROUP_UDP4_SENDMSG = 12,
    CGROUP_UDP6_SENDMSG = 13,
    CGROUP_UNIX_SENDMSG = 14,
    CGROUP_SYSCTL = 15,
    CGROUP_UDP4_RECVMSG = 16,
    CGROUP_UDP6_RECVMSG = 17,
    CGROUP_UNIX_RECVMSG = 18,
    CGROUP_GETSOCKOPT = 19,
    CGROUP_SETSOCKOPT = 20,
    CGROUP_INET4_GETPEERNAME = 21,
    CGROUP_INET6_GETPEERNAME = 22,
    CGROUP_UNIX_GETPEERNAME = 23,
    CGROUP_INET4_GETSOCKNAME = 24,
    CGROUP_INET6_GETSOCKNAME = 25,
    CGROUP_UNIX_GETSOCKNAME = 26,
    CGROUP_INET_SOCK_RELEASE = 27,
    CGROUP_LSM_START = 28,
    CGROUP_LSM_END = 27,
    MAX_CGROUP_BPF_ATTACH_TYPE = 28,
};

enum cgroup_filetype {
    CGROUP_FILE_PROCS = 0,
    CGROUP_FILE_TASKS = 1,
};

enum cgroup_opt_features {
    OPT_FEATURE_PRESSURE = 0,
    OPT_FEATURE_COUNT = 1,
};

enum cgroup_subsys_id {
    cpuset_cgrp_id = 0,
    cpu_cgrp_id = 1,
    cpuacct_cgrp_id = 2,
    io_cgrp_id = 3,
    memory_cgrp_id = 4,
    devices_cgrp_id = 5,
    freezer_cgrp_id = 6,
    net_cls_cgrp_id = 7,
    perf_event_cgrp_id = 8,
    net_prio_cgrp_id = 9,
    hugetlb_cgrp_id = 10,
    pids_cgrp_id = 11,
    rdma_cgrp_id = 12,
    misc_cgrp_id = 13,
    dmem_cgrp_id = 14,
    CGROUP_SUBSYS_COUNT = 15,
};

enum cgt_group_id {
    __RESERVED__ = 0,
    CGT_HCR_TID1 = 1,
    CGT_HCR_TID2 = 2,
    CGT_HCR_TID3 = 3,
    CGT_HCR_IMO = 4,
    CGT_HCR_FMO = 5,
    CGT_HCR_TIDCP = 6,
    CGT_HCR_TACR = 7,
    CGT_HCR_TSW = 8,
    CGT_HCR_TPC = 9,
    CGT_HCR_TPU = 10,
    CGT_HCR_TTLB = 11,
    CGT_HCR_TVM = 12,
    CGT_HCR_TDZ = 13,
    CGT_HCR_TRVM = 14,
    CGT_HCR_TLOR = 15,
    CGT_HCR_TERR = 16,
    CGT_HCR_APK = 17,
    CGT_HCR_NV = 18,
    CGT_HCR_NV_nNV2 = 19,
    CGT_HCR_NV1_nNV2 = 20,
    CGT_HCR_AT = 21,
    CGT_HCR_nFIEN = 22,
    CGT_HCR_TID4 = 23,
    CGT_HCR_TICAB = 24,
    CGT_HCR_TOCU = 25,
    CGT_HCR_ENSCXT = 26,
    CGT_HCR_TTLBIS = 27,
    CGT_HCR_TTLBOS = 28,
    CGT_MDCR_TPMCR = 29,
    CGT_MDCR_TPM = 30,
    CGT_MDCR_TDE = 31,
    CGT_MDCR_TDA = 32,
    CGT_MDCR_TDOSA = 33,
    CGT_MDCR_TDRA = 34,
    CGT_MDCR_E2PB = 35,
    CGT_MDCR_TPMS = 36,
    CGT_MDCR_TTRF = 37,
    CGT_MDCR_E2TB = 38,
    CGT_MDCR_TDCC = 39,
    CGT_CPTR_TAM = 40,
    CGT_CPTR_TCPAC = 41,
    CGT_HCRX_EnFPM = 42,
    CGT_HCRX_TCR2En = 43,
    CGT_CNTHCTL_EL1TVT = 44,
    CGT_CNTHCTL_EL1TVCT = 45,
    CGT_ICH_HCR_TC = 46,
    CGT_ICH_HCR_TALL0 = 47,
    CGT_ICH_HCR_TALL1 = 48,
    CGT_ICH_HCR_TDIR = 49,
    __MULTIPLE_CONTROL_BITS__ = 50,
    CGT_HCR_IMO_FMO_ICH_HCR_TC = 50,
    CGT_HCR_TID2_TID4 = 51,
    CGT_HCR_TTLB_TTLBIS = 52,
    CGT_HCR_TTLB_TTLBOS = 53,
    CGT_HCR_TVM_TRVM = 54,
    CGT_HCR_TVM_TRVM_HCRX_TCR2En = 55,
    CGT_HCR_TPU_TICAB = 56,
    CGT_HCR_TPU_TOCU = 57,
    CGT_HCR_NV1_nNV2_ENSCXT = 58,
    CGT_MDCR_TPM_TPMCR = 59,
    CGT_MDCR_TPM_HPMN = 60,
    CGT_MDCR_TDE_TDA = 61,
    CGT_MDCR_TDE_TDOSA = 62,
    CGT_MDCR_TDE_TDRA = 63,
    CGT_MDCR_TDCC_TDE_TDA = 64,
    CGT_ICH_HCR_TC_TDIR = 65,
    __COMPLEX_CONDITIONS__ = 66,
    CGT_CNTHCTL_EL1PCTEN = 66,
    CGT_CNTHCTL_EL1PTEN = 67,
    CGT_CNTHCTL_EL1NVPCT = 68,
    CGT_CNTHCTL_EL1NVVCT = 69,
    CGT_CPTR_TTA = 70,
    CGT_MDCR_HPMN = 71,
    __NR_CGT_GROUP_IDS__ = 72,
};

enum chacha_constants {
    CHACHA_CONSTANT_EXPA = 1634760805,
    CHACHA_CONSTANT_ND_3 = 857760878,
    CHACHA_CONSTANT_2_BY = 2036477234,
    CHACHA_CONSTANT_TE_K = 1797285236,
};

enum class_map_type {
    DD_CLASS_TYPE_DISJOINT_BITS = 0,
    DD_CLASS_TYPE_LEVEL_NUM = 1,
    DD_CLASS_TYPE_DISJOINT_NAMES = 2,
    DD_CLASS_TYPE_LEVEL_NAMES = 3,
};

enum cleanup_prefix_rt_t {
    CLEANUP_PREFIX_RT_NOP = 0,
    CLEANUP_PREFIX_RT_DEL = 1,
    CLEANUP_PREFIX_RT_EXPIRE = 2,
};

enum clear_refs_types {
    CLEAR_REFS_ALL = 1,
    CLEAR_REFS_ANON = 2,
    CLEAR_REFS_MAPPED = 3,
    CLEAR_REFS_SOFT_DIRTY = 4,
    CLEAR_REFS_MM_HIWATER_RSS = 5,
    CLEAR_REFS_LAST = 6,
};

enum clock_event_state {
    CLOCK_EVT_STATE_DETACHED = 0,
    CLOCK_EVT_STATE_SHUTDOWN = 1,
    CLOCK_EVT_STATE_PERIODIC = 2,
    CLOCK_EVT_STATE_ONESHOT = 3,
    CLOCK_EVT_STATE_ONESHOT_STOPPED = 4,
};

enum clocksource_ids {
    CSID_GENERIC = 0,
    CSID_ARM_ARCH_COUNTER = 1,
    CSID_S390_TOD = 2,
    CSID_X86_TSC_EARLY = 3,
    CSID_X86_TSC = 4,
    CSID_X86_KVM_CLK = 5,
    CSID_X86_ART = 6,
    CSID_MAX = 7,
};

enum closure_state {
    CLOSURE_BITS_START = 67108864,
    CLOSURE_DESTRUCTOR = 67108864,
    CLOSURE_WAITING = 268435456,
    CLOSURE_RUNNING = 1073741824,
};

enum cmd_type {
    CMD_ADDR = 1,
    CMD_LISTEN = 2,
    CMD_OPT = 4,
};

enum cmis_cdb_fw_write_mechanism {
    CMIS_CDB_FW_WRITE_MECHANISM_NONE = 0,
    CMIS_CDB_FW_WRITE_MECHANISM_LPL = 1,
    CMIS_CDB_FW_WRITE_MECHANISM_EPL = 16,
    CMIS_CDB_FW_WRITE_MECHANISM_BOTH = 17,
};

enum compact_priority {
    COMPACT_PRIO_SYNC_FULL = 0,
    MIN_COMPACT_PRIORITY = 0,
    COMPACT_PRIO_SYNC_LIGHT = 1,
    MIN_COMPACT_COSTLY_PRIORITY = 1,
    DEF_COMPACT_PRIORITY = 1,
    COMPACT_PRIO_ASYNC = 2,
    INIT_COMPACT_PRIORITY = 2,
};

enum compact_result {
    COMPACT_NOT_SUITABLE_ZONE = 0,
    COMPACT_SKIPPED = 1,
    COMPACT_DEFERRED = 2,
    COMPACT_NO_SUITABLE_PAGE = 3,
    COMPACT_CONTINUE = 4,
    COMPACT_COMPLETE = 5,
    COMPACT_PARTIAL_SKIPPED = 6,
    COMPACT_CONTENDED = 7,
    COMPACT_SUCCESS = 8,
};

enum compat_regset {
    REGSET_COMPAT_GPR = 0,
    REGSET_COMPAT_VFP = 1,
};

enum con_flush_mode {
    CONSOLE_FLUSH_PENDING = 0,
    CONSOLE_REPLAY_ALL = 1,
};

enum con_msg_format_flags {
    MSG_FORMAT_DEFAULT = 0,
    MSG_FORMAT_SYSLOG = 1,
};

enum con_scroll {
    SM_UP = 0,
    SM_DOWN = 1,
};

enum cons_flags {
    CON_PRINTBUFFER = 1,
    CON_CONSDEV = 2,
    CON_ENABLED = 4,
    CON_BOOT = 8,
    CON_ANYTIME = 16,
    CON_BRL = 32,
    CON_EXTENDED = 64,
    CON_SUSPENDED = 128,
    CON_NBCON = 256,
};

enum cpio_fields {
    C_MAGIC = 0,
    C_INO = 1,
    C_MODE = 2,
    C_UID = 3,
    C_GID = 4,
    C_NLINK = 5,
    C_MTIME = 6,
    C_FILESIZE = 7,
    C_MAJ = 8,
    C_MIN = 9,
    C_RMAJ = 10,
    C_RMIN = 11,
    C_NAMESIZE = 12,
    C_CHKSUM = 13,
    C_NFIELDS = 14,
};

enum cpu_idle_type {
    __CPU_NOT_IDLE = 0,
    CPU_IDLE = 1,
    CPU_NEWLY_IDLE = 2,
    CPU_MAX_IDLE_TYPES = 3,
};

enum cpu_led_event {
    CPU_LED_IDLE_START = 0,
    CPU_LED_IDLE_END = 1,
    CPU_LED_START = 2,
    CPU_LED_STOP = 3,
    CPU_LED_HALTED = 4,
};

enum cpu_mitigations {
    CPU_MITIGATIONS_OFF = 0,
    CPU_MITIGATIONS_AUTO = 1,
    CPU_MITIGATIONS_AUTO_NOSMT = 2,
};

enum cpu_pm_event {
    CPU_PM_ENTER = 0,
    CPU_PM_ENTER_FAILED = 1,
    CPU_PM_EXIT = 2,
    CPU_CLUSTER_PM_ENTER = 3,
    CPU_CLUSTER_PM_ENTER_FAILED = 4,
    CPU_CLUSTER_PM_EXIT = 5,
};

enum cpu_usage_stat {
    CPUTIME_USER = 0,
    CPUTIME_NICE = 1,
    CPUTIME_SYSTEM = 2,
    CPUTIME_SOFTIRQ = 3,
    CPUTIME_IRQ = 4,
    CPUTIME_IDLE = 5,
    CPUTIME_IOWAIT = 6,
    CPUTIME_STEAL = 7,
    CPUTIME_GUEST = 8,
    CPUTIME_GUEST_NICE = 9,
    NR_STATS = 10,
};

enum cpuacct_stat_index {
    CPUACCT_STAT_USER = 0,
    CPUACCT_STAT_SYSTEM = 1,
    CPUACCT_STAT_NSTATS = 2,
};

enum cpubiuctrl_regs {
    CPU_CREDIT_REG = 0,
    CPU_MCP_FLOW_REG = 1,
    CPU_WRITEBACK_CTRL_REG = 2,
    RAC_CONFIG0_REG = 3,
    RAC_CONFIG1_REG = 4,
    NUM_CPU_BIUCTRL_REGS = 5,
};

enum cpufreq_table_sorting {
    CPUFREQ_TABLE_UNSORTED = 0,
    CPUFREQ_TABLE_SORTED_ASCENDING = 1,
    CPUFREQ_TABLE_SORTED_DESCENDING = 2,
};

enum cpuhp_state {
    CPUHP_INVALID = -1,
    CPUHP_OFFLINE = 0,
    CPUHP_CREATE_THREADS = 1,
    CPUHP_PERF_PREPARE = 2,
    CPUHP_PERF_X86_PREPARE = 3,
    CPUHP_PERF_X86_AMD_UNCORE_PREP = 4,
    CPUHP_PERF_POWER = 5,
    CPUHP_PERF_SUPERH = 6,
    CPUHP_X86_HPET_DEAD = 7,
    CPUHP_X86_MCE_DEAD = 8,
    CPUHP_VIRT_NET_DEAD = 9,
    CPUHP_IBMVNIC_DEAD = 10,
    CPUHP_SLUB_DEAD = 11,
    CPUHP_DEBUG_OBJ_DEAD = 12,
    CPUHP_MM_WRITEBACK_DEAD = 13,
    CPUHP_MM_VMSTAT_DEAD = 14,
    CPUHP_SOFTIRQ_DEAD = 15,
    CPUHP_NET_MVNETA_DEAD = 16,
    CPUHP_CPUIDLE_DEAD = 17,
    CPUHP_ARM64_FPSIMD_DEAD = 18,
    CPUHP_ARM_OMAP_WAKE_DEAD = 19,
    CPUHP_IRQ_POLL_DEAD = 20,
    CPUHP_BLOCK_SOFTIRQ_DEAD = 21,
    CPUHP_BIO_DEAD = 22,
    CPUHP_ACPI_CPUDRV_DEAD = 23,
    CPUHP_S390_PFAULT_DEAD = 24,
    CPUHP_BLK_MQ_DEAD = 25,
    CPUHP_FS_BUFF_DEAD = 26,
    CPUHP_PRINTK_DEAD = 27,
    CPUHP_MM_MEMCQ_DEAD = 28,
    CPUHP_PERCPU_CNT_DEAD = 29,
    CPUHP_RADIX_DEAD = 30,
    CPUHP_PAGE_ALLOC = 31,
    CPUHP_NET_DEV_DEAD = 32,
    CPUHP_PCI_XGENE_DEAD = 33,
    CPUHP_IOMMU_IOVA_DEAD = 34,
    CPUHP_AP_ARM_CACHE_B15_RAC_DEAD = 35,
    CPUHP_PADATA_DEAD = 36,
    CPUHP_AP_DTPM_CPU_DEAD = 37,
    CPUHP_RANDOM_PREPARE = 38,
    CPUHP_WORKQUEUE_PREP = 39,
    CPUHP_POWER_NUMA_PREPARE = 40,
    CPUHP_HRTIMERS_PREPARE = 41,
    CPUHP_X2APIC_PREPARE = 42,
    CPUHP_SMPCFD_PREPARE = 43,
    CPUHP_RELAY_PREPARE = 44,
    CPUHP_MD_RAID5_PREPARE = 45,
    CPUHP_RCUTREE_PREP = 46,
    CPUHP_CPUIDLE_COUPLED_PREPARE = 47,
    CPUHP_POWERPC_PMAC_PREPARE = 48,
    CPUHP_POWERPC_MMU_CTX_PREPARE = 49,
    CPUHP_XEN_PREPARE = 50,
    CPUHP_XEN_EVTCHN_PREPARE = 51,
    CPUHP_ARM_SHMOBILE_SCU_PREPARE = 52,
    CPUHP_SH_SH3X_PREPARE = 53,
    CPUHP_TOPOLOGY_PREPARE = 54,
    CPUHP_NET_IUCV_PREPARE = 55,
    CPUHP_ARM_BL_PREPARE = 56,
    CPUHP_TRACE_RB_PREPARE = 57,
    CPUHP_MM_ZS_PREPARE = 58,
    CPUHP_MM_ZSWP_POOL_PREPARE = 59,
    CPUHP_KVM_PPC_BOOK3S_PREPARE = 60,
    CPUHP_ZCOMP_PREPARE = 61,
    CPUHP_TIMERS_PREPARE = 62,
    CPUHP_TMIGR_PREPARE = 63,
    CPUHP_MIPS_SOC_PREPARE = 64,
    CPUHP_BP_PREPARE_DYN = 65,
    CPUHP_BP_PREPARE_DYN_END = 85,
    CPUHP_BP_KICK_AP = 86,
    CPUHP_BRINGUP_CPU = 87,
    CPUHP_AP_IDLE_DEAD = 88,
    CPUHP_AP_OFFLINE = 89,
    CPUHP_AP_CACHECTRL_STARTING = 90,
    CPUHP_AP_SCHED_STARTING = 91,
    CPUHP_AP_RCUTREE_DYING = 92,
    CPUHP_AP_CPU_PM_STARTING = 93,
    CPUHP_AP_IRQ_GIC_STARTING = 94,
    CPUHP_AP_IRQ_HIP04_STARTING = 95,
    CPUHP_AP_IRQ_APPLE_AIC_STARTING = 96,
    CPUHP_AP_IRQ_ARMADA_XP_STARTING = 97,
    CPUHP_AP_IRQ_BCM2836_STARTING = 98,
    CPUHP_AP_IRQ_MIPS_GIC_STARTING = 99,
    CPUHP_AP_IRQ_EIOINTC_STARTING = 100,
    CPUHP_AP_IRQ_AVECINTC_STARTING = 101,
    CPUHP_AP_IRQ_SIFIVE_PLIC_STARTING = 102,
    CPUHP_AP_IRQ_THEAD_ACLINT_SSWI_STARTING = 103,
    CPUHP_AP_IRQ_RISCV_IMSIC_STARTING = 104,
    CPUHP_AP_IRQ_RISCV_SBI_IPI_STARTING = 105,
    CPUHP_AP_ARM_MVEBU_COHERENCY = 106,
    CPUHP_AP_PERF_X86_AMD_UNCORE_STARTING = 107,
    CPUHP_AP_PERF_X86_STARTING = 108,
    CPUHP_AP_PERF_X86_AMD_IBS_STARTING = 109,
    CPUHP_AP_PERF_XTENSA_STARTING = 110,
    CPUHP_AP_ARM_VFP_STARTING = 111,
    CPUHP_AP_ARM64_DEBUG_MONITORS_STARTING = 112,
    CPUHP_AP_PERF_ARM_HW_BREAKPOINT_STARTING = 113,
    CPUHP_AP_PERF_ARM_ACPI_STARTING = 114,
    CPUHP_AP_PERF_ARM_STARTING = 115,
    CPUHP_AP_PERF_RISCV_STARTING = 116,
    CPUHP_AP_ARM_L2X0_STARTING = 117,
    CPUHP_AP_EXYNOS4_MCT_TIMER_STARTING = 118,
    CPUHP_AP_ARM_ARCH_TIMER_STARTING = 119,
    CPUHP_AP_ARM_ARCH_TIMER_EVTSTRM_STARTING = 120,
    CPUHP_AP_ARM_GLOBAL_TIMER_STARTING = 121,
    CPUHP_AP_JCORE_TIMER_STARTING = 122,
    CPUHP_AP_ARM_TWD_STARTING = 123,
    CPUHP_AP_QCOM_TIMER_STARTING = 124,
    CPUHP_AP_TEGRA_TIMER_STARTING = 125,
    CPUHP_AP_ARMADA_TIMER_STARTING = 126,
    CPUHP_AP_MIPS_GIC_TIMER_STARTING = 127,
    CPUHP_AP_ARC_TIMER_STARTING = 128,
    CPUHP_AP_REALTEK_TIMER_STARTING = 129,
    CPUHP_AP_RISCV_TIMER_STARTING = 130,
    CPUHP_AP_CLINT_TIMER_STARTING = 131,
    CPUHP_AP_CSKY_TIMER_STARTING = 132,
    CPUHP_AP_TI_GP_TIMER_STARTING = 133,
    CPUHP_AP_HYPERV_TIMER_STARTING = 134,
    CPUHP_AP_DUMMY_TIMER_STARTING = 135,
    CPUHP_AP_ARM_XEN_STARTING = 136,
    CPUHP_AP_ARM_XEN_RUNSTATE_STARTING = 137,
    CPUHP_AP_ARM_CORESIGHT_STARTING = 138,
    CPUHP_AP_ARM_CORESIGHT_CTI_STARTING = 139,
    CPUHP_AP_ARM64_ISNDEP_STARTING = 140,
    CPUHP_AP_SMPCFD_DYING = 141,
    CPUHP_AP_HRTIMERS_DYING = 142,
    CPUHP_AP_TICK_DYING = 143,
    CPUHP_AP_X86_TBOOT_DYING = 144,
    CPUHP_AP_ARM_CACHE_B15_RAC_DYING = 145,
    CPUHP_AP_ONLINE = 146,
    CPUHP_TEARDOWN_CPU = 147,
    CPUHP_AP_ONLINE_IDLE = 148,
    CPUHP_AP_HYPERV_ONLINE = 149,
    CPUHP_AP_KVM_ONLINE = 150,
    CPUHP_AP_SCHED_WAIT_EMPTY = 151,
    CPUHP_AP_SMPBOOT_THREADS = 152,
    CPUHP_AP_IRQ_AFFINITY_ONLINE = 153,
    CPUHP_AP_BLK_MQ_ONLINE = 154,
    CPUHP_AP_ARM_MVEBU_SYNC_CLOCKS = 155,
    CPUHP_AP_X86_INTEL_EPB_ONLINE = 156,
    CPUHP_AP_PERF_ONLINE = 157,
    CPUHP_AP_PERF_X86_ONLINE = 158,
    CPUHP_AP_PERF_X86_UNCORE_ONLINE = 159,
    CPUHP_AP_PERF_X86_AMD_UNCORE_ONLINE = 160,
    CPUHP_AP_PERF_X86_AMD_POWER_ONLINE = 161,
    CPUHP_AP_PERF_S390_CF_ONLINE = 162,
    CPUHP_AP_PERF_S390_SF_ONLINE = 163,
    CPUHP_AP_PERF_ARM_CCI_ONLINE = 164,
    CPUHP_AP_PERF_ARM_CCN_ONLINE = 165,
    CPUHP_AP_PERF_ARM_HISI_CPA_ONLINE = 166,
    CPUHP_AP_PERF_ARM_HISI_DDRC_ONLINE = 167,
    CPUHP_AP_PERF_ARM_HISI_HHA_ONLINE = 168,
    CPUHP_AP_PERF_ARM_HISI_L3_ONLINE = 169,
    CPUHP_AP_PERF_ARM_HISI_PA_ONLINE = 170,
    CPUHP_AP_PERF_ARM_HISI_SLLC_ONLINE = 171,
    CPUHP_AP_PERF_ARM_HISI_PCIE_PMU_ONLINE = 172,
    CPUHP_AP_PERF_ARM_HNS3_PMU_ONLINE = 173,
    CPUHP_AP_PERF_ARM_L2X0_ONLINE = 174,
    CPUHP_AP_PERF_ARM_QCOM_L2_ONLINE = 175,
    CPUHP_AP_PERF_ARM_QCOM_L3_ONLINE = 176,
    CPUHP_AP_PERF_ARM_APM_XGENE_ONLINE = 177,
    CPUHP_AP_PERF_ARM_CAVIUM_TX2_UNCORE_ONLINE = 178,
    CPUHP_AP_PERF_ARM_MARVELL_CN10K_DDR_ONLINE = 179,
    CPUHP_AP_PERF_ARM_MRVL_PEM_ONLINE = 180,
    CPUHP_AP_PERF_POWERPC_NEST_IMC_ONLINE = 181,
    CPUHP_AP_PERF_POWERPC_CORE_IMC_ONLINE = 182,
    CPUHP_AP_PERF_POWERPC_THREAD_IMC_ONLINE = 183,
    CPUHP_AP_PERF_POWERPC_TRACE_IMC_ONLINE = 184,
    CPUHP_AP_PERF_POWERPC_HV_24x7_ONLINE = 185,
    CPUHP_AP_PERF_POWERPC_HV_GPCI_ONLINE = 186,
    CPUHP_AP_PERF_CSKY_ONLINE = 187,
    CPUHP_AP_TMIGR_ONLINE = 188,
    CPUHP_AP_WATCHDOG_ONLINE = 189,
    CPUHP_AP_WORKQUEUE_ONLINE = 190,
    CPUHP_AP_RANDOM_ONLINE = 191,
    CPUHP_AP_RCUTREE_ONLINE = 192,
    CPUHP_AP_KTHREADS_ONLINE = 193,
    CPUHP_AP_BASE_CACHEINFO_ONLINE = 194,
    CPUHP_AP_ONLINE_DYN = 195,
    CPUHP_AP_ONLINE_DYN_END = 235,
    CPUHP_AP_X86_HPET_ONLINE = 236,
    CPUHP_AP_X86_KVM_CLK_ONLINE = 237,
    CPUHP_AP_ACTIVE = 238,
    CPUHP_ONLINE = 239,
};

enum cpuhp_sync_state {
    SYNC_STATE_DEAD = 0,
    SYNC_STATE_KICKED = 1,
    SYNC_STATE_SHOULD_DIE = 2,
    SYNC_STATE_ALIVE = 3,
    SYNC_STATE_SHOULD_ONLINE = 4,
    SYNC_STATE_ONLINE = 5,
};

enum criteria {
    CR_POWER2_ALIGNED = 0,
    CR_GOAL_LEN_FAST = 1,
    CR_BEST_AVAIL_LEN = 2,
    CR_GOAL_LEN_SLOW = 3,
    CR_ANY_FREE = 4,
    EXT4_MB_NUM_CRS = 5,
};

enum crypto_attr_type_t {
    CRYPTOCFGA_UNSPEC = 0,
    CRYPTOCFGA_PRIORITY_VAL = 1,
    CRYPTOCFGA_REPORT_LARVAL = 2,
    CRYPTOCFGA_REPORT_HASH = 3,
    CRYPTOCFGA_REPORT_BLKCIPHER = 4,
    CRYPTOCFGA_REPORT_AEAD = 5,
    CRYPTOCFGA_REPORT_COMPRESS = 6,
    CRYPTOCFGA_REPORT_RNG = 7,
    CRYPTOCFGA_REPORT_CIPHER = 8,
    CRYPTOCFGA_REPORT_AKCIPHER = 9,
    CRYPTOCFGA_REPORT_KPP = 10,
    CRYPTOCFGA_REPORT_ACOMP = 11,
    CRYPTOCFGA_STAT_LARVAL = 12,
    CRYPTOCFGA_STAT_HASH = 13,
    CRYPTOCFGA_STAT_BLKCIPHER = 14,
    CRYPTOCFGA_STAT_AEAD = 15,
    CRYPTOCFGA_STAT_COMPRESS = 16,
    CRYPTOCFGA_STAT_RNG = 17,
    CRYPTOCFGA_STAT_CIPHER = 18,
    CRYPTOCFGA_STAT_AKCIPHER = 19,
    CRYPTOCFGA_STAT_KPP = 20,
    CRYPTOCFGA_STAT_ACOMP = 21,
    CRYPTOCFGA_REPORT_SIG = 22,
    __CRYPTOCFGA_MAX = 23,
};

enum ct_dccp_states {
    CT_DCCP_NONE = 0,
    CT_DCCP_REQUEST = 1,
    CT_DCCP_RESPOND = 2,
    CT_DCCP_PARTOPEN = 3,
    CT_DCCP_OPEN = 4,
    CT_DCCP_CLOSEREQ = 5,
    CT_DCCP_CLOSING = 6,
    CT_DCCP_TIMEWAIT = 7,
    CT_DCCP_IGNORE = 8,
    CT_DCCP_INVALID = 9,
    __CT_DCCP_MAX = 10,
};

enum ctx_state {
    CT_STATE_DISABLED = -1,
    CT_STATE_KERNEL = 0,
    CT_STATE_IDLE = 1,
    CT_STATE_USER = 2,
    CT_STATE_GUEST = 3,
    CT_STATE_MAX = 4,
};

enum d_real_type {
    D_REAL_DATA = 0,
    D_REAL_METADATA = 1,
};

enum d_walk_ret {
    D_WALK_CONTINUE = 0,
    D_WALK_QUIT = 1,
    D_WALK_NORETRY = 2,
    D_WALK_SKIP = 3,
};

enum data_formats {
    DATA_FMT_DIGEST = 0,
    DATA_FMT_DIGEST_WITH_ALGO = 1,
    DATA_FMT_DIGEST_WITH_TYPE_AND_ALGO = 2,
    DATA_FMT_STRING = 3,
    DATA_FMT_HEX = 4,
    DATA_FMT_UINT = 5,
};

enum dbc_state {
    DS_DISABLED = 0,
    DS_INITIALIZED = 1,
    DS_ENABLED = 2,
    DS_CONNECTED = 3,
    DS_CONFIGURED = 4,
    DS_MAX = 5,
};

enum dbg_active_el {
    DBG_ACTIVE_EL0 = 0,
    DBG_ACTIVE_EL1 = 1,
};

enum dbgfs_get_mode {
    DBGFS_GET_ALREADY = 0,
    DBGFS_GET_REGULAR = 1,
    DBGFS_GET_SHORT = 2,
};

enum dcb_general_attr_values {
    DCB_ATTR_VALUE_UNDEFINED = 255,
};

enum dcbevent_notif_type {
    DCB_APP_EVENT = 1,
};

enum dcbnl_app_attrs {
    DCB_APP_ATTR_UNDEFINED = 0,
    DCB_APP_ATTR_IDTYPE = 1,
    DCB_APP_ATTR_ID = 2,
    DCB_APP_ATTR_PRIORITY = 3,
    __DCB_APP_ATTR_ENUM_MAX = 4,
    DCB_APP_ATTR_MAX = 3,
};

enum dcbnl_attrs {
    DCB_ATTR_UNDEFINED = 0,
    DCB_ATTR_IFNAME = 1,
    DCB_ATTR_STATE = 2,
    DCB_ATTR_PFC_STATE = 3,
    DCB_ATTR_PFC_CFG = 4,
    DCB_ATTR_NUM_TC = 5,
    DCB_ATTR_PG_CFG = 6,
    DCB_ATTR_SET_ALL = 7,
    DCB_ATTR_PERM_HWADDR = 8,
    DCB_ATTR_CAP = 9,
    DCB_ATTR_NUMTCS = 10,
    DCB_ATTR_BCN = 11,
    DCB_ATTR_APP = 12,
    DCB_ATTR_IEEE = 13,
    DCB_ATTR_DCBX = 14,
    DCB_ATTR_FEATCFG = 15,
    DCB_ATTR_CEE = 16,
    __DCB_ATTR_ENUM_MAX = 17,
    DCB_ATTR_MAX = 16,
};

enum dcbnl_bcn_attrs {
    DCB_BCN_ATTR_UNDEFINED = 0,
    DCB_BCN_ATTR_RP_0 = 1,
    DCB_BCN_ATTR_RP_1 = 2,
    DCB_BCN_ATTR_RP_2 = 3,
    DCB_BCN_ATTR_RP_3 = 4,
    DCB_BCN_ATTR_RP_4 = 5,
    DCB_BCN_ATTR_RP_5 = 6,
    DCB_BCN_ATTR_RP_6 = 7,
    DCB_BCN_ATTR_RP_7 = 8,
    DCB_BCN_ATTR_RP_ALL = 9,
    DCB_BCN_ATTR_BCNA_0 = 10,
    DCB_BCN_ATTR_BCNA_1 = 11,
    DCB_BCN_ATTR_ALPHA = 12,
    DCB_BCN_ATTR_BETA = 13,
    DCB_BCN_ATTR_GD = 14,
    DCB_BCN_ATTR_GI = 15,
    DCB_BCN_ATTR_TMAX = 16,
    DCB_BCN_ATTR_TD = 17,
    DCB_BCN_ATTR_RMIN = 18,
    DCB_BCN_ATTR_W = 19,
    DCB_BCN_ATTR_RD = 20,
    DCB_BCN_ATTR_RU = 21,
    DCB_BCN_ATTR_WRTT = 22,
    DCB_BCN_ATTR_RI = 23,
    DCB_BCN_ATTR_C = 24,
    DCB_BCN_ATTR_ALL = 25,
    __DCB_BCN_ATTR_ENUM_MAX = 26,
    DCB_BCN_ATTR_MAX = 25,
};

enum dcbnl_cap_attrs {
    DCB_CAP_ATTR_UNDEFINED = 0,
    DCB_CAP_ATTR_ALL = 1,
    DCB_CAP_ATTR_PG = 2,
    DCB_CAP_ATTR_PFC = 3,
    DCB_CAP_ATTR_UP2TC = 4,
    DCB_CAP_ATTR_PG_TCS = 5,
    DCB_CAP_ATTR_PFC_TCS = 6,
    DCB_CAP_ATTR_GSP = 7,
    DCB_CAP_ATTR_BCN = 8,
    DCB_CAP_ATTR_DCBX = 9,
    __DCB_CAP_ATTR_ENUM_MAX = 10,
    DCB_CAP_ATTR_MAX = 9,
};

enum dcbnl_commands {
    DCB_CMD_UNDEFINED = 0,
    DCB_CMD_GSTATE = 1,
    DCB_CMD_SSTATE = 2,
    DCB_CMD_PGTX_GCFG = 3,
    DCB_CMD_PGTX_SCFG = 4,
    DCB_CMD_PGRX_GCFG = 5,
    DCB_CMD_PGRX_SCFG = 6,
    DCB_CMD_PFC_GCFG = 7,
    DCB_CMD_PFC_SCFG = 8,
    DCB_CMD_SET_ALL = 9,
    DCB_CMD_GPERM_HWADDR = 10,
    DCB_CMD_GCAP = 11,
    DCB_CMD_GNUMTCS = 12,
    DCB_CMD_SNUMTCS = 13,
    DCB_CMD_PFC_GSTATE = 14,
    DCB_CMD_PFC_SSTATE = 15,
    DCB_CMD_BCN_GCFG = 16,
    DCB_CMD_BCN_SCFG = 17,
    DCB_CMD_GAPP = 18,
    DCB_CMD_SAPP = 19,
    DCB_CMD_IEEE_SET = 20,
    DCB_CMD_IEEE_GET = 21,
    DCB_CMD_GDCBX = 22,
    DCB_CMD_SDCBX = 23,
    DCB_CMD_GFEATCFG = 24,
    DCB_CMD_SFEATCFG = 25,
    DCB_CMD_CEE_GET = 26,
    DCB_CMD_IEEE_DEL = 27,
    __DCB_CMD_ENUM_MAX = 28,
    DCB_CMD_MAX = 27,
};

enum dcbnl_featcfg_attrs {
    DCB_FEATCFG_ATTR_UNDEFINED = 0,
    DCB_FEATCFG_ATTR_ALL = 1,
    DCB_FEATCFG_ATTR_PG = 2,
    DCB_FEATCFG_ATTR_PFC = 3,
    DCB_FEATCFG_ATTR_APP = 4,
    __DCB_FEATCFG_ATTR_ENUM_MAX = 5,
    DCB_FEATCFG_ATTR_MAX = 4,
};

enum dcbnl_numtcs_attrs {
    DCB_NUMTCS_ATTR_UNDEFINED = 0,
    DCB_NUMTCS_ATTR_ALL = 1,
    DCB_NUMTCS_ATTR_PG = 2,
    DCB_NUMTCS_ATTR_PFC = 3,
    __DCB_NUMTCS_ATTR_ENUM_MAX = 4,
    DCB_NUMTCS_ATTR_MAX = 3,
};

enum dcbnl_pfc_up_attrs {
    DCB_PFC_UP_ATTR_UNDEFINED = 0,
    DCB_PFC_UP_ATTR_0 = 1,
    DCB_PFC_UP_ATTR_1 = 2,
    DCB_PFC_UP_ATTR_2 = 3,
    DCB_PFC_UP_ATTR_3 = 4,
    DCB_PFC_UP_ATTR_4 = 5,
    DCB_PFC_UP_ATTR_5 = 6,
    DCB_PFC_UP_ATTR_6 = 7,
    DCB_PFC_UP_ATTR_7 = 8,
    DCB_PFC_UP_ATTR_ALL = 9,
    __DCB_PFC_UP_ATTR_ENUM_MAX = 10,
    DCB_PFC_UP_ATTR_MAX = 9,
};

enum dcbnl_pg_attrs {
    DCB_PG_ATTR_UNDEFINED = 0,
    DCB_PG_ATTR_TC_0 = 1,
    DCB_PG_ATTR_TC_1 = 2,
    DCB_PG_ATTR_TC_2 = 3,
    DCB_PG_ATTR_TC_3 = 4,
    DCB_PG_ATTR_TC_4 = 5,
    DCB_PG_ATTR_TC_5 = 6,
    DCB_PG_ATTR_TC_6 = 7,
    DCB_PG_ATTR_TC_7 = 8,
    DCB_PG_ATTR_TC_MAX = 9,
    DCB_PG_ATTR_TC_ALL = 10,
    DCB_PG_ATTR_BW_ID_0 = 11,
    DCB_PG_ATTR_BW_ID_1 = 12,
    DCB_PG_ATTR_BW_ID_2 = 13,
    DCB_PG_ATTR_BW_ID_3 = 14,
    DCB_PG_ATTR_BW_ID_4 = 15,
    DCB_PG_ATTR_BW_ID_5 = 16,
    DCB_PG_ATTR_BW_ID_6 = 17,
    DCB_PG_ATTR_BW_ID_7 = 18,
    DCB_PG_ATTR_BW_ID_MAX = 19,
    DCB_PG_ATTR_BW_ID_ALL = 20,
    __DCB_PG_ATTR_ENUM_MAX = 21,
    DCB_PG_ATTR_MAX = 20,
};

enum dcbnl_tc_attrs {
    DCB_TC_ATTR_PARAM_UNDEFINED = 0,
    DCB_TC_ATTR_PARAM_PGID = 1,
    DCB_TC_ATTR_PARAM_UP_MAPPING = 2,
    DCB_TC_ATTR_PARAM_STRICT_PRIO = 3,
    DCB_TC_ATTR_PARAM_BW_PCT = 4,
    DCB_TC_ATTR_PARAM_ALL = 5,
    __DCB_TC_ATTR_PARAM_ENUM_MAX = 6,
    DCB_TC_ATTR_PARAM_MAX = 5,
};

enum dccp_state {
    DCCP_OPEN = 1,
    DCCP_REQUESTING = 2,
    DCCP_LISTEN = 10,
    DCCP_RESPOND = 3,
    DCCP_ACTIVE_CLOSEREQ = 4,
    DCCP_PASSIVE_CLOSE = 8,
    DCCP_CLOSING = 11,
    DCCP_TIME_WAIT = 6,
    DCCP_CLOSED = 7,
    DCCP_NEW_SYN_RECV = 12,
    DCCP_PARTOPEN = 14,
    DCCP_PASSIVE_CLOSEREQ = 15,
    DCCP_MAX_STATES = 16,
};

enum dd_data_dir {
    DD_READ = 0,
    DD_WRITE = 1,
};

enum dd_prio {
    DD_RT_PRIO = 0,
    DD_BE_PRIO = 1,
    DD_IDLE_PRIO = 2,
    DD_PRIO_MAX = 2,
};

enum dentry_d_lock_class {
    DENTRY_D_LOCK_NORMAL = 0,
    DENTRY_D_LOCK_NESTED = 1,
};

enum depot_counter_id {
    DEPOT_COUNTER_REFD_ALLOCS = 0,
    DEPOT_COUNTER_REFD_FREES = 1,
    DEPOT_COUNTER_REFD_INUSE = 2,
    DEPOT_COUNTER_FREELIST_SIZE = 3,
    DEPOT_COUNTER_PERSIST_COUNT = 4,
    DEPOT_COUNTER_PERSIST_BYTES = 5,
    DEPOT_COUNTER_COUNT = 6,
};

enum derived_key_type {
    ENC_KEY = 0,
    AUTH_KEY = 1,
};

enum desc_state {
    desc_miss = -1,
    desc_reserved = 0,
    desc_committed = 1,
    desc_finalized = 2,
    desc_reusable = 3,
};

enum dev_dma_attr {
    DEV_DMA_NOT_SUPPORTED = 0,
    DEV_DMA_NON_COHERENT = 1,
    DEV_DMA_COHERENT = 2,
};

enum dev_pm_opp_event {
    OPP_EVENT_ADD = 0,
    OPP_EVENT_REMOVE = 1,
    OPP_EVENT_ENABLE = 2,
    OPP_EVENT_DISABLE = 3,
    OPP_EVENT_ADJUST_VOLTAGE = 4,
};

enum dev_pm_qos_req_type {
    DEV_PM_QOS_RESUME_LATENCY = 1,
    DEV_PM_QOS_LATENCY_TOLERANCE = 2,
    DEV_PM_QOS_MIN_FREQUENCY = 3,
    DEV_PM_QOS_MAX_FREQUENCY = 4,
    DEV_PM_QOS_FLAGS = 5,
};

enum dev_prop_type {
    DEV_PROP_U8 = 0,
    DEV_PROP_U16 = 1,
    DEV_PROP_U32 = 2,
    DEV_PROP_U64 = 3,
    DEV_PROP_STRING = 4,
    DEV_PROP_REF = 5,
};

enum dev_type {
    DEV_UNKNOWN = 0,
    DEV_X1 = 1,
    DEV_X2 = 2,
    DEV_X4 = 3,
    DEV_X8 = 4,
    DEV_X16 = 5,
    DEV_X32 = 6,
    DEV_X64 = 7,
};

enum devcg_behavior {
    DEVCG_DEFAULT_NONE = 0,
    DEVCG_DEFAULT_ALLOW = 1,
    DEVCG_DEFAULT_DENY = 2,
};

enum devfreq_parent_dev_type {
    DEVFREQ_PARENT_DEV = 0,
    CPUFREQ_PARENT_DEV = 1,
};

enum devfreq_timer {
    DEVFREQ_TIMER_DEFERRABLE = 0,
    DEVFREQ_TIMER_DELAYED = 1,
    DEVFREQ_TIMER_NUM = 2,
};

enum device_link_state {
    DL_STATE_NONE = -1,
    DL_STATE_DORMANT = 0,
    DL_STATE_AVAILABLE = 1,
    DL_STATE_CONSUMER_PROBE = 2,
    DL_STATE_ACTIVE = 3,
    DL_STATE_SUPPLIER_UNBIND = 4,
};

enum device_physical_location_horizontal_position {
    DEVICE_HORI_POS_LEFT = 0,
    DEVICE_HORI_POS_CENTER = 1,
    DEVICE_HORI_POS_RIGHT = 2,
};

enum device_physical_location_panel {
    DEVICE_PANEL_TOP = 0,
    DEVICE_PANEL_BOTTOM = 1,
    DEVICE_PANEL_LEFT = 2,
    DEVICE_PANEL_RIGHT = 3,
    DEVICE_PANEL_FRONT = 4,
    DEVICE_PANEL_BACK = 5,
    DEVICE_PANEL_UNKNOWN = 6,
};

enum device_physical_location_vertical_position {
    DEVICE_VERT_POS_UPPER = 0,
    DEVICE_VERT_POS_CENTER = 1,
    DEVICE_VERT_POS_LOWER = 2,
};

enum device_removable {
    DEVICE_REMOVABLE_NOT_SUPPORTED = 0,
    DEVICE_REMOVABLE_UNKNOWN = 1,
    DEVICE_FIXED = 2,
    DEVICE_REMOVABLE = 3,
};

enum devkmsg_log_bits {
    __DEVKMSG_LOG_BIT_ON = 0,
    __DEVKMSG_LOG_BIT_OFF = 1,
    __DEVKMSG_LOG_BIT_LOCK = 2,
};

enum devkmsg_log_masks {
    DEVKMSG_LOG_MASK_ON = 1,
    DEVKMSG_LOG_MASK_OFF = 2,
    DEVKMSG_LOG_MASK_LOCK = 4,
};

enum devlink_attr {
    DEVLINK_ATTR_UNSPEC = 0,
    DEVLINK_ATTR_BUS_NAME = 1,
    DEVLINK_ATTR_DEV_NAME = 2,
    DEVLINK_ATTR_PORT_INDEX = 3,
    DEVLINK_ATTR_PORT_TYPE = 4,
    DEVLINK_ATTR_PORT_DESIRED_TYPE = 5,
    DEVLINK_ATTR_PORT_NETDEV_IFINDEX = 6,
    DEVLINK_ATTR_PORT_NETDEV_NAME = 7,
    DEVLINK_ATTR_PORT_IBDEV_NAME = 8,
    DEVLINK_ATTR_PORT_SPLIT_COUNT = 9,
    DEVLINK_ATTR_PORT_SPLIT_GROUP = 10,
    DEVLINK_ATTR_SB_INDEX = 11,
    DEVLINK_ATTR_SB_SIZE = 12,
    DEVLINK_ATTR_SB_INGRESS_POOL_COUNT = 13,
    DEVLINK_ATTR_SB_EGRESS_POOL_COUNT = 14,
    DEVLINK_ATTR_SB_INGRESS_TC_COUNT = 15,
    DEVLINK_ATTR_SB_EGRESS_TC_COUNT = 16,
    DEVLINK_ATTR_SB_POOL_INDEX = 17,
    DEVLINK_ATTR_SB_POOL_TYPE = 18,
    DEVLINK_ATTR_SB_POOL_SIZE = 19,
    DEVLINK_ATTR_SB_POOL_THRESHOLD_TYPE = 20,
    DEVLINK_ATTR_SB_THRESHOLD = 21,
    DEVLINK_ATTR_SB_TC_INDEX = 22,
    DEVLINK_ATTR_SB_OCC_CUR = 23,
    DEVLINK_ATTR_SB_OCC_MAX = 24,
    DEVLINK_ATTR_ESWITCH_MODE = 25,
    DEVLINK_ATTR_ESWITCH_INLINE_MODE = 26,
    DEVLINK_ATTR_DPIPE_TABLES = 27,
    DEVLINK_ATTR_DPIPE_TABLE = 28,
    DEVLINK_ATTR_DPIPE_TABLE_NAME = 29,
    DEVLINK_ATTR_DPIPE_TABLE_SIZE = 30,
    DEVLINK_ATTR_DPIPE_TABLE_MATCHES = 31,
    DEVLINK_ATTR_DPIPE_TABLE_ACTIONS = 32,
    DEVLINK_ATTR_DPIPE_TABLE_COUNTERS_ENABLED = 33,
    DEVLINK_ATTR_DPIPE_ENTRIES = 34,
    DEVLINK_ATTR_DPIPE_ENTRY = 35,
    DEVLINK_ATTR_DPIPE_ENTRY_INDEX = 36,
    DEVLINK_ATTR_DPIPE_ENTRY_MATCH_VALUES = 37,
    DEVLINK_ATTR_DPIPE_ENTRY_ACTION_VALUES = 38,
    DEVLINK_ATTR_DPIPE_ENTRY_COUNTER = 39,
    DEVLINK_ATTR_DPIPE_MATCH = 40,
    DEVLINK_ATTR_DPIPE_MATCH_VALUE = 41,
    DEVLINK_ATTR_DPIPE_MATCH_TYPE = 42,
    DEVLINK_ATTR_DPIPE_ACTION = 43,
    DEVLINK_ATTR_DPIPE_ACTION_VALUE = 44,
    DEVLINK_ATTR_DPIPE_ACTION_TYPE = 45,
    DEVLINK_ATTR_DPIPE_VALUE = 46,
    DEVLINK_ATTR_DPIPE_VALUE_MASK = 47,
    DEVLINK_ATTR_DPIPE_VALUE_MAPPING = 48,
    DEVLINK_ATTR_DPIPE_HEADERS = 49,
    DEVLINK_ATTR_DPIPE_HEADER = 50,
    DEVLINK_ATTR_DPIPE_HEADER_NAME = 51,
    DEVLINK_ATTR_DPIPE_HEADER_ID = 52,
    DEVLINK_ATTR_DPIPE_HEADER_FIELDS = 53,
    DEVLINK_ATTR_DPIPE_HEADER_GLOBAL = 54,
    DEVLINK_ATTR_DPIPE_HEADER_INDEX = 55,
    DEVLINK_ATTR_DPIPE_FIELD = 56,
    DEVLINK_ATTR_DPIPE_FIELD_NAME = 57,
    DEVLINK_ATTR_DPIPE_FIELD_ID = 58,
    DEVLINK_ATTR_DPIPE_FIELD_BITWIDTH = 59,
    DEVLINK_ATTR_DPIPE_FIELD_MAPPING_TYPE = 60,
    DEVLINK_ATTR_PAD = 61,
    DEVLINK_ATTR_ESWITCH_ENCAP_MODE = 62,
    DEVLINK_ATTR_RESOURCE_LIST = 63,
    DEVLINK_ATTR_RESOURCE = 64,
    DEVLINK_ATTR_RESOURCE_NAME = 65,
    DEVLINK_ATTR_RESOURCE_ID = 66,
    DEVLINK_ATTR_RESOURCE_SIZE = 67,
    DEVLINK_ATTR_RESOURCE_SIZE_NEW = 68,
    DEVLINK_ATTR_RESOURCE_SIZE_VALID = 69,
    DEVLINK_ATTR_RESOURCE_SIZE_MIN = 70,
    DEVLINK_ATTR_RESOURCE_SIZE_MAX = 71,
    DEVLINK_ATTR_RESOURCE_SIZE_GRAN = 72,
    DEVLINK_ATTR_RESOURCE_UNIT = 73,
    DEVLINK_ATTR_RESOURCE_OCC = 74,
    DEVLINK_ATTR_DPIPE_TABLE_RESOURCE_ID = 75,
    DEVLINK_ATTR_DPIPE_TABLE_RESOURCE_UNITS = 76,
    DEVLINK_ATTR_PORT_FLAVOUR = 77,
    DEVLINK_ATTR_PORT_NUMBER = 78,
    DEVLINK_ATTR_PORT_SPLIT_SUBPORT_NUMBER = 79,
    DEVLINK_ATTR_PARAM = 80,
    DEVLINK_ATTR_PARAM_NAME = 81,
    DEVLINK_ATTR_PARAM_GENERIC = 82,
    DEVLINK_ATTR_PARAM_TYPE = 83,
    DEVLINK_ATTR_PARAM_VALUES_LIST = 84,
    DEVLINK_ATTR_PARAM_VALUE = 85,
    DEVLINK_ATTR_PARAM_VALUE_DATA = 86,
    DEVLINK_ATTR_PARAM_VALUE_CMODE = 87,
    DEVLINK_ATTR_REGION_NAME = 88,
    DEVLINK_ATTR_REGION_SIZE = 89,
    DEVLINK_ATTR_REGION_SNAPSHOTS = 90,
    DEVLINK_ATTR_REGION_SNAPSHOT = 91,
    DEVLINK_ATTR_REGION_SNAPSHOT_ID = 92,
    DEVLINK_ATTR_REGION_CHUNKS = 93,
    DEVLINK_ATTR_REGION_CHUNK = 94,
    DEVLINK_ATTR_REGION_CHUNK_DATA = 95,
    DEVLINK_ATTR_REGION_CHUNK_ADDR = 96,
    DEVLINK_ATTR_REGION_CHUNK_LEN = 97,
    DEVLINK_ATTR_INFO_DRIVER_NAME = 98,
    DEVLINK_ATTR_INFO_SERIAL_NUMBER = 99,
    DEVLINK_ATTR_INFO_VERSION_FIXED = 100,
    DEVLINK_ATTR_INFO_VERSION_RUNNING = 101,
    DEVLINK_ATTR_INFO_VERSION_STORED = 102,
    DEVLINK_ATTR_INFO_VERSION_NAME = 103,
    DEVLINK_ATTR_INFO_VERSION_VALUE = 104,
    DEVLINK_ATTR_SB_POOL_CELL_SIZE = 105,
    DEVLINK_ATTR_FMSG = 106,
    DEVLINK_ATTR_FMSG_OBJ_NEST_START = 107,
    DEVLINK_ATTR_FMSG_PAIR_NEST_START = 108,
    DEVLINK_ATTR_FMSG_ARR_NEST_START = 109,
    DEVLINK_ATTR_FMSG_NEST_END = 110,
    DEVLINK_ATTR_FMSG_OBJ_NAME = 111,
    DEVLINK_ATTR_FMSG_OBJ_VALUE_TYPE = 112,
    DEVLINK_ATTR_FMSG_OBJ_VALUE_DATA = 113,
    DEVLINK_ATTR_HEALTH_REPORTER = 114,
    DEVLINK_ATTR_HEALTH_REPORTER_NAME = 115,
    DEVLINK_ATTR_HEALTH_REPORTER_STATE = 116,
    DEVLINK_ATTR_HEALTH_REPORTER_ERR_COUNT = 117,
    DEVLINK_ATTR_HEALTH_REPORTER_RECOVER_COUNT = 118,
    DEVLINK_ATTR_HEALTH_REPORTER_DUMP_TS = 119,
    DEVLINK_ATTR_HEALTH_REPORTER_GRACEFUL_PERIOD = 120,
    DEVLINK_ATTR_HEALTH_REPORTER_AUTO_RECOVER = 121,
    DEVLINK_ATTR_FLASH_UPDATE_FILE_NAME = 122,
    DEVLINK_ATTR_FLASH_UPDATE_COMPONENT = 123,
    DEVLINK_ATTR_FLASH_UPDATE_STATUS_MSG = 124,
    DEVLINK_ATTR_FLASH_UPDATE_STATUS_DONE = 125,
    DEVLINK_ATTR_FLASH_UPDATE_STATUS_TOTAL = 126,
    DEVLINK_ATTR_PORT_PCI_PF_NUMBER = 127,
    DEVLINK_ATTR_PORT_PCI_VF_NUMBER = 128,
    DEVLINK_ATTR_STATS = 129,
    DEVLINK_ATTR_TRAP_NAME = 130,
    DEVLINK_ATTR_TRAP_ACTION = 131,
    DEVLINK_ATTR_TRAP_TYPE = 132,
    DEVLINK_ATTR_TRAP_GENERIC = 133,
    DEVLINK_ATTR_TRAP_METADATA = 134,
    DEVLINK_ATTR_TRAP_GROUP_NAME = 135,
    DEVLINK_ATTR_RELOAD_FAILED = 136,
    DEVLINK_ATTR_HEALTH_REPORTER_DUMP_TS_NS = 137,
    DEVLINK_ATTR_NETNS_FD = 138,
    DEVLINK_ATTR_NETNS_PID = 139,
    DEVLINK_ATTR_NETNS_ID = 140,
    DEVLINK_ATTR_HEALTH_REPORTER_AUTO_DUMP = 141,
    DEVLINK_ATTR_TRAP_POLICER_ID = 142,
    DEVLINK_ATTR_TRAP_POLICER_RATE = 143,
    DEVLINK_ATTR_TRAP_POLICER_BURST = 144,
    DEVLINK_ATTR_PORT_FUNCTION = 145,
    DEVLINK_ATTR_INFO_BOARD_SERIAL_NUMBER = 146,
    DEVLINK_ATTR_PORT_LANES = 147,
    DEVLINK_ATTR_PORT_SPLITTABLE = 148,
    DEVLINK_ATTR_PORT_EXTERNAL = 149,
    DEVLINK_ATTR_PORT_CONTROLLER_NUMBER = 150,
    DEVLINK_ATTR_FLASH_UPDATE_STATUS_TIMEOUT = 151,
    DEVLINK_ATTR_FLASH_UPDATE_OVERWRITE_MASK = 152,
    DEVLINK_ATTR_RELOAD_ACTION = 153,
    DEVLINK_ATTR_RELOAD_ACTIONS_PERFORMED = 154,
    DEVLINK_ATTR_RELOAD_LIMITS = 155,
    DEVLINK_ATTR_DEV_STATS = 156,
    DEVLINK_ATTR_RELOAD_STATS = 157,
    DEVLINK_ATTR_RELOAD_STATS_ENTRY = 158,
    DEVLINK_ATTR_RELOAD_STATS_LIMIT = 159,
    DEVLINK_ATTR_RELOAD_STATS_VALUE = 160,
    DEVLINK_ATTR_REMOTE_RELOAD_STATS = 161,
    DEVLINK_ATTR_RELOAD_ACTION_INFO = 162,
    DEVLINK_ATTR_RELOAD_ACTION_STATS = 163,
    DEVLINK_ATTR_PORT_PCI_SF_NUMBER = 164,
    DEVLINK_ATTR_RATE_TYPE = 165,
    DEVLINK_ATTR_RATE_TX_SHARE = 166,
    DEVLINK_ATTR_RATE_TX_MAX = 167,
    DEVLINK_ATTR_RATE_NODE_NAME = 168,
    DEVLINK_ATTR_RATE_PARENT_NODE_NAME = 169,
    DEVLINK_ATTR_REGION_MAX_SNAPSHOTS = 170,
    DEVLINK_ATTR_LINECARD_INDEX = 171,
    DEVLINK_ATTR_LINECARD_STATE = 172,
    DEVLINK_ATTR_LINECARD_TYPE = 173,
    DEVLINK_ATTR_LINECARD_SUPPORTED_TYPES = 174,
    DEVLINK_ATTR_NESTED_DEVLINK = 175,
    DEVLINK_ATTR_SELFTESTS = 176,
    DEVLINK_ATTR_RATE_TX_PRIORITY = 177,
    DEVLINK_ATTR_RATE_TX_WEIGHT = 178,
    DEVLINK_ATTR_REGION_DIRECT = 179,
    __DEVLINK_ATTR_MAX = 180,
    DEVLINK_ATTR_MAX = 179,
};

enum devlink_attr_selftest_id {
    DEVLINK_ATTR_SELFTEST_ID_UNSPEC = 0,
    DEVLINK_ATTR_SELFTEST_ID_FLASH = 1,
    __DEVLINK_ATTR_SELFTEST_ID_MAX = 2,
    DEVLINK_ATTR_SELFTEST_ID_MAX = 1,
};

enum devlink_attr_selftest_result {
    DEVLINK_ATTR_SELFTEST_RESULT_UNSPEC = 0,
    DEVLINK_ATTR_SELFTEST_RESULT = 1,
    DEVLINK_ATTR_SELFTEST_RESULT_ID = 2,
    DEVLINK_ATTR_SELFTEST_RESULT_STATUS = 3,
    __DEVLINK_ATTR_SELFTEST_RESULT_MAX = 4,
    DEVLINK_ATTR_SELFTEST_RESULT_MAX = 3,
};

enum devlink_command {
    DEVLINK_CMD_UNSPEC = 0,
    DEVLINK_CMD_GET = 1,
    DEVLINK_CMD_SET = 2,
    DEVLINK_CMD_NEW = 3,
    DEVLINK_CMD_DEL = 4,
    DEVLINK_CMD_PORT_GET = 5,
    DEVLINK_CMD_PORT_SET = 6,
    DEVLINK_CMD_PORT_NEW = 7,
    DEVLINK_CMD_PORT_DEL = 8,
    DEVLINK_CMD_PORT_SPLIT = 9,
    DEVLINK_CMD_PORT_UNSPLIT = 10,
    DEVLINK_CMD_SB_GET = 11,
    DEVLINK_CMD_SB_SET = 12,
    DEVLINK_CMD_SB_NEW = 13,
    DEVLINK_CMD_SB_DEL = 14,
    DEVLINK_CMD_SB_POOL_GET = 15,
    DEVLINK_CMD_SB_POOL_SET = 16,
    DEVLINK_CMD_SB_POOL_NEW = 17,
    DEVLINK_CMD_SB_POOL_DEL = 18,
    DEVLINK_CMD_SB_PORT_POOL_GET = 19,
    DEVLINK_CMD_SB_PORT_POOL_SET = 20,
    DEVLINK_CMD_SB_PORT_POOL_NEW = 21,
    DEVLINK_CMD_SB_PORT_POOL_DEL = 22,
    DEVLINK_CMD_SB_TC_POOL_BIND_GET = 23,
    DEVLINK_CMD_SB_TC_POOL_BIND_SET = 24,
    DEVLINK_CMD_SB_TC_POOL_BIND_NEW = 25,
    DEVLINK_CMD_SB_TC_POOL_BIND_DEL = 26,
    DEVLINK_CMD_SB_OCC_SNAPSHOT = 27,
    DEVLINK_CMD_SB_OCC_MAX_CLEAR = 28,
    DEVLINK_CMD_ESWITCH_GET = 29,
    DEVLINK_CMD_ESWITCH_SET = 30,
    DEVLINK_CMD_DPIPE_TABLE_GET = 31,
    DEVLINK_CMD_DPIPE_ENTRIES_GET = 32,
    DEVLINK_CMD_DPIPE_HEADERS_GET = 33,
    DEVLINK_CMD_DPIPE_TABLE_COUNTERS_SET = 34,
    DEVLINK_CMD_RESOURCE_SET = 35,
    DEVLINK_CMD_RESOURCE_DUMP = 36,
    DEVLINK_CMD_RELOAD = 37,
    DEVLINK_CMD_PARAM_GET = 38,
    DEVLINK_CMD_PARAM_SET = 39,
    DEVLINK_CMD_PARAM_NEW = 40,
    DEVLINK_CMD_PARAM_DEL = 41,
    DEVLINK_CMD_REGION_GET = 42,
    DEVLINK_CMD_REGION_SET = 43,
    DEVLINK_CMD_REGION_NEW = 44,
    DEVLINK_CMD_REGION_DEL = 45,
    DEVLINK_CMD_REGION_READ = 46,
    DEVLINK_CMD_PORT_PARAM_GET = 47,
    DEVLINK_CMD_PORT_PARAM_SET = 48,
    DEVLINK_CMD_PORT_PARAM_NEW = 49,
    DEVLINK_CMD_PORT_PARAM_DEL = 50,
    DEVLINK_CMD_INFO_GET = 51,
    DEVLINK_CMD_HEALTH_REPORTER_GET = 52,
    DEVLINK_CMD_HEALTH_REPORTER_SET = 53,
    DEVLINK_CMD_HEALTH_REPORTER_RECOVER = 54,
    DEVLINK_CMD_HEALTH_REPORTER_DIAGNOSE = 55,
    DEVLINK_CMD_HEALTH_REPORTER_DUMP_GET = 56,
    DEVLINK_CMD_HEALTH_REPORTER_DUMP_CLEAR = 57,
    DEVLINK_CMD_FLASH_UPDATE = 58,
    DEVLINK_CMD_FLASH_UPDATE_END = 59,
    DEVLINK_CMD_FLASH_UPDATE_STATUS = 60,
    DEVLINK_CMD_TRAP_GET = 61,
    DEVLINK_CMD_TRAP_SET = 62,
    DEVLINK_CMD_TRAP_NEW = 63,
    DEVLINK_CMD_TRAP_DEL = 64,
    DEVLINK_CMD_TRAP_GROUP_GET = 65,
    DEVLINK_CMD_TRAP_GROUP_SET = 66,
    DEVLINK_CMD_TRAP_GROUP_NEW = 67,
    DEVLINK_CMD_TRAP_GROUP_DEL = 68,
    DEVLINK_CMD_TRAP_POLICER_GET = 69,
    DEVLINK_CMD_TRAP_POLICER_SET = 70,
    DEVLINK_CMD_TRAP_POLICER_NEW = 71,
    DEVLINK_CMD_TRAP_POLICER_DEL = 72,
    DEVLINK_CMD_HEALTH_REPORTER_TEST = 73,
    DEVLINK_CMD_RATE_GET = 74,
    DEVLINK_CMD_RATE_SET = 75,
    DEVLINK_CMD_RATE_NEW = 76,
    DEVLINK_CMD_RATE_DEL = 77,
    DEVLINK_CMD_LINECARD_GET = 78,
    DEVLINK_CMD_LINECARD_SET = 79,
    DEVLINK_CMD_LINECARD_NEW = 80,
    DEVLINK_CMD_LINECARD_DEL = 81,
    DEVLINK_CMD_SELFTESTS_GET = 82,
    DEVLINK_CMD_SELFTESTS_RUN = 83,
    DEVLINK_CMD_NOTIFY_FILTER_SET = 84,
    __DEVLINK_CMD_MAX = 85,
    DEVLINK_CMD_MAX = 84,
};

enum devlink_dpipe_action_type {
    DEVLINK_DPIPE_ACTION_TYPE_FIELD_MODIFY = 0,
};

enum devlink_dpipe_field_ethernet_id {
    DEVLINK_DPIPE_FIELD_ETHERNET_DST_MAC = 0,
};

enum devlink_dpipe_field_ipv4_id {
    DEVLINK_DPIPE_FIELD_IPV4_DST_IP = 0,
};

enum devlink_dpipe_field_ipv6_id {
    DEVLINK_DPIPE_FIELD_IPV6_DST_IP = 0,
};

enum devlink_dpipe_field_mapping_type {
    DEVLINK_DPIPE_FIELD_MAPPING_TYPE_NONE = 0,
    DEVLINK_DPIPE_FIELD_MAPPING_TYPE_IFINDEX = 1,
};

enum devlink_dpipe_header_id {
    DEVLINK_DPIPE_HEADER_ETHERNET = 0,
    DEVLINK_DPIPE_HEADER_IPV4 = 1,
    DEVLINK_DPIPE_HEADER_IPV6 = 2,
};

enum devlink_dpipe_match_type {
    DEVLINK_DPIPE_MATCH_TYPE_FIELD_EXACT = 0,
};

enum devlink_eswitch_encap_mode {
    DEVLINK_ESWITCH_ENCAP_MODE_NONE = 0,
    DEVLINK_ESWITCH_ENCAP_MODE_BASIC = 1,
};

enum devlink_health_reporter_state {
    DEVLINK_HEALTH_REPORTER_STATE_HEALTHY = 0,
    DEVLINK_HEALTH_REPORTER_STATE_ERROR = 1,
};

enum devlink_info_version_type {
    DEVLINK_INFO_VERSION_TYPE_NONE = 0,
    DEVLINK_INFO_VERSION_TYPE_COMPONENT = 1,
};

enum devlink_linecard_state {
    DEVLINK_LINECARD_STATE_UNSPEC = 0,
    DEVLINK_LINECARD_STATE_UNPROVISIONED = 1,
    DEVLINK_LINECARD_STATE_UNPROVISIONING = 2,
    DEVLINK_LINECARD_STATE_PROVISIONING = 3,
    DEVLINK_LINECARD_STATE_PROVISIONING_FAILED = 4,
    DEVLINK_LINECARD_STATE_PROVISIONED = 5,
    DEVLINK_LINECARD_STATE_ACTIVE = 6,
    __DEVLINK_LINECARD_STATE_MAX = 7,
    DEVLINK_LINECARD_STATE_MAX = 6,
};

enum devlink_multicast_groups {
    DEVLINK_MCGRP_CONFIG = 0,
};

enum devlink_param_cmode {
    DEVLINK_PARAM_CMODE_RUNTIME = 0,
    DEVLINK_PARAM_CMODE_DRIVERINIT = 1,
    DEVLINK_PARAM_CMODE_PERMANENT = 2,
    __DEVLINK_PARAM_CMODE_MAX = 3,
    DEVLINK_PARAM_CMODE_MAX = 2,
};

enum devlink_param_generic_id {
    DEVLINK_PARAM_GENERIC_ID_INT_ERR_RESET = 0,
    DEVLINK_PARAM_GENERIC_ID_MAX_MACS = 1,
    DEVLINK_PARAM_GENERIC_ID_ENABLE_SRIOV = 2,
    DEVLINK_PARAM_GENERIC_ID_REGION_SNAPSHOT = 3,
    DEVLINK_PARAM_GENERIC_ID_IGNORE_ARI = 4,
    DEVLINK_PARAM_GENERIC_ID_MSIX_VEC_PER_PF_MAX = 5,
    DEVLINK_PARAM_GENERIC_ID_MSIX_VEC_PER_PF_MIN = 6,
    DEVLINK_PARAM_GENERIC_ID_FW_LOAD_POLICY = 7,
    DEVLINK_PARAM_GENERIC_ID_RESET_DEV_ON_DRV_PROBE = 8,
    DEVLINK_PARAM_GENERIC_ID_ENABLE_ROCE = 9,
    DEVLINK_PARAM_GENERIC_ID_ENABLE_REMOTE_DEV_RESET = 10,
    DEVLINK_PARAM_GENERIC_ID_ENABLE_ETH = 11,
    DEVLINK_PARAM_GENERIC_ID_ENABLE_RDMA = 12,
    DEVLINK_PARAM_GENERIC_ID_ENABLE_VNET = 13,
    DEVLINK_PARAM_GENERIC_ID_ENABLE_IWARP = 14,
    DEVLINK_PARAM_GENERIC_ID_IO_EQ_SIZE = 15,
    DEVLINK_PARAM_GENERIC_ID_EVENT_EQ_SIZE = 16,
    __DEVLINK_PARAM_GENERIC_ID_MAX = 17,
    DEVLINK_PARAM_GENERIC_ID_MAX = 16,
};

enum devlink_param_type {
    DEVLINK_PARAM_TYPE_U8 = 0,
    DEVLINK_PARAM_TYPE_U16 = 1,
    DEVLINK_PARAM_TYPE_U32 = 2,
    DEVLINK_PARAM_TYPE_STRING = 3,
    DEVLINK_PARAM_TYPE_BOOL = 4,
};

enum devlink_port_flavour {
    DEVLINK_PORT_FLAVOUR_PHYSICAL = 0,
    DEVLINK_PORT_FLAVOUR_CPU = 1,
    DEVLINK_PORT_FLAVOUR_DSA = 2,
    DEVLINK_PORT_FLAVOUR_PCI_PF = 3,
    DEVLINK_PORT_FLAVOUR_PCI_VF = 4,
    DEVLINK_PORT_FLAVOUR_VIRTUAL = 5,
    DEVLINK_PORT_FLAVOUR_UNUSED = 6,
    DEVLINK_PORT_FLAVOUR_PCI_SF = 7,
};

enum devlink_port_fn_attr_cap {
    DEVLINK_PORT_FN_ATTR_CAP_ROCE_BIT = 0,
    DEVLINK_PORT_FN_ATTR_CAP_MIGRATABLE_BIT = 1,
    DEVLINK_PORT_FN_ATTR_CAP_IPSEC_CRYPTO_BIT = 2,
    DEVLINK_PORT_FN_ATTR_CAP_IPSEC_PACKET_BIT = 3,
    __DEVLINK_PORT_FN_ATTR_CAPS_MAX = 4,
};

enum devlink_port_fn_opstate {
    DEVLINK_PORT_FN_OPSTATE_DETACHED = 0,
    DEVLINK_PORT_FN_OPSTATE_ATTACHED = 1,
};

enum devlink_port_fn_state {
    DEVLINK_PORT_FN_STATE_INACTIVE = 0,
    DEVLINK_PORT_FN_STATE_ACTIVE = 1,
};

enum devlink_port_function_attr {
    DEVLINK_PORT_FUNCTION_ATTR_UNSPEC = 0,
    DEVLINK_PORT_FUNCTION_ATTR_HW_ADDR = 1,
    DEVLINK_PORT_FN_ATTR_STATE = 2,
    DEVLINK_PORT_FN_ATTR_OPSTATE = 3,
    DEVLINK_PORT_FN_ATTR_CAPS = 4,
    DEVLINK_PORT_FN_ATTR_DEVLINK = 5,
    DEVLINK_PORT_FN_ATTR_MAX_IO_EQS = 6,
    __DEVLINK_PORT_FUNCTION_ATTR_MAX = 7,
    DEVLINK_PORT_FUNCTION_ATTR_MAX = 6,
};

enum devlink_port_type {
    DEVLINK_PORT_TYPE_NOTSET = 0,
    DEVLINK_PORT_TYPE_AUTO = 1,
    DEVLINK_PORT_TYPE_ETH = 2,
    DEVLINK_PORT_TYPE_IB = 3,
};

enum devlink_rate_type {
    DEVLINK_RATE_TYPE_LEAF = 0,
    DEVLINK_RATE_TYPE_NODE = 1,
};

enum devlink_reload_action {
    DEVLINK_RELOAD_ACTION_UNSPEC = 0,
    DEVLINK_RELOAD_ACTION_DRIVER_REINIT = 1,
    DEVLINK_RELOAD_ACTION_FW_ACTIVATE = 2,
    __DEVLINK_RELOAD_ACTION_MAX = 3,
    DEVLINK_RELOAD_ACTION_MAX = 2,
};

enum devlink_reload_limit {
    DEVLINK_RELOAD_LIMIT_UNSPEC = 0,
    DEVLINK_RELOAD_LIMIT_NO_RESET = 1,
    __DEVLINK_RELOAD_LIMIT_MAX = 2,
    DEVLINK_RELOAD_LIMIT_MAX = 1,
};

enum devlink_resource_unit {
    DEVLINK_RESOURCE_UNIT_ENTRY = 0,
};

enum devlink_sb_pool_type {
    DEVLINK_SB_POOL_TYPE_INGRESS = 0,
    DEVLINK_SB_POOL_TYPE_EGRESS = 1,
};

enum devlink_sb_threshold_type {
    DEVLINK_SB_THRESHOLD_TYPE_STATIC = 0,
    DEVLINK_SB_THRESHOLD_TYPE_DYNAMIC = 1,
};

enum devlink_selftest_status {
    DEVLINK_SELFTEST_STATUS_SKIP = 0,
    DEVLINK_SELFTEST_STATUS_PASS = 1,
    DEVLINK_SELFTEST_STATUS_FAIL = 2,
};

enum devlink_trap_action {
    DEVLINK_TRAP_ACTION_DROP = 0,
    DEVLINK_TRAP_ACTION_TRAP = 1,
    DEVLINK_TRAP_ACTION_MIRROR = 2,
};

enum devlink_trap_generic_id {
    DEVLINK_TRAP_GENERIC_ID_SMAC_MC = 0,
    DEVLINK_TRAP_GENERIC_ID_VLAN_TAG_MISMATCH = 1,
    DEVLINK_TRAP_GENERIC_ID_INGRESS_VLAN_FILTER = 2,
    DEVLINK_TRAP_GENERIC_ID_INGRESS_STP_FILTER = 3,
    DEVLINK_TRAP_GENERIC_ID_EMPTY_TX_LIST = 4,
    DEVLINK_TRAP_GENERIC_ID_PORT_LOOPBACK_FILTER = 5,
    DEVLINK_TRAP_GENERIC_ID_BLACKHOLE_ROUTE = 6,
    DEVLINK_TRAP_GENERIC_ID_TTL_ERROR = 7,
    DEVLINK_TRAP_GENERIC_ID_TAIL_DROP = 8,
    DEVLINK_TRAP_GENERIC_ID_NON_IP_PACKET = 9,
    DEVLINK_TRAP_GENERIC_ID_UC_DIP_MC_DMAC = 10,
    DEVLINK_TRAP_GENERIC_ID_DIP_LB = 11,
    DEVLINK_TRAP_GENERIC_ID_SIP_MC = 12,
    DEVLINK_TRAP_GENERIC_ID_SIP_LB = 13,
    DEVLINK_TRAP_GENERIC_ID_CORRUPTED_IP_HDR = 14,
    DEVLINK_TRAP_GENERIC_ID_IPV4_SIP_BC = 15,
    DEVLINK_TRAP_GENERIC_ID_IPV6_MC_DIP_RESERVED_SCOPE = 16,
    DEVLINK_TRAP_GENERIC_ID_IPV6_MC_DIP_INTERFACE_LOCAL_SCOPE = 17,
    DEVLINK_TRAP_GENERIC_ID_MTU_ERROR = 18,
    DEVLINK_TRAP_GENERIC_ID_UNRESOLVED_NEIGH = 19,
    DEVLINK_TRAP_GENERIC_ID_RPF = 20,
    DEVLINK_TRAP_GENERIC_ID_REJECT_ROUTE = 21,
    DEVLINK_TRAP_GENERIC_ID_IPV4_LPM_UNICAST_MISS = 22,
    DEVLINK_TRAP_GENERIC_ID_IPV6_LPM_UNICAST_MISS = 23,
    DEVLINK_TRAP_GENERIC_ID_NON_ROUTABLE = 24,
    DEVLINK_TRAP_GENERIC_ID_DECAP_ERROR = 25,
    DEVLINK_TRAP_GENERIC_ID_OVERLAY_SMAC_MC = 26,
    DEVLINK_TRAP_GENERIC_ID_INGRESS_FLOW_ACTION_DROP = 27,
    DEVLINK_TRAP_GENERIC_ID_EGRESS_FLOW_ACTION_DROP = 28,
    DEVLINK_TRAP_GENERIC_ID_STP = 29,
    DEVLINK_TRAP_GENERIC_ID_LACP = 30,
    DEVLINK_TRAP_GENERIC_ID_LLDP = 31,
    DEVLINK_TRAP_GENERIC_ID_IGMP_QUERY = 32,
    DEVLINK_TRAP_GENERIC_ID_IGMP_V1_REPORT = 33,
    DEVLINK_TRAP_GENERIC_ID_IGMP_V2_REPORT = 34,
    DEVLINK_TRAP_GENERIC_ID_IGMP_V3_REPORT = 35,
    DEVLINK_TRAP_GENERIC_ID_IGMP_V2_LEAVE = 36,
    DEVLINK_TRAP_GENERIC_ID_MLD_QUERY = 37,
    DEVLINK_TRAP_GENERIC_ID_MLD_V1_REPORT = 38,
    DEVLINK_TRAP_GENERIC_ID_MLD_V2_REPORT = 39,
    DEVLINK_TRAP_GENERIC_ID_MLD_V1_DONE = 40,
    DEVLINK_TRAP_GENERIC_ID_IPV4_DHCP = 41,
    DEVLINK_TRAP_GENERIC_ID_IPV6_DHCP = 42,
    DEVLINK_TRAP_GENERIC_ID_ARP_REQUEST = 43,
    DEVLINK_TRAP_GENERIC_ID_ARP_RESPONSE = 44,
    DEVLINK_TRAP_GENERIC_ID_ARP_OVERLAY = 45,
    DEVLINK_TRAP_GENERIC_ID_IPV6_NEIGH_SOLICIT = 46,
    DEVLINK_TRAP_GENERIC_ID_IPV6_NEIGH_ADVERT = 47,
    DEVLINK_TRAP_GENERIC_ID_IPV4_BFD = 48,
    DEVLINK_TRAP_GENERIC_ID_IPV6_BFD = 49,
    DEVLINK_TRAP_GENERIC_ID_IPV4_OSPF = 50,
    DEVLINK_TRAP_GENERIC_ID_IPV6_OSPF = 51,
    DEVLINK_TRAP_GENERIC_ID_IPV4_BGP = 52,
    DEVLINK_TRAP_GENERIC_ID_IPV6_BGP = 53,
    DEVLINK_TRAP_GENERIC_ID_IPV4_VRRP = 54,
    DEVLINK_TRAP_GENERIC_ID_IPV6_VRRP = 55,
    DEVLINK_TRAP_GENERIC_ID_IPV4_PIM = 56,
    DEVLINK_TRAP_GENERIC_ID_IPV6_PIM = 57,
    DEVLINK_TRAP_GENERIC_ID_UC_LB = 58,
    DEVLINK_TRAP_GENERIC_ID_LOCAL_ROUTE = 59,
    DEVLINK_TRAP_GENERIC_ID_EXTERNAL_ROUTE = 60,
    DEVLINK_TRAP_GENERIC_ID_IPV6_UC_DIP_LINK_LOCAL_SCOPE = 61,
    DEVLINK_TRAP_GENERIC_ID_IPV6_DIP_ALL_NODES = 62,
    DEVLINK_TRAP_GENERIC_ID_IPV6_DIP_ALL_ROUTERS = 63,
    DEVLINK_TRAP_GENERIC_ID_IPV6_ROUTER_SOLICIT = 64,
    DEVLINK_TRAP_GENERIC_ID_IPV6_ROUTER_ADVERT = 65,
    DEVLINK_TRAP_GENERIC_ID_IPV6_REDIRECT = 66,
    DEVLINK_TRAP_GENERIC_ID_IPV4_ROUTER_ALERT = 67,
    DEVLINK_TRAP_GENERIC_ID_IPV6_ROUTER_ALERT = 68,
    DEVLINK_TRAP_GENERIC_ID_PTP_EVENT = 69,
    DEVLINK_TRAP_GENERIC_ID_PTP_GENERAL = 70,
    DEVLINK_TRAP_GENERIC_ID_FLOW_ACTION_SAMPLE = 71,
    DEVLINK_TRAP_GENERIC_ID_FLOW_ACTION_TRAP = 72,
    DEVLINK_TRAP_GENERIC_ID_EARLY_DROP = 73,
    DEVLINK_TRAP_GENERIC_ID_VXLAN_PARSING = 74,
    DEVLINK_TRAP_GENERIC_ID_LLC_SNAP_PARSING = 75,
    DEVLINK_TRAP_GENERIC_ID_VLAN_PARSING = 76,
    DEVLINK_TRAP_GENERIC_ID_PPPOE_PPP_PARSING = 77,
    DEVLINK_TRAP_GENERIC_ID_MPLS_PARSING = 78,
    DEVLINK_TRAP_GENERIC_ID_ARP_PARSING = 79,
    DEVLINK_TRAP_GENERIC_ID_IP_1_PARSING = 80,
    DEVLINK_TRAP_GENERIC_ID_IP_N_PARSING = 81,
    DEVLINK_TRAP_GENERIC_ID_GRE_PARSING = 82,
    DEVLINK_TRAP_GENERIC_ID_UDP_PARSING = 83,
    DEVLINK_TRAP_GENERIC_ID_TCP_PARSING = 84,
    DEVLINK_TRAP_GENERIC_ID_IPSEC_PARSING = 85,
    DEVLINK_TRAP_GENERIC_ID_SCTP_PARSING = 86,
    DEVLINK_TRAP_GENERIC_ID_DCCP_PARSING = 87,
    DEVLINK_TRAP_GENERIC_ID_GTP_PARSING = 88,
    DEVLINK_TRAP_GENERIC_ID_ESP_PARSING = 89,
    DEVLINK_TRAP_GENERIC_ID_BLACKHOLE_NEXTHOP = 90,
    DEVLINK_TRAP_GENERIC_ID_DMAC_FILTER = 91,
    DEVLINK_TRAP_GENERIC_ID_EAPOL = 92,
    DEVLINK_TRAP_GENERIC_ID_LOCKED_PORT = 93,
    __DEVLINK_TRAP_GENERIC_ID_MAX = 94,
    DEVLINK_TRAP_GENERIC_ID_MAX = 93,
};

enum devlink_trap_group_generic_id {
    DEVLINK_TRAP_GROUP_GENERIC_ID_L2_DROPS = 0,
    DEVLINK_TRAP_GROUP_GENERIC_ID_L3_DROPS = 1,
    DEVLINK_TRAP_GROUP_GENERIC_ID_L3_EXCEPTIONS = 2,
    DEVLINK_TRAP_GROUP_GENERIC_ID_BUFFER_DROPS = 3,
    DEVLINK_TRAP_GROUP_GENERIC_ID_TUNNEL_DROPS = 4,
    DEVLINK_TRAP_GROUP_GENERIC_ID_ACL_DROPS = 5,
    DEVLINK_TRAP_GROUP_GENERIC_ID_STP = 6,
    DEVLINK_TRAP_GROUP_GENERIC_ID_LACP = 7,
    DEVLINK_TRAP_GROUP_GENERIC_ID_LLDP = 8,
    DEVLINK_TRAP_GROUP_GENERIC_ID_MC_SNOOPING = 9,
    DEVLINK_TRAP_GROUP_GENERIC_ID_DHCP = 10,
    DEVLINK_TRAP_GROUP_GENERIC_ID_NEIGH_DISCOVERY = 11,
    DEVLINK_TRAP_GROUP_GENERIC_ID_BFD = 12,
    DEVLINK_TRAP_GROUP_GENERIC_ID_OSPF = 13,
    DEVLINK_TRAP_GROUP_GENERIC_ID_BGP = 14,
    DEVLINK_TRAP_GROUP_GENERIC_ID_VRRP = 15,
    DEVLINK_TRAP_GROUP_GENERIC_ID_PIM = 16,
    DEVLINK_TRAP_GROUP_GENERIC_ID_UC_LB = 17,
    DEVLINK_TRAP_GROUP_GENERIC_ID_LOCAL_DELIVERY = 18,
    DEVLINK_TRAP_GROUP_GENERIC_ID_EXTERNAL_DELIVERY = 19,
    DEVLINK_TRAP_GROUP_GENERIC_ID_IPV6 = 20,
    DEVLINK_TRAP_GROUP_GENERIC_ID_PTP_EVENT = 21,
    DEVLINK_TRAP_GROUP_GENERIC_ID_PTP_GENERAL = 22,
    DEVLINK_TRAP_GROUP_GENERIC_ID_ACL_SAMPLE = 23,
    DEVLINK_TRAP_GROUP_GENERIC_ID_ACL_TRAP = 24,
    DEVLINK_TRAP_GROUP_GENERIC_ID_PARSER_ERROR_DROPS = 25,
    DEVLINK_TRAP_GROUP_GENERIC_ID_EAPOL = 26,
    __DEVLINK_TRAP_GROUP_GENERIC_ID_MAX = 27,
    DEVLINK_TRAP_GROUP_GENERIC_ID_MAX = 26,
};

enum devlink_trap_type {
    DEVLINK_TRAP_TYPE_DROP = 0,
    DEVLINK_TRAP_TYPE_EXCEPTION = 1,
    DEVLINK_TRAP_TYPE_CONTROL = 2,
};

enum devm_ioremap_type {
    DEVM_IOREMAP = 0,
    DEVM_IOREMAP_UC = 1,
    DEVM_IOREMAP_WC = 2,
    DEVM_IOREMAP_NP = 3,
};

enum dfa_accept_flags {
    ACCEPT_FLAG_OWNER = 1,
};

enum die_val {
    DIE_UNUSED = 0,
    DIE_OOPS = 1,
};

enum digest_type {
    DIGEST_TYPE_IMA = 0,
    DIGEST_TYPE_VERITY = 1,
    DIGEST_TYPE__LAST = 2,
};

enum dim_cq_period_mode {
    DIM_CQ_PERIOD_MODE_START_FROM_EQE = 0,
    DIM_CQ_PERIOD_MODE_START_FROM_CQE = 1,
    DIM_CQ_PERIOD_NUM_MODES = 2,
};

enum dim_state {
    DIM_START_MEASURE = 0,
    DIM_MEASURE_IN_PROGRESS = 1,
    DIM_APPLY_NEW_PROFILE = 2,
};

enum dim_stats_state {
    DIM_STATS_WORSE = 0,
    DIM_STATS_SAME = 1,
    DIM_STATS_BETTER = 2,
};

enum dim_step_result {
    DIM_STEPPED = 0,
    DIM_TOO_TIRED = 1,
    DIM_ON_EDGE = 2,
};

enum dim_tune_state {
    DIM_PARKING_ON_TOP = 0,
    DIM_PARKING_TIRED = 1,
    DIM_GOING_RIGHT = 2,
    DIM_GOING_LEFT = 3,
};

enum display_flags {
    DISPLAY_FLAGS_HSYNC_LOW = 1,
    DISPLAY_FLAGS_HSYNC_HIGH = 2,
    DISPLAY_FLAGS_VSYNC_LOW = 4,
    DISPLAY_FLAGS_VSYNC_HIGH = 8,
    DISPLAY_FLAGS_DE_LOW = 16,
    DISPLAY_FLAGS_DE_HIGH = 32,
    DISPLAY_FLAGS_PIXDATA_POSEDGE = 64,
    DISPLAY_FLAGS_PIXDATA_NEGEDGE = 128,
    DISPLAY_FLAGS_INTERLACED = 256,
    DISPLAY_FLAGS_DOUBLESCAN = 512,
    DISPLAY_FLAGS_DOUBLECLK = 1024,
    DISPLAY_FLAGS_SYNC_POSEDGE = 2048,
    DISPLAY_FLAGS_SYNC_NEGEDGE = 4096,
};

enum dl_bw_request {
    dl_bw_req_deactivate = 0,
    dl_bw_req_alloc = 1,
    dl_bw_req_free = 2,
};

enum dl_dev_state {
    DL_DEV_NO_DRIVER = 0,
    DL_DEV_PROBING = 1,
    DL_DEV_DRIVER_BOUND = 2,
    DL_DEV_UNBINDING = 3,
};

enum dl_param {
    DL_RUNTIME = 0,
    DL_PERIOD = 1,
};

enum dma_ctrl_flags {
    DMA_PREP_INTERRUPT = 1,
    DMA_CTRL_ACK = 2,
    DMA_PREP_PQ_DISABLE_P = 4,
    DMA_PREP_PQ_DISABLE_Q = 8,
    DMA_PREP_CONTINUE = 16,
    DMA_PREP_FENCE = 32,
    DMA_CTRL_REUSE = 64,
    DMA_PREP_CMD = 128,
    DMA_PREP_REPEAT = 256,
    DMA_PREP_LOAD_EOT = 512,
};

enum dma_data_direction {
    DMA_BIDIRECTIONAL = 0,
    DMA_TO_DEVICE = 1,
    DMA_FROM_DEVICE = 2,
    DMA_NONE = 3,
};

enum dma_desc_metadata_mode {
    DESC_METADATA_NONE = 0,
    DESC_METADATA_CLIENT = 1,
    DESC_METADATA_ENGINE = 2,
};

enum dma_fence_flag_bits {
    DMA_FENCE_FLAG_SIGNALED_BIT = 0,
    DMA_FENCE_FLAG_TIMESTAMP_BIT = 1,
    DMA_FENCE_FLAG_ENABLE_SIGNAL_BIT = 2,
    DMA_FENCE_FLAG_USER_BITS = 3,
};

enum dma_reg {
    DMA_RING_CFG = 0,
    DMA_CTRL = 1,
    DMA_STATUS = 2,
    DMA_SCB_BURST_SIZE = 3,
    DMA_ARB_CTRL = 4,
    DMA_PRIORITY_0 = 5,
    DMA_PRIORITY_1 = 6,
    DMA_PRIORITY_2 = 7,
    DMA_INDEX2RING_0 = 8,
    DMA_INDEX2RING_1 = 9,
    DMA_INDEX2RING_2 = 10,
    DMA_INDEX2RING_3 = 11,
    DMA_INDEX2RING_4 = 12,
    DMA_INDEX2RING_5 = 13,
    DMA_INDEX2RING_6 = 14,
    DMA_INDEX2RING_7 = 15,
    DMA_RING0_TIMEOUT = 16,
    DMA_RING1_TIMEOUT = 17,
    DMA_RING2_TIMEOUT = 18,
    DMA_RING3_TIMEOUT = 19,
    DMA_RING4_TIMEOUT = 20,
    DMA_RING5_TIMEOUT = 21,
    DMA_RING6_TIMEOUT = 22,
    DMA_RING7_TIMEOUT = 23,
    DMA_RING8_TIMEOUT = 24,
    DMA_RING9_TIMEOUT = 25,
    DMA_RING10_TIMEOUT = 26,
    DMA_RING11_TIMEOUT = 27,
    DMA_RING12_TIMEOUT = 28,
    DMA_RING13_TIMEOUT = 29,
    DMA_RING14_TIMEOUT = 30,
    DMA_RING15_TIMEOUT = 31,
    DMA_RING16_TIMEOUT = 32,
};

enum dma_residue_granularity {
    DMA_RESIDUE_GRANULARITY_DESCRIPTOR = 0,
    DMA_RESIDUE_GRANULARITY_SEGMENT = 1,
    DMA_RESIDUE_GRANULARITY_BURST = 2,
};

enum dma_resv_usage {
    DMA_RESV_USAGE_KERNEL = 0,
    DMA_RESV_USAGE_WRITE = 1,
    DMA_RESV_USAGE_READ = 2,
    DMA_RESV_USAGE_BOOKKEEP = 3,
};

enum dma_ring_reg {
    TDMA_READ_PTR = 0,
    RDMA_WRITE_PTR = 0,
    TDMA_READ_PTR_HI = 1,
    RDMA_WRITE_PTR_HI = 1,
    TDMA_CONS_INDEX = 2,
    RDMA_PROD_INDEX = 2,
    TDMA_PROD_INDEX = 3,
    RDMA_CONS_INDEX = 3,
    DMA_RING_BUF_SIZE = 4,
    DMA_START_ADDR = 5,
    DMA_START_ADDR_HI = 6,
    DMA_END_ADDR = 7,
    DMA_END_ADDR_HI = 8,
    DMA_MBUF_DONE_THRESH = 9,
    TDMA_FLOW_PERIOD = 10,
    RDMA_XON_XOFF_THRESH = 10,
    TDMA_WRITE_PTR = 11,
    RDMA_READ_PTR = 11,
    TDMA_WRITE_PTR_HI = 12,
    RDMA_READ_PTR_HI = 12,
};

enum dma_slave_buswidth {
    DMA_SLAVE_BUSWIDTH_UNDEFINED = 0,
    DMA_SLAVE_BUSWIDTH_1_BYTE = 1,
    DMA_SLAVE_BUSWIDTH_2_BYTES = 2,
    DMA_SLAVE_BUSWIDTH_3_BYTES = 3,
    DMA_SLAVE_BUSWIDTH_4_BYTES = 4,
    DMA_SLAVE_BUSWIDTH_8_BYTES = 8,
    DMA_SLAVE_BUSWIDTH_16_BYTES = 16,
    DMA_SLAVE_BUSWIDTH_32_BYTES = 32,
    DMA_SLAVE_BUSWIDTH_64_BYTES = 64,
    DMA_SLAVE_BUSWIDTH_128_BYTES = 128,
};

enum dma_status {
    DMA_COMPLETE = 0,
    DMA_IN_PROGRESS = 1,
    DMA_PAUSED = 2,
    DMA_ERROR = 3,
    DMA_OUT_OF_ORDER = 4,
};

enum dma_transaction_type {
    DMA_MEMCPY = 0,
    DMA_XOR = 1,
    DMA_PQ = 2,
    DMA_XOR_VAL = 3,
    DMA_PQ_VAL = 4,
    DMA_MEMSET = 5,
    DMA_MEMSET_SG = 6,
    DMA_INTERRUPT = 7,
    DMA_PRIVATE = 8,
    DMA_ASYNC_TX = 9,
    DMA_SLAVE = 10,
    DMA_CYCLIC = 11,
    DMA_INTERLEAVE = 12,
    DMA_COMPLETION_NO_ORDER = 13,
    DMA_REPEAT = 14,
    DMA_LOAD_EOT = 15,
    DMA_TX_TYPE_END = 16,
};

enum dma_transfer_direction {
    DMA_MEM_TO_MEM = 0,
    DMA_MEM_TO_DEV = 1,
    DMA_DEV_TO_MEM = 2,
    DMA_DEV_TO_DEV = 3,
    DMA_TRANS_NONE = 4,
};

enum dmaengine_alignment {
    DMAENGINE_ALIGN_1_BYTE = 0,
    DMAENGINE_ALIGN_2_BYTES = 1,
    DMAENGINE_ALIGN_4_BYTES = 2,
    DMAENGINE_ALIGN_8_BYTES = 3,
    DMAENGINE_ALIGN_16_BYTES = 4,
    DMAENGINE_ALIGN_32_BYTES = 5,
    DMAENGINE_ALIGN_64_BYTES = 6,
    DMAENGINE_ALIGN_128_BYTES = 7,
    DMAENGINE_ALIGN_256_BYTES = 8,
};

enum dmaengine_tx_result {
    DMA_TRANS_NOERROR = 0,
    DMA_TRANS_READ_FAILED = 1,
    DMA_TRANS_WRITE_FAILED = 2,
    DMA_TRANS_ABORTED = 3,
};

enum dmi_device_type {
    DMI_DEV_TYPE_ANY = 0,
    DMI_DEV_TYPE_OTHER = 1,
    DMI_DEV_TYPE_UNKNOWN = 2,
    DMI_DEV_TYPE_VIDEO = 3,
    DMI_DEV_TYPE_SCSI = 4,
    DMI_DEV_TYPE_ETHERNET = 5,
    DMI_DEV_TYPE_TOKENRING = 6,
    DMI_DEV_TYPE_SOUND = 7,
    DMI_DEV_TYPE_PATA = 8,
    DMI_DEV_TYPE_SATA = 9,
    DMI_DEV_TYPE_SAS = 10,
    DMI_DEV_TYPE_IPMI = -1,
    DMI_DEV_TYPE_OEM_STRING = -2,
    DMI_DEV_TYPE_DEV_ONBOARD = -3,
    DMI_DEV_TYPE_DEV_SLOT = -4,
};

enum dmi_entry_type {
    DMI_ENTRY_BIOS = 0,
    DMI_ENTRY_SYSTEM = 1,
    DMI_ENTRY_BASEBOARD = 2,
    DMI_ENTRY_CHASSIS = 3,
    DMI_ENTRY_PROCESSOR = 4,
    DMI_ENTRY_MEM_CONTROLLER = 5,
    DMI_ENTRY_MEM_MODULE = 6,
    DMI_ENTRY_CACHE = 7,
    DMI_ENTRY_PORT_CONNECTOR = 8,
    DMI_ENTRY_SYSTEM_SLOT = 9,
    DMI_ENTRY_ONBOARD_DEVICE = 10,
    DMI_ENTRY_OEMSTRINGS = 11,
    DMI_ENTRY_SYSCONF = 12,
    DMI_ENTRY_BIOS_LANG = 13,
    DMI_ENTRY_GROUP_ASSOC = 14,
    DMI_ENTRY_SYSTEM_EVENT_LOG = 15,
    DMI_ENTRY_PHYS_MEM_ARRAY = 16,
    DMI_ENTRY_MEM_DEVICE = 17,
    DMI_ENTRY_32_MEM_ERROR = 18,
    DMI_ENTRY_MEM_ARRAY_MAPPED_ADDR = 19,
    DMI_ENTRY_MEM_DEV_MAPPED_ADDR = 20,
    DMI_ENTRY_BUILTIN_POINTING_DEV = 21,
    DMI_ENTRY_PORTABLE_BATTERY = 22,
    DMI_ENTRY_SYSTEM_RESET = 23,
    DMI_ENTRY_HW_SECURITY = 24,
    DMI_ENTRY_SYSTEM_POWER_CONTROLS = 25,
    DMI_ENTRY_VOLTAGE_PROBE = 26,
    DMI_ENTRY_COOLING_DEV = 27,
    DMI_ENTRY_TEMP_PROBE = 28,
    DMI_ENTRY_ELECTRICAL_CURRENT_PROBE = 29,
    DMI_ENTRY_OOB_REMOTE_ACCESS = 30,
    DMI_ENTRY_BIS_ENTRY = 31,
    DMI_ENTRY_SYSTEM_BOOT = 32,
    DMI_ENTRY_MGMT_DEV = 33,
    DMI_ENTRY_MGMT_DEV_COMPONENT = 34,
    DMI_ENTRY_MGMT_DEV_THRES = 35,
    DMI_ENTRY_MEM_CHANNEL = 36,
    DMI_ENTRY_IPMI_DEV = 37,
    DMI_ENTRY_SYS_POWER_SUPPLY = 38,
    DMI_ENTRY_ADDITIONAL = 39,
    DMI_ENTRY_ONBOARD_DEV_EXT = 40,
    DMI_ENTRY_MGMT_CONTROLLER_HOST = 41,
    DMI_ENTRY_INACTIVE = 126,
    DMI_ENTRY_END_OF_TABLE = 127,
};

enum dmi_field {
    DMI_NONE = 0,
    DMI_BIOS_VENDOR = 1,
    DMI_BIOS_VERSION = 2,
    DMI_BIOS_DATE = 3,
    DMI_BIOS_RELEASE = 4,
    DMI_EC_FIRMWARE_RELEASE = 5,
    DMI_SYS_VENDOR = 6,
    DMI_PRODUCT_NAME = 7,
    DMI_PRODUCT_VERSION = 8,
    DMI_PRODUCT_SERIAL = 9,
    DMI_PRODUCT_UUID = 10,
    DMI_PRODUCT_SKU = 11,
    DMI_PRODUCT_FAMILY = 12,
    DMI_BOARD_VENDOR = 13,
    DMI_BOARD_NAME = 14,
    DMI_BOARD_VERSION = 15,
    DMI_BOARD_SERIAL = 16,
    DMI_BOARD_ASSET_TAG = 17,
    DMI_CHASSIS_VENDOR = 18,
    DMI_CHASSIS_TYPE = 19,
    DMI_CHASSIS_VERSION = 20,
    DMI_CHASSIS_SERIAL = 21,
    DMI_CHASSIS_ASSET_TAG = 22,
    DMI_STRING_MAX = 23,
    DMI_OEM_STRING = 24,
};

enum dns_lookup_status {
    DNS_LOOKUP_NOT_DONE = 0,
    DNS_LOOKUP_GOOD = 1,
    DNS_LOOKUP_GOOD_WITH_BAD = 2,
    DNS_LOOKUP_BAD = 3,
    DNS_LOOKUP_GOT_NOT_FOUND = 4,
    DNS_LOOKUP_GOT_LOCAL_FAILURE = 5,
    DNS_LOOKUP_GOT_TEMP_FAILURE = 6,
    DNS_LOOKUP_GOT_NS_FAILURE = 7,
    NR__dns_lookup_status = 8,
};

enum dns_payload_content_type {
    DNS_PAYLOAD_IS_SERVER_LIST = 0,
};

enum dpll_a {
    DPLL_A_ID = 1,
    DPLL_A_MODULE_NAME = 2,
    DPLL_A_PAD = 3,
    DPLL_A_CLOCK_ID = 4,
    DPLL_A_MODE = 5,
    DPLL_A_MODE_SUPPORTED = 6,
    DPLL_A_LOCK_STATUS = 7,
    DPLL_A_TEMP = 8,
    DPLL_A_TYPE = 9,
    DPLL_A_LOCK_STATUS_ERROR = 10,
    DPLL_A_CLOCK_QUALITY_LEVEL = 11,
    __DPLL_A_MAX = 12,
    DPLL_A_MAX = 11,
};

enum dpll_a_pin {
    DPLL_A_PIN_ID = 1,
    DPLL_A_PIN_PARENT_ID = 2,
    DPLL_A_PIN_MODULE_NAME = 3,
    DPLL_A_PIN_PAD = 4,
    DPLL_A_PIN_CLOCK_ID = 5,
    DPLL_A_PIN_BOARD_LABEL = 6,
    DPLL_A_PIN_PANEL_LABEL = 7,
    DPLL_A_PIN_PACKAGE_LABEL = 8,
    DPLL_A_PIN_TYPE = 9,
    DPLL_A_PIN_DIRECTION = 10,
    DPLL_A_PIN_FREQUENCY = 11,
    DPLL_A_PIN_FREQUENCY_SUPPORTED = 12,
    DPLL_A_PIN_FREQUENCY_MIN = 13,
    DPLL_A_PIN_FREQUENCY_MAX = 14,
    DPLL_A_PIN_PRIO = 15,
    DPLL_A_PIN_STATE = 16,
    DPLL_A_PIN_CAPABILITIES = 17,
    DPLL_A_PIN_PARENT_DEVICE = 18,
    DPLL_A_PIN_PARENT_PIN = 19,
    DPLL_A_PIN_PHASE_ADJUST_MIN = 20,
    DPLL_A_PIN_PHASE_ADJUST_MAX = 21,
    DPLL_A_PIN_PHASE_ADJUST = 22,
    DPLL_A_PIN_PHASE_OFFSET = 23,
    DPLL_A_PIN_FRACTIONAL_FREQUENCY_OFFSET = 24,
    DPLL_A_PIN_ESYNC_FREQUENCY = 25,
    DPLL_A_PIN_ESYNC_FREQUENCY_SUPPORTED = 26,
    DPLL_A_PIN_ESYNC_PULSE = 27,
    __DPLL_A_PIN_MAX = 28,
    DPLL_A_PIN_MAX = 27,
};

enum dpll_clock_quality_level {
    DPLL_CLOCK_QUALITY_LEVEL_ITU_OPT1_PRC = 1,
    DPLL_CLOCK_QUALITY_LEVEL_ITU_OPT1_SSU_A = 2,
    DPLL_CLOCK_QUALITY_LEVEL_ITU_OPT1_SSU_B = 3,
    DPLL_CLOCK_QUALITY_LEVEL_ITU_OPT1_EEC1 = 4,
    DPLL_CLOCK_QUALITY_LEVEL_ITU_OPT1_PRTC = 5,
    DPLL_CLOCK_QUALITY_LEVEL_ITU_OPT1_EPRTC = 6,
    DPLL_CLOCK_QUALITY_LEVEL_ITU_OPT1_EEEC = 7,
    DPLL_CLOCK_QUALITY_LEVEL_ITU_OPT1_EPRC = 8,
    __DPLL_CLOCK_QUALITY_LEVEL_MAX = 9,
    DPLL_CLOCK_QUALITY_LEVEL_MAX = 8,
};

enum dpll_cmd {
    DPLL_CMD_DEVICE_ID_GET = 1,
    DPLL_CMD_DEVICE_GET = 2,
    DPLL_CMD_DEVICE_SET = 3,
    DPLL_CMD_DEVICE_CREATE_NTF = 4,
    DPLL_CMD_DEVICE_DELETE_NTF = 5,
    DPLL_CMD_DEVICE_CHANGE_NTF = 6,
    DPLL_CMD_PIN_ID_GET = 7,
    DPLL_CMD_PIN_GET = 8,
    DPLL_CMD_PIN_SET = 9,
    DPLL_CMD_PIN_CREATE_NTF = 10,
    DPLL_CMD_PIN_DELETE_NTF = 11,
    DPLL_CMD_PIN_CHANGE_NTF = 12,
    __DPLL_CMD_MAX = 13,
    DPLL_CMD_MAX = 12,
};

enum dpll_lock_status {
    DPLL_LOCK_STATUS_UNLOCKED = 1,
    DPLL_LOCK_STATUS_LOCKED = 2,
    DPLL_LOCK_STATUS_LOCKED_HO_ACQ = 3,
    DPLL_LOCK_STATUS_HOLDOVER = 4,
    __DPLL_LOCK_STATUS_MAX = 5,
    DPLL_LOCK_STATUS_MAX = 4,
};

enum dpll_lock_status_error {
    DPLL_LOCK_STATUS_ERROR_NONE = 1,
    DPLL_LOCK_STATUS_ERROR_UNDEFINED = 2,
    DPLL_LOCK_STATUS_ERROR_MEDIA_DOWN = 3,
    DPLL_LOCK_STATUS_ERROR_FRACTIONAL_FREQUENCY_OFFSET_TOO_HIGH = 4,
    __DPLL_LOCK_STATUS_ERROR_MAX = 5,
    DPLL_LOCK_STATUS_ERROR_MAX = 4,
};

enum dpll_mode {
    DPLL_MODE_MANUAL = 1,
    DPLL_MODE_AUTOMATIC = 2,
    __DPLL_MODE_MAX = 3,
    DPLL_MODE_MAX = 2,
};

enum dpll_pin_capabilities {
    DPLL_PIN_CAPABILITIES_DIRECTION_CAN_CHANGE = 1,
    DPLL_PIN_CAPABILITIES_PRIORITY_CAN_CHANGE = 2,
    DPLL_PIN_CAPABILITIES_STATE_CAN_CHANGE = 4,
};

enum dpll_pin_direction {
    DPLL_PIN_DIRECTION_INPUT = 1,
    DPLL_PIN_DIRECTION_OUTPUT = 2,
    __DPLL_PIN_DIRECTION_MAX = 3,
    DPLL_PIN_DIRECTION_MAX = 2,
};

enum dpll_pin_state {
    DPLL_PIN_STATE_CONNECTED = 1,
    DPLL_PIN_STATE_DISCONNECTED = 2,
    DPLL_PIN_STATE_SELECTABLE = 3,
    __DPLL_PIN_STATE_MAX = 4,
    DPLL_PIN_STATE_MAX = 3,
};

enum dpll_pin_type {
    DPLL_PIN_TYPE_MUX = 1,
    DPLL_PIN_TYPE_EXT = 2,
    DPLL_PIN_TYPE_SYNCE_ETH_PORT = 3,
    DPLL_PIN_TYPE_INT_OSCILLATOR = 4,
    DPLL_PIN_TYPE_GNSS = 5,
    __DPLL_PIN_TYPE_MAX = 6,
    DPLL_PIN_TYPE_MAX = 5,
};

enum dpll_type {
    DPLL_TYPE_PPS = 1,
    DPLL_TYPE_EEC = 2,
    __DPLL_TYPE_MAX = 3,
    DPLL_TYPE_MAX = 2,
};

enum dpm_order {
    DPM_ORDER_NONE = 0,
    DPM_ORDER_DEV_AFTER_PARENT = 1,
    DPM_ORDER_PARENT_BEFORE_DEV = 2,
    DPM_ORDER_DEV_LAST = 3,
};

enum drbg_prefixes {
    DRBG_PREFIX0 = 0,
    DRBG_PREFIX1 = 1,
    DRBG_PREFIX2 = 2,
    DRBG_PREFIX3 = 3,
};

enum drbg_seed_state {
    DRBG_SEED_STATE_UNSEEDED = 0,
    DRBG_SEED_STATE_PARTIAL = 1,
    DRBG_SEED_STATE_FULL = 2,
};

enum drm_bridge_attach_flags {
    DRM_BRIDGE_ATTACH_NO_CONNECTOR = 1,
};

enum drm_bridge_ops {
    DRM_BRIDGE_OP_DETECT = 1,
    DRM_BRIDGE_OP_EDID = 2,
    DRM_BRIDGE_OP_HPD = 4,
    DRM_BRIDGE_OP_MODES = 8,
    DRM_BRIDGE_OP_HDMI = 16,
};

enum drm_bus_flags {
    DRM_BUS_FLAG_DE_LOW = 1,
    DRM_BUS_FLAG_DE_HIGH = 2,
    DRM_BUS_FLAG_PIXDATA_DRIVE_POSEDGE = 4,
    DRM_BUS_FLAG_PIXDATA_DRIVE_NEGEDGE = 8,
    DRM_BUS_FLAG_PIXDATA_SAMPLE_POSEDGE = 8,
    DRM_BUS_FLAG_PIXDATA_SAMPLE_NEGEDGE = 4,
    DRM_BUS_FLAG_DATA_MSB_TO_LSB = 16,
    DRM_BUS_FLAG_DATA_LSB_TO_MSB = 32,
    DRM_BUS_FLAG_SYNC_DRIVE_POSEDGE = 64,
    DRM_BUS_FLAG_SYNC_DRIVE_NEGEDGE = 128,
    DRM_BUS_FLAG_SYNC_SAMPLE_POSEDGE = 128,
    DRM_BUS_FLAG_SYNC_SAMPLE_NEGEDGE = 64,
    DRM_BUS_FLAG_SHARP_SIGNALS = 256,
};

enum drm_color_encoding {
    DRM_COLOR_YCBCR_BT601 = 0,
    DRM_COLOR_YCBCR_BT709 = 1,
    DRM_COLOR_YCBCR_BT2020 = 2,
    DRM_COLOR_ENCODING_MAX = 3,
};

enum drm_color_lut_tests {
    DRM_COLOR_LUT_EQUAL_CHANNELS = 1,
    DRM_COLOR_LUT_NON_DECREASING = 2,
};

enum drm_color_range {
    DRM_COLOR_YCBCR_LIMITED_RANGE = 0,
    DRM_COLOR_YCBCR_FULL_RANGE = 1,
    DRM_COLOR_RANGE_MAX = 2,
};

enum drm_colorspace {
    DRM_MODE_COLORIMETRY_DEFAULT = 0,
    DRM_MODE_COLORIMETRY_NO_DATA = 0,
    DRM_MODE_COLORIMETRY_SMPTE_170M_YCC = 1,
    DRM_MODE_COLORIMETRY_BT709_YCC = 2,
    DRM_MODE_COLORIMETRY_XVYCC_601 = 3,
    DRM_MODE_COLORIMETRY_XVYCC_709 = 4,
    DRM_MODE_COLORIMETRY_SYCC_601 = 5,
    DRM_MODE_COLORIMETRY_OPYCC_601 = 6,
    DRM_MODE_COLORIMETRY_OPRGB = 7,
    DRM_MODE_COLORIMETRY_BT2020_CYCC = 8,
    DRM_MODE_COLORIMETRY_BT2020_RGB = 9,
    DRM_MODE_COLORIMETRY_BT2020_YCC = 10,
    DRM_MODE_COLORIMETRY_DCI_P3_RGB_D65 = 11,
    DRM_MODE_COLORIMETRY_DCI_P3_RGB_THEATER = 12,
    DRM_MODE_COLORIMETRY_RGB_WIDE_FIXED = 13,
    DRM_MODE_COLORIMETRY_RGB_WIDE_FLOAT = 14,
    DRM_MODE_COLORIMETRY_BT601_YCC = 15,
    DRM_MODE_COLORIMETRY_COUNT = 16,
};

enum drm_connector_force {
    DRM_FORCE_UNSPECIFIED = 0,
    DRM_FORCE_OFF = 1,
    DRM_FORCE_ON = 2,
    DRM_FORCE_ON_DIGITAL = 3,
};

enum drm_connector_registration_state {
    DRM_CONNECTOR_INITIALIZING = 0,
    DRM_CONNECTOR_REGISTERED = 1,
    DRM_CONNECTOR_UNREGISTERED = 2,
};

enum drm_connector_status {
    connector_status_connected = 1,
    connector_status_disconnected = 2,
    connector_status_unknown = 3,
};

enum drm_connector_tv_mode {
    DRM_MODE_TV_MODE_NTSC = 0,
    DRM_MODE_TV_MODE_NTSC_443 = 1,
    DRM_MODE_TV_MODE_NTSC_J = 2,
    DRM_MODE_TV_MODE_PAL = 3,
    DRM_MODE_TV_MODE_PAL_M = 4,
    DRM_MODE_TV_MODE_PAL_N = 5,
    DRM_MODE_TV_MODE_SECAM = 6,
    DRM_MODE_TV_MODE_MONOCHROME = 7,
    DRM_MODE_TV_MODE_MAX = 8,
};

enum drm_debug_category {
    DRM_UT_CORE = 0,
    DRM_UT_DRIVER = 1,
    DRM_UT_KMS = 2,
    DRM_UT_PRIME = 3,
    DRM_UT_ATOMIC = 4,
    DRM_UT_VBL = 5,
    DRM_UT_STATE = 6,
    DRM_UT_LEASE = 7,
    DRM_UT_DP = 8,
    DRM_UT_DRMRES = 9,
};

enum drm_driver_feature {
    DRIVER_GEM = 1,
    DRIVER_MODESET = 2,
    DRIVER_RENDER = 8,
    DRIVER_ATOMIC = 16,
    DRIVER_SYNCOBJ = 32,
    DRIVER_SYNCOBJ_TIMELINE = 64,
    DRIVER_COMPUTE_ACCEL = 128,
    DRIVER_GEM_GPUVA = 256,
    DRIVER_CURSOR_HOTSPOT = 512,
    DRIVER_USE_AGP = 33554432,
    DRIVER_LEGACY = 67108864,
    DRIVER_PCI_DMA = 134217728,
    DRIVER_SG = 268435456,
    DRIVER_HAVE_DMA = 536870912,
    DRIVER_HAVE_IRQ = 1073741824,
};

enum drm_gem_object_status {
    DRM_GEM_OBJECT_RESIDENT = 1,
    DRM_GEM_OBJECT_PURGEABLE = 2,
    DRM_GEM_OBJECT_ACTIVE = 4,
};

enum drm_gpuva_flags {
    DRM_GPUVA_INVALIDATED = 1,
    DRM_GPUVA_SPARSE = 2,
    DRM_GPUVA_USERBITS = 4,
};

enum drm_gpuva_op_type {
    DRM_GPUVA_OP_MAP = 0,
    DRM_GPUVA_OP_REMAP = 1,
    DRM_GPUVA_OP_UNMAP = 2,
    DRM_GPUVA_OP_PREFETCH = 3,
};

enum drm_gpuvm_flags {
    DRM_GPUVM_RESV_PROTECTED = 1,
    DRM_GPUVM_USERBITS = 2,
};

enum drm_hdmi_broadcast_rgb {
    DRM_HDMI_BROADCAST_RGB_AUTO = 0,
    DRM_HDMI_BROADCAST_RGB_FULL = 1,
    DRM_HDMI_BROADCAST_RGB_LIMITED = 2,
};

enum drm_ioctl_flags {
    DRM_AUTH = 1,
    DRM_MASTER = 2,
    DRM_ROOT_ONLY = 4,
    DRM_RENDER_ALLOW = 32,
};

enum drm_link_status {
    DRM_LINK_STATUS_GOOD = 0,
    DRM_LINK_STATUS_BAD = 1,
};

enum drm_lvds_dual_link_pixels {
    DRM_LVDS_DUAL_LINK_EVEN_ODD_PIXELS = 0,
    DRM_LVDS_DUAL_LINK_ODD_EVEN_PIXELS = 1,
};

enum drm_minor_type {
    DRM_MINOR_PRIMARY = 0,
    DRM_MINOR_CONTROL = 1,
    DRM_MINOR_RENDER = 2,
    DRM_MINOR_ACCEL = 32,
};

enum drm_mm_insert_mode {
    DRM_MM_INSERT_BEST = 0,
    DRM_MM_INSERT_LOW = 1,
    DRM_MM_INSERT_HIGH = 2,
    DRM_MM_INSERT_EVICT = 3,
    DRM_MM_INSERT_ONCE = 2147483648,
    DRM_MM_INSERT_HIGHEST = 2147483650,
    DRM_MM_INSERT_LOWEST = 2147483649,
};

enum drm_mode_analog {
    DRM_MODE_ANALOG_NTSC = 0,
    DRM_MODE_ANALOG_PAL = 1,
};

enum drm_mode_status {
    MODE_OK = 0,
    MODE_HSYNC = 1,
    MODE_VSYNC = 2,
    MODE_H_ILLEGAL = 3,
    MODE_V_ILLEGAL = 4,
    MODE_BAD_WIDTH = 5,
    MODE_NOMODE = 6,
    MODE_NO_INTERLACE = 7,
    MODE_NO_DBLESCAN = 8,
    MODE_NO_VSCAN = 9,
    MODE_MEM = 10,
    MODE_VIRTUAL_X = 11,
    MODE_VIRTUAL_Y = 12,
    MODE_MEM_VIRT = 13,
    MODE_NOCLOCK = 14,
    MODE_CLOCK_HIGH = 15,
    MODE_CLOCK_LOW = 16,
    MODE_CLOCK_RANGE = 17,
    MODE_BAD_HVALUE = 18,
    MODE_BAD_VVALUE = 19,
    MODE_BAD_VSCAN = 20,
    MODE_HSYNC_NARROW = 21,
    MODE_HSYNC_WIDE = 22,
    MODE_HBLANK_NARROW = 23,
    MODE_HBLANK_WIDE = 24,
    MODE_VSYNC_NARROW = 25,
    MODE_VSYNC_WIDE = 26,
    MODE_VBLANK_NARROW = 27,
    MODE_VBLANK_WIDE = 28,
    MODE_PANEL = 29,
    MODE_INTERLACE_WIDTH = 30,
    MODE_ONE_WIDTH = 31,
    MODE_ONE_HEIGHT = 32,
    MODE_ONE_SIZE = 33,
    MODE_NO_REDUCED = 34,
    MODE_NO_STEREO = 35,
    MODE_NO_420 = 36,
    MODE_STALE = -3,
    MODE_BAD = -2,
    MODE_ERROR = -1,
};

enum drm_mode_subconnector {
    DRM_MODE_SUBCONNECTOR_Automatic = 0,
    DRM_MODE_SUBCONNECTOR_Unknown = 0,
    DRM_MODE_SUBCONNECTOR_VGA = 1,
    DRM_MODE_SUBCONNECTOR_DVID = 3,
    DRM_MODE_SUBCONNECTOR_DVIA = 4,
    DRM_MODE_SUBCONNECTOR_Composite = 5,
    DRM_MODE_SUBCONNECTOR_SVIDEO = 6,
    DRM_MODE_SUBCONNECTOR_Component = 8,
    DRM_MODE_SUBCONNECTOR_SCART = 9,
    DRM_MODE_SUBCONNECTOR_DisplayPort = 10,
    DRM_MODE_SUBCONNECTOR_HDMIA = 11,
    DRM_MODE_SUBCONNECTOR_Native = 15,
    DRM_MODE_SUBCONNECTOR_Wireless = 18,
};

enum drm_of_lvds_pixels {
    DRM_OF_LVDS_EVEN = 1,
    DRM_OF_LVDS_ODD = 2,
};

enum drm_panel_orientation {
    DRM_MODE_PANEL_ORIENTATION_UNKNOWN = -1,
    DRM_MODE_PANEL_ORIENTATION_NORMAL = 0,
    DRM_MODE_PANEL_ORIENTATION_BOTTOM_UP = 1,
    DRM_MODE_PANEL_ORIENTATION_LEFT_UP = 2,
    DRM_MODE_PANEL_ORIENTATION_RIGHT_UP = 3,
};

enum drm_plane_type {
    DRM_PLANE_TYPE_OVERLAY = 0,
    DRM_PLANE_TYPE_PRIMARY = 1,
    DRM_PLANE_TYPE_CURSOR = 2,
};

enum drm_privacy_screen_status {
    PRIVACY_SCREEN_DISABLED = 0,
    PRIVACY_SCREEN_ENABLED = 1,
    PRIVACY_SCREEN_DISABLED_LOCKED = 2,
    PRIVACY_SCREEN_ENABLED_LOCKED = 3,
};

enum drm_scaling_filter {
    DRM_SCALING_FILTER_DEFAULT = 0,
    DRM_SCALING_FILTER_NEAREST_NEIGHBOR = 1,
};

enum drm_stat_type {
    _DRM_STAT_LOCK = 0,
    _DRM_STAT_OPENS = 1,
    _DRM_STAT_CLOSES = 2,
    _DRM_STAT_IOCTLS = 3,
    _DRM_STAT_LOCKS = 4,
    _DRM_STAT_UNLOCKS = 5,
    _DRM_STAT_VALUE = 6,
    _DRM_STAT_BYTE = 7,
    _DRM_STAT_COUNT = 8,
    _DRM_STAT_IRQ = 9,
    _DRM_STAT_PRIMARY = 10,
    _DRM_STAT_SECONDARY = 11,
    _DRM_STAT_DMA = 12,
    _DRM_STAT_SPECIAL = 13,
    _DRM_STAT_MISSED = 14,
};

enum drm_vblank_seq_type {
    _DRM_VBLANK_ABSOLUTE = 0,
    _DRM_VBLANK_RELATIVE = 1,
    _DRM_VBLANK_HIGH_CRTC_MASK = 62,
    _DRM_VBLANK_EVENT = 67108864,
    _DRM_VBLANK_FLIP = 134217728,
    _DRM_VBLANK_NEXTONMISS = 268435456,
    _DRM_VBLANK_SECONDARY = 536870912,
    _DRM_VBLANK_SIGNAL = 1073741824,
};

enum dsa_db_type {
    DSA_DB_PORT = 0,
    DSA_DB_LAG = 1,
    DSA_DB_BRIDGE = 2,
};

enum dsa_tag_protocol {
    DSA_TAG_PROTO_NONE = 0,
    DSA_TAG_PROTO_BRCM = 1,
    DSA_TAG_PROTO_BRCM_LEGACY = 22,
    DSA_TAG_PROTO_BRCM_PREPEND = 2,
    DSA_TAG_PROTO_DSA = 3,
    DSA_TAG_PROTO_EDSA = 4,
    DSA_TAG_PROTO_GSWIP = 5,
    DSA_TAG_PROTO_KSZ9477 = 6,
    DSA_TAG_PROTO_KSZ9893 = 7,
    DSA_TAG_PROTO_LAN9303 = 8,
    DSA_TAG_PROTO_MTK = 9,
    DSA_TAG_PROTO_QCA = 10,
    DSA_TAG_PROTO_TRAILER = 11,
    DSA_TAG_PROTO_8021Q = 12,
    DSA_TAG_PROTO_SJA1105 = 13,
    DSA_TAG_PROTO_KSZ8795 = 14,
    DSA_TAG_PROTO_OCELOT = 15,
    DSA_TAG_PROTO_AR9331 = 16,
    DSA_TAG_PROTO_RTL4_A = 17,
    DSA_TAG_PROTO_HELLCREEK = 18,
    DSA_TAG_PROTO_XRS700X = 19,
    DSA_TAG_PROTO_OCELOT_8021Q = 20,
    DSA_TAG_PROTO_SEVILLE = 21,
    DSA_TAG_PROTO_SJA1110 = 23,
    DSA_TAG_PROTO_RTL8_4 = 24,
    DSA_TAG_PROTO_RTL8_4T = 25,
    DSA_TAG_PROTO_RZN1_A5PSW = 26,
    DSA_TAG_PROTO_LAN937X = 27,
    DSA_TAG_PROTO_VSC73XX_8021Q = 28,
};

enum dynevent_type {
    DYNEVENT_TYPE_SYNTH = 1,
    DYNEVENT_TYPE_KPROBE = 2,
    DYNEVENT_TYPE_NONE = 3,
};

enum ecryptfs_token_types {
    ECRYPTFS_PASSWORD = 0,
    ECRYPTFS_PRIVATE_KEY = 1,
};

enum edac_mc_layer_type {
    EDAC_MC_LAYER_BRANCH = 0,
    EDAC_MC_LAYER_CHANNEL = 1,
    EDAC_MC_LAYER_SLOT = 2,
    EDAC_MC_LAYER_CHIP_SELECT = 3,
    EDAC_MC_LAYER_ALL_MEM = 4,
};

enum edac_type {
    EDAC_UNKNOWN = 0,
    EDAC_NONE = 1,
    EDAC_RESERVED = 2,
    EDAC_PARITY = 3,
    EDAC_EC = 4,
    EDAC_SECDED = 5,
    EDAC_S2ECD2ED = 6,
    EDAC_S4ECD4ED = 7,
    EDAC_S8ECD8ED = 8,
    EDAC_S16ECD16ED = 9,
};

enum edid_block_status {
    EDID_BLOCK_OK = 0,
    EDID_BLOCK_READ_FAIL = 1,
    EDID_BLOCK_NULL = 2,
    EDID_BLOCK_ZERO = 3,
    EDID_BLOCK_HEADER_CORRUPT = 4,
    EDID_BLOCK_HEADER_REPAIR = 5,
    EDID_BLOCK_HEADER_FIXED = 6,
    EDID_BLOCK_CHECKSUM = 7,
    EDID_BLOCK_VERSION = 8,
};

enum efi_cmdline_option {
    EFI_CMDLINE_NONE = 0,
    EFI_CMDLINE_MODE_NUM = 1,
    EFI_CMDLINE_RES = 2,
    EFI_CMDLINE_AUTO = 3,
    EFI_CMDLINE_LIST = 4,
};

enum efi_rts_ids {
    EFI_NONE = 0,
    EFI_GET_TIME = 1,
    EFI_SET_TIME = 2,
    EFI_GET_WAKEUP_TIME = 3,
    EFI_SET_WAKEUP_TIME = 4,
    EFI_GET_VARIABLE = 5,
    EFI_GET_NEXT_VARIABLE = 6,
    EFI_SET_VARIABLE = 7,
    EFI_QUERY_VARIABLE_INFO = 8,
    EFI_GET_NEXT_HIGH_MONO_COUNT = 9,
    EFI_RESET_SYSTEM = 10,
    EFI_UPDATE_CAPSULE = 11,
    EFI_QUERY_CAPSULE_CAPS = 12,
    EFI_ACPI_PRM_HANDLER = 13,
};

enum efi_secureboot_mode {
    efi_secureboot_mode_unset = 0,
    efi_secureboot_mode_unknown = 1,
    efi_secureboot_mode_disabled = 2,
    efi_secureboot_mode_enabled = 3,
};

enum efistub_event_type {
    EFISTUB_EVT_INITRD = 0,
    EFISTUB_EVT_LOAD_OPTIONS = 1,
    EFISTUB_EVT_COUNT = 2,
};

enum elv_merge {
    ELEVATOR_NO_MERGE = 0,
    ELEVATOR_FRONT_MERGE = 1,
    ELEVATOR_BACK_MERGE = 2,
    ELEVATOR_DISCARD_MERGE = 3,
};

enum enable_type {
    undefined = -1,
    user_disabled = 0,
    auto_disabled = 1,
    user_enabled = 2,
    auto_enabled = 3,
};

enum environment_cap {
    ENVIRON_ANY = 0,
    ENVIRON_INDOOR = 1,
    ENVIRON_OUTDOOR = 2,
};

enum error_detector {
    ERROR_DETECTOR_KFENCE = 0,
    ERROR_DETECTOR_KASAN = 1,
    ERROR_DETECTOR_WARN = 2,
};

enum ethnl_sock_type {
    ETHTOOL_SOCK_TYPE_MODULE_FW_FLASH = 0,
};

enum ethtool_c33_pse_admin_state {
    ETHTOOL_C33_PSE_ADMIN_STATE_UNKNOWN = 1,
    ETHTOOL_C33_PSE_ADMIN_STATE_DISABLED = 2,
    ETHTOOL_C33_PSE_ADMIN_STATE_ENABLED = 3,
};

enum ethtool_c33_pse_ext_state {
    ETHTOOL_C33_PSE_EXT_STATE_ERROR_CONDITION = 1,
    ETHTOOL_C33_PSE_EXT_STATE_MR_MPS_VALID = 2,
    ETHTOOL_C33_PSE_EXT_STATE_MR_PSE_ENABLE = 3,
    ETHTOOL_C33_PSE_EXT_STATE_OPTION_DETECT_TED = 4,
    ETHTOOL_C33_PSE_EXT_STATE_OPTION_VPORT_LIM = 5,
    ETHTOOL_C33_PSE_EXT_STATE_OVLD_DETECTED = 6,
    ETHTOOL_C33_PSE_EXT_STATE_PD_DLL_POWER_TYPE = 7,
    ETHTOOL_C33_PSE_EXT_STATE_POWER_NOT_AVAILABLE = 8,
    ETHTOOL_C33_PSE_EXT_STATE_SHORT_DETECTED = 9,
};

enum ethtool_c33_pse_ext_substate_error_condition {
    ETHTOOL_C33_PSE_EXT_SUBSTATE_ERROR_CONDITION_NON_EXISTING_PORT = 1,
    ETHTOOL_C33_PSE_EXT_SUBSTATE_ERROR_CONDITION_UNDEFINED_PORT = 2,
    ETHTOOL_C33_PSE_EXT_SUBSTATE_ERROR_CONDITION_INTERNAL_HW_FAULT = 3,
    ETHTOOL_C33_PSE_EXT_SUBSTATE_ERROR_CONDITION_COMM_ERROR_AFTER_FORCE_ON = 4,
    ETHTOOL_C33_PSE_EXT_SUBSTATE_ERROR_CONDITION_UNKNOWN_PORT_STATUS = 5,
    ETHTOOL_C33_PSE_EXT_SUBSTATE_ERROR_CONDITION_HOST_CRASH_TURN_OFF = 6,
    ETHTOOL_C33_PSE_EXT_SUBSTATE_ERROR_CONDITION_HOST_CRASH_FORCE_SHUTDOWN = 7,
    ETHTOOL_C33_PSE_EXT_SUBSTATE_ERROR_CONDITION_CONFIG_CHANGE = 8,
    ETHTOOL_C33_PSE_EXT_SUBSTATE_ERROR_CONDITION_DETECTED_OVER_TEMP = 9,
};

enum ethtool_c33_pse_ext_substate_mr_pse_enable {
    ETHTOOL_C33_PSE_EXT_SUBSTATE_MR_PSE_ENABLE_DISABLE_PIN_ACTIVE = 1,
};

enum ethtool_c33_pse_ext_substate_option_detect_ted {
    ETHTOOL_C33_PSE_EXT_SUBSTATE_OPTION_DETECT_TED_DET_IN_PROCESS = 1,
    ETHTOOL_C33_PSE_EXT_SUBSTATE_OPTION_DETECT_TED_CONNECTION_CHECK_ERROR = 2,
};

enum ethtool_c33_pse_ext_substate_option_vport_lim {
    ETHTOOL_C33_PSE_EXT_SUBSTATE_OPTION_VPORT_LIM_HIGH_VOLTAGE = 1,
    ETHTOOL_C33_PSE_EXT_SUBSTATE_OPTION_VPORT_LIM_LOW_VOLTAGE = 2,
    ETHTOOL_C33_PSE_EXT_SUBSTATE_OPTION_VPORT_LIM_VOLTAGE_INJECTION = 3,
};

enum ethtool_c33_pse_ext_substate_ovld_detected {
    ETHTOOL_C33_PSE_EXT_SUBSTATE_OVLD_DETECTED_OVERLOAD = 1,
};

enum ethtool_c33_pse_ext_substate_power_not_available {
    ETHTOOL_C33_PSE_EXT_SUBSTATE_POWER_NOT_AVAILABLE_BUDGET_EXCEEDED = 1,
    ETHTOOL_C33_PSE_EXT_SUBSTATE_POWER_NOT_AVAILABLE_PORT_PW_LIMIT_EXCEEDS_CONTROLLER_BUDGET = 2,
    ETHTOOL_C33_PSE_EXT_SUBSTATE_POWER_NOT_AVAILABLE_PD_REQUEST_EXCEEDS_PORT_LIMIT = 3,
    ETHTOOL_C33_PSE_EXT_SUBSTATE_POWER_NOT_AVAILABLE_HW_PW_LIMIT = 4,
};

enum ethtool_c33_pse_ext_substate_short_detected {
    ETHTOOL_C33_PSE_EXT_SUBSTATE_SHORT_DETECTED_SHORT_CONDITION = 1,
};

enum ethtool_c33_pse_pw_d_status {
    ETHTOOL_C33_PSE_PW_D_STATUS_UNKNOWN = 1,
    ETHTOOL_C33_PSE_PW_D_STATUS_DISABLED = 2,
    ETHTOOL_C33_PSE_PW_D_STATUS_SEARCHING = 3,
    ETHTOOL_C33_PSE_PW_D_STATUS_DELIVERING = 4,
    ETHTOOL_C33_PSE_PW_D_STATUS_TEST = 5,
    ETHTOOL_C33_PSE_PW_D_STATUS_FAULT = 6,
    ETHTOOL_C33_PSE_PW_D_STATUS_OTHERFAULT = 7,
};

enum ethtool_cmis_cdb_cmd_id {
    ETHTOOL_CMIS_CDB_CMD_QUERY_STATUS = 0,
    ETHTOOL_CMIS_CDB_CMD_MODULE_FEATURES = 64,
    ETHTOOL_CMIS_CDB_CMD_FW_MANAGMENT_FEATURES = 65,
    ETHTOOL_CMIS_CDB_CMD_START_FW_DOWNLOAD = 257,
    ETHTOOL_CMIS_CDB_CMD_WRITE_FW_BLOCK_LPL = 259,
    ETHTOOL_CMIS_CDB_CMD_WRITE_FW_BLOCK_EPL = 260,
    ETHTOOL_CMIS_CDB_CMD_COMPLETE_FW_DOWNLOAD = 263,
    ETHTOOL_CMIS_CDB_CMD_RUN_FW_IMAGE = 265,
    ETHTOOL_CMIS_CDB_CMD_COMMIT_FW_IMAGE = 266,
};

enum ethtool_fec_config_bits {
    ETHTOOL_FEC_NONE_BIT = 0,
    ETHTOOL_FEC_AUTO_BIT = 1,
    ETHTOOL_FEC_OFF_BIT = 2,
    ETHTOOL_FEC_RS_BIT = 3,
    ETHTOOL_FEC_BASER_BIT = 4,
    ETHTOOL_FEC_LLRS_BIT = 5,
};

enum ethtool_flags {
    ETH_FLAG_TXVLAN = 128,
    ETH_FLAG_RXVLAN = 256,
    ETH_FLAG_LRO = 32768,
    ETH_FLAG_NTUPLE = 134217728,
    ETH_FLAG_RXHASH = 268435456,
};

enum ethtool_header_flags {
    ETHTOOL_FLAG_COMPACT_BITSETS = 1,
    ETHTOOL_FLAG_OMIT_REPLY = 2,
    ETHTOOL_FLAG_STATS = 4,
};

enum ethtool_link_ext_state {
    ETHTOOL_LINK_EXT_STATE_AUTONEG = 0,
    ETHTOOL_LINK_EXT_STATE_LINK_TRAINING_FAILURE = 1,
    ETHTOOL_LINK_EXT_STATE_LINK_LOGICAL_MISMATCH = 2,
    ETHTOOL_LINK_EXT_STATE_BAD_SIGNAL_INTEGRITY = 3,
    ETHTOOL_LINK_EXT_STATE_NO_CABLE = 4,
    ETHTOOL_LINK_EXT_STATE_CABLE_ISSUE = 5,
    ETHTOOL_LINK_EXT_STATE_EEPROM_ISSUE = 6,
    ETHTOOL_LINK_EXT_STATE_CALIBRATION_FAILURE = 7,
    ETHTOOL_LINK_EXT_STATE_POWER_BUDGET_EXCEEDED = 8,
    ETHTOOL_LINK_EXT_STATE_OVERHEAT = 9,
    ETHTOOL_LINK_EXT_STATE_MODULE = 10,
};

enum ethtool_link_ext_substate_autoneg {
    ETHTOOL_LINK_EXT_SUBSTATE_AN_NO_PARTNER_DETECTED = 1,
    ETHTOOL_LINK_EXT_SUBSTATE_AN_ACK_NOT_RECEIVED = 2,
    ETHTOOL_LINK_EXT_SUBSTATE_AN_NEXT_PAGE_EXCHANGE_FAILED = 3,
    ETHTOOL_LINK_EXT_SUBSTATE_AN_NO_PARTNER_DETECTED_FORCE_MODE = 4,
    ETHTOOL_LINK_EXT_SUBSTATE_AN_FEC_MISMATCH_DURING_OVERRIDE = 5,
    ETHTOOL_LINK_EXT_SUBSTATE_AN_NO_HCD = 6,
};

enum ethtool_link_ext_substate_bad_signal_integrity {
    ETHTOOL_LINK_EXT_SUBSTATE_BSI_LARGE_NUMBER_OF_PHYSICAL_ERRORS = 1,
    ETHTOOL_LINK_EXT_SUBSTATE_BSI_UNSUPPORTED_RATE = 2,
    ETHTOOL_LINK_EXT_SUBSTATE_BSI_SERDES_REFERENCE_CLOCK_LOST = 3,
    ETHTOOL_LINK_EXT_SUBSTATE_BSI_SERDES_ALOS = 4,
};

enum ethtool_link_ext_substate_cable_issue {
    ETHTOOL_LINK_EXT_SUBSTATE_CI_UNSUPPORTED_CABLE = 1,
    ETHTOOL_LINK_EXT_SUBSTATE_CI_CABLE_TEST_FAILURE = 2,
};

enum ethtool_link_ext_substate_link_logical_mismatch {
    ETHTOOL_LINK_EXT_SUBSTATE_LLM_PCS_DID_NOT_ACQUIRE_BLOCK_LOCK = 1,
    ETHTOOL_LINK_EXT_SUBSTATE_LLM_PCS_DID_NOT_ACQUIRE_AM_LOCK = 2,
    ETHTOOL_LINK_EXT_SUBSTATE_LLM_PCS_DID_NOT_GET_ALIGN_STATUS = 3,
    ETHTOOL_LINK_EXT_SUBSTATE_LLM_FC_FEC_IS_NOT_LOCKED = 4,
    ETHTOOL_LINK_EXT_SUBSTATE_LLM_RS_FEC_IS_NOT_LOCKED = 5,
};

enum ethtool_link_ext_substate_link_training {
    ETHTOOL_LINK_EXT_SUBSTATE_LT_KR_FRAME_LOCK_NOT_ACQUIRED = 1,
    ETHTOOL_LINK_EXT_SUBSTATE_LT_KR_LINK_INHIBIT_TIMEOUT = 2,
    ETHTOOL_LINK_EXT_SUBSTATE_LT_KR_LINK_PARTNER_DID_NOT_SET_RECEIVER_READY = 3,
    ETHTOOL_LINK_EXT_SUBSTATE_LT_REMOTE_FAULT = 4,
};

enum ethtool_link_ext_substate_module {
    ETHTOOL_LINK_EXT_SUBSTATE_MODULE_CMIS_NOT_READY = 1,
};

enum ethtool_link_mode_bit_indices {
    ETHTOOL_LINK_MODE_10baseT_Half_BIT = 0,
    ETHTOOL_LINK_MODE_10baseT_Full_BIT = 1,
    ETHTOOL_LINK_MODE_100baseT_Half_BIT = 2,
    ETHTOOL_LINK_MODE_100baseT_Full_BIT = 3,
    ETHTOOL_LINK_MODE_1000baseT_Half_BIT = 4,
    ETHTOOL_LINK_MODE_1000baseT_Full_BIT = 5,
    ETHTOOL_LINK_MODE_Autoneg_BIT = 6,
    ETHTOOL_LINK_MODE_TP_BIT = 7,
    ETHTOOL_LINK_MODE_AUI_BIT = 8,
    ETHTOOL_LINK_MODE_MII_BIT = 9,
    ETHTOOL_LINK_MODE_FIBRE_BIT = 10,
    ETHTOOL_LINK_MODE_BNC_BIT = 11,
    ETHTOOL_LINK_MODE_10000baseT_Full_BIT = 12,
    ETHTOOL_LINK_MODE_Pause_BIT = 13,
    ETHTOOL_LINK_MODE_Asym_Pause_BIT = 14,
    ETHTOOL_LINK_MODE_2500baseX_Full_BIT = 15,
    ETHTOOL_LINK_MODE_Backplane_BIT = 16,
    ETHTOOL_LINK_MODE_1000baseKX_Full_BIT = 17,
    ETHTOOL_LINK_MODE_10000baseKX4_Full_BIT = 18,
    ETHTOOL_LINK_MODE_10000baseKR_Full_BIT = 19,
    ETHTOOL_LINK_MODE_10000baseR_FEC_BIT = 20,
    ETHTOOL_LINK_MODE_20000baseMLD2_Full_BIT = 21,
    ETHTOOL_LINK_MODE_20000baseKR2_Full_BIT = 22,
    ETHTOOL_LINK_MODE_40000baseKR4_Full_BIT = 23,
    ETHTOOL_LINK_MODE_40000baseCR4_Full_BIT = 24,
    ETHTOOL_LINK_MODE_40000baseSR4_Full_BIT = 25,
    ETHTOOL_LINK_MODE_40000baseLR4_Full_BIT = 26,
    ETHTOOL_LINK_MODE_56000baseKR4_Full_BIT = 27,
    ETHTOOL_LINK_MODE_56000baseCR4_Full_BIT = 28,
    ETHTOOL_LINK_MODE_56000baseSR4_Full_BIT = 29,
    ETHTOOL_LINK_MODE_56000baseLR4_Full_BIT = 30,
    ETHTOOL_LINK_MODE_25000baseCR_Full_BIT = 31,
    ETHTOOL_LINK_MODE_25000baseKR_Full_BIT = 32,
    ETHTOOL_LINK_MODE_25000baseSR_Full_BIT = 33,
    ETHTOOL_LINK_MODE_50000baseCR2_Full_BIT = 34,
    ETHTOOL_LINK_MODE_50000baseKR2_Full_BIT = 35,
    ETHTOOL_LINK_MODE_100000baseKR4_Full_BIT = 36,
    ETHTOOL_LINK_MODE_100000baseSR4_Full_BIT = 37,
    ETHTOOL_LINK_MODE_100000baseCR4_Full_BIT = 38,
    ETHTOOL_LINK_MODE_100000baseLR4_ER4_Full_BIT = 39,
    ETHTOOL_LINK_MODE_50000baseSR2_Full_BIT = 40,
    ETHTOOL_LINK_MODE_1000baseX_Full_BIT = 41,
    ETHTOOL_LINK_MODE_10000baseCR_Full_BIT = 42,
    ETHTOOL_LINK_MODE_10000baseSR_Full_BIT = 43,
    ETHTOOL_LINK_MODE_10000baseLR_Full_BIT = 44,
    ETHTOOL_LINK_MODE_10000baseLRM_Full_BIT = 45,
    ETHTOOL_LINK_MODE_10000baseER_Full_BIT = 46,
    ETHTOOL_LINK_MODE_2500baseT_Full_BIT = 47,
    ETHTOOL_LINK_MODE_5000baseT_Full_BIT = 48,
    ETHTOOL_LINK_MODE_FEC_NONE_BIT = 49,
    ETHTOOL_LINK_MODE_FEC_RS_BIT = 50,
    ETHTOOL_LINK_MODE_FEC_BASER_BIT = 51,
    ETHTOOL_LINK_MODE_50000baseKR_Full_BIT = 52,
    ETHTOOL_LINK_MODE_50000baseSR_Full_BIT = 53,
    ETHTOOL_LINK_MODE_50000baseCR_Full_BIT = 54,
    ETHTOOL_LINK_MODE_50000baseLR_ER_FR_Full_BIT = 55,
    ETHTOOL_LINK_MODE_50000baseDR_Full_BIT = 56,
    ETHTOOL_LINK_MODE_100000baseKR2_Full_BIT = 57,
    ETHTOOL_LINK_MODE_100000baseSR2_Full_BIT = 58,
    ETHTOOL_LINK_MODE_100000baseCR2_Full_BIT = 59,
    ETHTOOL_LINK_MODE_100000baseLR2_ER2_FR2_Full_BIT = 60,
    ETHTOOL_LINK_MODE_100000baseDR2_Full_BIT = 61,
    ETHTOOL_LINK_MODE_200000baseKR4_Full_BIT = 62,
    ETHTOOL_LINK_MODE_200000baseSR4_Full_BIT = 63,
    ETHTOOL_LINK_MODE_200000baseLR4_ER4_FR4_Full_BIT = 64,
    ETHTOOL_LINK_MODE_200000baseDR4_Full_BIT = 65,
    ETHTOOL_LINK_MODE_200000baseCR4_Full_BIT = 66,
    ETHTOOL_LINK_MODE_100baseT1_Full_BIT = 67,
    ETHTOOL_LINK_MODE_1000baseT1_Full_BIT = 68,
    ETHTOOL_LINK_MODE_400000baseKR8_Full_BIT = 69,
    ETHTOOL_LINK_MODE_400000baseSR8_Full_BIT = 70,
    ETHTOOL_LINK_MODE_400000baseLR8_ER8_FR8_Full_BIT = 71,
    ETHTOOL_LINK_MODE_400000baseDR8_Full_BIT = 72,
    ETHTOOL_LINK_MODE_400000baseCR8_Full_BIT = 73,
    ETHTOOL_LINK_MODE_FEC_LLRS_BIT = 74,
    ETHTOOL_LINK_MODE_100000baseKR_Full_BIT = 75,
    ETHTOOL_LINK_MODE_100000baseSR_Full_BIT = 76,
    ETHTOOL_LINK_MODE_100000baseLR_ER_FR_Full_BIT = 77,
    ETHTOOL_LINK_MODE_100000baseCR_Full_BIT = 78,
    ETHTOOL_LINK_MODE_100000baseDR_Full_BIT = 79,
    ETHTOOL_LINK_MODE_200000baseKR2_Full_BIT = 80,
    ETHTOOL_LINK_MODE_200000baseSR2_Full_BIT = 81,
    ETHTOOL_LINK_MODE_200000baseLR2_ER2_FR2_Full_BIT = 82,
    ETHTOOL_LINK_MODE_200000baseDR2_Full_BIT = 83,
    ETHTOOL_LINK_MODE_200000baseCR2_Full_BIT = 84,
    ETHTOOL_LINK_MODE_400000baseKR4_Full_BIT = 85,
    ETHTOOL_LINK_MODE_400000baseSR4_Full_BIT = 86,
    ETHTOOL_LINK_MODE_400000baseLR4_ER4_FR4_Full_BIT = 87,
    ETHTOOL_LINK_MODE_400000baseDR4_Full_BIT = 88,
    ETHTOOL_LINK_MODE_400000baseCR4_Full_BIT = 89,
    ETHTOOL_LINK_MODE_100baseFX_Half_BIT = 90,
    ETHTOOL_LINK_MODE_100baseFX_Full_BIT = 91,
    ETHTOOL_LINK_MODE_10baseT1L_Full_BIT = 92,
    ETHTOOL_LINK_MODE_800000baseCR8_Full_BIT = 93,
    ETHTOOL_LINK_MODE_800000baseKR8_Full_BIT = 94,
    ETHTOOL_LINK_MODE_800000baseDR8_Full_BIT = 95,
    ETHTOOL_LINK_MODE_800000baseDR8_2_Full_BIT = 96,
    ETHTOOL_LINK_MODE_800000baseSR8_Full_BIT = 97,
    ETHTOOL_LINK_MODE_800000baseVR8_Full_BIT = 98,
    ETHTOOL_LINK_MODE_10baseT1S_Full_BIT = 99,
    ETHTOOL_LINK_MODE_10baseT1S_Half_BIT = 100,
    ETHTOOL_LINK_MODE_10baseT1S_P2MP_Half_BIT = 101,
    ETHTOOL_LINK_MODE_10baseT1BRR_Full_BIT = 102,
    __ETHTOOL_LINK_MODE_MASK_NBITS = 103,
};

enum ethtool_mac_stats_src {
    ETHTOOL_MAC_STATS_SRC_AGGREGATE = 0,
    ETHTOOL_MAC_STATS_SRC_EMAC = 1,
    ETHTOOL_MAC_STATS_SRC_PMAC = 2,
};

enum ethtool_mm_verify_status {
    ETHTOOL_MM_VERIFY_STATUS_UNKNOWN = 0,
    ETHTOOL_MM_VERIFY_STATUS_INITIAL = 1,
    ETHTOOL_MM_VERIFY_STATUS_VERIFYING = 2,
    ETHTOOL_MM_VERIFY_STATUS_SUCCEEDED = 3,
    ETHTOOL_MM_VERIFY_STATUS_FAILED = 4,
    ETHTOOL_MM_VERIFY_STATUS_DISABLED = 5,
};

enum ethtool_module_fw_flash_status {
    ETHTOOL_MODULE_FW_FLASH_STATUS_STARTED = 1,
    ETHTOOL_MODULE_FW_FLASH_STATUS_IN_PROGRESS = 2,
    ETHTOOL_MODULE_FW_FLASH_STATUS_COMPLETED = 3,
    ETHTOOL_MODULE_FW_FLASH_STATUS_ERROR = 4,
};

enum ethtool_module_power_mode {
    ETHTOOL_MODULE_POWER_MODE_LOW = 1,
    ETHTOOL_MODULE_POWER_MODE_HIGH = 2,
};

enum ethtool_module_power_mode_policy {
    ETHTOOL_MODULE_POWER_MODE_POLICY_HIGH = 1,
    ETHTOOL_MODULE_POWER_MODE_POLICY_AUTO = 2,
};

enum ethtool_multicast_groups {
    ETHNL_MCGRP_MONITOR = 0,
};

enum ethtool_phys_id_state {
    ETHTOOL_ID_INACTIVE = 0,
    ETHTOOL_ID_ACTIVE = 1,
    ETHTOOL_ID_ON = 2,
    ETHTOOL_ID_OFF = 3,
};

enum ethtool_podl_pse_admin_state {
    ETHTOOL_PODL_PSE_ADMIN_STATE_UNKNOWN = 1,
    ETHTOOL_PODL_PSE_ADMIN_STATE_DISABLED = 2,
    ETHTOOL_PODL_PSE_ADMIN_STATE_ENABLED = 3,
};

enum ethtool_podl_pse_pw_d_status {
    ETHTOOL_PODL_PSE_PW_D_STATUS_UNKNOWN = 1,
    ETHTOOL_PODL_PSE_PW_D_STATUS_DISABLED = 2,
    ETHTOOL_PODL_PSE_PW_D_STATUS_SEARCHING = 3,
    ETHTOOL_PODL_PSE_PW_D_STATUS_DELIVERING = 4,
    ETHTOOL_PODL_PSE_PW_D_STATUS_SLEEP = 5,
    ETHTOOL_PODL_PSE_PW_D_STATUS_IDLE = 6,
    ETHTOOL_PODL_PSE_PW_D_STATUS_ERROR = 7,
};

enum ethtool_pse_types {
    ETHTOOL_PSE_UNKNOWN = 1,
    ETHTOOL_PSE_PODL = 2,
    ETHTOOL_PSE_C33 = 4,
};

enum ethtool_reset_flags {
    ETH_RESET_MGMT = 1,
    ETH_RESET_IRQ = 2,
    ETH_RESET_DMA = 4,
    ETH_RESET_FILTER = 8,
    ETH_RESET_OFFLOAD = 16,
    ETH_RESET_MAC = 32,
    ETH_RESET_PHY = 64,
    ETH_RESET_RAM = 128,
    ETH_RESET_AP = 256,
    ETH_RESET_DEDICATED = 65535,
    ETH_RESET_ALL = 4294967295,
};

enum ethtool_sfeatures_retval_bits {
    ETHTOOL_F_UNSUPPORTED__BIT = 0,
    ETHTOOL_F_WISH__BIT = 1,
    ETHTOOL_F_COMPAT__BIT = 2,
};

enum ethtool_stringset {
    ETH_SS_TEST = 0,
    ETH_SS_STATS = 1,
    ETH_SS_PRIV_FLAGS = 2,
    ETH_SS_NTUPLE_FILTERS = 3,
    ETH_SS_FEATURES = 4,
    ETH_SS_RSS_HASH_FUNCS = 5,
    ETH_SS_TUNABLES = 6,
    ETH_SS_PHY_STATS = 7,
    ETH_SS_PHY_TUNABLES = 8,
    ETH_SS_LINK_MODES = 9,
    ETH_SS_MSG_CLASSES = 10,
    ETH_SS_WOL_MODES = 11,
    ETH_SS_SOF_TIMESTAMPING = 12,
    ETH_SS_TS_TX_TYPES = 13,
    ETH_SS_TS_RX_FILTERS = 14,
    ETH_SS_UDP_TUNNEL_TYPES = 15,
    ETH_SS_STATS_STD = 16,
    ETH_SS_STATS_ETH_PHY = 17,
    ETH_SS_STATS_ETH_MAC = 18,
    ETH_SS_STATS_ETH_CTRL = 19,
    ETH_SS_STATS_RMON = 20,
    ETH_SS_STATS_PHY = 21,
    ETH_SS_TS_FLAGS = 22,
    ETH_SS_COUNT = 23,
};

enum ethtool_supported_ring_param {
    ETHTOOL_RING_USE_RX_BUF_LEN = 1,
    ETHTOOL_RING_USE_CQE_SIZE = 2,
    ETHTOOL_RING_USE_TX_PUSH = 4,
    ETHTOOL_RING_USE_RX_PUSH = 8,
    ETHTOOL_RING_USE_TX_PUSH_BUF_LEN = 16,
    ETHTOOL_RING_USE_TCP_DATA_SPLIT = 32,
    ETHTOOL_RING_USE_HDS_THRS = 64,
};

enum ethtool_tcp_data_split {
    ETHTOOL_TCP_DATA_SPLIT_UNKNOWN = 0,
    ETHTOOL_TCP_DATA_SPLIT_DISABLED = 1,
    ETHTOOL_TCP_DATA_SPLIT_ENABLED = 2,
};

enum ethtool_test_flags {
    ETH_TEST_FL_OFFLINE = 1,
    ETH_TEST_FL_FAILED = 2,
    ETH_TEST_FL_EXTERNAL_LB = 4,
    ETH_TEST_FL_EXTERNAL_LB_DONE = 8,
};

enum event_command_flags {
    EVENT_CMD_FL_POST_TRIGGER = 1,
    EVENT_CMD_FL_NEEDS_REC = 2,
};

enum event_trigger_type {
    ETT_NONE = 0,
    ETT_TRACE_ONOFF = 1,
    ETT_SNAPSHOT = 2,
    ETT_STACKTRACE = 4,
    ETT_EVENT_ENABLE = 8,
    ETT_EVENT_HIST = 16,
    ETT_HIST_ENABLE = 32,
    ETT_EVENT_EPROBE = 64,
};

enum event_type_t {
    EVENT_FLEXIBLE = 1,
    EVENT_PINNED = 2,
    EVENT_TIME = 4,
    EVENT_FROZEN = 8,
    EVENT_CPU = 16,
    EVENT_CGROUP = 32,
    EVENT_ALL = 3,
    EVENT_TIME_FROZEN = 12,
};

enum evm_ima_xattr_type {
    IMA_XATTR_DIGEST = 1,
    EVM_XATTR_HMAC = 2,
    EVM_IMA_XATTR_DIGSIG = 3,
    IMA_XATTR_DIGEST_NG = 4,
    EVM_XATTR_PORTABLE_DIGSIG = 5,
    IMA_VERITY_DIGSIG = 6,
    IMA_XATTR_LAST = 7,
};

enum exact_level {
    NOT_EXACT = 0,
    EXACT = 1,
    RANGE_WITHIN = 2,
};

enum exception_type {
    except_type_sync = 0,
    except_type_irq = 128,
    except_type_fiq = 256,
    except_type_serror = 384,
};

enum execmem_range_flags {
    EXECMEM_KASAN_SHADOW = 1,
    EXECMEM_ROX_CACHE = 2,
};

enum execmem_type {
    EXECMEM_DEFAULT = 0,
    EXECMEM_MODULE_TEXT = 0,
    EXECMEM_KPROBES = 1,
    EXECMEM_FTRACE = 2,
    EXECMEM_BPF = 3,
    EXECMEM_MODULE_DATA = 4,
    EXECMEM_TYPE_MAX = 5,
};

enum ext4_journal_trigger_type {
    EXT4_JTR_ORPHAN_FILE = 0,
    EXT4_JTR_NONE = 1,
};

enum ext4_li_mode {
    EXT4_LI_MODE_PREFETCH_BBITMAP = 0,
    EXT4_LI_MODE_ITABLE = 1,
};

enum fail_dup_mod_reason {
    FAIL_DUP_MOD_BECOMING = 0,
    FAIL_DUP_MOD_LOAD = 1,
};

enum fanotify_event_type {
    FANOTIFY_EVENT_TYPE_FID = 0,
    FANOTIFY_EVENT_TYPE_FID_NAME = 1,
    FANOTIFY_EVENT_TYPE_PATH = 2,
    FANOTIFY_EVENT_TYPE_PATH_PERM = 3,
    FANOTIFY_EVENT_TYPE_OVERFLOW = 4,
    FANOTIFY_EVENT_TYPE_FS_ERROR = 5,
    __FANOTIFY_EVENT_TYPE_NUM = 6,
};

enum fault_flag {
    FAULT_FLAG_WRITE = 1,
    FAULT_FLAG_MKWRITE = 2,
    FAULT_FLAG_ALLOW_RETRY = 4,
    FAULT_FLAG_RETRY_NOWAIT = 8,
    FAULT_FLAG_KILLABLE = 16,
    FAULT_FLAG_TRIED = 32,
    FAULT_FLAG_USER = 64,
    FAULT_FLAG_REMOTE = 128,
    FAULT_FLAG_INSTRUCTION = 256,
    FAULT_FLAG_INTERRUPTIBLE = 512,
    FAULT_FLAG_UNSHARE = 1024,
    FAULT_FLAG_ORIG_PTE_VALID = 2048,
    FAULT_FLAG_VMA_LOCK = 4096,
};

enum fbq_type {
    regular = 0,
    remote = 1,
    all = 2,
};

enum fetch_op {
    FETCH_OP_NOP = 0,
    FETCH_OP_REG = 1,
    FETCH_OP_STACK = 2,
    FETCH_OP_STACKP = 3,
    FETCH_OP_RETVAL = 4,
    FETCH_OP_IMM = 5,
    FETCH_OP_COMM = 6,
    FETCH_OP_ARG = 7,
    FETCH_OP_FOFFS = 8,
    FETCH_OP_DATA = 9,
    FETCH_OP_EDATA = 10,
    FETCH_OP_DEREF = 11,
    FETCH_OP_UDEREF = 12,
    FETCH_OP_ST_RAW = 13,
    FETCH_OP_ST_MEM = 14,
    FETCH_OP_ST_UMEM = 15,
    FETCH_OP_ST_STRING = 16,
    FETCH_OP_ST_USTRING = 17,
    FETCH_OP_ST_SYMSTR = 18,
    FETCH_OP_ST_EDATA = 19,
    FETCH_OP_MOD_BF = 20,
    FETCH_OP_LP_ARRAY = 21,
    FETCH_OP_TP_ARG = 22,
    FETCH_OP_END = 23,
    FETCH_NOP_SYMBOL = 24,
};

enum fg_filter_id {
    __NO_FGF__ = 0,
    HCRX_FGTnXS = 1,
    __NR_FG_FILTER_IDS__ = 2,
};

enum fgt_group_id {
    __NO_FGT_GROUP__ = 0,
    HFGxTR_GROUP = 1,
    HDFGRTR_GROUP = 2,
    HDFGWTR_GROUP = 2,
    HFGITR_GROUP = 3,
    HAFGRTR_GROUP = 4,
    __NR_FGT_GROUP_IDS__ = 5,
};

enum fib6_walk_state {
    FWS_S = 0,
    FWS_L = 1,
    FWS_R = 2,
    FWS_C = 3,
    FWS_U = 4,
};

enum fib_event_type {
    FIB_EVENT_ENTRY_REPLACE = 0,
    FIB_EVENT_ENTRY_APPEND = 1,
    FIB_EVENT_ENTRY_ADD = 2,
    FIB_EVENT_ENTRY_DEL = 3,
    FIB_EVENT_RULE_ADD = 4,
    FIB_EVENT_RULE_DEL = 5,
    FIB_EVENT_NH_ADD = 6,
    FIB_EVENT_NH_DEL = 7,
    FIB_EVENT_VIF_ADD = 8,
    FIB_EVENT_VIF_DEL = 9,
};

enum fid_type {
    FILEID_ROOT = 0,
    FILEID_INO32_GEN = 1,
    FILEID_INO32_GEN_PARENT = 2,
    FILEID_BTRFS_WITHOUT_PARENT = 77,
    FILEID_BTRFS_WITH_PARENT = 78,
    FILEID_BTRFS_WITH_PARENT_ROOT = 79,
    FILEID_UDF_WITHOUT_PARENT = 81,
    FILEID_UDF_WITH_PARENT = 82,
    FILEID_NILFS_WITHOUT_PARENT = 97,
    FILEID_NILFS_WITH_PARENT = 98,
    FILEID_FAT_WITHOUT_PARENT = 113,
    FILEID_FAT_WITH_PARENT = 114,
    FILEID_INO64_GEN = 129,
    FILEID_INO64_GEN_PARENT = 130,
    FILEID_LUSTRE = 151,
    FILEID_BCACHEFS_WITHOUT_PARENT = 177,
    FILEID_BCACHEFS_WITH_PARENT = 178,
    FILEID_KERNFS = 254,
    FILEID_INVALID = 255,
};

enum field_op_id {
    FIELD_OP_NONE = 0,
    FIELD_OP_PLUS = 1,
    FIELD_OP_MINUS = 2,
    FIELD_OP_UNARY_MINUS = 3,
    FIELD_OP_DIV = 4,
    FIELD_OP_MULT = 5,
};

enum file_time_flags {
    S_ATIME = 1,
    S_MTIME = 2,
    S_CTIME = 4,
    S_VERSION = 8,
};

enum filter_op_ids {
    OP_GLOB = 0,
    OP_NE = 1,
    OP_EQ = 2,
    OP_LE = 3,
    OP_LT = 4,
    OP_GE = 5,
    OP_GT = 6,
    OP_BAND = 7,
    OP_MAX = 8,
};

enum filter_pred_fn {
    FILTER_PRED_FN_NOP = 0,
    FILTER_PRED_FN_64 = 1,
    FILTER_PRED_FN_64_CPUMASK = 2,
    FILTER_PRED_FN_S64 = 3,
    FILTER_PRED_FN_U64 = 4,
    FILTER_PRED_FN_32 = 5,
    FILTER_PRED_FN_32_CPUMASK = 6,
    FILTER_PRED_FN_S32 = 7,
    FILTER_PRED_FN_U32 = 8,
    FILTER_PRED_FN_16 = 9,
    FILTER_PRED_FN_16_CPUMASK = 10,
    FILTER_PRED_FN_S16 = 11,
    FILTER_PRED_FN_U16 = 12,
    FILTER_PRED_FN_8 = 13,
    FILTER_PRED_FN_8_CPUMASK = 14,
    FILTER_PRED_FN_S8 = 15,
    FILTER_PRED_FN_U8 = 16,
    FILTER_PRED_FN_COMM = 17,
    FILTER_PRED_FN_STRING = 18,
    FILTER_PRED_FN_STRLOC = 19,
    FILTER_PRED_FN_STRRELLOC = 20,
    FILTER_PRED_FN_PCHAR_USER = 21,
    FILTER_PRED_FN_PCHAR = 22,
    FILTER_PRED_FN_CPU = 23,
    FILTER_PRED_FN_CPU_CPUMASK = 24,
    FILTER_PRED_FN_CPUMASK = 25,
    FILTER_PRED_FN_CPUMASK_CPU = 26,
    FILTER_PRED_FN_FUNCTION = 27,
    FILTER_PRED_FN_ = 28,
    FILTER_PRED_TEST_VISITED = 29,
};

enum fit_type {
    NOTHING_FIT = 0,
    FL_FIT_TYPE = 1,
    LE_FIT_TYPE = 2,
    RE_FIT_TYPE = 3,
    NE_FIT_TYPE = 4,
};

enum fixed_addresses {
    FIX_HOLE = 0,
    FIX_FDT_END = 1,
    FIX_FDT = 514,
    FIX_EARLYCON_MEM_BASE = 515,
    FIX_TEXT_POKE0 = 516,
    FIX_ENTRY_TRAMP_TEXT4 = 517,
    FIX_ENTRY_TRAMP_TEXT3 = 518,
    FIX_ENTRY_TRAMP_TEXT2 = 519,
    FIX_ENTRY_TRAMP_TEXT1 = 520,
    __end_of_permanent_fixed_addresses = 521,
    FIX_BTMAP_END = 521,
    FIX_BTMAP_BEGIN = 968,
    FIX_PTE = 969,
    FIX_PMD = 970,
    FIX_PUD = 971,
    FIX_P4D = 972,
    FIX_PGD = 973,
    __end_of_fixed_addresses = 974,
};

enum flow_action_hw_stats {
    FLOW_ACTION_HW_STATS_IMMEDIATE = 1,
    FLOW_ACTION_HW_STATS_DELAYED = 2,
    FLOW_ACTION_HW_STATS_ANY = 3,
    FLOW_ACTION_HW_STATS_DISABLED = 4,
    FLOW_ACTION_HW_STATS_DONT_CARE = 7,
};

enum flow_action_hw_stats_bit {
    FLOW_ACTION_HW_STATS_IMMEDIATE_BIT = 0,
    FLOW_ACTION_HW_STATS_DELAYED_BIT = 1,
    FLOW_ACTION_HW_STATS_DISABLED_BIT = 2,
    FLOW_ACTION_HW_STATS_NUM_BITS = 3,
};

enum flow_action_id {
    FLOW_ACTION_ACCEPT = 0,
    FLOW_ACTION_DROP = 1,
    FLOW_ACTION_TRAP = 2,
    FLOW_ACTION_GOTO = 3,
    FLOW_ACTION_REDIRECT = 4,
    FLOW_ACTION_MIRRED = 5,
    FLOW_ACTION_REDIRECT_INGRESS = 6,
    FLOW_ACTION_MIRRED_INGRESS = 7,
    FLOW_ACTION_VLAN_PUSH = 8,
    FLOW_ACTION_VLAN_POP = 9,
    FLOW_ACTION_VLAN_MANGLE = 10,
    FLOW_ACTION_TUNNEL_ENCAP = 11,
    FLOW_ACTION_TUNNEL_DECAP = 12,
    FLOW_ACTION_MANGLE = 13,
    FLOW_ACTION_ADD = 14,
    FLOW_ACTION_CSUM = 15,
    FLOW_ACTION_MARK = 16,
    FLOW_ACTION_PTYPE = 17,
    FLOW_ACTION_PRIORITY = 18,
    FLOW_ACTION_RX_QUEUE_MAPPING = 19,
    FLOW_ACTION_WAKE = 20,
    FLOW_ACTION_QUEUE = 21,
    FLOW_ACTION_SAMPLE = 22,
    FLOW_ACTION_POLICE = 23,
    FLOW_ACTION_CT = 24,
    FLOW_ACTION_CT_METADATA = 25,
    FLOW_ACTION_MPLS_PUSH = 26,
    FLOW_ACTION_MPLS_POP = 27,
    FLOW_ACTION_MPLS_MANGLE = 28,
    FLOW_ACTION_GATE = 29,
    FLOW_ACTION_PPPOE_PUSH = 30,
    FLOW_ACTION_JUMP = 31,
    FLOW_ACTION_PIPE = 32,
    FLOW_ACTION_VLAN_PUSH_ETH = 33,
    FLOW_ACTION_VLAN_POP_ETH = 34,
    FLOW_ACTION_CONTINUE = 35,
    NUM_FLOW_ACTIONS = 36,
};

enum flow_action_mangle_base {
    FLOW_ACT_MANGLE_UNSPEC = 0,
    FLOW_ACT_MANGLE_HDR_TYPE_ETH = 1,
    FLOW_ACT_MANGLE_HDR_TYPE_IP4 = 2,
    FLOW_ACT_MANGLE_HDR_TYPE_IP6 = 3,
    FLOW_ACT_MANGLE_HDR_TYPE_TCP = 4,
    FLOW_ACT_MANGLE_HDR_TYPE_UDP = 5,
};

enum flow_block_binder_type {
    FLOW_BLOCK_BINDER_TYPE_UNSPEC = 0,
    FLOW_BLOCK_BINDER_TYPE_CLSACT_INGRESS = 1,
    FLOW_BLOCK_BINDER_TYPE_CLSACT_EGRESS = 2,
    FLOW_BLOCK_BINDER_TYPE_RED_EARLY_DROP = 3,
    FLOW_BLOCK_BINDER_TYPE_RED_MARK = 4,
};

enum flow_block_command {
    FLOW_BLOCK_BIND = 0,
    FLOW_BLOCK_UNBIND = 1,
};

enum flow_cls_command {
    FLOW_CLS_REPLACE = 0,
    FLOW_CLS_DESTROY = 1,
    FLOW_CLS_STATS = 2,
    FLOW_CLS_TMPLT_CREATE = 3,
    FLOW_CLS_TMPLT_DESTROY = 4,
};

enum flow_dissect_ret {
    FLOW_DISSECT_RET_OUT_GOOD = 0,
    FLOW_DISSECT_RET_OUT_BAD = 1,
    FLOW_DISSECT_RET_PROTO_AGAIN = 2,
    FLOW_DISSECT_RET_IPPROTO_AGAIN = 3,
    FLOW_DISSECT_RET_CONTINUE = 4,
};

enum flow_dissector_ctrl_flags {
    FLOW_DIS_IS_FRAGMENT = 1,
    FLOW_DIS_FIRST_FRAG = 2,
    FLOW_DIS_F_TUNNEL_CSUM = 4,
    FLOW_DIS_F_TUNNEL_DONT_FRAGMENT = 8,
    FLOW_DIS_F_TUNNEL_OAM = 16,
    FLOW_DIS_F_TUNNEL_CRIT_OPT = 32,
    FLOW_DIS_ENCAPSULATION = 64,
};

enum flow_dissector_key_id {
    FLOW_DISSECTOR_KEY_CONTROL = 0,
    FLOW_DISSECTOR_KEY_BASIC = 1,
    FLOW_DISSECTOR_KEY_IPV4_ADDRS = 2,
    FLOW_DISSECTOR_KEY_IPV6_ADDRS = 3,
    FLOW_DISSECTOR_KEY_PORTS = 4,
    FLOW_DISSECTOR_KEY_PORTS_RANGE = 5,
    FLOW_DISSECTOR_KEY_ICMP = 6,
    FLOW_DISSECTOR_KEY_ETH_ADDRS = 7,
    FLOW_DISSECTOR_KEY_TIPC = 8,
    FLOW_DISSECTOR_KEY_ARP = 9,
    FLOW_DISSECTOR_KEY_VLAN = 10,
    FLOW_DISSECTOR_KEY_FLOW_LABEL = 11,
    FLOW_DISSECTOR_KEY_GRE_KEYID = 12,
    FLOW_DISSECTOR_KEY_MPLS_ENTROPY = 13,
    FLOW_DISSECTOR_KEY_ENC_KEYID = 14,
    FLOW_DISSECTOR_KEY_ENC_IPV4_ADDRS = 15,
    FLOW_DISSECTOR_KEY_ENC_IPV6_ADDRS = 16,
    FLOW_DISSECTOR_KEY_ENC_CONTROL = 17,
    FLOW_DISSECTOR_KEY_ENC_PORTS = 18,
    FLOW_DISSECTOR_KEY_MPLS = 19,
    FLOW_DISSECTOR_KEY_TCP = 20,
    FLOW_DISSECTOR_KEY_IP = 21,
    FLOW_DISSECTOR_KEY_CVLAN = 22,
    FLOW_DISSECTOR_KEY_ENC_IP = 23,
    FLOW_DISSECTOR_KEY_ENC_OPTS = 24,
    FLOW_DISSECTOR_KEY_META = 25,
    FLOW_DISSECTOR_KEY_CT = 26,
    FLOW_DISSECTOR_KEY_HASH = 27,
    FLOW_DISSECTOR_KEY_NUM_OF_VLANS = 28,
    FLOW_DISSECTOR_KEY_PPPOE = 29,
    FLOW_DISSECTOR_KEY_L2TPV3 = 30,
    FLOW_DISSECTOR_KEY_CFM = 31,
    FLOW_DISSECTOR_KEY_IPSEC = 32,
    FLOW_DISSECTOR_KEY_MAX = 33,
};

enum flowlabel_reflect {
    FLOWLABEL_REFLECT_ESTABLISHED = 1,
    FLOWLABEL_REFLECT_TCP_RESET = 2,
    FLOWLABEL_REFLECT_ICMPV6_ECHO_REPLIES = 4,
};

enum folio_references {
    FOLIOREF_RECLAIM = 0,
    FOLIOREF_RECLAIM_CLEAN = 1,
    FOLIOREF_KEEP = 2,
    FOLIOREF_ACTIVATE = 3,
};

enum folio_walk_level {
    FW_LEVEL_PTE = 0,
    FW_LEVEL_PMD = 1,
    FW_LEVEL_PUD = 2,
};

enum format_state {
    FORMAT_STATE_NONE = 0,
    FORMAT_STATE_NUM = 1,
    FORMAT_STATE_WIDTH = 2,
    FORMAT_STATE_PRECISION = 3,
    FORMAT_STATE_CHAR = 4,
    FORMAT_STATE_STR = 5,
    FORMAT_STATE_PTR = 6,
    FORMAT_STATE_PERCENT_CHAR = 7,
    FORMAT_STATE_INVALID = 8,
};

enum fortify_func {
    FORTIFY_FUNC_strncpy = 0,
    FORTIFY_FUNC_strnlen = 1,
    FORTIFY_FUNC_strlen = 2,
    FORTIFY_FUNC_strscpy = 3,
    FORTIFY_FUNC_strlcat = 4,
    FORTIFY_FUNC_strcat = 5,
    FORTIFY_FUNC_strncat = 6,
    FORTIFY_FUNC_memset = 7,
    FORTIFY_FUNC_memcpy = 8,
    FORTIFY_FUNC_memmove = 9,
    FORTIFY_FUNC_memscan = 10,
    FORTIFY_FUNC_memcmp = 11,
    FORTIFY_FUNC_memchr = 12,
    FORTIFY_FUNC_memchr_inv = 13,
    FORTIFY_FUNC_kmemdup = 14,
    FORTIFY_FUNC_strcpy = 15,
    FORTIFY_FUNC_UNKNOWN = 16,
};

enum fp_type {
    FP_STATE_CURRENT = 0,
    FP_STATE_FPSIMD = 1,
    FP_STATE_SVE = 2,
};

enum framer_clock_type {
    FRAMER_CLOCK_EXT = 0,
    FRAMER_CLOCK_INT = 1,
};

enum framer_event {
    FRAMER_EVENT_STATUS = 0,
};

enum framer_iface {
    FRAMER_IFACE_E1 = 0,
    FRAMER_IFACE_T1 = 1,
};

enum freeze_holder {
    FREEZE_HOLDER_KERNEL = 1,
    FREEZE_HOLDER_USERSPACE = 2,
    FREEZE_MAY_NEST = 4,
};

enum freezer_state_flags {
    CGROUP_FREEZER_ONLINE = 1,
    CGROUP_FREEZING_SELF = 2,
    CGROUP_FREEZING_PARENT = 4,
    CGROUP_FROZEN = 8,
    CGROUP_FREEZING = 6,
};

enum freq_qos_req_type {
    FREQ_QOS_MIN = 1,
    FREQ_QOS_MAX = 2,
};

enum fs_context_phase {
    FS_CONTEXT_CREATE_PARAMS = 0,
    FS_CONTEXT_CREATING = 1,
    FS_CONTEXT_AWAITING_MOUNT = 2,
    FS_CONTEXT_AWAITING_RECONF = 3,
    FS_CONTEXT_RECONF_PARAMS = 4,
    FS_CONTEXT_RECONFIGURING = 5,
    FS_CONTEXT_FAILED = 6,
};

enum fs_context_purpose {
    FS_CONTEXT_FOR_MOUNT = 0,
    FS_CONTEXT_FOR_SUBMOUNT = 1,
    FS_CONTEXT_FOR_RECONFIGURE = 2,
};

enum fs_value_type {
    fs_value_is_undefined = 0,
    fs_value_is_flag = 1,
    fs_value_is_string = 2,
    fs_value_is_blob = 3,
    fs_value_is_filename = 4,
    fs_value_is_file = 5,
};

enum fsconfig_command {
    FSCONFIG_SET_FLAG = 0,
    FSCONFIG_SET_STRING = 1,
    FSCONFIG_SET_BINARY = 2,
    FSCONFIG_SET_PATH = 3,
    FSCONFIG_SET_PATH_EMPTY = 4,
    FSCONFIG_SET_FD = 5,
    FSCONFIG_CMD_CREATE = 6,
    FSCONFIG_CMD_RECONFIGURE = 7,
    FSCONFIG_CMD_CREATE_EXCL = 8,
};

enum fsl_mc_pool_type {
    FSL_MC_POOL_DPMCP = 0,
    FSL_MC_POOL_DPBP = 1,
    FSL_MC_POOL_DPCON = 2,
    FSL_MC_POOL_IRQ = 3,
    FSL_MC_NUM_POOL_TYPES = 4,
};

enum fsnotify_data_type {
    FSNOTIFY_EVENT_NONE = 0,
    FSNOTIFY_EVENT_FILE_RANGE = 1,
    FSNOTIFY_EVENT_PATH = 2,
    FSNOTIFY_EVENT_INODE = 3,
    FSNOTIFY_EVENT_DENTRY = 4,
    FSNOTIFY_EVENT_ERROR = 5,
};

enum fsnotify_group_prio {
    FSNOTIFY_PRIO_NORMAL = 0,
    FSNOTIFY_PRIO_CONTENT = 1,
    FSNOTIFY_PRIO_PRE_CONTENT = 2,
    __FSNOTIFY_PRIO_NUM = 3,
};

enum fsnotify_iter_type {
    FSNOTIFY_ITER_TYPE_INODE = 0,
    FSNOTIFY_ITER_TYPE_VFSMOUNT = 1,
    FSNOTIFY_ITER_TYPE_SB = 2,
    FSNOTIFY_ITER_TYPE_PARENT = 3,
    FSNOTIFY_ITER_TYPE_INODE2 = 4,
    FSNOTIFY_ITER_TYPE_COUNT = 5,
};

enum fsnotify_obj_type {
    FSNOTIFY_OBJ_TYPE_ANY = -1,
    FSNOTIFY_OBJ_TYPE_INODE = 0,
    FSNOTIFY_OBJ_TYPE_VFSMOUNT = 1,
    FSNOTIFY_OBJ_TYPE_SB = 2,
    FSNOTIFY_OBJ_TYPE_COUNT = 3,
    FSNOTIFY_OBJ_TYPE_DETACHED = 3,
};

enum ftr_type {
    FTR_EXACT = 0,
    FTR_LOWER_SAFE = 1,
    FTR_HIGHER_SAFE = 2,
    FTR_HIGHER_OR_ZERO_SAFE = 3,
};

enum ftrace_bug_type {
    FTRACE_BUG_UNKNOWN = 0,
    FTRACE_BUG_INIT = 1,
    FTRACE_BUG_NOP = 2,
    FTRACE_BUG_CALL = 3,
    FTRACE_BUG_UPDATE = 4,
};

enum ftrace_dump_mode {
    DUMP_NONE = 0,
    DUMP_ALL = 1,
    DUMP_ORIG = 2,
    DUMP_PARAM = 3,
};

enum ftrace_ops_cmd {
    FTRACE_OPS_CMD_ENABLE_SHARE_IPMODIFY_SELF = 0,
    FTRACE_OPS_CMD_ENABLE_SHARE_IPMODIFY_PEER = 1,
    FTRACE_OPS_CMD_DISABLE_SHARE_IPMODIFY_PEER = 2,
};

enum funcs {
    func_alt0 = 0,
    func_alt1___2 = 1,
    func_alt2___2 = 2,
    func_alt3___2 = 3,
    func_alt4___2 = 4,
    func_gpio___2 = 5,
    func_alt6___2 = 6,
    func_alt7___2 = 7,
    func_alt8___2 = 8,
    func_none = 9,
    func_aaud = 10,
    func_dcd0 = 11,
    func_dpi = 12,
    func_dsi0_te_ext = 13,
    func_dsi1_te_ext = 14,
    func_dsr0 = 15,
    func_dtr0 = 16,
    func_gpclk0___2 = 17,
    func_gpclk1___2 = 18,
    func_gpclk2___2 = 19,
    func_gpclk3 = 20,
    func_gpclk4 = 21,
    func_gpclk5 = 22,
    func_i2c0 = 23,
    func_i2c1 = 24,
    func_i2c2 = 25,
    func_i2c3 = 26,
    func_i2c4 = 27,
    func_i2c5 = 28,
    func_i2c6 = 29,
    func_i2s0 = 30,
    func_i2s1 = 31,
    func_i2s2 = 32,
    func_ir = 33,
    func_mic = 34,
    func_pcie_clkreq_n = 35,
    func_pio = 36,
    func_proc_rio = 37,
    func_pwm0 = 38,
    func_pwm1 = 39,
    func_ri0 = 40,
    func_sd0___2 = 41,
    func_sd1 = 42,
    func_spi0 = 43,
    func_spi1 = 44,
    func_spi2 = 45,
    func_spi3 = 46,
    func_spi4 = 47,
    func_spi5 = 48,
    func_spi6 = 49,
    func_spi7 = 50,
    func_spi8 = 51,
    func_uart0___2 = 52,
    func_uart1___2 = 53,
    func_uart2___2 = 54,
    func_uart3 = 55,
    func_uart4 = 56,
    func_uart5 = 57,
    func_vbus0 = 58,
    func_vbus1 = 59,
    func_vbus2 = 60,
    func_vbus3 = 61,
    func_____2 = 62,
    func_count___2 = 62,
    func_invalid = 62,
};

enum futex_access {
    FUTEX_READ = 0,
    FUTEX_WRITE = 1,
};

enum fw_opt {
    FW_OPT_UEVENT = 1,
    FW_OPT_NOWAIT = 2,
    FW_OPT_USERHELPER = 4,
    FW_OPT_NO_WARN = 8,
    FW_OPT_NOCACHE = 16,
    FW_OPT_NOFALLBACK_SYSFS = 32,
    FW_OPT_FALLBACK_PLATFORM = 64,
    FW_OPT_PARTIAL = 128,
};

enum fw_status {
    FW_STATUS_UNKNOWN = 0,
    FW_STATUS_LOADING = 1,
    FW_STATUS_DONE = 2,
    FW_STATUS_ABORTED = 3,
};

enum fw_upload_err {
    FW_UPLOAD_ERR_NONE = 0,
    FW_UPLOAD_ERR_HW_ERROR = 1,
    FW_UPLOAD_ERR_TIMEOUT = 2,
    FW_UPLOAD_ERR_CANCELED = 3,
    FW_UPLOAD_ERR_BUSY = 4,
    FW_UPLOAD_ERR_INVALID_SIZE = 5,
    FW_UPLOAD_ERR_RW_ERROR = 6,
    FW_UPLOAD_ERR_WEAROUT = 7,
    FW_UPLOAD_ERR_FW_INVALID = 8,
    FW_UPLOAD_ERR_MAX = 9,
};

enum fw_upload_prog {
    FW_UPLOAD_PROG_IDLE = 0,
    FW_UPLOAD_PROG_RECEIVING = 1,
    FW_UPLOAD_PROG_PREPARING = 2,
    FW_UPLOAD_PROG_TRANSFERRING = 3,
    FW_UPLOAD_PROG_PROGRAMMING = 4,
    FW_UPLOAD_PROG_MAX = 5,
};

enum genl_validate_flags {
    GENL_DONT_VALIDATE_STRICT = 1,
    GENL_DONT_VALIDATE_DUMP = 2,
    GENL_DONT_VALIDATE_DUMP_STRICT = 4,
};

enum genpd_notication {
    GENPD_NOTIFY_PRE_OFF = 0,
    GENPD_NOTIFY_OFF = 1,
    GENPD_NOTIFY_PRE_ON = 2,
    GENPD_NOTIFY_ON = 3,
};

enum gic_intid_range {
    SGI_RANGE = 0,
    PPI_RANGE = 1,
    SPI_RANGE = 2,
    EPPI_RANGE = 3,
    ESPI_RANGE = 4,
    LPI_RANGE = 5,
    __INVALID_RANGE__ = 6,
};

enum gic_type {
    GIC_V2 = 0,
    GIC_V3 = 1,
};

enum gpd_status {
    GENPD_STATE_ON = 0,
    GENPD_STATE_OFF = 1,
};

enum gpio_lookup_flags {
    GPIO_ACTIVE_HIGH = 0,
    GPIO_ACTIVE_LOW = 1,
    GPIO_OPEN_DRAIN = 2,
    GPIO_OPEN_SOURCE = 4,
    GPIO_PERSISTENT = 0,
    GPIO_TRANSITORY = 8,
    GPIO_PULL_UP = 16,
    GPIO_PULL_DOWN = 32,
    GPIO_PULL_DISABLE = 64,
    GPIO_LOOKUP_FLAGS_DEFAULT = 0,
};

enum gpio_v2_line_attr_id {
    GPIO_V2_LINE_ATTR_ID_FLAGS = 1,
    GPIO_V2_LINE_ATTR_ID_OUTPUT_VALUES = 2,
    GPIO_V2_LINE_ATTR_ID_DEBOUNCE = 3,
};

enum gpio_v2_line_changed_type {
    GPIO_V2_LINE_CHANGED_REQUESTED = 1,
    GPIO_V2_LINE_CHANGED_RELEASED = 2,
    GPIO_V2_LINE_CHANGED_CONFIG = 3,
};

enum gpio_v2_line_event_id {
    GPIO_V2_LINE_EVENT_RISING_EDGE = 1,
    GPIO_V2_LINE_EVENT_FALLING_EDGE = 2,
};

enum gpio_v2_line_flag {
    GPIO_V2_LINE_FLAG_USED = 1,
    GPIO_V2_LINE_FLAG_ACTIVE_LOW = 2,
    GPIO_V2_LINE_FLAG_INPUT = 4,
    GPIO_V2_LINE_FLAG_OUTPUT = 8,
    GPIO_V2_LINE_FLAG_EDGE_RISING = 16,
    GPIO_V2_LINE_FLAG_EDGE_FALLING = 32,
    GPIO_V2_LINE_FLAG_OPEN_DRAIN = 64,
    GPIO_V2_LINE_FLAG_OPEN_SOURCE = 128,
    GPIO_V2_LINE_FLAG_BIAS_PULL_UP = 256,
    GPIO_V2_LINE_FLAG_BIAS_PULL_DOWN = 512,
    GPIO_V2_LINE_FLAG_BIAS_DISABLED = 1024,
    GPIO_V2_LINE_FLAG_EVENT_CLOCK_REALTIME = 2048,
    GPIO_V2_LINE_FLAG_EVENT_CLOCK_HTE = 4096,
};

enum gpiod_flags {
    GPIOD_ASIS = 0,
    GPIOD_IN = 1,
    GPIOD_OUT_LOW = 3,
    GPIOD_OUT_HIGH = 7,
    GPIOD_OUT_LOW_OPEN_DRAIN = 11,
    GPIOD_OUT_HIGH_OPEN_DRAIN = 15,
};

enum graph_filter_type {
    GRAPH_FILTER_NOTRACE = 0,
    GRAPH_FILTER_FUNCTION = 1,
};

enum gre_conntrack {
    GRE_CT_UNREPLIED = 0,
    GRE_CT_REPLIED = 1,
    GRE_CT_MAX = 2,
};

enum gro_result {
    GRO_MERGED = 0,
    GRO_MERGED_FREE = 1,
    GRO_HELD = 2,
    GRO_NORMAL = 3,
    GRO_CONSUMED = 4,
};

typedef enum gro_result gro_result_t;

enum group_type {
    group_has_spare = 0,
    group_fully_busy = 1,
    group_misfit_task = 2,
    group_smt_balance = 3,
    group_asym_packing = 4,
    group_imbalanced = 5,
    group_overloaded = 6,
};

enum handle_to_path_flags {
    HANDLE_CHECK_PERMS = 1,
    HANDLE_CHECK_SUBTREE = 2,
};

enum handler_id {
    HANDLER_ONMATCH = 1,
    HANDLER_ONMAX = 2,
    HANDLER_ONCHANGE = 3,
};

enum handshake_auth {
    HANDSHAKE_AUTH_UNSPEC = 0,
    HANDSHAKE_AUTH_UNAUTH = 1,
    HANDSHAKE_AUTH_PSK = 2,
    HANDSHAKE_AUTH_X509 = 3,
};

enum handshake_handler_class {
    HANDSHAKE_HANDLER_CLASS_NONE = 0,
    HANDSHAKE_HANDLER_CLASS_TLSHD = 1,
    HANDSHAKE_HANDLER_CLASS_MAX = 2,
};

enum handshake_msg_type {
    HANDSHAKE_MSG_TYPE_UNSPEC = 0,
    HANDSHAKE_MSG_TYPE_CLIENTHELLO = 1,
    HANDSHAKE_MSG_TYPE_SERVERHELLO = 2,
};

enum hash_algo {
    HASH_ALGO_MD4 = 0,
    HASH_ALGO_MD5 = 1,
    HASH_ALGO_SHA1 = 2,
    HASH_ALGO_RIPE_MD_160 = 3,
    HASH_ALGO_SHA256 = 4,
    HASH_ALGO_SHA384 = 5,
    HASH_ALGO_SHA512 = 6,
    HASH_ALGO_SHA224 = 7,
    HASH_ALGO_RIPE_MD_128 = 8,
    HASH_ALGO_RIPE_MD_256 = 9,
    HASH_ALGO_RIPE_MD_320 = 10,
    HASH_ALGO_WP_256 = 11,
    HASH_ALGO_WP_384 = 12,
    HASH_ALGO_WP_512 = 13,
    HASH_ALGO_TGR_128 = 14,
    HASH_ALGO_TGR_160 = 15,
    HASH_ALGO_TGR_192 = 16,
    HASH_ALGO_SM3_256 = 17,
    HASH_ALGO_STREEBOG_256 = 18,
    HASH_ALGO_STREEBOG_512 = 19,
    HASH_ALGO_SHA3_256 = 20,
    HASH_ALGO_SHA3_384 = 21,
    HASH_ALGO_SHA3_512 = 22,
    HASH_ALGO__LAST = 23,
};

enum hctx_type {
    HCTX_TYPE_DEFAULT = 0,
    HCTX_TYPE_READ = 1,
    HCTX_TYPE_POLL = 2,
    HCTX_MAX_TYPES = 3,
};

enum hdmi_3d_structure {
    HDMI_3D_STRUCTURE_INVALID = -1,
    HDMI_3D_STRUCTURE_FRAME_PACKING = 0,
    HDMI_3D_STRUCTURE_FIELD_ALTERNATIVE = 1,
    HDMI_3D_STRUCTURE_LINE_ALTERNATIVE = 2,
    HDMI_3D_STRUCTURE_SIDE_BY_SIDE_FULL = 3,
    HDMI_3D_STRUCTURE_L_DEPTH = 4,
    HDMI_3D_STRUCTURE_L_DEPTH_GFX_GFX_DEPTH = 5,
    HDMI_3D_STRUCTURE_TOP_AND_BOTTOM = 6,
    HDMI_3D_STRUCTURE_SIDE_BY_SIDE_HALF = 8,
};

enum hdmi_active_aspect {
    HDMI_ACTIVE_ASPECT_16_9_TOP = 2,
    HDMI_ACTIVE_ASPECT_14_9_TOP = 3,
    HDMI_ACTIVE_ASPECT_16_9_CENTER = 4,
    HDMI_ACTIVE_ASPECT_PICTURE = 8,
    HDMI_ACTIVE_ASPECT_4_3 = 9,
    HDMI_ACTIVE_ASPECT_16_9 = 10,
    HDMI_ACTIVE_ASPECT_14_9 = 11,
    HDMI_ACTIVE_ASPECT_4_3_SP_14_9 = 13,
    HDMI_ACTIVE_ASPECT_16_9_SP_14_9 = 14,
    HDMI_ACTIVE_ASPECT_16_9_SP_4_3 = 15,
};

enum hdmi_audio_coding_type {
    HDMI_AUDIO_CODING_TYPE_STREAM = 0,
    HDMI_AUDIO_CODING_TYPE_PCM = 1,
    HDMI_AUDIO_CODING_TYPE_AC3 = 2,
    HDMI_AUDIO_CODING_TYPE_MPEG1 = 3,
    HDMI_AUDIO_CODING_TYPE_MP3 = 4,
    HDMI_AUDIO_CODING_TYPE_MPEG2 = 5,
    HDMI_AUDIO_CODING_TYPE_AAC_LC = 6,
    HDMI_AUDIO_CODING_TYPE_DTS = 7,
    HDMI_AUDIO_CODING_TYPE_ATRAC = 8,
    HDMI_AUDIO_CODING_TYPE_DSD = 9,
    HDMI_AUDIO_CODING_TYPE_EAC3 = 10,
    HDMI_AUDIO_CODING_TYPE_DTS_HD = 11,
    HDMI_AUDIO_CODING_TYPE_MLP = 12,
    HDMI_AUDIO_CODING_TYPE_DST = 13,
    HDMI_AUDIO_CODING_TYPE_WMA_PRO = 14,
    HDMI_AUDIO_CODING_TYPE_CXT = 15,
};

enum hdmi_audio_coding_type_ext {
    HDMI_AUDIO_CODING_TYPE_EXT_CT = 0,
    HDMI_AUDIO_CODING_TYPE_EXT_HE_AAC = 1,
    HDMI_AUDIO_CODING_TYPE_EXT_HE_AAC_V2 = 2,
    HDMI_AUDIO_CODING_TYPE_EXT_MPEG_SURROUND = 3,
    HDMI_AUDIO_CODING_TYPE_EXT_MPEG4_HE_AAC = 4,
    HDMI_AUDIO_CODING_TYPE_EXT_MPEG4_HE_AAC_V2 = 5,
    HDMI_AUDIO_CODING_TYPE_EXT_MPEG4_AAC_LC = 6,
    HDMI_AUDIO_CODING_TYPE_EXT_DRA = 7,
    HDMI_AUDIO_CODING_TYPE_EXT_MPEG4_HE_AAC_SURROUND = 8,
    HDMI_AUDIO_CODING_TYPE_EXT_MPEG4_AAC_LC_SURROUND = 10,
};

enum hdmi_audio_sample_frequency {
    HDMI_AUDIO_SAMPLE_FREQUENCY_STREAM = 0,
    HDMI_AUDIO_SAMPLE_FREQUENCY_32000 = 1,
    HDMI_AUDIO_SAMPLE_FREQUENCY_44100 = 2,
    HDMI_AUDIO_SAMPLE_FREQUENCY_48000 = 3,
    HDMI_AUDIO_SAMPLE_FREQUENCY_88200 = 4,
    HDMI_AUDIO_SAMPLE_FREQUENCY_96000 = 5,
    HDMI_AUDIO_SAMPLE_FREQUENCY_176400 = 6,
    HDMI_AUDIO_SAMPLE_FREQUENCY_192000 = 7,
};

enum hdmi_audio_sample_size {
    HDMI_AUDIO_SAMPLE_SIZE_STREAM = 0,
    HDMI_AUDIO_SAMPLE_SIZE_16 = 1,
    HDMI_AUDIO_SAMPLE_SIZE_20 = 2,
    HDMI_AUDIO_SAMPLE_SIZE_24 = 3,
};

enum hdmi_colorimetry {
    HDMI_COLORIMETRY_NONE = 0,
    HDMI_COLORIMETRY_ITU_601 = 1,
    HDMI_COLORIMETRY_ITU_709 = 2,
    HDMI_COLORIMETRY_EXTENDED = 3,
};

enum hdmi_colorspace {
    HDMI_COLORSPACE_RGB = 0,
    HDMI_COLORSPACE_YUV422 = 1,
    HDMI_COLORSPACE_YUV444 = 2,
    HDMI_COLORSPACE_YUV420 = 3,
    HDMI_COLORSPACE_RESERVED4 = 4,
    HDMI_COLORSPACE_RESERVED5 = 5,
    HDMI_COLORSPACE_RESERVED6 = 6,
    HDMI_COLORSPACE_IDO_DEFINED = 7,
};

enum hdmi_content_type {
    HDMI_CONTENT_TYPE_GRAPHICS = 0,
    HDMI_CONTENT_TYPE_PHOTO = 1,
    HDMI_CONTENT_TYPE_CINEMA = 2,
    HDMI_CONTENT_TYPE_GAME = 3,
};

enum hdmi_eotf {
    HDMI_EOTF_TRADITIONAL_GAMMA_SDR = 0,
    HDMI_EOTF_TRADITIONAL_GAMMA_HDR = 1,
    HDMI_EOTF_SMPTE_ST2084 = 2,
    HDMI_EOTF_BT_2100_HLG = 3,
};

enum hdmi_extended_colorimetry {
    HDMI_EXTENDED_COLORIMETRY_XV_YCC_601 = 0,
    HDMI_EXTENDED_COLORIMETRY_XV_YCC_709 = 1,
    HDMI_EXTENDED_COLORIMETRY_S_YCC_601 = 2,
    HDMI_EXTENDED_COLORIMETRY_OPYCC_601 = 3,
    HDMI_EXTENDED_COLORIMETRY_OPRGB = 4,
    HDMI_EXTENDED_COLORIMETRY_BT2020_CONST_LUM = 5,
    HDMI_EXTENDED_COLORIMETRY_BT2020 = 6,
    HDMI_EXTENDED_COLORIMETRY_RESERVED = 7,
};

enum hdmi_infoframe_type {
    HDMI_INFOFRAME_TYPE_VENDOR = 129,
    HDMI_INFOFRAME_TYPE_AVI = 130,
    HDMI_INFOFRAME_TYPE_SPD = 131,
    HDMI_INFOFRAME_TYPE_AUDIO = 132,
    HDMI_INFOFRAME_TYPE_DRM = 135,
};

enum hdmi_metadata_type {
    HDMI_STATIC_METADATA_TYPE1 = 0,
};

enum hdmi_nups {
    HDMI_NUPS_UNKNOWN = 0,
    HDMI_NUPS_HORIZONTAL = 1,
    HDMI_NUPS_VERTICAL = 2,
    HDMI_NUPS_BOTH = 3,
};

enum hdmi_picture_aspect {
    HDMI_PICTURE_ASPECT_NONE = 0,
    HDMI_PICTURE_ASPECT_4_3 = 1,
    HDMI_PICTURE_ASPECT_16_9 = 2,
    HDMI_PICTURE_ASPECT_64_27 = 3,
    HDMI_PICTURE_ASPECT_256_135 = 4,
    HDMI_PICTURE_ASPECT_RESERVED = 5,
};

enum hdmi_quantization_range {
    HDMI_QUANTIZATION_RANGE_DEFAULT = 0,
    HDMI_QUANTIZATION_RANGE_LIMITED = 1,
    HDMI_QUANTIZATION_RANGE_FULL = 2,
    HDMI_QUANTIZATION_RANGE_RESERVED = 3,
};

enum hdmi_scan_mode {
    HDMI_SCAN_MODE_NONE = 0,
    HDMI_SCAN_MODE_OVERSCAN = 1,
    HDMI_SCAN_MODE_UNDERSCAN = 2,
    HDMI_SCAN_MODE_RESERVED = 3,
};

enum hdmi_spd_sdi {
    HDMI_SPD_SDI_UNKNOWN = 0,
    HDMI_SPD_SDI_DSTB = 1,
    HDMI_SPD_SDI_DVDP = 2,
    HDMI_SPD_SDI_DVHS = 3,
    HDMI_SPD_SDI_HDDVR = 4,
    HDMI_SPD_SDI_DVC = 5,
    HDMI_SPD_SDI_DSC = 6,
    HDMI_SPD_SDI_VCD = 7,
    HDMI_SPD_SDI_GAME = 8,
    HDMI_SPD_SDI_PC = 9,
    HDMI_SPD_SDI_BD = 10,
    HDMI_SPD_SDI_SACD = 11,
    HDMI_SPD_SDI_HDDVD = 12,
    HDMI_SPD_SDI_PMP = 13,
};

enum hdmi_ycc_quantization_range {
    HDMI_YCC_QUANTIZATION_RANGE_LIMITED = 0,
    HDMI_YCC_QUANTIZATION_RANGE_FULL = 1,
};

enum header_fields {
    HDR_PCR = 0,
    HDR_DIGEST = 1,
    HDR_TEMPLATE_NAME = 2,
    HDR_TEMPLATE_DATA = 3,
    HDR__LAST = 4,
};

enum header_opt {
    IPE_HEADER_POLICY_NAME = 0,
    IPE_HEADER_POLICY_VERSION = 1,
    __IPE_HEADER_MAX = 2,
};

enum hid_battery_status {
    HID_BATTERY_UNKNOWN = 0,
    HID_BATTERY_QUERIED = 1,
    HID_BATTERY_REPORTED = 2,
};

enum hid_class_request {
    HID_REQ_GET_REPORT = 1,
    HID_REQ_GET_IDLE = 2,
    HID_REQ_GET_PROTOCOL = 3,
    HID_REQ_SET_REPORT = 9,
    HID_REQ_SET_IDLE = 10,
    HID_REQ_SET_PROTOCOL = 11,
};

enum hid_report_type {
    HID_INPUT_REPORT = 0,
    HID_OUTPUT_REPORT = 1,
    HID_FEATURE_REPORT = 2,
    HID_REPORT_TYPES = 3,
};

enum hid_type {
    HID_TYPE_OTHER = 0,
    HID_TYPE_USBMOUSE = 1,
    HID_TYPE_USBNONE = 2,
};

enum hist_field_flags {
    HIST_FIELD_FL_HITCOUNT = 1,
    HIST_FIELD_FL_KEY = 2,
    HIST_FIELD_FL_STRING = 4,
    HIST_FIELD_FL_HEX = 8,
    HIST_FIELD_FL_SYM = 16,
    HIST_FIELD_FL_SYM_OFFSET = 32,
    HIST_FIELD_FL_EXECNAME = 64,
    HIST_FIELD_FL_SYSCALL = 128,
    HIST_FIELD_FL_STACKTRACE = 256,
    HIST_FIELD_FL_LOG2 = 512,
    HIST_FIELD_FL_TIMESTAMP = 1024,
    HIST_FIELD_FL_TIMESTAMP_USECS = 2048,
    HIST_FIELD_FL_VAR = 4096,
    HIST_FIELD_FL_EXPR = 8192,
    HIST_FIELD_FL_VAR_REF = 16384,
    HIST_FIELD_FL_CPU = 32768,
    HIST_FIELD_FL_ALIAS = 65536,
    HIST_FIELD_FL_BUCKET = 131072,
    HIST_FIELD_FL_CONST = 262144,
    HIST_FIELD_FL_PERCENT = 524288,
    HIST_FIELD_FL_GRAPH = 1048576,
};

enum hist_field_fn {
    HIST_FIELD_FN_NOP = 0,
    HIST_FIELD_FN_VAR_REF = 1,
    HIST_FIELD_FN_COUNTER = 2,
    HIST_FIELD_FN_CONST = 3,
    HIST_FIELD_FN_LOG2 = 4,
    HIST_FIELD_FN_BUCKET = 5,
    HIST_FIELD_FN_TIMESTAMP = 6,
    HIST_FIELD_FN_CPU = 7,
    HIST_FIELD_FN_STRING = 8,
    HIST_FIELD_FN_DYNSTRING = 9,
    HIST_FIELD_FN_RELDYNSTRING = 10,
    HIST_FIELD_FN_PSTRING = 11,
    HIST_FIELD_FN_S64 = 12,
    HIST_FIELD_FN_U64 = 13,
    HIST_FIELD_FN_S32 = 14,
    HIST_FIELD_FN_U32 = 15,
    HIST_FIELD_FN_S16 = 16,
    HIST_FIELD_FN_U16 = 17,
    HIST_FIELD_FN_S8 = 18,
    HIST_FIELD_FN_U8 = 19,
    HIST_FIELD_FN_UMINUS = 20,
    HIST_FIELD_FN_MINUS = 21,
    HIST_FIELD_FN_PLUS = 22,
    HIST_FIELD_FN_DIV = 23,
    HIST_FIELD_FN_MULT = 24,
    HIST_FIELD_FN_DIV_POWER2 = 25,
    HIST_FIELD_FN_DIV_NOT_POWER2 = 26,
    HIST_FIELD_FN_DIV_MULT_SHIFT = 27,
    HIST_FIELD_FN_EXECNAME = 28,
    HIST_FIELD_FN_STACK = 29,
};

enum hk_flags {
    HK_FLAG_DOMAIN = 1,
    HK_FLAG_MANAGED_IRQ = 2,
    HK_FLAG_KERNEL_NOISE = 4,
};

enum hk_type {
    HK_TYPE_DOMAIN = 0,
    HK_TYPE_MANAGED_IRQ = 1,
    HK_TYPE_KERNEL_NOISE = 2,
    HK_TYPE_MAX = 3,
    HK_TYPE_TICK = 2,
    HK_TYPE_TIMER = 2,
    HK_TYPE_RCU = 2,
    HK_TYPE_MISC = 2,
    HK_TYPE_WQ = 2,
    HK_TYPE_KTHREAD = 2,
};

enum hmm_pfn_flags {
    HMM_PFN_VALID = 9223372036854775808ULL,
    HMM_PFN_WRITE = 4611686018427387904ULL,
    HMM_PFN_ERROR = 2305843009213693952ULL,
    HMM_PFN_ORDER_SHIFT = 56ULL,
    HMM_PFN_REQ_FAULT = 9223372036854775808ULL,
    HMM_PFN_REQ_WRITE = 4611686018427387904ULL,
    HMM_PFN_FLAGS = 18374686479671623680ULL,
};

enum hn_flags_bits {
    HANDSHAKE_F_NET_DRAINING = 0,
};

enum hp_flags_bits {
    HANDSHAKE_F_PROTO_NOTIFY = 0,
};

enum hprobe_state {
    HPROBE_LEASED = 0,
    HPROBE_STABLE = 1,
    HPROBE_GONE = 2,
    HPROBE_CONSUMED = 3,
};

enum hr_flags_bits {
    HANDSHAKE_F_REQ_COMPLETED = 0,
    HANDSHAKE_F_REQ_SESSION = 1,
};

enum hrtimer_base_type {
    HRTIMER_BASE_MONOTONIC = 0,
    HRTIMER_BASE_REALTIME = 1,
    HRTIMER_BASE_BOOTTIME = 2,
    HRTIMER_BASE_TAI = 3,
    HRTIMER_BASE_MONOTONIC_SOFT = 4,
    HRTIMER_BASE_REALTIME_SOFT = 5,
    HRTIMER_BASE_BOOTTIME_SOFT = 6,
    HRTIMER_BASE_TAI_SOFT = 7,
    HRTIMER_MAX_CLOCK_BASES = 8,
};

enum hrtimer_mode {
    HRTIMER_MODE_ABS = 0,
    HRTIMER_MODE_REL = 1,
    HRTIMER_MODE_PINNED = 2,
    HRTIMER_MODE_SOFT = 4,
    HRTIMER_MODE_HARD = 8,
    HRTIMER_MODE_ABS_PINNED = 2,
    HRTIMER_MODE_REL_PINNED = 3,
    HRTIMER_MODE_ABS_SOFT = 4,
    HRTIMER_MODE_REL_SOFT = 5,
    HRTIMER_MODE_ABS_PINNED_SOFT = 6,
    HRTIMER_MODE_REL_PINNED_SOFT = 7,
    HRTIMER_MODE_ABS_HARD = 8,
    HRTIMER_MODE_REL_HARD = 9,
    HRTIMER_MODE_ABS_PINNED_HARD = 10,
    HRTIMER_MODE_REL_PINNED_HARD = 11,
};

enum hrtimer_restart {
    HRTIMER_NORESTART = 0,
    HRTIMER_RESTART = 1,
};

enum hub_activation_type {
    HUB_INIT = 0,
    HUB_INIT2 = 1,
    HUB_INIT3 = 2,
    HUB_POST_RESET = 3,
    HUB_RESUME = 4,
    HUB_RESET_RESUME = 5,
};

enum hub_led_mode {
    INDICATOR_AUTO = 0,
    INDICATOR_CYCLE = 1,
    INDICATOR_GREEN_BLINK = 2,
    INDICATOR_GREEN_BLINK_OFF = 3,
    INDICATOR_AMBER_BLINK = 4,
    INDICATOR_AMBER_BLINK_OFF = 5,
    INDICATOR_ALT_BLINK = 6,
    INDICATOR_ALT_BLINK_OFF = 7,
} __attribute__((mode(byte)));

enum hub_quiescing_type {
    HUB_DISCONNECT = 0,
    HUB_PRE_RESET = 1,
    HUB_SUSPEND = 2,
};

enum hugetlb_memory_event {
    HUGETLB_MAX = 0,
    HUGETLB_NR_MEMORY_EVENTS = 1,
};

enum hugetlb_page_flags {
    HPG_restore_reserve = 0,
    HPG_migratable = 1,
    HPG_temporary = 2,
    HPG_freed = 3,
    HPG_vmemmap_optimized = 4,
    HPG_raw_hwp_unreliable = 5,
    __NR_HPAGEFLAGS = 6,
};

enum hugetlb_param {
    Opt_gid___5 = 0,
    Opt_min_size = 1,
    Opt_mode___4 = 2,
    Opt_nr_inodes = 3,
    Opt_pagesize = 4,
    Opt_size = 5,
    Opt_uid___5 = 6,
};

enum hugetlbfs_size_type {
    NO_SIZE = 0,
    SIZE_STD = 1,
    SIZE_PERCENT = 2,
};

enum hw_breakpoint_ops {
    HW_BREAKPOINT_INSTALL = 0,
    HW_BREAKPOINT_UNINSTALL = 1,
    HW_BREAKPOINT_RESTORE = 2,
};

enum hw_event_mc_err_type {
    HW_EVENT_ERR_CORRECTED = 0,
    HW_EVENT_ERR_UNCORRECTED = 1,
    HW_EVENT_ERR_DEFERRED = 2,
    HW_EVENT_ERR_FATAL = 3,
    HW_EVENT_ERR_INFO = 4,
};

enum hw_protection_action {
    HWPROT_ACT_SHUTDOWN = 0,
    HWPROT_ACT_REBOOT = 1,
};

enum hwmon_chip_attributes {
    hwmon_chip_temp_reset_history = 0,
    hwmon_chip_in_reset_history = 1,
    hwmon_chip_curr_reset_history = 2,
    hwmon_chip_power_reset_history = 3,
    hwmon_chip_register_tz = 4,
    hwmon_chip_update_interval = 5,
    hwmon_chip_alarms = 6,
    hwmon_chip_samples = 7,
    hwmon_chip_curr_samples = 8,
    hwmon_chip_in_samples = 9,
    hwmon_chip_power_samples = 10,
    hwmon_chip_temp_samples = 11,
    hwmon_chip_beep_enable = 12,
    hwmon_chip_pec = 13,
};

enum hwmon_curr_attributes {
    hwmon_curr_enable = 0,
    hwmon_curr_input = 1,
    hwmon_curr_min = 2,
    hwmon_curr_max = 3,
    hwmon_curr_lcrit = 4,
    hwmon_curr_crit = 5,
    hwmon_curr_average = 6,
    hwmon_curr_lowest = 7,
    hwmon_curr_highest = 8,
    hwmon_curr_reset_history = 9,
    hwmon_curr_label = 10,
    hwmon_curr_alarm = 11,
    hwmon_curr_min_alarm = 12,
    hwmon_curr_max_alarm = 13,
    hwmon_curr_lcrit_alarm = 14,
    hwmon_curr_crit_alarm = 15,
    hwmon_curr_rated_min = 16,
    hwmon_curr_rated_max = 17,
    hwmon_curr_beep = 18,
};

enum hwmon_energy_attributes {
    hwmon_energy_enable = 0,
    hwmon_energy_input = 1,
    hwmon_energy_label = 2,
};

enum hwmon_fan_attributes {
    hwmon_fan_enable = 0,
    hwmon_fan_input = 1,
    hwmon_fan_label = 2,
    hwmon_fan_min = 3,
    hwmon_fan_max = 4,
    hwmon_fan_div = 5,
    hwmon_fan_pulses = 6,
    hwmon_fan_target = 7,
    hwmon_fan_alarm = 8,
    hwmon_fan_min_alarm = 9,
    hwmon_fan_max_alarm = 10,
    hwmon_fan_fault = 11,
    hwmon_fan_beep = 12,
};

enum hwmon_humidity_attributes {
    hwmon_humidity_enable = 0,
    hwmon_humidity_input = 1,
    hwmon_humidity_label = 2,
    hwmon_humidity_min = 3,
    hwmon_humidity_min_hyst = 4,
    hwmon_humidity_max = 5,
    hwmon_humidity_max_hyst = 6,
    hwmon_humidity_alarm = 7,
    hwmon_humidity_fault = 8,
    hwmon_humidity_rated_min = 9,
    hwmon_humidity_rated_max = 10,
    hwmon_humidity_min_alarm = 11,
    hwmon_humidity_max_alarm = 12,
};

enum hwmon_in_attributes {
    hwmon_in_enable = 0,
    hwmon_in_input = 1,
    hwmon_in_min = 2,
    hwmon_in_max = 3,
    hwmon_in_lcrit = 4,
    hwmon_in_crit = 5,
    hwmon_in_average = 6,
    hwmon_in_lowest = 7,
    hwmon_in_highest = 8,
    hwmon_in_reset_history = 9,
    hwmon_in_label = 10,
    hwmon_in_alarm = 11,
    hwmon_in_min_alarm = 12,
    hwmon_in_max_alarm = 13,
    hwmon_in_lcrit_alarm = 14,
    hwmon_in_crit_alarm = 15,
    hwmon_in_rated_min = 16,
    hwmon_in_rated_max = 17,
    hwmon_in_beep = 18,
    hwmon_in_fault = 19,
};

enum hwmon_intrusion_attributes {
    hwmon_intrusion_alarm = 0,
    hwmon_intrusion_beep = 1,
};

enum hwmon_power_attributes {
    hwmon_power_enable = 0,
    hwmon_power_average = 1,
    hwmon_power_average_interval = 2,
    hwmon_power_average_interval_max = 3,
    hwmon_power_average_interval_min = 4,
    hwmon_power_average_highest = 5,
    hwmon_power_average_lowest = 6,
    hwmon_power_average_max = 7,
    hwmon_power_average_min = 8,
    hwmon_power_input = 9,
    hwmon_power_input_highest = 10,
    hwmon_power_input_lowest = 11,
    hwmon_power_reset_history = 12,
    hwmon_power_accuracy = 13,
    hwmon_power_cap = 14,
    hwmon_power_cap_hyst = 15,
    hwmon_power_cap_max = 16,
    hwmon_power_cap_min = 17,
    hwmon_power_min = 18,
    hwmon_power_max = 19,
    hwmon_power_crit = 20,
    hwmon_power_lcrit = 21,
    hwmon_power_label = 22,
    hwmon_power_alarm = 23,
    hwmon_power_cap_alarm = 24,
    hwmon_power_min_alarm = 25,
    hwmon_power_max_alarm = 26,
    hwmon_power_lcrit_alarm = 27,
    hwmon_power_crit_alarm = 28,
    hwmon_power_rated_min = 29,
    hwmon_power_rated_max = 30,
};

enum hwmon_pwm_attributes {
    hwmon_pwm_input = 0,
    hwmon_pwm_enable = 1,
    hwmon_pwm_mode = 2,
    hwmon_pwm_freq = 3,
    hwmon_pwm_auto_channels_temp = 4,
};

enum hwmon_sensor_types {
    hwmon_chip = 0,
    hwmon_temp = 1,
    hwmon_in = 2,
    hwmon_curr = 3,
    hwmon_power = 4,
    hwmon_energy = 5,
    hwmon_humidity = 6,
    hwmon_fan = 7,
    hwmon_pwm = 8,
    hwmon_intrusion = 9,
    hwmon_max = 10,
};

enum hwmon_temp_attributes {
    hwmon_temp_enable = 0,
    hwmon_temp_input = 1,
    hwmon_temp_type = 2,
    hwmon_temp_lcrit = 3,
    hwmon_temp_lcrit_hyst = 4,
    hwmon_temp_min = 5,
    hwmon_temp_min_hyst = 6,
    hwmon_temp_max = 7,
    hwmon_temp_max_hyst = 8,
    hwmon_temp_crit = 9,
    hwmon_temp_crit_hyst = 10,
    hwmon_temp_emergency = 11,
    hwmon_temp_emergency_hyst = 12,
    hwmon_temp_alarm = 13,
    hwmon_temp_lcrit_alarm = 14,
    hwmon_temp_min_alarm = 15,
    hwmon_temp_max_alarm = 16,
    hwmon_temp_crit_alarm = 17,
    hwmon_temp_emergency_alarm = 18,
    hwmon_temp_fault = 19,
    hwmon_temp_offset = 20,
    hwmon_temp_label = 21,
    hwmon_temp_lowest = 22,
    hwmon_temp_highest = 23,
    hwmon_temp_reset_history = 24,
    hwmon_temp_rated_min = 25,
    hwmon_temp_rated_max = 26,
    hwmon_temp_beep = 27,
};

enum hwparam_type {
    hwparam_ioport = 0,
    hwparam_iomem = 1,
    hwparam_ioport_or_iomem = 2,
    hwparam_irq = 3,
    hwparam_dma = 4,
    hwparam_dma_addr = 5,
    hwparam_other = 6,
};

enum hwtstamp_flags {
    HWTSTAMP_FLAG_BONDED_PHC_INDEX = 1,
    HWTSTAMP_FLAG_LAST = 1,
    HWTSTAMP_FLAG_MASK = 1,
};

enum hwtstamp_provider_qualifier {
    HWTSTAMP_PROVIDER_QUALIFIER_PRECISE = 0,
    HWTSTAMP_PROVIDER_QUALIFIER_APPROX = 1,
    HWTSTAMP_PROVIDER_QUALIFIER_CNT = 2,
};

enum hwtstamp_rx_filters {
    HWTSTAMP_FILTER_NONE = 0,
    HWTSTAMP_FILTER_ALL = 1,
    HWTSTAMP_FILTER_SOME = 2,
    HWTSTAMP_FILTER_PTP_V1_L4_EVENT = 3,
    HWTSTAMP_FILTER_PTP_V1_L4_SYNC = 4,
    HWTSTAMP_FILTER_PTP_V1_L4_DELAY_REQ = 5,
    HWTSTAMP_FILTER_PTP_V2_L4_EVENT = 6,
    HWTSTAMP_FILTER_PTP_V2_L4_SYNC = 7,
    HWTSTAMP_FILTER_PTP_V2_L4_DELAY_REQ = 8,
    HWTSTAMP_FILTER_PTP_V2_L2_EVENT = 9,
    HWTSTAMP_FILTER_PTP_V2_L2_SYNC = 10,
    HWTSTAMP_FILTER_PTP_V2_L2_DELAY_REQ = 11,
    HWTSTAMP_FILTER_PTP_V2_EVENT = 12,
    HWTSTAMP_FILTER_PTP_V2_SYNC = 13,
    HWTSTAMP_FILTER_PTP_V2_DELAY_REQ = 14,
    HWTSTAMP_FILTER_NTP_ALL = 15,
    __HWTSTAMP_FILTER_CNT = 16,
};

enum hwtstamp_source {
    HWTSTAMP_SOURCE_UNSPEC = 0,
    HWTSTAMP_SOURCE_NETDEV = 1,
    HWTSTAMP_SOURCE_PHYLIB = 2,
};

enum hwtstamp_tx_types {
    HWTSTAMP_TX_OFF = 0,
    HWTSTAMP_TX_ON = 1,
    HWTSTAMP_TX_ONESTEP_SYNC = 2,
    HWTSTAMP_TX_ONESTEP_P2P = 3,
    __HWTSTAMP_TX_CNT = 4,
};

enum i2c_alert_protocol {
    I2C_PROTOCOL_SMBUS_ALERT = 0,
    I2C_PROTOCOL_SMBUS_HOST_NOTIFY = 1,
};

enum i2c_slave_event {
    I2C_SLAVE_READ_REQUESTED = 0,
    I2C_SLAVE_WRITE_REQUESTED = 1,
    I2C_SLAVE_READ_PROCESSED = 2,
    I2C_SLAVE_WRITE_RECEIVED = 3,
    I2C_SLAVE_STOP = 4,
};

enum ib_atomic_cap {
    IB_ATOMIC_NONE = 0,
    IB_ATOMIC_HCA = 1,
    IB_ATOMIC_GLOB = 2,
};

enum ib_cq_notify_flags {
    IB_CQ_SOLICITED = 1,
    IB_CQ_NEXT_COMP = 2,
    IB_CQ_SOLICITED_MASK = 3,
    IB_CQ_REPORT_MISSED_EVENTS = 4,
};

enum ib_event_type {
    IB_EVENT_CQ_ERR = 0,
    IB_EVENT_QP_FATAL = 1,
    IB_EVENT_QP_REQ_ERR = 2,
    IB_EVENT_QP_ACCESS_ERR = 3,
    IB_EVENT_COMM_EST = 4,
    IB_EVENT_SQ_DRAINED = 5,
    IB_EVENT_PATH_MIG = 6,
    IB_EVENT_PATH_MIG_ERR = 7,
    IB_EVENT_DEVICE_FATAL = 8,
    IB_EVENT_PORT_ACTIVE = 9,
    IB_EVENT_PORT_ERR = 10,
    IB_EVENT_LID_CHANGE = 11,
    IB_EVENT_PKEY_CHANGE = 12,
    IB_EVENT_SM_CHANGE = 13,
    IB_EVENT_SRQ_ERR = 14,
    IB_EVENT_SRQ_LIMIT_REACHED = 15,
    IB_EVENT_QP_LAST_WQE_REACHED = 16,
    IB_EVENT_CLIENT_REREGISTER = 17,
    IB_EVENT_GID_CHANGE = 18,
    IB_EVENT_WQ_FATAL = 19,
};

enum ib_flow_action_type {
    IB_FLOW_ACTION_UNSPECIFIED = 0,
    IB_FLOW_ACTION_ESP = 1,
};

enum ib_flow_attr_type {
    IB_FLOW_ATTR_NORMAL = 0,
    IB_FLOW_ATTR_ALL_DEFAULT = 1,
    IB_FLOW_ATTR_MC_DEFAULT = 2,
    IB_FLOW_ATTR_SNIFFER = 3,
};

enum ib_flow_spec_type {
    IB_FLOW_SPEC_ETH = 32,
    IB_FLOW_SPEC_IB = 34,
    IB_FLOW_SPEC_IPV4 = 48,
    IB_FLOW_SPEC_IPV6 = 49,
    IB_FLOW_SPEC_ESP = 52,
    IB_FLOW_SPEC_TCP = 64,
    IB_FLOW_SPEC_UDP = 65,
    IB_FLOW_SPEC_VXLAN_TUNNEL = 80,
    IB_FLOW_SPEC_GRE = 81,
    IB_FLOW_SPEC_MPLS = 96,
    IB_FLOW_SPEC_INNER = 256,
    IB_FLOW_SPEC_ACTION_TAG = 4096,
    IB_FLOW_SPEC_ACTION_DROP = 4097,
    IB_FLOW_SPEC_ACTION_HANDLE = 4098,
    IB_FLOW_SPEC_ACTION_COUNT = 4099,
};

enum ib_gid_type {
    IB_GID_TYPE_IB = 0,
    IB_GID_TYPE_ROCE = 1,
    IB_GID_TYPE_ROCE_UDP_ENCAP = 2,
    IB_GID_TYPE_SIZE = 3,
};

enum ib_mig_state {
    IB_MIG_MIGRATED = 0,
    IB_MIG_REARM = 1,
    IB_MIG_ARMED = 2,
};

enum ib_mr_type {
    IB_MR_TYPE_MEM_REG = 0,
    IB_MR_TYPE_SG_GAPS = 1,
    IB_MR_TYPE_DM = 2,
    IB_MR_TYPE_USER = 3,
    IB_MR_TYPE_DMA = 4,
    IB_MR_TYPE_INTEGRITY = 5,
};

enum ib_mtu {
    IB_MTU_256 = 1,
    IB_MTU_512 = 2,
    IB_MTU_1024 = 3,
    IB_MTU_2048 = 4,
    IB_MTU_4096 = 5,
};

enum ib_mw_type {
    IB_MW_TYPE_1 = 1,
    IB_MW_TYPE_2 = 2,
};

enum ib_poll_context {
    IB_POLL_SOFTIRQ = 0,
    IB_POLL_WORKQUEUE = 1,
    IB_POLL_UNBOUND_WORKQUEUE = 2,
    IB_POLL_LAST_POOL_TYPE = 2,
    IB_POLL_DIRECT = 3,
};

enum ib_port_state {
    IB_PORT_NOP = 0,
    IB_PORT_DOWN = 1,
    IB_PORT_INIT = 2,
    IB_PORT_ARMED = 3,
    IB_PORT_ACTIVE = 4,
    IB_PORT_ACTIVE_DEFER = 5,
};

enum ib_qp_state {
    IB_QPS_RESET = 0,
    IB_QPS_INIT = 1,
    IB_QPS_RTR = 2,
    IB_QPS_RTS = 3,
    IB_QPS_SQD = 4,
    IB_QPS_SQE = 5,
    IB_QPS_ERR = 6,
};

enum ib_qp_type {
    IB_QPT_SMI = 0,
    IB_QPT_GSI = 1,
    IB_QPT_RC = 2,
    IB_QPT_UC = 3,
    IB_QPT_UD = 4,
    IB_QPT_RAW_IPV6 = 5,
    IB_QPT_RAW_ETHERTYPE = 6,
    IB_QPT_RAW_PACKET = 8,
    IB_QPT_XRC_INI = 9,
    IB_QPT_XRC_TGT = 10,
    IB_QPT_MAX = 11,
    IB_QPT_DRIVER = 255,
    IB_QPT_RESERVED1 = 4096,
    IB_QPT_RESERVED2 = 4097,
    IB_QPT_RESERVED3 = 4098,
    IB_QPT_RESERVED4 = 4099,
    IB_QPT_RESERVED5 = 4100,
    IB_QPT_RESERVED6 = 4101,
    IB_QPT_RESERVED7 = 4102,
    IB_QPT_RESERVED8 = 4103,
    IB_QPT_RESERVED9 = 4104,
    IB_QPT_RESERVED10 = 4105,
};

enum ib_sig_err_type {
    IB_SIG_BAD_GUARD = 0,
    IB_SIG_BAD_REFTAG = 1,
    IB_SIG_BAD_APPTAG = 2,
};

enum ib_sig_type {
    IB_SIGNAL_ALL_WR = 0,
    IB_SIGNAL_REQ_WR = 1,
};

enum ib_signature_type {
    IB_SIG_TYPE_NONE = 0,
    IB_SIG_TYPE_T10_DIF = 1,
};

enum ib_srq_attr_mask {
    IB_SRQ_MAX_WR = 1,
    IB_SRQ_LIMIT = 2,
};

enum ib_srq_type {
    IB_SRQT_BASIC = 0,
    IB_SRQT_XRC = 1,
    IB_SRQT_TM = 2,
};

enum ib_t10_dif_bg_type {
    IB_T10DIF_CRC = 0,
    IB_T10DIF_CSUM = 1,
};

enum ib_uverbs_access_flags {
    IB_UVERBS_ACCESS_LOCAL_WRITE = 1,
    IB_UVERBS_ACCESS_REMOTE_WRITE = 2,
    IB_UVERBS_ACCESS_REMOTE_READ = 4,
    IB_UVERBS_ACCESS_REMOTE_ATOMIC = 8,
    IB_UVERBS_ACCESS_MW_BIND = 16,
    IB_UVERBS_ACCESS_ZERO_BASED = 32,
    IB_UVERBS_ACCESS_ON_DEMAND = 64,
    IB_UVERBS_ACCESS_HUGETLB = 128,
    IB_UVERBS_ACCESS_FLUSH_GLOBAL = 256,
    IB_UVERBS_ACCESS_FLUSH_PERSISTENT = 512,
    IB_UVERBS_ACCESS_RELAXED_ORDERING = 1048576,
    IB_UVERBS_ACCESS_OPTIONAL_RANGE = 1072693248,
};

enum ib_uverbs_advise_mr_advice {
    IB_UVERBS_ADVISE_MR_ADVICE_PREFETCH = 0,
    IB_UVERBS_ADVISE_MR_ADVICE_PREFETCH_WRITE = 1,
    IB_UVERBS_ADVISE_MR_ADVICE_PREFETCH_NO_FAULT = 2,
};

enum ib_uverbs_create_qp_mask {
    IB_UVERBS_CREATE_QP_MASK_IND_TABLE = 1,
};

enum ib_uverbs_device_cap_flags {
    IB_UVERBS_DEVICE_RESIZE_MAX_WR = 1ULL,
    IB_UVERBS_DEVICE_BAD_PKEY_CNTR = 2ULL,
    IB_UVERBS_DEVICE_BAD_QKEY_CNTR = 4ULL,
    IB_UVERBS_DEVICE_RAW_MULTI = 8ULL,
    IB_UVERBS_DEVICE_AUTO_PATH_MIG = 16ULL,
    IB_UVERBS_DEVICE_CHANGE_PHY_PORT = 32ULL,
    IB_UVERBS_DEVICE_UD_AV_PORT_ENFORCE = 64ULL,
    IB_UVERBS_DEVICE_CURR_QP_STATE_MOD = 128ULL,
    IB_UVERBS_DEVICE_SHUTDOWN_PORT = 256ULL,
    IB_UVERBS_DEVICE_PORT_ACTIVE_EVENT = 1024ULL,
    IB_UVERBS_DEVICE_SYS_IMAGE_GUID = 2048ULL,
    IB_UVERBS_DEVICE_RC_RNR_NAK_GEN = 4096ULL,
    IB_UVERBS_DEVICE_SRQ_RESIZE = 8192ULL,
    IB_UVERBS_DEVICE_N_NOTIFY_CQ = 16384ULL,
    IB_UVERBS_DEVICE_MEM_WINDOW = 131072ULL,
    IB_UVERBS_DEVICE_UD_IP_CSUM = 262144ULL,
    IB_UVERBS_DEVICE_XRC = 1048576ULL,
    IB_UVERBS_DEVICE_MEM_MGT_EXTENSIONS = 2097152ULL,
    IB_UVERBS_DEVICE_MEM_WINDOW_TYPE_2A = 8388608ULL,
    IB_UVERBS_DEVICE_MEM_WINDOW_TYPE_2B = 16777216ULL,
    IB_UVERBS_DEVICE_RC_IP_CSUM = 33554432ULL,
    IB_UVERBS_DEVICE_RAW_IP_CSUM = 67108864ULL,
    IB_UVERBS_DEVICE_MANAGED_FLOW_STEERING = 536870912ULL,
    IB_UVERBS_DEVICE_RAW_SCATTER_FCS = 17179869184ULL,
    IB_UVERBS_DEVICE_PCI_WRITE_END_PADDING = 68719476736ULL,
    IB_UVERBS_DEVICE_FLUSH_GLOBAL = 274877906944ULL,
    IB_UVERBS_DEVICE_FLUSH_PERSISTENT = 549755813888ULL,
    IB_UVERBS_DEVICE_ATOMIC_WRITE = 1099511627776ULL,
};

enum ib_uverbs_gid_type {
    IB_UVERBS_GID_TYPE_IB = 0,
    IB_UVERBS_GID_TYPE_ROCE_V1 = 1,
    IB_UVERBS_GID_TYPE_ROCE_V2 = 2,
};

enum ib_uverbs_qp_create_flags {
    IB_UVERBS_QP_CREATE_BLOCK_MULTICAST_LOOPBACK = 2,
    IB_UVERBS_QP_CREATE_SCATTER_FCS = 256,
    IB_UVERBS_QP_CREATE_CVLAN_STRIPPING = 512,
    IB_UVERBS_QP_CREATE_PCI_WRITE_END_PADDING = 2048,
    IB_UVERBS_QP_CREATE_SQ_SIG_ALL = 4096,
};

enum ib_uverbs_qp_type {
    IB_UVERBS_QPT_RC = 2,
    IB_UVERBS_QPT_UC = 3,
    IB_UVERBS_QPT_UD = 4,
    IB_UVERBS_QPT_RAW_PACKET = 8,
    IB_UVERBS_QPT_XRC_INI = 9,
    IB_UVERBS_QPT_XRC_TGT = 10,
    IB_UVERBS_QPT_DRIVER = 255,
};

enum ib_uverbs_raw_packet_caps {
    IB_UVERBS_RAW_PACKET_CAP_CVLAN_STRIPPING = 1,
    IB_UVERBS_RAW_PACKET_CAP_SCATTER_FCS = 2,
    IB_UVERBS_RAW_PACKET_CAP_IP_CSUM = 4,
    IB_UVERBS_RAW_PACKET_CAP_DELAY_DROP = 8,
};

enum ib_uverbs_srq_type {
    IB_UVERBS_SRQT_BASIC = 0,
    IB_UVERBS_SRQT_XRC = 1,
    IB_UVERBS_SRQT_TM = 2,
};

enum ib_uverbs_wc_opcode {
    IB_UVERBS_WC_SEND = 0,
    IB_UVERBS_WC_RDMA_WRITE = 1,
    IB_UVERBS_WC_RDMA_READ = 2,
    IB_UVERBS_WC_COMP_SWAP = 3,
    IB_UVERBS_WC_FETCH_ADD = 4,
    IB_UVERBS_WC_BIND_MW = 5,
    IB_UVERBS_WC_LOCAL_INV = 6,
    IB_UVERBS_WC_TSO = 7,
    IB_UVERBS_WC_FLUSH = 8,
    IB_UVERBS_WC_ATOMIC_WRITE = 9,
};

enum ib_uverbs_wq_flags {
    IB_UVERBS_WQ_FLAGS_CVLAN_STRIPPING = 1,
    IB_UVERBS_WQ_FLAGS_SCATTER_FCS = 2,
    IB_UVERBS_WQ_FLAGS_DELAY_DROP = 4,
    IB_UVERBS_WQ_FLAGS_PCI_WRITE_END_PADDING = 8,
};

enum ib_uverbs_wq_type {
    IB_UVERBS_WQT_RQ = 0,
};

enum ib_uverbs_wr_opcode {
    IB_UVERBS_WR_RDMA_WRITE = 0,
    IB_UVERBS_WR_RDMA_WRITE_WITH_IMM = 1,
    IB_UVERBS_WR_SEND = 2,
    IB_UVERBS_WR_SEND_WITH_IMM = 3,
    IB_UVERBS_WR_RDMA_READ = 4,
    IB_UVERBS_WR_ATOMIC_CMP_AND_SWP = 5,
    IB_UVERBS_WR_ATOMIC_FETCH_AND_ADD = 6,
    IB_UVERBS_WR_LOCAL_INV = 7,
    IB_UVERBS_WR_BIND_MW = 8,
    IB_UVERBS_WR_SEND_WITH_INV = 9,
    IB_UVERBS_WR_TSO = 10,
    IB_UVERBS_WR_RDMA_READ_WITH_INV = 11,
    IB_UVERBS_WR_MASKED_ATOMIC_CMP_AND_SWP = 12,
    IB_UVERBS_WR_MASKED_ATOMIC_FETCH_AND_ADD = 13,
    IB_UVERBS_WR_FLUSH = 14,
    IB_UVERBS_WR_ATOMIC_WRITE = 15,
};

enum ib_uverbs_write_cmds {
    IB_USER_VERBS_CMD_GET_CONTEXT = 0,
    IB_USER_VERBS_CMD_QUERY_DEVICE = 1,
    IB_USER_VERBS_CMD_QUERY_PORT = 2,
    IB_USER_VERBS_CMD_ALLOC_PD = 3,
    IB_USER_VERBS_CMD_DEALLOC_PD = 4,
    IB_USER_VERBS_CMD_CREATE_AH = 5,
    IB_USER_VERBS_CMD_MODIFY_AH = 6,
    IB_USER_VERBS_CMD_QUERY_AH = 7,
    IB_USER_VERBS_CMD_DESTROY_AH = 8,
    IB_USER_VERBS_CMD_REG_MR = 9,
    IB_USER_VERBS_CMD_REG_SMR = 10,
    IB_USER_VERBS_CMD_REREG_MR = 11,
    IB_USER_VERBS_CMD_QUERY_MR = 12,
    IB_USER_VERBS_CMD_DEREG_MR = 13,
    IB_USER_VERBS_CMD_ALLOC_MW = 14,
    IB_USER_VERBS_CMD_BIND_MW = 15,
    IB_USER_VERBS_CMD_DEALLOC_MW = 16,
    IB_USER_VERBS_CMD_CREATE_COMP_CHANNEL = 17,
    IB_USER_VERBS_CMD_CREATE_CQ = 18,
    IB_USER_VERBS_CMD_RESIZE_CQ = 19,
    IB_USER_VERBS_CMD_DESTROY_CQ = 20,
    IB_USER_VERBS_CMD_POLL_CQ = 21,
    IB_USER_VERBS_CMD_PEEK_CQ = 22,
    IB_USER_VERBS_CMD_REQ_NOTIFY_CQ = 23,
    IB_USER_VERBS_CMD_CREATE_QP = 24,
    IB_USER_VERBS_CMD_QUERY_QP = 25,
    IB_USER_VERBS_CMD_MODIFY_QP = 26,
    IB_USER_VERBS_CMD_DESTROY_QP = 27,
    IB_USER_VERBS_CMD_POST_SEND = 28,
    IB_USER_VERBS_CMD_POST_RECV = 29,
    IB_USER_VERBS_CMD_ATTACH_MCAST = 30,
    IB_USER_VERBS_CMD_DETACH_MCAST = 31,
    IB_USER_VERBS_CMD_CREATE_SRQ = 32,
    IB_USER_VERBS_CMD_MODIFY_SRQ = 33,
    IB_USER_VERBS_CMD_QUERY_SRQ = 34,
    IB_USER_VERBS_CMD_DESTROY_SRQ = 35,
    IB_USER_VERBS_CMD_POST_SRQ_RECV = 36,
    IB_USER_VERBS_CMD_OPEN_XRCD = 37,
    IB_USER_VERBS_CMD_CLOSE_XRCD = 38,
    IB_USER_VERBS_CMD_CREATE_XSRQ = 39,
    IB_USER_VERBS_CMD_OPEN_QP = 40,
};

enum ib_wc_opcode {
    IB_WC_SEND = 0,
    IB_WC_RDMA_WRITE = 1,
    IB_WC_RDMA_READ = 2,
    IB_WC_COMP_SWAP = 3,
    IB_WC_FETCH_ADD = 4,
    IB_WC_BIND_MW = 5,
    IB_WC_LOCAL_INV = 6,
    IB_WC_LSO = 7,
    IB_WC_ATOMIC_WRITE = 9,
    IB_WC_REG_MR = 10,
    IB_WC_MASKED_COMP_SWAP = 11,
    IB_WC_MASKED_FETCH_ADD = 12,
    IB_WC_FLUSH = 8,
    IB_WC_RECV = 128,
    IB_WC_RECV_RDMA_WITH_IMM = 129,
};

enum ib_wc_status {
    IB_WC_SUCCESS = 0,
    IB_WC_LOC_LEN_ERR = 1,
    IB_WC_LOC_QP_OP_ERR = 2,
    IB_WC_LOC_EEC_OP_ERR = 3,
    IB_WC_LOC_PROT_ERR = 4,
    IB_WC_WR_FLUSH_ERR = 5,
    IB_WC_MW_BIND_ERR = 6,
    IB_WC_BAD_RESP_ERR = 7,
    IB_WC_LOC_ACCESS_ERR = 8,
    IB_WC_REM_INV_REQ_ERR = 9,
    IB_WC_REM_ACCESS_ERR = 10,
    IB_WC_REM_OP_ERR = 11,
    IB_WC_RETRY_EXC_ERR = 12,
    IB_WC_RNR_RETRY_EXC_ERR = 13,
    IB_WC_LOC_RDD_VIOL_ERR = 14,
    IB_WC_REM_INV_RD_REQ_ERR = 15,
    IB_WC_REM_ABORT_ERR = 16,
    IB_WC_INV_EECN_ERR = 17,
    IB_WC_INV_EEC_STATE_ERR = 18,
    IB_WC_FATAL_ERR = 19,
    IB_WC_RESP_TIMEOUT_ERR = 20,
    IB_WC_GENERAL_ERR = 21,
};

enum ib_wq_state {
    IB_WQS_RESET = 0,
    IB_WQS_RDY = 1,
    IB_WQS_ERR = 2,
};

enum ib_wq_type {
    IB_WQT_RQ = 0,
};

enum ib_wr_opcode {
    IB_WR_RDMA_WRITE = 0,
    IB_WR_RDMA_WRITE_WITH_IMM = 1,
    IB_WR_SEND = 2,
    IB_WR_SEND_WITH_IMM = 3,
    IB_WR_RDMA_READ = 4,
    IB_WR_ATOMIC_CMP_AND_SWP = 5,
    IB_WR_ATOMIC_FETCH_AND_ADD = 6,
    IB_WR_BIND_MW = 8,
    IB_WR_LSO = 10,
    IB_WR_SEND_WITH_INV = 9,
    IB_WR_RDMA_READ_WITH_INV = 11,
    IB_WR_LOCAL_INV = 7,
    IB_WR_MASKED_ATOMIC_CMP_AND_SWP = 12,
    IB_WR_MASKED_ATOMIC_FETCH_AND_ADD = 13,
    IB_WR_FLUSH = 14,
    IB_WR_ATOMIC_WRITE = 15,
    IB_WR_REG_MR = 32,
    IB_WR_REG_MR_INTEGRITY = 33,
    IB_WR_RESERVED1 = 240,
    IB_WR_RESERVED2 = 241,
    IB_WR_RESERVED3 = 242,
    IB_WR_RESERVED4 = 243,
    IB_WR_RESERVED5 = 244,
    IB_WR_RESERVED6 = 245,
    IB_WR_RESERVED7 = 246,
    IB_WR_RESERVED8 = 247,
    IB_WR_RESERVED9 = 248,
    IB_WR_RESERVED10 = 249,
};

enum ieee80211_bss_type {
    IEEE80211_BSS_TYPE_ESS = 0,
    IEEE80211_BSS_TYPE_PBSS = 1,
    IEEE80211_BSS_TYPE_IBSS = 2,
    IEEE80211_BSS_TYPE_MBSS = 3,
    IEEE80211_BSS_TYPE_ANY = 4,
};

enum ieee80211_edmg_bw_config {
    IEEE80211_EDMG_BW_CONFIG_4 = 4,
    IEEE80211_EDMG_BW_CONFIG_5 = 5,
    IEEE80211_EDMG_BW_CONFIG_6 = 6,
    IEEE80211_EDMG_BW_CONFIG_7 = 7,
    IEEE80211_EDMG_BW_CONFIG_8 = 8,
    IEEE80211_EDMG_BW_CONFIG_9 = 9,
    IEEE80211_EDMG_BW_CONFIG_10 = 10,
    IEEE80211_EDMG_BW_CONFIG_11 = 11,
    IEEE80211_EDMG_BW_CONFIG_12 = 12,
    IEEE80211_EDMG_BW_CONFIG_13 = 13,
    IEEE80211_EDMG_BW_CONFIG_14 = 14,
    IEEE80211_EDMG_BW_CONFIG_15 = 15,
};

enum ieee802154_filtering_level {
    IEEE802154_FILTERING_NONE = 0,
    IEEE802154_FILTERING_1_FCS = 1,
    IEEE802154_FILTERING_2_PROMISCUOUS = 2,
    IEEE802154_FILTERING_3_SCAN = 3,
    IEEE802154_FILTERING_4_FRAME_FIELDS = 4,
};

enum ieee8021q_traffic_type {
    IEEE8021Q_TT_BK = 0,
    IEEE8021Q_TT_BE = 1,
    IEEE8021Q_TT_EE = 2,
    IEEE8021Q_TT_CA = 3,
    IEEE8021Q_TT_VI = 4,
    IEEE8021Q_TT_VO = 5,
    IEEE8021Q_TT_IC = 6,
    IEEE8021Q_TT_NC = 7,
    IEEE8021Q_TT_MAX = 8,
};

enum ieee_attrs {
    DCB_ATTR_IEEE_UNSPEC = 0,
    DCB_ATTR_IEEE_ETS = 1,
    DCB_ATTR_IEEE_PFC = 2,
    DCB_ATTR_IEEE_APP_TABLE = 3,
    DCB_ATTR_IEEE_PEER_ETS = 4,
    DCB_ATTR_IEEE_PEER_PFC = 5,
    DCB_ATTR_IEEE_PEER_APP = 6,
    DCB_ATTR_IEEE_MAXRATE = 7,
    DCB_ATTR_IEEE_QCN = 8,
    DCB_ATTR_IEEE_QCN_STATS = 9,
    DCB_ATTR_DCB_BUFFER = 10,
    DCB_ATTR_DCB_APP_TRUST_TABLE = 11,
    DCB_ATTR_DCB_REWR_TABLE = 12,
    __DCB_ATTR_IEEE_MAX = 13,
};

enum ieee_attrs_app {
    DCB_ATTR_IEEE_APP_UNSPEC = 0,
    DCB_ATTR_IEEE_APP = 1,
    DCB_ATTR_DCB_APP = 2,
    __DCB_ATTR_IEEE_APP_MAX = 3,
};

enum ima_fs_flags {
    IMA_FS_BUSY = 0,
};

enum ima_hooks {
    NONE = 0,
    FILE_CHECK = 1,
    MMAP_CHECK = 2,
    MMAP_CHECK_REQPROT = 3,
    BPRM_CHECK = 4,
    CREDS_CHECK = 5,
    POST_SETATTR = 6,
    MODULE_CHECK = 7,
    FIRMWARE_CHECK = 8,
    KEXEC_KERNEL_CHECK = 9,
    KEXEC_INITRAMFS_CHECK = 10,
    POLICY_CHECK = 11,
    KEXEC_CMDLINE = 12,
    KEY_CHECK = 13,
    CRITICAL_DATA = 14,
    SETXATTR_CHECK = 15,
    MAX_CHECK = 16,
};

enum ima_show_type {
    IMA_SHOW_BINARY = 0,
    IMA_SHOW_BINARY_NO_FIELD_LEN = 1,
    IMA_SHOW_BINARY_OLD_STRING_FMT = 2,
    IMA_SHOW_ASCII = 3,
};

enum in6_addr_gen_mode {
    IN6_ADDR_GEN_MODE_EUI64 = 0,
    IN6_ADDR_GEN_MODE_NONE = 1,
    IN6_ADDR_GEN_MODE_STABLE_PRIVACY = 2,
    IN6_ADDR_GEN_MODE_RANDOM = 3,
};

enum inet_csk_ack_state_t {
    ICSK_ACK_SCHED = 1,
    ICSK_ACK_TIMER = 2,
    ICSK_ACK_PUSHED = 4,
    ICSK_ACK_PUSHED2 = 8,
    ICSK_ACK_NOW = 16,
    ICSK_ACK_NOMEM = 32,
};

enum inode_i_mutex_lock_class {
    I_MUTEX_NORMAL = 0,
    I_MUTEX_PARENT = 1,
    I_MUTEX_CHILD = 2,
    I_MUTEX_XATTR = 3,
    I_MUTEX_NONDIR2 = 4,
    I_MUTEX_PARENT2 = 5,
};

enum input_clock_type {
    INPUT_CLK_REAL = 0,
    INPUT_CLK_MONO = 1,
    INPUT_CLK_BOOT = 2,
    INPUT_CLK_MAX = 3,
};

enum insn_emulation_mode {
    INSN_UNDEF = 0,
    INSN_EMULATE = 1,
    INSN_HW = 2,
};

enum integrity_status {
    INTEGRITY_PASS = 0,
    INTEGRITY_PASS_IMMUTABLE = 1,
    INTEGRITY_FAIL = 2,
    INTEGRITY_FAIL_IMMUTABLE = 3,
    INTEGRITY_NOLABEL = 4,
    INTEGRITY_NOXATTRS = 5,
    INTEGRITY_UNKNOWN = 6,
};

enum io_pgtable_caps {
    IO_PGTABLE_CAP_CUSTOM_ALLOCATOR = 1,
};

enum io_pgtable_fmt {
    ARM_32_LPAE_S1 = 0,
    ARM_32_LPAE_S2 = 1,
    ARM_64_LPAE_S1 = 2,
    ARM_64_LPAE_S2 = 3,
    ARM_V7S = 4,
    ARM_MALI_LPAE = 5,
    AMD_IOMMU_V1 = 6,
    AMD_IOMMU_V2 = 7,
    APPLE_DART = 8,
    APPLE_DART2 = 9,
    IO_PGTABLE_NUM_FMTS = 10,
};

enum io_uring_cmd_flags {
    IO_URING_F_COMPLETE_DEFER = 1,
    IO_URING_F_UNLOCKED = 2,
    IO_URING_F_MULTISHOT = 4,
    IO_URING_F_IOWQ = 8,
    IO_URING_F_NONBLOCK = -2147483648,
    IO_URING_F_SQE128 = 256,
    IO_URING_F_CQE32 = 512,
    IO_URING_F_IOPOLL = 1024,
    IO_URING_F_CANCEL = 2048,
    IO_URING_F_COMPAT = 4096,
    IO_URING_F_TASK_DEAD = 8192,
};

enum io_uring_msg_ring_flags {
    IORING_MSG_DATA = 0,
    IORING_MSG_SEND_FD = 1,
};

enum io_uring_napi_op {
    IO_URING_NAPI_REGISTER_OP = 0,
    IO_URING_NAPI_STATIC_ADD_ID = 1,
    IO_URING_NAPI_STATIC_DEL_ID = 2,
};

enum io_uring_napi_tracking_strategy {
    IO_URING_NAPI_TRACKING_DYNAMIC = 0,
    IO_URING_NAPI_TRACKING_STATIC = 1,
    IO_URING_NAPI_TRACKING_INACTIVE = 255,
};

enum io_uring_op {
    IORING_OP_NOP = 0,
    IORING_OP_READV = 1,
    IORING_OP_WRITEV = 2,
    IORING_OP_FSYNC = 3,
    IORING_OP_READ_FIXED = 4,
    IORING_OP_WRITE_FIXED = 5,
    IORING_OP_POLL_ADD = 6,
    IORING_OP_POLL_REMOVE = 7,
    IORING_OP_SYNC_FILE_RANGE = 8,
    IORING_OP_SENDMSG = 9,
    IORING_OP_RECVMSG = 10,
    IORING_OP_TIMEOUT = 11,
    IORING_OP_TIMEOUT_REMOVE = 12,
    IORING_OP_ACCEPT = 13,
    IORING_OP_ASYNC_CANCEL = 14,
    IORING_OP_LINK_TIMEOUT = 15,
    IORING_OP_CONNECT = 16,
    IORING_OP_FALLOCATE = 17,
    IORING_OP_OPENAT = 18,
    IORING_OP_CLOSE = 19,
    IORING_OP_FILES_UPDATE = 20,
    IORING_OP_STATX = 21,
    IORING_OP_READ = 22,
    IORING_OP_WRITE = 23,
    IORING_OP_FADVISE = 24,
    IORING_OP_MADVISE = 25,
    IORING_OP_SEND = 26,
    IORING_OP_RECV = 27,
    IORING_OP_OPENAT2 = 28,
    IORING_OP_EPOLL_CTL = 29,
    IORING_OP_SPLICE = 30,
    IORING_OP_PROVIDE_BUFFERS = 31,
    IORING_OP_REMOVE_BUFFERS = 32,
    IORING_OP_TEE = 33,
    IORING_OP_SHUTDOWN = 34,
    IORING_OP_RENAMEAT = 35,
    IORING_OP_UNLINKAT = 36,
    IORING_OP_MKDIRAT = 37,
    IORING_OP_SYMLINKAT = 38,
    IORING_OP_LINKAT = 39,
    IORING_OP_MSG_RING = 40,
    IORING_OP_FSETXATTR = 41,
    IORING_OP_SETXATTR = 42,
    IORING_OP_FGETXATTR = 43,
    IORING_OP_GETXATTR = 44,
    IORING_OP_SOCKET = 45,
    IORING_OP_URING_CMD = 46,
    IORING_OP_SEND_ZC = 47,
    IORING_OP_SENDMSG_ZC = 48,
    IORING_OP_READ_MULTISHOT = 49,
    IORING_OP_WAITID = 50,
    IORING_OP_FUTEX_WAIT = 51,
    IORING_OP_FUTEX_WAKE = 52,
    IORING_OP_FUTEX_WAITV = 53,
    IORING_OP_FIXED_FD_INSTALL = 54,
    IORING_OP_FTRUNCATE = 55,
    IORING_OP_BIND = 56,
    IORING_OP_LISTEN = 57,
    IORING_OP_LAST = 58,
};

enum io_uring_register_op {
    IORING_REGISTER_BUFFERS = 0,
    IORING_UNREGISTER_BUFFERS = 1,
    IORING_REGISTER_FILES = 2,
    IORING_UNREGISTER_FILES = 3,
    IORING_REGISTER_EVENTFD = 4,
    IORING_UNREGISTER_EVENTFD = 5,
    IORING_REGISTER_FILES_UPDATE = 6,
    IORING_REGISTER_EVENTFD_ASYNC = 7,
    IORING_REGISTER_PROBE = 8,
    IORING_REGISTER_PERSONALITY = 9,
    IORING_UNREGISTER_PERSONALITY = 10,
    IORING_REGISTER_RESTRICTIONS = 11,
    IORING_REGISTER_ENABLE_RINGS = 12,
    IORING_REGISTER_FILES2 = 13,
    IORING_REGISTER_FILES_UPDATE2 = 14,
    IORING_REGISTER_BUFFERS2 = 15,
    IORING_REGISTER_BUFFERS_UPDATE = 16,
    IORING_REGISTER_IOWQ_AFF = 17,
    IORING_UNREGISTER_IOWQ_AFF = 18,
    IORING_REGISTER_IOWQ_MAX_WORKERS = 19,
    IORING_REGISTER_RING_FDS = 20,
    IORING_UNREGISTER_RING_FDS = 21,
    IORING_REGISTER_PBUF_RING = 22,
    IORING_UNREGISTER_PBUF_RING = 23,
    IORING_REGISTER_SYNC_CANCEL = 24,
    IORING_REGISTER_FILE_ALLOC_RANGE = 25,
    IORING_REGISTER_PBUF_STATUS = 26,
    IORING_REGISTER_NAPI = 27,
    IORING_UNREGISTER_NAPI = 28,
    IORING_REGISTER_CLOCK = 29,
    IORING_REGISTER_CLONE_BUFFERS = 30,
    IORING_REGISTER_SEND_MSG_RING = 31,
    IORING_REGISTER_RESIZE_RINGS = 33,
    IORING_REGISTER_MEM_REGION = 34,
    IORING_REGISTER_LAST = 35,
    IORING_REGISTER_USE_REGISTERED_RING = 2147483648,
};

enum io_uring_register_pbuf_ring_flags {
    IOU_PBUF_RING_MMAP = 1,
    IOU_PBUF_RING_INC = 2,
};

enum io_uring_register_restriction_op {
    IORING_RESTRICTION_REGISTER_OP = 0,
    IORING_RESTRICTION_SQE_OP = 1,
    IORING_RESTRICTION_SQE_FLAGS_ALLOWED = 2,
    IORING_RESTRICTION_SQE_FLAGS_REQUIRED = 3,
    IORING_RESTRICTION_LAST = 4,
};

enum io_uring_socket_op {
    SOCKET_URING_OP_SIOCINQ = 0,
    SOCKET_URING_OP_SIOCOUTQ = 1,
    SOCKET_URING_OP_GETSOCKOPT = 2,
    SOCKET_URING_OP_SETSOCKOPT = 3,
};

enum io_uring_sqe_flags_bit {
    IOSQE_FIXED_FILE_BIT = 0,
    IOSQE_IO_DRAIN_BIT = 1,
    IOSQE_IO_LINK_BIT = 2,
    IOSQE_IO_HARDLINK_BIT = 3,
    IOSQE_ASYNC_BIT = 4,
    IOSQE_BUFFER_SELECT_BIT = 5,
    IOSQE_CQE_SKIP_SUCCESS_BIT = 6,
};

enum io_wq_cancel {
    IO_WQ_CANCEL_OK = 0,
    IO_WQ_CANCEL_RUNNING = 1,
    IO_WQ_CANCEL_NOTFOUND = 2,
};

enum io_wq_type {
    IO_WQ_BOUND = 0,
    IO_WQ_UNBOUND = 1,
};

enum ioam6_event_attr {
    IOAM6_EVENT_ATTR_UNSPEC = 0,
    IOAM6_EVENT_ATTR_TRACE_NAMESPACE = 1,
    IOAM6_EVENT_ATTR_TRACE_NODELEN = 2,
    IOAM6_EVENT_ATTR_TRACE_TYPE = 3,
    IOAM6_EVENT_ATTR_TRACE_DATA = 4,
    __IOAM6_EVENT_ATTR_MAX = 5,
};

enum ioam6_event_type {
    IOAM6_EVENT_UNSPEC = 0,
    IOAM6_EVENT_TRACE = 1,
};

enum iodev_type {
    IODEV_CPUIF = 0,
    IODEV_DIST = 1,
    IODEV_REDIST = 2,
    IODEV_ITS = 3,
};

enum iommu_cap {
    IOMMU_CAP_CACHE_COHERENCY = 0,
    IOMMU_CAP_NOEXEC = 1,
    IOMMU_CAP_PRE_BOOT_PROTECTION = 2,
    IOMMU_CAP_ENFORCE_CACHE_COHERENCY = 3,
    IOMMU_CAP_DEFERRED_FLUSH = 4,
    IOMMU_CAP_DIRTY_TRACKING = 5,
};

enum iommu_dev_features {
    IOMMU_DEV_FEAT_SVA = 0,
    IOMMU_DEV_FEAT_IOPF = 1,
};

enum iommu_dma_cookie_type {
    IOMMU_DMA_IOVA_COOKIE = 0,
    IOMMU_DMA_MSI_COOKIE = 1,
};

enum iommu_dma_queue_type {
    IOMMU_DMA_OPTS_PER_CPU_QUEUE = 0,
    IOMMU_DMA_OPTS_SINGLE_QUEUE = 1,
};

enum iommu_fault_type {
    IOMMU_FAULT_PAGE_REQ = 1,
};

enum iommu_page_response_code {
    IOMMU_PAGE_RESP_SUCCESS = 0,
    IOMMU_PAGE_RESP_INVALID = 1,
    IOMMU_PAGE_RESP_FAILURE = 2,
};

enum iommu_resv_type {
    IOMMU_RESV_DIRECT = 0,
    IOMMU_RESV_DIRECT_RELAXABLE = 1,
    IOMMU_RESV_RESERVED = 2,
    IOMMU_RESV_MSI = 3,
    IOMMU_RESV_SW_MSI = 4,
};

enum iommufd_hwpt_alloc_flags {
    IOMMU_HWPT_ALLOC_NEST_PARENT = 1,
    IOMMU_HWPT_ALLOC_DIRTY_TRACKING = 2,
    IOMMU_HWPT_FAULT_ID_VALID = 4,
    IOMMU_HWPT_ALLOC_PASID = 8,
};

enum iommufd_object_type {
    IOMMUFD_OBJ_NONE = 0,
    IOMMUFD_OBJ_ANY = 0,
    IOMMUFD_OBJ_DEVICE = 1,
    IOMMUFD_OBJ_HWPT_PAGING = 2,
    IOMMUFD_OBJ_HWPT_NESTED = 3,
    IOMMUFD_OBJ_IOAS = 4,
    IOMMUFD_OBJ_ACCESS = 5,
    IOMMUFD_OBJ_FAULT = 6,
    IOMMUFD_OBJ_VIOMMU = 7,
    IOMMUFD_OBJ_VDEVICE = 8,
    IOMMUFD_OBJ_MAX = 9,
};

enum ip6_defrag_users {
    IP6_DEFRAG_LOCAL_DELIVER = 0,
    IP6_DEFRAG_CONNTRACK_IN = 1,
    __IP6_DEFRAG_CONNTRACK_IN = 65536,
    IP6_DEFRAG_CONNTRACK_OUT = 65537,
    __IP6_DEFRAG_CONNTRACK_OUT = 131072,
    IP6_DEFRAG_CONNTRACK_BRIDGE_IN = 131073,
    __IP6_DEFRAG_CONNTRACK_BRIDGE_IN = 196608,
};

enum ip_conntrack_dir {
    IP_CT_DIR_ORIGINAL = 0,
    IP_CT_DIR_REPLY = 1,
    IP_CT_DIR_MAX = 2,
};

enum ip_conntrack_info {
    IP_CT_ESTABLISHED = 0,
    IP_CT_RELATED = 1,
    IP_CT_NEW = 2,
    IP_CT_IS_REPLY = 3,
    IP_CT_ESTABLISHED_REPLY = 3,
    IP_CT_RELATED_REPLY = 4,
    IP_CT_NUMBER = 5,
    IP_CT_UNTRACKED = 7,
};

enum ip_conntrack_status {
    IPS_EXPECTED_BIT = 0,
    IPS_EXPECTED = 1,
    IPS_SEEN_REPLY_BIT = 1,
    IPS_SEEN_REPLY = 2,
    IPS_ASSURED_BIT = 2,
    IPS_ASSURED = 4,
    IPS_CONFIRMED_BIT = 3,
    IPS_CONFIRMED = 8,
    IPS_SRC_NAT_BIT = 4,
    IPS_SRC_NAT = 16,
    IPS_DST_NAT_BIT = 5,
    IPS_DST_NAT = 32,
    IPS_NAT_MASK = 48,
    IPS_SEQ_ADJUST_BIT = 6,
    IPS_SEQ_ADJUST = 64,
    IPS_SRC_NAT_DONE_BIT = 7,
    IPS_SRC_NAT_DONE = 128,
    IPS_DST_NAT_DONE_BIT = 8,
    IPS_DST_NAT_DONE = 256,
    IPS_NAT_DONE_MASK = 384,
    IPS_DYING_BIT = 9,
    IPS_DYING = 512,
    IPS_FIXED_TIMEOUT_BIT = 10,
    IPS_FIXED_TIMEOUT = 1024,
    IPS_TEMPLATE_BIT = 11,
    IPS_TEMPLATE = 2048,
    IPS_UNTRACKED_BIT = 12,
    IPS_UNTRACKED = 4096,
    IPS_NAT_CLASH_BIT = 12,
    IPS_NAT_CLASH = 4096,
    IPS_HELPER_BIT = 13,
    IPS_HELPER = 8192,
    IPS_OFFLOAD_BIT = 14,
    IPS_OFFLOAD = 16384,
    IPS_HW_OFFLOAD_BIT = 15,
    IPS_HW_OFFLOAD = 32768,
    IPS_UNCHANGEABLE_MASK = 56313,
    __IPS_MAX_BIT = 16,
};

enum ip_defrag_users {
    IP_DEFRAG_LOCAL_DELIVER = 0,
    IP_DEFRAG_CALL_RA_CHAIN = 1,
    IP_DEFRAG_CONNTRACK_IN = 2,
    __IP_DEFRAG_CONNTRACK_IN_END = 65537,
    IP_DEFRAG_CONNTRACK_OUT = 65538,
    __IP_DEFRAG_CONNTRACK_OUT_END = 131073,
    IP_DEFRAG_CONNTRACK_BRIDGE_IN = 131074,
    __IP_DEFRAG_CONNTRACK_BRIDGE_IN = 196609,
    IP_DEFRAG_VS_IN = 196610,
    IP_DEFRAG_VS_OUT = 196611,
    IP_DEFRAG_VS_FWD = 196612,
    IP_DEFRAG_AF_PACKET = 196613,
    IP_DEFRAG_MACVLAN = 196614,
};

enum ipe_action_type {
    IPE_ACTION_ALLOW = 0,
    IPE_ACTION_DENY = 1,
    __IPE_ACTION_MAX = 2,
};

enum ipe_hook_type {
    IPE_HOOK_BPRM_CHECK = 0,
    IPE_HOOK_MMAP = 1,
    IPE_HOOK_MPROTECT = 2,
    IPE_HOOK_KERNEL_READ = 3,
    IPE_HOOK_KERNEL_LOAD = 4,
    __IPE_HOOK_MAX = 5,
};

enum ipe_match {
    IPE_MATCH_RULE = 0,
    IPE_MATCH_TABLE = 1,
    IPE_MATCH_GLOBAL = 2,
    __IPE_MATCH_MAX = 3,
};

enum ipe_op_type {
    IPE_OP_EXEC = 0,
    IPE_OP_FIRMWARE = 1,
    IPE_OP_KERNEL_MODULE = 2,
    IPE_OP_KEXEC_IMAGE = 3,
    IPE_OP_KEXEC_INITRAMFS = 4,
    IPE_OP_POLICY = 5,
    IPE_OP_X509 = 6,
    __IPE_OP_MAX = 7,
};

enum ipe_prop_type {
    IPE_PROP_BOOT_VERIFIED_FALSE = 0,
    IPE_PROP_BOOT_VERIFIED_TRUE = 1,
    IPE_PROP_DMV_ROOTHASH = 2,
    IPE_PROP_DMV_SIG_FALSE = 3,
    IPE_PROP_DMV_SIG_TRUE = 4,
    IPE_PROP_FSV_DIGEST = 5,
    IPE_PROP_FSV_SIG_FALSE = 6,
    IPE_PROP_FSV_SIG_TRUE = 7,
    __IPE_PROP_MAX = 8,
};

enum ipi_msg_type {
    IPI_RESCHEDULE = 0,
    IPI_CALL_FUNC = 1,
    IPI_CPU_STOP = 2,
    IPI_CPU_STOP_NMI = 3,
    IPI_TIMER = 4,
    IPI_IRQ_WORK = 5,
    NR_IPI = 6,
    IPI_CPU_BACKTRACE = 6,
    IPI_KGDB_ROUNDUP = 7,
    MAX_IPI = 8,
};

enum irq_domain_bus_token {
    DOMAIN_BUS_ANY = 0,
    DOMAIN_BUS_WIRED = 1,
    DOMAIN_BUS_GENERIC_MSI = 2,
    DOMAIN_BUS_PCI_MSI = 3,
    DOMAIN_BUS_PLATFORM_MSI = 4,
    DOMAIN_BUS_NEXUS = 5,
    DOMAIN_BUS_IPI = 6,
    DOMAIN_BUS_FSL_MC_MSI = 7,
    DOMAIN_BUS_TI_SCI_INTA_MSI = 8,
    DOMAIN_BUS_WAKEUP = 9,
    DOMAIN_BUS_VMD_MSI = 10,
    DOMAIN_BUS_PCI_DEVICE_MSI = 11,
    DOMAIN_BUS_PCI_DEVICE_MSIX = 12,
    DOMAIN_BUS_DMAR = 13,
    DOMAIN_BUS_AMDVI = 14,
    DOMAIN_BUS_DEVICE_MSI = 15,
    DOMAIN_BUS_WIRED_TO_MSI = 16,
};

enum irq_gc_flags {
    IRQ_GC_INIT_MASK_CACHE = 1,
    IRQ_GC_INIT_NESTED_LOCK = 2,
    IRQ_GC_MASK_CACHE_PER_TYPE = 4,
    IRQ_GC_NO_MASK = 8,
    IRQ_GC_BE_IO = 16,
};

enum irqchip_irq_state {
    IRQCHIP_STATE_PENDING = 0,
    IRQCHIP_STATE_ACTIVE = 1,
    IRQCHIP_STATE_MASKED = 2,
    IRQCHIP_STATE_LINE_LEVEL = 3,
};

enum irqreturn {
    IRQ_NONE = 0,
    IRQ_HANDLED = 1,
    IRQ_WAKE_THREAD = 2,
};

typedef enum irqreturn irqreturn_t;

enum iter_type {
    ITER_UBUF = 0,
    ITER_IOVEC = 1,
    ITER_BVEC = 2,
    ITER_KVEC = 3,
    ITER_FOLIOQ = 4,
    ITER_XARRAY = 5,
    ITER_DISCARD = 6,
};

enum its_vcpu_info_cmd_type {
    MAP_VLPI = 0,
    GET_VLPI = 1,
    PROP_UPDATE_VLPI = 2,
    PROP_UPDATE_AND_INV_VLPI = 3,
    SCHEDULE_VPE = 4,
    DESCHEDULE_VPE = 5,
    COMMIT_VPE = 6,
    INVALL_VPE = 7,
    PROP_UPDATE_VSGI = 8,
};

enum jbd2_shrink_type {
    JBD2_SHRINK_DESTROY = 0,
    JBD2_SHRINK_BUSY_STOP = 1,
    JBD2_SHRINK_BUSY_SKIP = 2,
};

enum jbd_state_bits {
    BH_JBD = 16,
    BH_JWrite = 17,
    BH_Freed = 18,
    BH_Revoked = 19,
    BH_RevokeValid = 20,
    BH_JBDDirty = 21,
    BH_JournalHead = 22,
    BH_Shadow = 23,
    BH_Verified = 24,
    BH_JBDPrivateStart = 25,
};

enum jump_label_type {
    JUMP_LABEL_NOP = 0,
    JUMP_LABEL_JMP = 1,
};

enum kcmp_type {
    KCMP_FILE = 0,
    KCMP_VM = 1,
    KCMP_FILES = 2,
    KCMP_FS = 3,
    KCMP_SIGHAND = 4,
    KCMP_IO = 5,
    KCMP_SYSVSEM = 6,
    KCMP_EPOLL_TFD = 7,
    KCMP_TYPES = 8,
};

enum kcore_type {
    KCORE_TEXT = 0,
    KCORE_VMALLOC = 1,
    KCORE_RAM = 2,
    KCORE_VMEMMAP = 3,
    KCORE_USER = 4,
};

enum kdb_msgsrc {
    KDB_MSGSRC_INTERNAL = 0,
    KDB_MSGSRC_PRINTK = 1,
};

enum kernel_load_data_id {
    LOADING_UNKNOWN = 0,
    LOADING_FIRMWARE = 1,
    LOADING_MODULE = 2,
    LOADING_KEXEC_IMAGE = 3,
    LOADING_KEXEC_INITRAMFS = 4,
    LOADING_POLICY = 5,
    LOADING_X509_CERTIFICATE = 6,
    LOADING_MAX_ID = 7,
};

enum kernel_pkey_operation {
    kernel_pkey_encrypt = 0,
    kernel_pkey_decrypt = 1,
    kernel_pkey_sign = 2,
    kernel_pkey_verify = 3,
};

enum kernel_read_file_id {
    READING_UNKNOWN = 0,
    READING_FIRMWARE = 1,
    READING_MODULE = 2,
    READING_KEXEC_IMAGE = 3,
    READING_KEXEC_INITRAMFS = 4,
    READING_POLICY = 5,
    READING_X509_CERTIFICATE = 6,
    READING_MAX_ID = 7,
};

enum kernfs_node_flag {
    KERNFS_ACTIVATED = 16,
    KERNFS_NS = 32,
    KERNFS_HAS_SEQ_SHOW = 64,
    KERNFS_HAS_MMAP = 128,
    KERNFS_LOCKDEP = 256,
    KERNFS_HIDDEN = 512,
    KERNFS_SUICIDAL = 1024,
    KERNFS_SUICIDED = 2048,
    KERNFS_EMPTY_DIR = 4096,
    KERNFS_HAS_RELEASE = 8192,
    KERNFS_REMOVING = 16384,
};

enum kernfs_node_type {
    KERNFS_DIR = 1,
    KERNFS_FILE = 2,
    KERNFS_LINK = 4,
};

enum kernfs_root_flag {
    KERNFS_ROOT_CREATE_DEACTIVATED = 1,
    KERNFS_ROOT_EXTRA_OPEN_PERM_CHECK = 2,
    KERNFS_ROOT_SUPPORT_EXPORTOP = 4,
    KERNFS_ROOT_SUPPORT_USER_XATTR = 8,
};

enum key_being_used_for {
    VERIFYING_MODULE_SIGNATURE = 0,
    VERIFYING_FIRMWARE_SIGNATURE = 1,
    VERIFYING_KEXEC_PE_SIGNATURE = 2,
    VERIFYING_KEY_SIGNATURE = 3,
    VERIFYING_KEY_SELF_SIGNATURE = 4,
    VERIFYING_UNSPECIFIED_SIGNATURE = 5,
    NR__KEY_BEING_USED_FOR = 6,
};

enum key_lookup_flag {
    KEY_LOOKUP_CREATE = 1,
    KEY_LOOKUP_PARTIAL = 2,
    KEY_LOOKUP_ALL = 3,
};

enum key_need_perm {
    KEY_NEED_UNSPECIFIED = 0,
    KEY_NEED_VIEW = 1,
    KEY_NEED_READ = 2,
    KEY_NEED_WRITE = 3,
    KEY_NEED_SEARCH = 4,
    KEY_NEED_LINK = 5,
    KEY_NEED_SETATTR = 6,
    KEY_NEED_UNLINK = 7,
    KEY_SYSADMIN_OVERRIDE = 8,
    KEY_AUTHTOKEN_OVERRIDE = 9,
    KEY_DEFER_PERM_CHECK = 10,
};

enum key_notification_subtype {
    NOTIFY_KEY_INSTANTIATED = 0,
    NOTIFY_KEY_UPDATED = 1,
    NOTIFY_KEY_LINKED = 2,
    NOTIFY_KEY_UNLINKED = 3,
    NOTIFY_KEY_CLEARED = 4,
    NOTIFY_KEY_REVOKED = 5,
    NOTIFY_KEY_INVALIDATED = 6,
    NOTIFY_KEY_SETATTR = 7,
};

enum key_state {
    KEY_IS_UNINSTANTIATED = 0,
    KEY_IS_POSITIVE = 1,
};

enum kfunc_ptr_arg_type {
    KF_ARG_PTR_TO_CTX = 0,
    KF_ARG_PTR_TO_ALLOC_BTF_ID = 1,
    KF_ARG_PTR_TO_REFCOUNTED_KPTR = 2,
    KF_ARG_PTR_TO_DYNPTR = 3,
    KF_ARG_PTR_TO_ITER = 4,
    KF_ARG_PTR_TO_LIST_HEAD = 5,
    KF_ARG_PTR_TO_LIST_NODE = 6,
    KF_ARG_PTR_TO_BTF_ID = 7,
    KF_ARG_PTR_TO_MEM = 8,
    KF_ARG_PTR_TO_MEM_SIZE = 9,
    KF_ARG_PTR_TO_CALLBACK = 10,
    KF_ARG_PTR_TO_RB_ROOT = 11,
    KF_ARG_PTR_TO_RB_NODE = 12,
    KF_ARG_PTR_TO_NULL = 13,
    KF_ARG_PTR_TO_CONST_STR = 14,
    KF_ARG_PTR_TO_MAP = 15,
    KF_ARG_PTR_TO_WORKQUEUE = 16,
    KF_ARG_PTR_TO_IRQ_FLAG = 17,
};

enum kgdb_bpstate {
    BP_UNDEFINED = 0,
    BP_REMOVED = 1,
    BP_SET = 2,
    BP_ACTIVE = 3,
};

enum kgdb_bptype {
    BP_BREAKPOINT = 0,
    BP_HARDWARE_BREAKPOINT = 1,
    BP_WRITE_WATCHPOINT = 2,
    BP_READ_WATCHPOINT = 3,
    BP_ACCESS_WATCHPOINT = 4,
    BP_POKE_BREAKPOINT = 5,
};

enum kmalloc_cache_type {
    KMALLOC_NORMAL = 0,
    KMALLOC_RANDOM_START = 0,
    KMALLOC_RANDOM_END = 15,
    KMALLOC_RECLAIM = 16,
    KMALLOC_DMA = 17,
    KMALLOC_CGROUP = 18,
    NR_KMALLOC_TYPES = 19,
};

enum kmsg_dump_reason {
    KMSG_DUMP_UNDEF = 0,
    KMSG_DUMP_PANIC = 1,
    KMSG_DUMP_OOPS = 2,
    KMSG_DUMP_EMERG = 3,
    KMSG_DUMP_SHUTDOWN = 4,
    KMSG_DUMP_MAX = 5,
};

enum kobj_ns_type {
    KOBJ_NS_TYPE_NONE = 0,
    KOBJ_NS_TYPE_NET = 1,
    KOBJ_NS_TYPES = 2,
};

enum kobject_action {
    KOBJ_ADD = 0,
    KOBJ_REMOVE = 1,
    KOBJ_CHANGE = 2,
    KOBJ_MOVE = 3,
    KOBJ_ONLINE = 4,
    KOBJ_OFFLINE = 5,
    KOBJ_BIND = 6,
    KOBJ_UNBIND = 7,
};

enum kprobe_slot_state {
    SLOT_CLEAN = 0,
    SLOT_DIRTY = 1,
    SLOT_USED = 2,
};

enum kunwind_source {
    KUNWIND_SOURCE_UNKNOWN = 0,
    KUNWIND_SOURCE_FRAME = 1,
    KUNWIND_SOURCE_CALLER = 2,
    KUNWIND_SOURCE_TASK = 3,
    KUNWIND_SOURCE_REGS_PC = 4,
};

enum kvm_arch_timer_regs {
    TIMER_REG_CNT = 0,
    TIMER_REG_CVAL = 1,
    TIMER_REG_TVAL = 2,
    TIMER_REG_CTL = 3,
    TIMER_REG_VOFF = 4,
};

enum kvm_arch_timers {
    TIMER_PTIMER = 0,
    TIMER_VTIMER = 1,
    NR_KVM_EL0_TIMERS = 2,
    TIMER_HVTIMER = 2,
    TIMER_HPTIMER = 3,
    NR_KVM_TIMERS = 4,
};

enum kvm_bus {
    KVM_MMIO_BUS = 0,
    KVM_PIO_BUS = 1,
    KVM_VIRTIO_CCW_NOTIFY_BUS = 2,
    KVM_FAST_MMIO_BUS = 3,
    KVM_IOCSR_BUS = 4,
    KVM_NR_BUSES = 5,
};

enum kvm_device_type {
    KVM_DEV_TYPE_FSL_MPIC_20 = 1,
    KVM_DEV_TYPE_FSL_MPIC_42 = 2,
    KVM_DEV_TYPE_XICS = 3,
    KVM_DEV_TYPE_VFIO = 4,
    KVM_DEV_TYPE_ARM_VGIC_V2 = 5,
    KVM_DEV_TYPE_FLIC = 6,
    KVM_DEV_TYPE_ARM_VGIC_V3 = 7,
    KVM_DEV_TYPE_ARM_VGIC_ITS = 8,
    KVM_DEV_TYPE_XIVE = 9,
    KVM_DEV_TYPE_ARM_PV_TIME = 10,
    KVM_DEV_TYPE_RISCV_AIA = 11,
    KVM_DEV_TYPE_LOONGARCH_IPI = 12,
    KVM_DEV_TYPE_LOONGARCH_EIOINTC = 13,
    KVM_DEV_TYPE_LOONGARCH_PCHPIC = 14,
    KVM_DEV_TYPE_MAX = 15,
};

enum kvm_gfn_range_filter {
    KVM_FILTER_SHARED = 1,
    KVM_FILTER_PRIVATE = 2,
};

enum kvm_mode {
    KVM_MODE_DEFAULT = 0,
    KVM_MODE_PROTECTED = 1,
    KVM_MODE_NV = 2,
    KVM_MODE_NONE = 3,
};

enum kvm_mr_change {
    KVM_MR_CREATE = 0,
    KVM_MR_DELETE = 1,
    KVM_MR_MOVE = 2,
    KVM_MR_FLAGS_ONLY = 3,
};

enum kvm_pgtable_prot {
    KVM_PGTABLE_PROT_X = 1ULL,
    KVM_PGTABLE_PROT_W = 2ULL,
    KVM_PGTABLE_PROT_R = 4ULL,
    KVM_PGTABLE_PROT_DEVICE = 8ULL,
    KVM_PGTABLE_PROT_NORMAL_NC = 16ULL,
    KVM_PGTABLE_PROT_SW0 = 36028797018963968ULL,
    KVM_PGTABLE_PROT_SW1 = 72057594037927936ULL,
    KVM_PGTABLE_PROT_SW2 = 144115188075855872ULL,
    KVM_PGTABLE_PROT_SW3 = 288230376151711744ULL,
};

enum kvm_pgtable_stage2_flags {
    KVM_PGTABLE_S2_NOFWB = 1,
    KVM_PGTABLE_S2_IDMAP = 2,
};

enum kvm_pgtable_walk_flags {
    KVM_PGTABLE_WALK_LEAF = 1,
    KVM_PGTABLE_WALK_TABLE_PRE = 2,
    KVM_PGTABLE_WALK_TABLE_POST = 4,
    KVM_PGTABLE_WALK_SHARED = 8,
    KVM_PGTABLE_WALK_HANDLE_FAULT = 16,
    KVM_PGTABLE_WALK_SKIP_BBM_TLBI = 32,
    KVM_PGTABLE_WALK_SKIP_CMO = 64,
};

enum kvm_smccc_filter_action {
    KVM_SMCCC_FILTER_HANDLE = 0,
    KVM_SMCCC_FILTER_DENY = 1,
    KVM_SMCCC_FILTER_FWD_TO_USER = 2,
    NR_SMCCC_FILTER_ACTIONS = 3,
};

enum kvm_stat_kind {
    KVM_STAT_VM = 0,
    KVM_STAT_VCPU = 1,
};

enum kvm_wfx_trap_policy {
    KVM_WFX_NOTRAP_SINGLE_TASK = 0,
    KVM_WFX_NOTRAP = 1,
    KVM_WFX_TRAP = 2,
};

enum l2tp_debug_flags {
    L2TP_MSG_DEBUG = 1,
    L2TP_MSG_CONTROL = 2,
    L2TP_MSG_SEQ = 4,
    L2TP_MSG_DATA = 8,
};

enum l3mdev_type {
    L3MDEV_TYPE_UNSPEC = 0,
    L3MDEV_TYPE_VRF = 1,
    __L3MDEV_TYPE_MAX = 2,
};

enum label_flags {
    FLAG_HAT = 1,
    FLAG_UNCONFINED = 2,
    FLAG_NULL = 4,
    FLAG_IX_ON_NAME_ERROR = 8,
    FLAG_IMMUTIBLE = 16,
    FLAG_USER_DEFINED = 32,
    FLAG_NO_LIST_REF = 64,
    FLAG_NS_COUNT = 128,
    FLAG_IN_TREE = 256,
    FLAG_PROFILE = 512,
    FLAG_EXPLICIT = 1024,
    FLAG_STALE = 2048,
    FLAG_INTERRUPTIBLE = 4096,
    FLAG_REVOKED = 8192,
    FLAG_DEBUG1 = 16384,
    FLAG_DEBUG2 = 32768,
};

enum label_initialized {
    LABEL_INVALID = 0,
    LABEL_INITIALIZED = 1,
    LABEL_PENDING = 2,
};

enum landlock_key_type {
    LANDLOCK_KEY_INODE = 1,
    LANDLOCK_KEY_NET_PORT = 2,
};

enum landlock_rule_type {
    LANDLOCK_RULE_PATH_BENEATH = 1,
    LANDLOCK_RULE_NET_PORT = 2,
};

enum led_brightness {
    LED_OFF = 0,
    LED_ON = 1,
    LED_HALF = 127,
    LED_FULL = 255,
};

enum led_default_state {
    LEDS_DEFSTATE_OFF = 0,
    LEDS_DEFSTATE_ON = 1,
    LEDS_DEFSTATE_KEEP = 2,
};

enum legacy_fs_param {
    LEGACY_FS_UNSET_PARAMS = 0,
    LEGACY_FS_MONOLITHIC_PARAMS = 1,
    LEGACY_FS_INDIVIDUAL_PARAMS = 2,
};

enum legacy_insn_status {
    INSN_DEPRECATED = 0,
    INSN_OBSOLETE = 1,
    INSN_UNAVAILABLE = 2,
};

enum link_inband_signalling {
    LINK_INBAND_DISABLE = 1,
    LINK_INBAND_ENABLE = 2,
    LINK_INBAND_BYPASS = 4,
};

enum linux_mptcp_mib_field {
    MPTCP_MIB_NUM = 0,
    MPTCP_MIB_MPCAPABLEPASSIVE = 1,
    MPTCP_MIB_MPCAPABLEACTIVE = 2,
    MPTCP_MIB_MPCAPABLEACTIVEACK = 3,
    MPTCP_MIB_MPCAPABLEPASSIVEACK = 4,
    MPTCP_MIB_MPCAPABLEPASSIVEFALLBACK = 5,
    MPTCP_MIB_MPCAPABLEACTIVEFALLBACK = 6,
    MPTCP_MIB_MPCAPABLEACTIVEDROP = 7,
    MPTCP_MIB_MPCAPABLEACTIVEDISABLED = 8,
    MPTCP_MIB_MPCAPABLEENDPATTEMPT = 9,
    MPTCP_MIB_TOKENFALLBACKINIT = 10,
    MPTCP_MIB_RETRANSSEGS = 11,
    MPTCP_MIB_JOINNOTOKEN = 12,
    MPTCP_MIB_JOINSYNRX = 13,
    MPTCP_MIB_JOINSYNBACKUPRX = 14,
    MPTCP_MIB_JOINSYNACKRX = 15,
    MPTCP_MIB_JOINSYNACKBACKUPRX = 16,
    MPTCP_MIB_JOINSYNACKMAC = 17,
    MPTCP_MIB_JOINACKRX = 18,
    MPTCP_MIB_JOINACKMAC = 19,
    MPTCP_MIB_JOINSYNTX = 20,
    MPTCP_MIB_JOINSYNTXCREATSKERR = 21,
    MPTCP_MIB_JOINSYNTXBINDERR = 22,
    MPTCP_MIB_JOINSYNTXCONNECTERR = 23,
    MPTCP_MIB_DSSNOMATCH = 24,
    MPTCP_MIB_DSSCORRUPTIONFALLBACK = 25,
    MPTCP_MIB_DSSCORRUPTIONRESET = 26,
    MPTCP_MIB_INFINITEMAPTX = 27,
    MPTCP_MIB_INFINITEMAPRX = 28,
    MPTCP_MIB_DSSTCPMISMATCH = 29,
    MPTCP_MIB_DATACSUMERR = 30,
    MPTCP_MIB_OFOQUEUETAIL = 31,
    MPTCP_MIB_OFOQUEUE = 32,
    MPTCP_MIB_OFOMERGE = 33,
    MPTCP_MIB_NODSSWINDOW = 34,
    MPTCP_MIB_DUPDATA = 35,
    MPTCP_MIB_ADDADDR = 36,
    MPTCP_MIB_ADDADDRTX = 37,
    MPTCP_MIB_ADDADDRTXDROP = 38,
    MPTCP_MIB_ECHOADD = 39,
    MPTCP_MIB_ECHOADDTX = 40,
    MPTCP_MIB_ECHOADDTXDROP = 41,
    MPTCP_MIB_PORTADD = 42,
    MPTCP_MIB_ADDADDRDROP = 43,
    MPTCP_MIB_JOINPORTSYNRX = 44,
    MPTCP_MIB_JOINPORTSYNACKRX = 45,
    MPTCP_MIB_JOINPORTACKRX = 46,
    MPTCP_MIB_MISMATCHPORTSYNRX = 47,
    MPTCP_MIB_MISMATCHPORTACKRX = 48,
    MPTCP_MIB_RMADDR = 49,
    MPTCP_MIB_RMADDRDROP = 50,
    MPTCP_MIB_RMADDRTX = 51,
    MPTCP_MIB_RMADDRTXDROP = 52,
    MPTCP_MIB_RMSUBFLOW = 53,
    MPTCP_MIB_MPPRIOTX = 54,
    MPTCP_MIB_MPPRIORX = 55,
    MPTCP_MIB_MPFAILTX = 56,
    MPTCP_MIB_MPFAILRX = 57,
    MPTCP_MIB_MPFASTCLOSETX = 58,
    MPTCP_MIB_MPFASTCLOSERX = 59,
    MPTCP_MIB_MPRSTTX = 60,
    MPTCP_MIB_MPRSTRX = 61,
    MPTCP_MIB_RCVPRUNED = 62,
    MPTCP_MIB_SUBFLOWSTALE = 63,
    MPTCP_MIB_SUBFLOWRECOVER = 64,
    MPTCP_MIB_SNDWNDSHARED = 65,
    MPTCP_MIB_RCVWNDSHARED = 66,
    MPTCP_MIB_RCVWNDCONFLICTUPDATE = 67,
    MPTCP_MIB_RCVWNDCONFLICT = 68,
    MPTCP_MIB_CURRESTAB = 69,
    MPTCP_MIB_BLACKHOLE = 70,
    __MPTCP_MIB_MAX = 71,
};

enum lockdep_ok {
    LOCKDEP_STILL_OK = 0,
    LOCKDEP_NOW_UNRELIABLE = 1,
};

enum lockdown_reason {
    LOCKDOWN_NONE = 0,
    LOCKDOWN_MODULE_SIGNATURE = 1,
    LOCKDOWN_DEV_MEM = 2,
    LOCKDOWN_EFI_TEST = 3,
    LOCKDOWN_KEXEC = 4,
    LOCKDOWN_HIBERNATION = 5,
    LOCKDOWN_PCI_ACCESS = 6,
    LOCKDOWN_IOPORT = 7,
    LOCKDOWN_MSR = 8,
    LOCKDOWN_ACPI_TABLES = 9,
    LOCKDOWN_DEVICE_TREE = 10,
    LOCKDOWN_PCMCIA_CIS = 11,
    LOCKDOWN_TIOCSSERIAL = 12,
    LOCKDOWN_MODULE_PARAMETERS = 13,
    LOCKDOWN_MMIOTRACE = 14,
    LOCKDOWN_DEBUGFS = 15,
    LOCKDOWN_XMON_WR = 16,
    LOCKDOWN_BPF_WRITE_USER = 17,
    LOCKDOWN_DBG_WRITE_KERNEL = 18,
    LOCKDOWN_RTAS_ERROR_INJECTION = 19,
    LOCKDOWN_INTEGRITY_MAX = 20,
    LOCKDOWN_KCORE = 21,
    LOCKDOWN_KPROBES = 22,
    LOCKDOWN_BPF_READ_KERNEL = 23,
    LOCKDOWN_DBG_READ_KERNEL = 24,
    LOCKDOWN_PERF = 25,
    LOCKDOWN_TRACEFS = 26,
    LOCKDOWN_XMON_RW = 27,
    LOCKDOWN_XFRM_SECRET = 28,
    LOCKDOWN_CONFIDENTIALITY_MAX = 29,
};

enum lru_list {
    LRU_INACTIVE_ANON = 0,
    LRU_ACTIVE_ANON = 1,
    LRU_INACTIVE_FILE = 2,
    LRU_ACTIVE_FILE = 3,
    LRU_UNEVICTABLE = 4,
    NR_LRU_LISTS = 5,
};

enum lru_status {
    LRU_REMOVED = 0,
    LRU_REMOVED_RETRY = 1,
    LRU_ROTATE = 2,
    LRU_SKIP = 3,
    LRU_RETRY = 4,
    LRU_STOP = 5,
};

enum lruvec_flags {
    LRUVEC_CGROUP_CONGESTED = 0,
    LRUVEC_NODE_CONGESTED = 1,
};

enum lsm_event {
    LSM_POLICY_CHANGE = 0,
};

enum lsm_integrity_type {
    LSM_INT_DMVERITY_SIG_VALID = 0,
    LSM_INT_DMVERITY_ROOTHASH = 1,
    LSM_INT_FSVERITY_BUILTINSIG_VALID = 2,
};

enum lsm_order {
    LSM_ORDER_FIRST = -1,
    LSM_ORDER_MUTABLE = 0,
    LSM_ORDER_LAST = 1,
};

enum lsm_rule_types {
    LSM_OBJ_USER = 0,
    LSM_OBJ_ROLE = 1,
    LSM_OBJ_TYPE = 2,
    LSM_SUBJ_USER = 3,
    LSM_SUBJ_ROLE = 4,
    LSM_SUBJ_TYPE = 5,
};

enum lw_bits {
    LW_URGENT = 0,
};

enum lwtunnel_encap_types {
    LWTUNNEL_ENCAP_NONE = 0,
    LWTUNNEL_ENCAP_MPLS = 1,
    LWTUNNEL_ENCAP_IP = 2,
    LWTUNNEL_ENCAP_ILA = 3,
    LWTUNNEL_ENCAP_IP6 = 4,
    LWTUNNEL_ENCAP_SEG6 = 5,
    LWTUNNEL_ENCAP_BPF = 6,
    LWTUNNEL_ENCAP_SEG6_LOCAL = 7,
    LWTUNNEL_ENCAP_RPL = 8,
    LWTUNNEL_ENCAP_IOAM6 = 9,
    LWTUNNEL_ENCAP_XFRM = 10,
    __LWTUNNEL_ENCAP_MAX = 11,
};

enum lwtunnel_ip6_t {
    LWTUNNEL_IP6_UNSPEC = 0,
    LWTUNNEL_IP6_ID = 1,
    LWTUNNEL_IP6_DST = 2,
    LWTUNNEL_IP6_SRC = 3,
    LWTUNNEL_IP6_HOPLIMIT = 4,
    LWTUNNEL_IP6_TC = 5,
    LWTUNNEL_IP6_FLAGS = 6,
    LWTUNNEL_IP6_PAD = 7,
    LWTUNNEL_IP6_OPTS = 8,
    __LWTUNNEL_IP6_MAX = 9,
};

enum lwtunnel_ip_t {
    LWTUNNEL_IP_UNSPEC = 0,
    LWTUNNEL_IP_ID = 1,
    LWTUNNEL_IP_DST = 2,
    LWTUNNEL_IP_SRC = 3,
    LWTUNNEL_IP_TTL = 4,
    LWTUNNEL_IP_TOS = 5,
    LWTUNNEL_IP_FLAGS = 6,
    LWTUNNEL_IP_PAD = 7,
    LWTUNNEL_IP_OPTS = 8,
    __LWTUNNEL_IP_MAX = 9,
};

enum lzma2_seq {
    SEQ_CONTROL = 0,
    SEQ_UNCOMPRESSED_1 = 1,
    SEQ_UNCOMPRESSED_2 = 2,
    SEQ_COMPRESSED_0 = 3,
    SEQ_COMPRESSED_1 = 4,
    SEQ_PROPERTIES = 5,
    SEQ_LZMA_PREPARE = 6,
    SEQ_LZMA_RUN = 7,
    SEQ_COPY = 8,
};

enum lzma_state {
    STATE_LIT_LIT = 0,
    STATE_MATCH_LIT_LIT = 1,
    STATE_REP_LIT_LIT = 2,
    STATE_SHORTREP_LIT_LIT = 3,
    STATE_MATCH_LIT = 4,
    STATE_REP_LIT = 5,
    STATE_SHORTREP_LIT = 6,
    STATE_LIT_MATCH = 7,
    STATE_LIT_LONGREP = 8,
    STATE_LIT_SHORTREP = 9,
    STATE_NONLIT_MATCH = 10,
    STATE_NONLIT_REP = 11,
};

enum macsec_offload {
    MACSEC_OFFLOAD_OFF = 0,
    MACSEC_OFFLOAD_PHY = 1,
    MACSEC_OFFLOAD_MAC = 2,
    __MACSEC_OFFLOAD_END = 3,
    MACSEC_OFFLOAD_MAX = 2,
};

enum macsec_validation_type {
    MACSEC_VALIDATE_DISABLED = 0,
    MACSEC_VALIDATE_CHECK = 1,
    MACSEC_VALIDATE_STRICT = 2,
    __MACSEC_VALIDATE_END = 3,
    MACSEC_VALIDATE_MAX = 2,
};

enum maple_status {
    ma_active = 0,
    ma_start = 1,
    ma_root = 2,
    ma_none = 3,
    ma_pause = 4,
    ma_overflow = 5,
    ma_underflow = 6,
    ma_error = 7,
};

enum maple_type {
    maple_dense = 0,
    maple_leaf_64 = 1,
    maple_range_64 = 2,
    maple_arange_64 = 3,
};

enum mapping_flags {
    AS_EIO = 0,
    AS_ENOSPC = 1,
    AS_MM_ALL_LOCKS = 2,
    AS_UNEVICTABLE = 3,
    AS_EXITING = 4,
    AS_NO_WRITEBACK_TAGS = 5,
    AS_RELEASE_ALWAYS = 6,
    AS_STABLE_WRITES = 7,
    AS_INACCESSIBLE = 8,
    AS_FOLIO_ORDER_BITS = 5,
    AS_FOLIO_ORDER_MIN = 16,
    AS_FOLIO_ORDER_MAX = 21,
};

enum mapping_status {
    MAPPING_OK = 0,
    MAPPING_INVALID = 1,
    MAPPING_EMPTY = 2,
    MAPPING_DATA_FIN = 3,
    MAPPING_DUMMY = 4,
    MAPPING_BAD_CSUM = 5,
    MAPPING_NODSS = 6,
};

enum mctrl_gpio_idx {
    UART_GPIO_CTS = 0,
    UART_GPIO_DSR = 1,
    UART_GPIO_DCD = 2,
    UART_GPIO_RNG = 3,
    UART_GPIO_RI = 3,
    UART_GPIO_RTS = 4,
    UART_GPIO_DTR = 5,
    UART_GPIO_MAX = 6,
};

enum mem_type {
    MEM_EMPTY = 0,
    MEM_RESERVED = 1,
    MEM_UNKNOWN = 2,
    MEM_FPM = 3,
    MEM_EDO = 4,
    MEM_BEDO = 5,
    MEM_SDR = 6,
    MEM_RDR = 7,
    MEM_DDR = 8,
    MEM_RDDR = 9,
    MEM_RMBS = 10,
    MEM_DDR2 = 11,
    MEM_FB_DDR2 = 12,
    MEM_RDDR2 = 13,
    MEM_XDR = 14,
    MEM_DDR3 = 15,
    MEM_RDDR3 = 16,
    MEM_LRDDR3 = 17,
    MEM_LPDDR3 = 18,
    MEM_DDR4 = 19,
    MEM_RDDR4 = 20,
    MEM_LRDDR4 = 21,
    MEM_LPDDR4 = 22,
    MEM_DDR5 = 23,
    MEM_RDDR5 = 24,
    MEM_LRDDR5 = 25,
    MEM_NVDIMM = 26,
    MEM_WIO2 = 27,
    MEM_HBM2 = 28,
    MEM_HBM3 = 29,
};

enum membarrier_cmd {
    MEMBARRIER_CMD_QUERY = 0,
    MEMBARRIER_CMD_GLOBAL = 1,
    MEMBARRIER_CMD_GLOBAL_EXPEDITED = 2,
    MEMBARRIER_CMD_REGISTER_GLOBAL_EXPEDITED = 4,
    MEMBARRIER_CMD_PRIVATE_EXPEDITED = 8,
    MEMBARRIER_CMD_REGISTER_PRIVATE_EXPEDITED = 16,
    MEMBARRIER_CMD_PRIVATE_EXPEDITED_SYNC_CORE = 32,
    MEMBARRIER_CMD_REGISTER_PRIVATE_EXPEDITED_SYNC_CORE = 64,
    MEMBARRIER_CMD_PRIVATE_EXPEDITED_RSEQ = 128,
    MEMBARRIER_CMD_REGISTER_PRIVATE_EXPEDITED_RSEQ = 256,
    MEMBARRIER_CMD_GET_REGISTRATIONS = 512,
    MEMBARRIER_CMD_SHARED = 1,
};

enum membarrier_cmd_flag {
    MEMBARRIER_CMD_FLAG_CPU = 1,
};

enum memblock_flags {
    MEMBLOCK_NONE = 0,
    MEMBLOCK_HOTPLUG = 1,
    MEMBLOCK_MIRROR = 2,
    MEMBLOCK_NOMAP = 4,
    MEMBLOCK_DRIVER_MANAGED = 8,
    MEMBLOCK_RSRV_NOINIT = 16,
};

enum memcg_memory_event {
    MEMCG_LOW = 0,
    MEMCG_HIGH = 1,
    MEMCG_MAX = 2,
    MEMCG_OOM = 3,
    MEMCG_OOM_KILL = 4,
    MEMCG_OOM_GROUP_KILL = 5,
    MEMCG_SWAP_HIGH = 6,
    MEMCG_SWAP_MAX = 7,
    MEMCG_SWAP_FAIL = 8,
    MEMCG_NR_MEMORY_EVENTS = 9,
};

enum memcg_stat_item {
    MEMCG_SWAP = 46,
    MEMCG_SOCK = 47,
    MEMCG_PERCPU_B = 48,
    MEMCG_VMALLOC = 49,
    MEMCG_KMEM = 50,
    MEMCG_ZSWAP_B = 51,
    MEMCG_ZSWAPPED = 52,
    MEMCG_NR_STAT = 53,
};

enum meminit_context {
    MEMINIT_EARLY = 0,
    MEMINIT_HOTPLUG = 1,
};

enum memory_type {
    MEMORY_DEVICE_PRIVATE = 1,
    MEMORY_DEVICE_COHERENT = 2,
    MEMORY_DEVICE_FS_DAX = 3,
    MEMORY_DEVICE_GENERIC = 4,
    MEMORY_DEVICE_PCI_P2PDMA = 5,
};

enum metadata_type {
    METADATA_IP_TUNNEL = 0,
    METADATA_HW_PORT_MUX = 1,
    METADATA_MACSEC = 2,
    METADATA_XFRM = 3,
};

enum mfill_atomic_mode {
    MFILL_ATOMIC_COPY = 0,
    MFILL_ATOMIC_ZEROPAGE = 1,
    MFILL_ATOMIC_CONTINUE = 2,
    MFILL_ATOMIC_POISON = 3,
    NR_MFILL_ATOMIC_MODES = 4,
};

enum migrate_mode {
    MIGRATE_ASYNC = 0,
    MIGRATE_SYNC_LIGHT = 1,
    MIGRATE_SYNC = 2,
};

enum migrate_reason {
    MR_COMPACTION = 0,
    MR_MEMORY_FAILURE = 1,
    MR_MEMORY_HOTPLUG = 2,
    MR_SYSCALL = 3,
    MR_MEMPOLICY_MBIND = 4,
    MR_NUMA_MISPLACED = 5,
    MR_CONTIG_RANGE = 6,
    MR_LONGTERM_PIN = 7,
    MR_DEMOTION = 8,
    MR_DAMON = 9,
    MR_TYPES = 10,
};

enum migratetype {
    MIGRATE_UNMOVABLE = 0,
    MIGRATE_MOVABLE = 1,
    MIGRATE_RECLAIMABLE = 2,
    MIGRATE_PCPTYPES = 3,
    MIGRATE_HIGHATOMIC = 3,
    MIGRATE_CMA = 4,
    MIGRATE_ISOLATE = 5,
    MIGRATE_TYPES = 6,
};

enum migration_type {
    migrate_load = 0,
    migrate_util = 1,
    migrate_task = 2,
    migrate_misfit = 3,
};

enum mipi_dsi_compression_algo {
    MIPI_DSI_COMPRESSION_DSC = 0,
    MIPI_DSI_COMPRESSION_VENDOR = 3,
};

enum mipi_dsi_dcs_tear_mode {
    MIPI_DSI_DCS_TEAR_MODE_VBLANK = 0,
    MIPI_DSI_DCS_TEAR_MODE_VHBLANK = 1,
};

enum mipi_dsi_pixel_format {
    MIPI_DSI_FMT_RGB888 = 0,
    MIPI_DSI_FMT_RGB666 = 1,
    MIPI_DSI_FMT_RGB666_PACKED = 2,
    MIPI_DSI_FMT_RGB565 = 3,
};

enum misc_res_type {
    MISC_CG_RES_TYPES = 0,
};

enum mitigation_state {
    SPECTRE_UNAFFECTED = 0,
    SPECTRE_MITIGATED = 1,
    SPECTRE_VULNERABLE = 2,
};

enum mm_cid_state {
    MM_CID_UNSET = 4294967295,
    MM_CID_LAZY_PUT = 2147483648,
};

enum mmc_busy_cmd {
    MMC_BUSY_CMD6 = 0,
    MMC_BUSY_ERASE = 1,
    MMC_BUSY_HPI = 2,
    MMC_BUSY_EXTR_SINGLE = 3,
    MMC_BUSY_IO = 4,
};

enum mmc_drv_op {
    MMC_DRV_OP_IOCTL = 0,
    MMC_DRV_OP_IOCTL_RPMB = 1,
    MMC_DRV_OP_BOOT_WP = 2,
    MMC_DRV_OP_GET_CARD_STATUS = 3,
    MMC_DRV_OP_GET_EXT_CSD = 4,
};

enum mmc_err_stat {
    MMC_ERR_CMD_TIMEOUT = 0,
    MMC_ERR_CMD_CRC = 1,
    MMC_ERR_DAT_TIMEOUT = 2,
    MMC_ERR_DAT_CRC = 3,
    MMC_ERR_AUTO_CMD = 4,
    MMC_ERR_ADMA = 5,
    MMC_ERR_TUNING = 6,
    MMC_ERR_CMDQ_RED = 7,
    MMC_ERR_CMDQ_GCE = 8,
    MMC_ERR_CMDQ_ICCE = 9,
    MMC_ERR_REQ_TIMEOUT = 10,
    MMC_ERR_CMDQ_REQ_TIMEOUT = 11,
    MMC_ERR_ICE_CFG = 12,
    MMC_ERR_CTRL_TIMEOUT = 13,
    MMC_ERR_UNEXPECTED_IRQ = 14,
    MMC_ERR_MAX = 15,
};

enum mmc_issue_type {
    MMC_ISSUE_SYNC = 0,
    MMC_ISSUE_DCMD = 1,
    MMC_ISSUE_ASYNC = 2,
    MMC_ISSUE_MAX = 3,
};

enum mminit_level {
    MMINIT_WARNING = 0,
    MMINIT_VERIFY = 1,
    MMINIT_TRACE = 2,
};

enum mmu_notifier_event {
    MMU_NOTIFY_UNMAP = 0,
    MMU_NOTIFY_CLEAR = 1,
    MMU_NOTIFY_PROTECTION_VMA = 2,
    MMU_NOTIFY_PROTECTION_PAGE = 3,
    MMU_NOTIFY_SOFT_DIRTY = 4,
    MMU_NOTIFY_RELEASE = 5,
    MMU_NOTIFY_MIGRATE = 6,
    MMU_NOTIFY_EXCLUSIVE = 7,
};

enum mnt_tree_flags_t {
    MNT_TREE_MOVE = 1,
    MNT_TREE_BENEATH = 2,
};

enum mod_license {
    NOT_GPL_ONLY = 0,
    GPL_ONLY = 1,
};

enum mod_mem_type {
    MOD_TEXT = 0,
    MOD_DATA = 1,
    MOD_RODATA = 2,
    MOD_RO_AFTER_INIT = 3,
    MOD_INIT_TEXT = 4,
    MOD_INIT_DATA = 5,
    MOD_INIT_RODATA = 6,
    MOD_MEM_NUM_TYPES = 7,
    MOD_INVALID = -1,
};

enum mode_set_atomic {
    LEAVE_ATOMIC_MODE_SET = 0,
    ENTER_ATOMIC_MODE_SET = 1,
};

enum module_state {
    MODULE_STATE_LIVE = 0,
    MODULE_STATE_COMING = 1,
    MODULE_STATE_GOING = 2,
    MODULE_STATE_UNFORMED = 3,
};

enum mousedev_emul {
    MOUSEDEV_EMUL_PS2 = 0,
    MOUSEDEV_EMUL_IMPS = 1,
    MOUSEDEV_EMUL_EXPS = 2,
};

enum mptcp_addr_signal_status {
    MPTCP_ADD_ADDR_SIGNAL = 0,
    MPTCP_ADD_ADDR_ECHO = 1,
    MPTCP_RM_ADDR_SIGNAL = 2,
};

enum mptcp_event_attr {
    MPTCP_ATTR_UNSPEC = 0,
    MPTCP_ATTR_TOKEN = 1,
    MPTCP_ATTR_FAMILY = 2,
    MPTCP_ATTR_LOC_ID = 3,
    MPTCP_ATTR_REM_ID = 4,
    MPTCP_ATTR_SADDR4 = 5,
    MPTCP_ATTR_SADDR6 = 6,
    MPTCP_ATTR_DADDR4 = 7,
    MPTCP_ATTR_DADDR6 = 8,
    MPTCP_ATTR_SPORT = 9,
    MPTCP_ATTR_DPORT = 10,
    MPTCP_ATTR_BACKUP = 11,
    MPTCP_ATTR_ERROR = 12,
    MPTCP_ATTR_FLAGS = 13,
    MPTCP_ATTR_TIMEOUT = 14,
    MPTCP_ATTR_IF_IDX = 15,
    MPTCP_ATTR_RESET_REASON = 16,
    MPTCP_ATTR_RESET_FLAGS = 17,
    MPTCP_ATTR_SERVER_SIDE = 18,
    __MPTCP_ATTR_MAX = 19,
};

enum mptcp_event_type {
    MPTCP_EVENT_UNSPEC = 0,
    MPTCP_EVENT_CREATED = 1,
    MPTCP_EVENT_ESTABLISHED = 2,
    MPTCP_EVENT_CLOSED = 3,
    MPTCP_EVENT_ANNOUNCED = 6,
    MPTCP_EVENT_REMOVED = 7,
    MPTCP_EVENT_SUB_ESTABLISHED = 10,
    MPTCP_EVENT_SUB_CLOSED = 11,
    MPTCP_EVENT_SUB_PRIORITY = 13,
    MPTCP_EVENT_LISTENER_CREATED = 15,
    MPTCP_EVENT_LISTENER_CLOSED = 16,
};

enum mptcp_pm_status {
    MPTCP_PM_ADD_ADDR_RECEIVED = 0,
    MPTCP_PM_ADD_ADDR_SEND_ACK = 1,
    MPTCP_PM_RM_ADDR_RECEIVED = 2,
    MPTCP_PM_ESTABLISHED = 3,
    MPTCP_PM_SUBFLOW_ESTABLISHED = 4,
    MPTCP_PM_ALREADY_ESTABLISHED = 5,
    MPTCP_PM_MPC_ENDPOINT_ACCOUNTED = 6,
};

enum mptcp_pm_type {
    MPTCP_PM_TYPE_KERNEL = 0,
    MPTCP_PM_TYPE_USERSPACE = 1,
    __MPTCP_PM_TYPE_NR = 2,
    __MPTCP_PM_TYPE_MAX = 1,
};

enum mq_rq_state {
    MQ_RQ_IDLE = 0,
    MQ_RQ_IN_FLIGHT = 1,
    MQ_RQ_COMPLETE = 2,
};

enum mscode_actions {
    ACT_mscode_note_content_type = 0,
    ACT_mscode_note_digest = 1,
    ACT_mscode_note_digest_algo = 2,
    NR__mscode_actions = 3,
};

enum msdos_sys_ind {
    DOS_EXTENDED_PARTITION = 5,
    LINUX_EXTENDED_PARTITION = 133,
    WIN98_EXTENDED_PARTITION = 15,
    LINUX_DATA_PARTITION = 131,
    LINUX_LVM_PARTITION = 142,
    LINUX_RAID_PARTITION = 253,
    SOLARIS_X86_PARTITION = 130,
    NEW_SOLARIS_X86_PARTITION = 191,
    DM6_AUX1PARTITION = 81,
    DM6_AUX3PARTITION = 83,
    DM6_PARTITION = 84,
    EZD_PARTITION = 85,
    FREEBSD_PARTITION = 165,
    OPENBSD_PARTITION = 166,
    NETBSD_PARTITION = 169,
    BSDI_PARTITION = 183,
    MINIX_PARTITION = 129,
    UNIXWARE_PARTITION = 99,
};

enum msi_desc_filter {
    MSI_DESC_ALL = 0,
    MSI_DESC_NOTASSOCIATED = 1,
    MSI_DESC_ASSOCIATED = 2,
};

enum msi_domain_ids {
    MSI_DEFAULT_DOMAIN = 0,
    MSI_MAX_DEVICE_IRQDOMAINS = 1,
};

enum mthp_stat_item {
    MTHP_STAT_ANON_FAULT_ALLOC = 0,
    MTHP_STAT_ANON_FAULT_FALLBACK = 1,
    MTHP_STAT_ANON_FAULT_FALLBACK_CHARGE = 2,
    MTHP_STAT_ZSWPOUT = 3,
    MTHP_STAT_SWPIN = 4,
    MTHP_STAT_SWPIN_FALLBACK = 5,
    MTHP_STAT_SWPIN_FALLBACK_CHARGE = 6,
    MTHP_STAT_SWPOUT = 7,
    MTHP_STAT_SWPOUT_FALLBACK = 8,
    MTHP_STAT_SHMEM_ALLOC = 9,
    MTHP_STAT_SHMEM_FALLBACK = 10,
    MTHP_STAT_SHMEM_FALLBACK_CHARGE = 11,
    MTHP_STAT_SPLIT = 12,
    MTHP_STAT_SPLIT_FAILED = 13,
    MTHP_STAT_SPLIT_DEFERRED = 14,
    MTHP_STAT_NR_ANON = 15,
    MTHP_STAT_NR_ANON_PARTIALLY_MAPPED = 16,
    __MTHP_STAT_COUNT = 17,
};

enum multi_stop_state {
    MULTI_STOP_NONE = 0,
    MULTI_STOP_PREPARE = 1,
    MULTI_STOP_DISABLE_IRQ = 2,
    MULTI_STOP_RUN = 3,
    MULTI_STOP_EXIT = 4,
};

enum nbcon_prio {
    NBCON_PRIO_NONE = 0,
    NBCON_PRIO_NORMAL = 1,
    NBCON_PRIO_EMERGENCY = 2,
    NBCON_PRIO_PANIC = 3,
    NBCON_PRIO_MAX = 4,
};

enum net_device_flags {
    IFF_UP = 1,
    IFF_BROADCAST = 2,
    IFF_DEBUG = 4,
    IFF_LOOPBACK = 8,
    IFF_POINTOPOINT = 16,
    IFF_NOTRAILERS = 32,
    IFF_RUNNING = 64,
    IFF_NOARP = 128,
    IFF_PROMISC = 256,
    IFF_ALLMULTI = 512,
    IFF_MASTER = 1024,
    IFF_SLAVE = 2048,
    IFF_MULTICAST = 4096,
    IFF_PORTSEL = 8192,
    IFF_AUTOMEDIA = 16384,
    IFF_DYNAMIC = 32768,
    IFF_LOWER_UP = 65536,
    IFF_DORMANT = 131072,
    IFF_ECHO = 262144,
};

enum net_device_path_type {
    DEV_PATH_ETHERNET = 0,
    DEV_PATH_VLAN = 1,
    DEV_PATH_BRIDGE = 2,
    DEV_PATH_PPPOE = 3,
    DEV_PATH_DSA = 4,
    DEV_PATH_MTK_WDMA = 5,
};

enum net_shaper_binding_type {
    NET_SHAPER_BINDING_TYPE_NETDEV = 0,
};

enum net_shaper_metric {
    NET_SHAPER_METRIC_BPS = 0,
    NET_SHAPER_METRIC_PPS = 1,
};

enum net_shaper_scope {
    NET_SHAPER_SCOPE_UNSPEC = 0,
    NET_SHAPER_SCOPE_NETDEV = 1,
    NET_SHAPER_SCOPE_QUEUE = 2,
    NET_SHAPER_SCOPE_NODE = 3,
    __NET_SHAPER_SCOPE_MAX = 4,
    NET_SHAPER_SCOPE_MAX = 3,
};

enum net_xmit_qdisc_t {
    __NET_XMIT_STOLEN = 65536,
    __NET_XMIT_BYPASS = 131072,
};

enum netdev_cmd {
    NETDEV_UP = 1,
    NETDEV_DOWN = 2,
    NETDEV_REBOOT = 3,
    NETDEV_CHANGE = 4,
    NETDEV_REGISTER = 5,
    NETDEV_UNREGISTER = 6,
    NETDEV_CHANGEMTU = 7,
    NETDEV_CHANGEADDR = 8,
    NETDEV_PRE_CHANGEADDR = 9,
    NETDEV_GOING_DOWN = 10,
    NETDEV_CHANGENAME = 11,
    NETDEV_FEAT_CHANGE = 12,
    NETDEV_BONDING_FAILOVER = 13,
    NETDEV_PRE_UP = 14,
    NETDEV_PRE_TYPE_CHANGE = 15,
    NETDEV_POST_TYPE_CHANGE = 16,
    NETDEV_POST_INIT = 17,
    NETDEV_PRE_UNINIT = 18,
    NETDEV_RELEASE = 19,
    NETDEV_NOTIFY_PEERS = 20,
    NETDEV_JOIN = 21,
    NETDEV_CHANGEUPPER = 22,
    NETDEV_RESEND_IGMP = 23,
    NETDEV_PRECHANGEMTU = 24,
    NETDEV_CHANGEINFODATA = 25,
    NETDEV_BONDING_INFO = 26,
    NETDEV_PRECHANGEUPPER = 27,
    NETDEV_CHANGELOWERSTATE = 28,
    NETDEV_UDP_TUNNEL_PUSH_INFO = 29,
    NETDEV_UDP_TUNNEL_DROP_INFO = 30,
    NETDEV_CHANGE_TX_QUEUE_LEN = 31,
    NETDEV_CVLAN_FILTER_PUSH_INFO = 32,
    NETDEV_CVLAN_FILTER_DROP_INFO = 33,
    NETDEV_SVLAN_FILTER_PUSH_INFO = 34,
    NETDEV_SVLAN_FILTER_DROP_INFO = 35,
    NETDEV_OFFLOAD_XSTATS_ENABLE = 36,
    NETDEV_OFFLOAD_XSTATS_DISABLE = 37,
    NETDEV_OFFLOAD_XSTATS_REPORT_USED = 38,
    NETDEV_OFFLOAD_XSTATS_REPORT_DELTA = 39,
    NETDEV_XDP_FEAT_CHANGE = 40,
};

enum netdev_lag_hash {
    NETDEV_LAG_HASH_NONE = 0,
    NETDEV_LAG_HASH_L2 = 1,
    NETDEV_LAG_HASH_L34 = 2,
    NETDEV_LAG_HASH_L23 = 3,
    NETDEV_LAG_HASH_E23 = 4,
    NETDEV_LAG_HASH_E34 = 5,
    NETDEV_LAG_HASH_VLAN_SRCMAC = 6,
    NETDEV_LAG_HASH_UNKNOWN = 7,
};

enum netdev_lag_tx_type {
    NETDEV_LAG_TX_TYPE_UNKNOWN = 0,
    NETDEV_LAG_TX_TYPE_RANDOM = 1,
    NETDEV_LAG_TX_TYPE_BROADCAST = 2,
    NETDEV_LAG_TX_TYPE_ROUNDROBIN = 3,
    NETDEV_LAG_TX_TYPE_ACTIVEBACKUP = 4,
    NETDEV_LAG_TX_TYPE_HASH = 5,
};

enum netdev_ml_priv_type {
    ML_PRIV_NONE = 0,
    ML_PRIV_CAN = 1,
};

enum netdev_offload_xstats_type {
    NETDEV_OFFLOAD_XSTATS_TYPE_L3 = 1,
};

enum netdev_priv_flags {
    IFF_802_1Q_VLAN = 1,
    IFF_EBRIDGE = 2,
    IFF_BONDING = 4,
    IFF_ISATAP = 8,
    IFF_WAN_HDLC = 16,
    IFF_XMIT_DST_RELEASE = 32,
    IFF_DONT_BRIDGE = 64,
    IFF_DISABLE_NETPOLL = 128,
    IFF_MACVLAN_PORT = 256,
    IFF_BRIDGE_PORT = 512,
    IFF_OVS_DATAPATH = 1024,
    IFF_TX_SKB_SHARING = 2048,
    IFF_UNICAST_FLT = 4096,
    IFF_TEAM_PORT = 8192,
    IFF_SUPP_NOFCS = 16384,
    IFF_LIVE_ADDR_CHANGE = 32768,
    IFF_MACVLAN = 65536,
    IFF_XMIT_DST_RELEASE_PERM = 131072,
    IFF_L3MDEV_MASTER = 262144,
    IFF_NO_QUEUE = 524288,
    IFF_OPENVSWITCH = 1048576,
    IFF_L3MDEV_SLAVE = 2097152,
    IFF_TEAM = 4194304,
    IFF_RXFH_CONFIGURED = 8388608,
    IFF_PHONY_HEADROOM = 16777216,
    IFF_MACSEC = 33554432,
    IFF_NO_RX_HANDLER = 67108864,
    IFF_FAILOVER = 134217728,
    IFF_FAILOVER_SLAVE = 268435456,
    IFF_L3MDEV_RX_HANDLER = 536870912,
    IFF_NO_ADDRCONF = 1073741824,
    IFF_TX_SKB_NO_LINEAR = 2147483648,
};

enum netdev_qstats_scope {
    NETDEV_QSTATS_SCOPE_QUEUE = 1,
};

enum netdev_queue_state_t {
    __QUEUE_STATE_DRV_XOFF = 0,
    __QUEUE_STATE_STACK_XOFF = 1,
    __QUEUE_STATE_FROZEN = 2,
};

enum netdev_queue_type {
    NETDEV_QUEUE_TYPE_RX = 0,
    NETDEV_QUEUE_TYPE_TX = 1,
};

enum netdev_reg_state {
    NETREG_UNINITIALIZED = 0,
    NETREG_REGISTERED = 1,
    NETREG_UNREGISTERING = 2,
    NETREG_UNREGISTERED = 3,
    NETREG_RELEASED = 4,
    NETREG_DUMMY = 5,
};

enum netdev_stat_type {
    NETDEV_PCPU_STAT_NONE = 0,
    NETDEV_PCPU_STAT_LSTATS = 1,
    NETDEV_PCPU_STAT_TSTATS = 2,
    NETDEV_PCPU_STAT_DSTATS = 3,
};

enum netdev_state_t {
    __LINK_STATE_START = 0,
    __LINK_STATE_PRESENT = 1,
    __LINK_STATE_NOCARRIER = 2,
    __LINK_STATE_LINKWATCH_PENDING = 3,
    __LINK_STATE_DORMANT = 4,
    __LINK_STATE_TESTING = 5,
};

enum netdev_tx {
    __NETDEV_TX_MIN = -2147483648,
    NETDEV_TX_OK = 0,
    NETDEV_TX_BUSY = 16,
};

typedef enum netdev_tx netdev_tx_t;

enum netdev_xdp_act {
    NETDEV_XDP_ACT_BASIC = 1,
    NETDEV_XDP_ACT_REDIRECT = 2,
    NETDEV_XDP_ACT_NDO_XMIT = 4,
    NETDEV_XDP_ACT_XSK_ZEROCOPY = 8,
    NETDEV_XDP_ACT_HW_OFFLOAD = 16,
    NETDEV_XDP_ACT_RX_SG = 32,
    NETDEV_XDP_ACT_NDO_XMIT_SG = 64,
    NETDEV_XDP_ACT_MASK = 127,
};

enum netdev_xdp_rx_metadata {
    NETDEV_XDP_RX_METADATA_TIMESTAMP = 1,
    NETDEV_XDP_RX_METADATA_HASH = 2,
    NETDEV_XDP_RX_METADATA_VLAN_TAG = 4,
};

enum netdev_xsk_flags {
    NETDEV_XSK_FLAGS_TX_TIMESTAMP = 1,
    NETDEV_XSK_FLAGS_TX_CHECKSUM = 2,
    NETDEV_XSK_FLAGS_TX_LAUNCH_TIME_FIFO = 4,
};

enum netevent_notif_type {
    NETEVENT_NEIGH_UPDATE = 1,
    NETEVENT_REDIRECT = 2,
    NETEVENT_DELAY_PROBE_TIME_UPDATE = 3,
    NETEVENT_IPV4_MPATH_HASH_UPDATE = 4,
    NETEVENT_IPV6_MPATH_HASH_UPDATE = 5,
    NETEVENT_IPV4_FWD_UPDATE_PRIORITY_UPDATE = 6,
};

enum netkit_action {
    NETKIT_NEXT = -1,
    NETKIT_PASS = 0,
    NETKIT_DROP = 2,
    NETKIT_REDIRECT = 7,
};

enum netkit_mode {
    NETKIT_L2 = 0,
    NETKIT_L3 = 1,
};

enum netkit_scrub {
    NETKIT_SCRUB_NONE = 0,
    NETKIT_SCRUB_DEFAULT = 1,
};

enum netlink_attribute_type {
    NL_ATTR_TYPE_INVALID = 0,
    NL_ATTR_TYPE_FLAG = 1,
    NL_ATTR_TYPE_U8 = 2,
    NL_ATTR_TYPE_U16 = 3,
    NL_ATTR_TYPE_U32 = 4,
    NL_ATTR_TYPE_U64 = 5,
    NL_ATTR_TYPE_S8 = 6,
    NL_ATTR_TYPE_S16 = 7,
    NL_ATTR_TYPE_S32 = 8,
    NL_ATTR_TYPE_S64 = 9,
    NL_ATTR_TYPE_BINARY = 10,
    NL_ATTR_TYPE_STRING = 11,
    NL_ATTR_TYPE_NUL_STRING = 12,
    NL_ATTR_TYPE_NESTED = 13,
    NL_ATTR_TYPE_NESTED_ARRAY = 14,
    NL_ATTR_TYPE_BITFIELD32 = 15,
    NL_ATTR_TYPE_SINT = 16,
    NL_ATTR_TYPE_UINT = 17,
};

enum netlink_policy_type_attr {
    NL_POLICY_TYPE_ATTR_UNSPEC = 0,
    NL_POLICY_TYPE_ATTR_TYPE = 1,
    NL_POLICY_TYPE_ATTR_MIN_VALUE_S = 2,
    NL_POLICY_TYPE_ATTR_MAX_VALUE_S = 3,
    NL_POLICY_TYPE_ATTR_MIN_VALUE_U = 4,
    NL_POLICY_TYPE_ATTR_MAX_VALUE_U = 5,
    NL_POLICY_TYPE_ATTR_MIN_LENGTH = 6,
    NL_POLICY_TYPE_ATTR_MAX_LENGTH = 7,
    NL_POLICY_TYPE_ATTR_POLICY_IDX = 8,
    NL_POLICY_TYPE_ATTR_POLICY_MAXTYPE = 9,
    NL_POLICY_TYPE_ATTR_BITFIELD32_MASK = 10,
    NL_POLICY_TYPE_ATTR_PAD = 11,
    NL_POLICY_TYPE_ATTR_MASK = 12,
    __NL_POLICY_TYPE_ATTR_MAX = 13,
    NL_POLICY_TYPE_ATTR_MAX = 12,
};

enum netlink_skb_flags {
    NETLINK_SKB_DST = 8,
};

enum netlink_validation {
    NL_VALIDATE_LIBERAL = 0,
    NL_VALIDATE_TRAILING = 1,
    NL_VALIDATE_MAXTYPE = 2,
    NL_VALIDATE_UNSPEC = 4,
    NL_VALIDATE_STRICT_ATTRS = 8,
    NL_VALIDATE_NESTED = 16,
};

enum netns_bpf_attach_type {
    NETNS_BPF_INVALID = -1,
    NETNS_BPF_FLOW_DISSECTOR = 0,
    NETNS_BPF_SK_LOOKUP = 1,
    MAX_NETNS_BPF_ATTACH_TYPE = 2,
};

enum nexthop_event_type {
    NEXTHOP_EVENT_DEL = 0,
    NEXTHOP_EVENT_REPLACE = 1,
    NEXTHOP_EVENT_RES_TABLE_PRE_REPLACE = 2,
    NEXTHOP_EVENT_BUCKET_REPLACE = 3,
    NEXTHOP_EVENT_HW_STATS_REPORT_DELTA = 4,
};

enum nf_ct_ext_id {
    NF_CT_EXT_HELPER = 0,
    NF_CT_EXT_NAT = 1,
    NF_CT_EXT_SEQADJ = 2,
    NF_CT_EXT_ACCT = 3,
    NF_CT_EXT_ECACHE = 4,
    NF_CT_EXT_TSTAMP = 5,
    NF_CT_EXT_TIMEOUT = 6,
    NF_CT_EXT_LABELS = 7,
    NF_CT_EXT_SYNPROXY = 8,
    NF_CT_EXT_ACT_CT = 9,
    NF_CT_EXT_NUM = 10,
};

enum nf_dev_hooks {
    NF_NETDEV_INGRESS = 0,
    NF_NETDEV_EGRESS = 1,
    NF_NETDEV_NUMHOOKS = 2,
};

enum nf_hook_ops_type {
    NF_HOOK_OP_UNDEFINED = 0,
    NF_HOOK_OP_NF_TABLES = 1,
    NF_HOOK_OP_BPF = 2,
};

enum nf_inet_hooks {
    NF_INET_PRE_ROUTING = 0,
    NF_INET_LOCAL_IN = 1,
    NF_INET_FORWARD = 2,
    NF_INET_LOCAL_OUT = 3,
    NF_INET_POST_ROUTING = 4,
    NF_INET_NUMHOOKS = 5,
    NF_INET_INGRESS = 5,
};

enum nf_ip6_hook_priorities {
    NF_IP6_PRI_FIRST = -2147483648,
    NF_IP6_PRI_RAW_BEFORE_DEFRAG = -450,
    NF_IP6_PRI_CONNTRACK_DEFRAG = -400,
    NF_IP6_PRI_RAW = -300,
    NF_IP6_PRI_SELINUX_FIRST = -225,
    NF_IP6_PRI_CONNTRACK = -200,
    NF_IP6_PRI_MANGLE = -150,
    NF_IP6_PRI_NAT_DST = -100,
    NF_IP6_PRI_FILTER = 0,
    NF_IP6_PRI_SECURITY = 50,
    NF_IP6_PRI_NAT_SRC = 100,
    NF_IP6_PRI_SELINUX_LAST = 225,
    NF_IP6_PRI_CONNTRACK_HELPER = 300,
    NF_IP6_PRI_LAST = 2147483647,
};

enum nf_ip_hook_priorities {
    NF_IP_PRI_FIRST = -2147483648,
    NF_IP_PRI_RAW_BEFORE_DEFRAG = -450,
    NF_IP_PRI_CONNTRACK_DEFRAG = -400,
    NF_IP_PRI_RAW = -300,
    NF_IP_PRI_SELINUX_FIRST = -225,
    NF_IP_PRI_CONNTRACK = -200,
    NF_IP_PRI_MANGLE = -150,
    NF_IP_PRI_NAT_DST = -100,
    NF_IP_PRI_FILTER = 0,
    NF_IP_PRI_SECURITY = 50,
    NF_IP_PRI_NAT_SRC = 100,
    NF_IP_PRI_SELINUX_LAST = 225,
    NF_IP_PRI_CONNTRACK_HELPER = 300,
    NF_IP_PRI_CONNTRACK_CONFIRM = 2147483647,
    NF_IP_PRI_LAST = 2147483647,
};

enum nf_log_type {
    NF_LOG_TYPE_LOG = 0,
    NF_LOG_TYPE_ULOG = 1,
    NF_LOG_TYPE_MAX = 2,
};

enum nf_nat_manip_type;

enum nfs3_stable_how {
    NFS_UNSTABLE = 0,
    NFS_DATA_SYNC = 1,
    NFS_FILE_SYNC = 2,
    NFS_INVALID_STABLE_HOW = -1,
};

enum nfs4_change_attr_type {
    NFS4_CHANGE_TYPE_IS_MONOTONIC_INCR = 0,
    NFS4_CHANGE_TYPE_IS_VERSION_COUNTER = 1,
    NFS4_CHANGE_TYPE_IS_VERSION_COUNTER_NOPNFS = 2,
    NFS4_CHANGE_TYPE_IS_TIME_METADATA = 3,
    NFS4_CHANGE_TYPE_IS_UNDEFINED = 4,
};

enum nfs_opnum4 {
    OP_ACCESS = 3,
    OP_CLOSE = 4,
    OP_COMMIT = 5,
    OP_CREATE = 6,
    OP_DELEGPURGE = 7,
    OP_DELEGRETURN = 8,
    OP_GETATTR = 9,
    OP_GETFH = 10,
    OP_LINK = 11,
    OP_LOCK = 12,
    OP_LOCKT = 13,
    OP_LOCKU = 14,
    OP_LOOKUP = 15,
    OP_LOOKUPP = 16,
    OP_NVERIFY = 17,
    OP_OPEN = 18,
    OP_OPENATTR = 19,
    OP_OPEN_CONFIRM = 20,
    OP_OPEN_DOWNGRADE = 21,
    OP_PUTFH = 22,
    OP_PUTPUBFH = 23,
    OP_PUTROOTFH = 24,
    OP_READ = 25,
    OP_READDIR = 26,
    OP_READLINK = 27,
    OP_REMOVE = 28,
    OP_RENAME = 29,
    OP_RENEW = 30,
    OP_RESTOREFH = 31,
    OP_SAVEFH = 32,
    OP_SECINFO = 33,
    OP_SETATTR = 34,
    OP_SETCLIENTID = 35,
    OP_SETCLIENTID_CONFIRM = 36,
    OP_VERIFY = 37,
    OP_WRITE = 38,
    OP_RELEASE_LOCKOWNER = 39,
    OP_BACKCHANNEL_CTL = 40,
    OP_BIND_CONN_TO_SESSION = 41,
    OP_EXCHANGE_ID = 42,
    OP_CREATE_SESSION = 43,
    OP_DESTROY_SESSION = 44,
    OP_FREE_STATEID = 45,
    OP_GET_DIR_DELEGATION = 46,
    OP_GETDEVICEINFO = 47,
    OP_GETDEVICELIST = 48,
    OP_LAYOUTCOMMIT = 49,
    OP_LAYOUTGET = 50,
    OP_LAYOUTRETURN = 51,
    OP_SECINFO_NO_NAME = 52,
    OP_SEQUENCE = 53,
    OP_SET_SSV = 54,
    OP_TEST_STATEID = 55,
    OP_WANT_DELEGATION = 56,
    OP_DESTROY_CLIENTID = 57,
    OP_RECLAIM_COMPLETE = 58,
    OP_ALLOCATE = 59,
    OP_COPY = 60,
    OP_COPY_NOTIFY = 61,
    OP_DEALLOCATE = 62,
    OP_IO_ADVISE = 63,
    OP_LAYOUTERROR = 64,
    OP_LAYOUTSTATS = 65,
    OP_OFFLOAD_CANCEL = 66,
    OP_OFFLOAD_STATUS = 67,
    OP_READ_PLUS = 68,
    OP_SEEK = 69,
    OP_WRITE_SAME = 70,
    OP_CLONE = 71,
    OP_GETXATTR = 72,
    OP_SETXATTR = 73,
    OP_LISTXATTRS = 74,
    OP_REMOVEXATTR = 75,
    OP_ILLEGAL = 10044,
};

enum nfs_stat {
    NFS_OK = 0,
    NFSERR_PERM = 1,
    NFSERR_NOENT = 2,
    NFSERR_IO = 5,
    NFSERR_NXIO = 6,
    NFSERR_EAGAIN = 11,
    NFSERR_ACCES = 13,
    NFSERR_EXIST = 17,
    NFSERR_XDEV = 18,
    NFSERR_NODEV = 19,
    NFSERR_NOTDIR = 20,
    NFSERR_ISDIR = 21,
    NFSERR_INVAL = 22,
    NFSERR_FBIG = 27,
    NFSERR_NOSPC = 28,
    NFSERR_ROFS = 30,
    NFSERR_MLINK = 31,
    NFSERR_NAMETOOLONG = 63,
    NFSERR_NOTEMPTY = 66,
    NFSERR_DQUOT = 69,
    NFSERR_STALE = 70,
    NFSERR_REMOTE = 71,
    NFSERR_WFLUSH = 99,
    NFSERR_BADHANDLE = 10001,
    NFSERR_NOT_SYNC = 10002,
    NFSERR_BAD_COOKIE = 10003,
    NFSERR_NOTSUPP = 10004,
    NFSERR_TOOSMALL = 10005,
    NFSERR_SERVERFAULT = 10006,
    NFSERR_BADTYPE = 10007,
    NFSERR_JUKEBOX = 10008,
    NFSERR_SAME = 10009,
    NFSERR_DENIED = 10010,
    NFSERR_EXPIRED = 10011,
    NFSERR_LOCKED = 10012,
    NFSERR_GRACE = 10013,
    NFSERR_FHEXPIRED = 10014,
    NFSERR_SHARE_DENIED = 10015,
    NFSERR_WRONGSEC = 10016,
    NFSERR_CLID_INUSE = 10017,
    NFSERR_RESOURCE = 10018,
    NFSERR_MOVED = 10019,
    NFSERR_NOFILEHANDLE = 10020,
    NFSERR_MINOR_VERS_MISMATCH = 10021,
    NFSERR_STALE_CLIENTID = 10022,
    NFSERR_STALE_STATEID = 10023,
    NFSERR_OLD_STATEID = 10024,
    NFSERR_BAD_STATEID = 10025,
    NFSERR_BAD_SEQID = 10026,
    NFSERR_NOT_SAME = 10027,
    NFSERR_LOCK_RANGE = 10028,
    NFSERR_SYMLINK = 10029,
    NFSERR_RESTOREFH = 10030,
    NFSERR_LEASE_MOVED = 10031,
    NFSERR_ATTRNOTSUPP = 10032,
    NFSERR_NO_GRACE = 10033,
    NFSERR_RECLAIM_BAD = 10034,
    NFSERR_RECLAIM_CONFLICT = 10035,
    NFSERR_BAD_XDR = 10036,
    NFSERR_LOCKS_HELD = 10037,
    NFSERR_OPENMODE = 10038,
    NFSERR_BADOWNER = 10039,
    NFSERR_BADCHAR = 10040,
    NFSERR_BADNAME = 10041,
    NFSERR_BAD_RANGE = 10042,
    NFSERR_LOCK_NOTSUPP = 10043,
    NFSERR_OP_ILLEGAL = 10044,
    NFSERR_DEADLOCK = 10045,
    NFSERR_FILE_OPEN = 10046,
    NFSERR_ADMIN_REVOKED = 10047,
    NFSERR_CB_PATH_DOWN = 10048,
};

enum nfsstat4 {
    NFS4_OK = 0,
    NFS4ERR_PERM = 1,
    NFS4ERR_NOENT = 2,
    NFS4ERR_IO = 5,
    NFS4ERR_NXIO = 6,
    NFS4ERR_ACCESS = 13,
    NFS4ERR_EXIST = 17,
    NFS4ERR_XDEV = 18,
    NFS4ERR_NOTDIR = 20,
    NFS4ERR_ISDIR = 21,
    NFS4ERR_INVAL = 22,
    NFS4ERR_FBIG = 27,
    NFS4ERR_NOSPC = 28,
    NFS4ERR_ROFS = 30,
    NFS4ERR_MLINK = 31,
    NFS4ERR_NAMETOOLONG = 63,
    NFS4ERR_NOTEMPTY = 66,
    NFS4ERR_DQUOT = 69,
    NFS4ERR_STALE = 70,
    NFS4ERR_BADHANDLE = 10001,
    NFS4ERR_BAD_COOKIE = 10003,
    NFS4ERR_NOTSUPP = 10004,
    NFS4ERR_TOOSMALL = 10005,
    NFS4ERR_SERVERFAULT = 10006,
    NFS4ERR_BADTYPE = 10007,
    NFS4ERR_DELAY = 10008,
    NFS4ERR_SAME = 10009,
    NFS4ERR_DENIED = 10010,
    NFS4ERR_EXPIRED = 10011,
    NFS4ERR_LOCKED = 10012,
    NFS4ERR_GRACE = 10013,
    NFS4ERR_FHEXPIRED = 10014,
    NFS4ERR_SHARE_DENIED = 10015,
    NFS4ERR_WRONGSEC = 10016,
    NFS4ERR_CLID_INUSE = 10017,
    NFS4ERR_RESOURCE = 10018,
    NFS4ERR_MOVED = 10019,
    NFS4ERR_NOFILEHANDLE = 10020,
    NFS4ERR_MINOR_VERS_MISMATCH = 10021,
    NFS4ERR_STALE_CLIENTID = 10022,
    NFS4ERR_STALE_STATEID = 10023,
    NFS4ERR_OLD_STATEID = 10024,
    NFS4ERR_BAD_STATEID = 10025,
    NFS4ERR_BAD_SEQID = 10026,
    NFS4ERR_NOT_SAME = 10027,
    NFS4ERR_LOCK_RANGE = 10028,
    NFS4ERR_SYMLINK = 10029,
    NFS4ERR_RESTOREFH = 10030,
    NFS4ERR_LEASE_MOVED = 10031,
    NFS4ERR_ATTRNOTSUPP = 10032,
    NFS4ERR_NO_GRACE = 10033,
    NFS4ERR_RECLAIM_BAD = 10034,
    NFS4ERR_RECLAIM_CONFLICT = 10035,
    NFS4ERR_BADXDR = 10036,
    NFS4ERR_LOCKS_HELD = 10037,
    NFS4ERR_OPENMODE = 10038,
    NFS4ERR_BADOWNER = 10039,
    NFS4ERR_BADCHAR = 10040,
    NFS4ERR_BADNAME = 10041,
    NFS4ERR_BAD_RANGE = 10042,
    NFS4ERR_LOCK_NOTSUPP = 10043,
    NFS4ERR_OP_ILLEGAL = 10044,
    NFS4ERR_DEADLOCK = 10045,
    NFS4ERR_FILE_OPEN = 10046,
    NFS4ERR_ADMIN_REVOKED = 10047,
    NFS4ERR_CB_PATH_DOWN = 10048,
    NFS4ERR_BADIOMODE = 10049,
    NFS4ERR_BADLAYOUT = 10050,
    NFS4ERR_BAD_SESSION_DIGEST = 10051,
    NFS4ERR_BADSESSION = 10052,
    NFS4ERR_BADSLOT = 10053,
    NFS4ERR_COMPLETE_ALREADY = 10054,
    NFS4ERR_CONN_NOT_BOUND_TO_SESSION = 10055,
    NFS4ERR_DELEG_ALREADY_WANTED = 10056,
    NFS4ERR_BACK_CHAN_BUSY = 10057,
    NFS4ERR_LAYOUTTRYLATER = 10058,
    NFS4ERR_LAYOUTUNAVAILABLE = 10059,
    NFS4ERR_NOMATCHING_LAYOUT = 10060,
    NFS4ERR_RECALLCONFLICT = 10061,
    NFS4ERR_UNKNOWN_LAYOUTTYPE = 10062,
    NFS4ERR_SEQ_MISORDERED = 10063,
    NFS4ERR_SEQUENCE_POS = 10064,
    NFS4ERR_REQ_TOO_BIG = 10065,
    NFS4ERR_REP_TOO_BIG = 10066,
    NFS4ERR_REP_TOO_BIG_TO_CACHE = 10067,
    NFS4ERR_RETRY_UNCACHED_REP = 10068,
    NFS4ERR_UNSAFE_COMPOUND = 10069,
    NFS4ERR_TOO_MANY_OPS = 10070,
    NFS4ERR_OP_NOT_IN_SESSION = 10071,
    NFS4ERR_HASH_ALG_UNSUPP = 10072,
    NFS4ERR_CLIENTID_BUSY = 10074,
    NFS4ERR_PNFS_IO_HOLE = 10075,
    NFS4ERR_SEQ_FALSE_RETRY = 10076,
    NFS4ERR_BAD_HIGH_SLOT = 10077,
    NFS4ERR_DEADSESSION = 10078,
    NFS4ERR_ENCR_ALG_UNSUPP = 10079,
    NFS4ERR_PNFS_NO_LAYOUT = 10080,
    NFS4ERR_NOT_ONLY_OP = 10081,
    NFS4ERR_WRONG_CRED = 10082,
    NFS4ERR_WRONG_TYPE = 10083,
    NFS4ERR_DIRDELEG_UNAVAIL = 10084,
    NFS4ERR_REJECT_DELEG = 10085,
    NFS4ERR_RETURNCONFLICT = 10086,
    NFS4ERR_DELEG_REVOKED = 10087,
    NFS4ERR_PARTNER_NOTSUPP = 10088,
    NFS4ERR_PARTNER_NO_AUTH = 10089,
    NFS4ERR_UNION_NOTSUPP = 10090,
    NFS4ERR_OFFLOAD_DENIED = 10091,
    NFS4ERR_WRONG_LFS = 10092,
    NFS4ERR_BADLABEL = 10093,
    NFS4ERR_OFFLOAD_NO_REQS = 10094,
    NFS4ERR_NOXATTR = 10095,
    NFS4ERR_XATTR2BIG = 10096,
    NFS4ERR_FIRST_FREE = 10097,
};

enum nh_notifier_info_type {
    NH_NOTIFIER_INFO_TYPE_SINGLE = 0,
    NH_NOTIFIER_INFO_TYPE_GRP = 1,
    NH_NOTIFIER_INFO_TYPE_RES_TABLE = 2,
    NH_NOTIFIER_INFO_TYPE_RES_BUCKET = 3,
    NH_NOTIFIER_INFO_TYPE_GRP_HW_STATS = 4,
};

enum nl80211_auth_type {
    NL80211_AUTHTYPE_OPEN_SYSTEM = 0,
    NL80211_AUTHTYPE_SHARED_KEY = 1,
    NL80211_AUTHTYPE_FT = 2,
    NL80211_AUTHTYPE_NETWORK_EAP = 3,
    NL80211_AUTHTYPE_SAE = 4,
    NL80211_AUTHTYPE_FILS_SK = 5,
    NL80211_AUTHTYPE_FILS_SK_PFS = 6,
    NL80211_AUTHTYPE_FILS_PK = 7,
    __NL80211_AUTHTYPE_NUM = 8,
    NL80211_AUTHTYPE_MAX = 7,
    NL80211_AUTHTYPE_AUTOMATIC = 8,
};

enum nl80211_band {
    NL80211_BAND_2GHZ = 0,
    NL80211_BAND_5GHZ = 1,
    NL80211_BAND_60GHZ = 2,
    NL80211_BAND_6GHZ = 3,
    NL80211_BAND_S1GHZ = 4,
    NL80211_BAND_LC = 5,
    NUM_NL80211_BANDS = 6,
};

enum nl80211_bss_select_attr {
    __NL80211_BSS_SELECT_ATTR_INVALID = 0,
    NL80211_BSS_SELECT_ATTR_RSSI = 1,
    NL80211_BSS_SELECT_ATTR_BAND_PREF = 2,
    NL80211_BSS_SELECT_ATTR_RSSI_ADJUST = 3,
    __NL80211_BSS_SELECT_ATTR_AFTER_LAST = 4,
    NL80211_BSS_SELECT_ATTR_MAX = 3,
};

enum nl80211_chan_width {
    NL80211_CHAN_WIDTH_20_NOHT = 0,
    NL80211_CHAN_WIDTH_20 = 1,
    NL80211_CHAN_WIDTH_40 = 2,
    NL80211_CHAN_WIDTH_80 = 3,
    NL80211_CHAN_WIDTH_80P80 = 4,
    NL80211_CHAN_WIDTH_160 = 5,
    NL80211_CHAN_WIDTH_5 = 6,
    NL80211_CHAN_WIDTH_10 = 7,
    NL80211_CHAN_WIDTH_1 = 8,
    NL80211_CHAN_WIDTH_2 = 9,
    NL80211_CHAN_WIDTH_4 = 10,
    NL80211_CHAN_WIDTH_8 = 11,
    NL80211_CHAN_WIDTH_16 = 12,
    NL80211_CHAN_WIDTH_320 = 13,
};

enum nl80211_dfs_regions {
    NL80211_DFS_UNSET = 0,
    NL80211_DFS_FCC = 1,
    NL80211_DFS_ETSI = 2,
    NL80211_DFS_JP = 3,
};

enum nl80211_dfs_state {
    NL80211_DFS_USABLE = 0,
    NL80211_DFS_UNAVAILABLE = 1,
    NL80211_DFS_AVAILABLE = 2,
};

enum nl80211_iftype {
    NL80211_IFTYPE_UNSPECIFIED = 0,
    NL80211_IFTYPE_ADHOC = 1,
    NL80211_IFTYPE_STATION = 2,
    NL80211_IFTYPE_AP = 3,
    NL80211_IFTYPE_AP_VLAN = 4,
    NL80211_IFTYPE_WDS = 5,
    NL80211_IFTYPE_MONITOR = 6,
    NL80211_IFTYPE_MESH_POINT = 7,
    NL80211_IFTYPE_P2P_CLIENT = 8,
    NL80211_IFTYPE_P2P_GO = 9,
    NL80211_IFTYPE_P2P_DEVICE = 10,
    NL80211_IFTYPE_OCB = 11,
    NL80211_IFTYPE_NAN = 12,
    NUM_NL80211_IFTYPES = 13,
    NL80211_IFTYPE_MAX = 12,
};

enum nl80211_key_mode {
    NL80211_KEY_RX_TX = 0,
    NL80211_KEY_NO_TX = 1,
    NL80211_KEY_SET_TX = 2,
};

enum nl80211_mfp {
    NL80211_MFP_NO = 0,
    NL80211_MFP_REQUIRED = 1,
    NL80211_MFP_OPTIONAL = 2,
};

enum nl80211_reg_initiator {
    NL80211_REGDOM_SET_BY_CORE = 0,
    NL80211_REGDOM_SET_BY_USER = 1,
    NL80211_REGDOM_SET_BY_DRIVER = 2,
    NL80211_REGDOM_SET_BY_COUNTRY_IE = 3,
};

enum nl80211_sae_pwe_mechanism {
    NL80211_SAE_PWE_UNSPECIFIED = 0,
    NL80211_SAE_PWE_HUNT_AND_PECK = 1,
    NL80211_SAE_PWE_HASH_TO_ELEMENT = 2,
    NL80211_SAE_PWE_BOTH = 3,
};

enum nl80211_sar_type {
    NL80211_SAR_TYPE_POWER = 0,
    NUM_NL80211_SAR_TYPE = 1,
};

enum nl80211_user_reg_hint_type {
    NL80211_USER_REG_HINT_USER = 0,
    NL80211_USER_REG_HINT_CELL_BASE = 1,
    NL80211_USER_REG_HINT_INDOOR = 2,
};

enum nl802154_cca_modes {
    __NL802154_CCA_INVALID = 0,
    NL802154_CCA_ENERGY = 1,
    NL802154_CCA_CARRIER = 2,
    NL802154_CCA_ENERGY_CARRIER = 3,
    NL802154_CCA_ALOHA = 4,
    NL802154_CCA_UWB_SHR = 5,
    NL802154_CCA_UWB_MULTIPLEXED = 6,
    __NL802154_CCA_ATTR_AFTER_LAST = 7,
    NL802154_CCA_ATTR_MAX = 6,
};

enum nl802154_cca_opts {
    NL802154_CCA_OPT_ENERGY_CARRIER_AND = 0,
    NL802154_CCA_OPT_ENERGY_CARRIER_OR = 1,
    __NL802154_CCA_OPT_ATTR_AFTER_LAST = 2,
    NL802154_CCA_OPT_ATTR_MAX = 1,
};

enum nl802154_supported_bool_states {
    NL802154_SUPPORTED_BOOL_FALSE = 0,
    NL802154_SUPPORTED_BOOL_TRUE = 1,
    __NL802154_SUPPORTED_BOOL_INVALD = 2,
    NL802154_SUPPORTED_BOOL_BOTH = 3,
    __NL802154_SUPPORTED_BOOL_AFTER_LAST = 4,
    NL802154_SUPPORTED_BOOL_MAX = 3,
};

enum nla_policy_validation {
    NLA_VALIDATE_NONE = 0,
    NLA_VALIDATE_RANGE = 1,
    NLA_VALIDATE_RANGE_WARN_TOO_LONG = 2,
    NLA_VALIDATE_MIN = 3,
    NLA_VALIDATE_MAX = 4,
    NLA_VALIDATE_MASK = 5,
    NLA_VALIDATE_RANGE_PTR = 6,
    NLA_VALIDATE_FUNCTION = 7,
};

enum nlmsgerr_attrs {
    NLMSGERR_ATTR_UNUSED = 0,
    NLMSGERR_ATTR_MSG = 1,
    NLMSGERR_ATTR_OFFS = 2,
    NLMSGERR_ATTR_COOKIE = 3,
    NLMSGERR_ATTR_POLICY = 4,
    NLMSGERR_ATTR_MISS_TYPE = 5,
    NLMSGERR_ATTR_MISS_NEST = 6,
    __NLMSGERR_ATTR_MAX = 7,
    NLMSGERR_ATTR_MAX = 6,
};

enum node_stat_item {
    NR_LRU_BASE = 0,
    NR_INACTIVE_ANON = 0,
    NR_ACTIVE_ANON = 1,
    NR_INACTIVE_FILE = 2,
    NR_ACTIVE_FILE = 3,
    NR_UNEVICTABLE = 4,
    NR_SLAB_RECLAIMABLE_B = 5,
    NR_SLAB_UNRECLAIMABLE_B = 6,
    NR_ISOLATED_ANON = 7,
    NR_ISOLATED_FILE = 8,
    WORKINGSET_NODES = 9,
    WORKINGSET_REFAULT_BASE = 10,
    WORKINGSET_REFAULT_ANON = 10,
    WORKINGSET_REFAULT_FILE = 11,
    WORKINGSET_ACTIVATE_BASE = 12,
    WORKINGSET_ACTIVATE_ANON = 12,
    WORKINGSET_ACTIVATE_FILE = 13,
    WORKINGSET_RESTORE_BASE = 14,
    WORKINGSET_RESTORE_ANON = 14,
    WORKINGSET_RESTORE_FILE = 15,
    WORKINGSET_NODERECLAIM = 16,
    NR_ANON_MAPPED = 17,
    NR_FILE_MAPPED = 18,
    NR_FILE_PAGES = 19,
    NR_FILE_DIRTY = 20,
    NR_WRITEBACK = 21,
    NR_WRITEBACK_TEMP = 22,
    NR_SHMEM = 23,
    NR_SHMEM_THPS = 24,
    NR_SHMEM_PMDMAPPED = 25,
    NR_FILE_THPS = 26,
    NR_FILE_PMDMAPPED = 27,
    NR_ANON_THPS = 28,
    NR_VMSCAN_WRITE = 29,
    NR_VMSCAN_IMMEDIATE = 30,
    NR_DIRTIED = 31,
    NR_WRITTEN = 32,
    NR_THROTTLED_WRITTEN = 33,
    NR_KERNEL_MISC_RECLAIMABLE = 34,
    NR_FOLL_PIN_ACQUIRED = 35,
    NR_FOLL_PIN_RELEASED = 36,
    NR_KERNEL_STACK_KB = 37,
    NR_PAGETABLE = 38,
    NR_SECONDARY_PAGETABLE = 39,
    NR_IOMMU_PAGES = 40,
    NR_SWAPCACHE = 41,
    PGDEMOTE_KSWAPD = 42,
    PGDEMOTE_DIRECT = 43,
    PGDEMOTE_KHUGEPAGED = 44,
    NR_HUGETLB = 45,
    NR_VM_NODE_STAT_ITEMS = 46,
};

enum node_states {
    N_POSSIBLE = 0,
    N_ONLINE = 1,
    N_NORMAL_MEMORY = 2,
    N_HIGH_MEMORY = 2,
    N_MEMORY = 3,
    N_CPU = 4,
    N_GENERIC_INITIATOR = 5,
    NR_NODE_STATES = 6,
};

enum notify_state {
    SECCOMP_NOTIFY_INIT = 0,
    SECCOMP_NOTIFY_SENT = 1,
    SECCOMP_NOTIFY_REPLIED = 2,
};

enum nvmem_type {
    NVMEM_TYPE_UNKNOWN = 0,
    NVMEM_TYPE_EEPROM = 1,
    NVMEM_TYPE_OTP = 2,
    NVMEM_TYPE_BATTERY_BACKED = 3,
    NVMEM_TYPE_FRAM = 4,
};

enum objext_flags {
    OBJEXTS_ALLOC_FAIL = 4,
    __NR_OBJEXTS_FLAGS = 8,
};

enum of_gpio_flags {
    OF_GPIO_ACTIVE_LOW = 1,
    OF_GPIO_SINGLE_ENDED = 2,
    OF_GPIO_OPEN_DRAIN = 4,
    OF_GPIO_TRANSITORY = 8,
    OF_GPIO_PULL_UP = 16,
    OF_GPIO_PULL_DOWN = 32,
    OF_GPIO_PULL_DISABLE = 64,
};

enum of_overlay_notify_action {
    OF_OVERLAY_INIT = 0,
    OF_OVERLAY_PRE_APPLY = 1,
    OF_OVERLAY_POST_APPLY = 2,
    OF_OVERLAY_PRE_REMOVE = 3,
    OF_OVERLAY_POST_REMOVE = 4,
};

enum of_reconfig_change {
    OF_RECONFIG_NO_CHANGE = 0,
    OF_RECONFIG_CHANGE_ADD = 1,
    OF_RECONFIG_CHANGE_REMOVE = 2,
};

enum offload_act_command {
    FLOW_ACT_REPLACE = 0,
    FLOW_ACT_DESTROY = 1,
    FLOW_ACT_STATS = 2,
};

enum oom_constraint {
    CONSTRAINT_NONE = 0,
    CONSTRAINT_CPUSET = 1,
    CONSTRAINT_MEMORY_POLICY = 2,
    CONSTRAINT_MEMCG = 3,
};

enum opal_atom_width {
    OPAL_WIDTH_TINY = 0,
    OPAL_WIDTH_SHORT = 1,
    OPAL_WIDTH_MEDIUM = 2,
    OPAL_WIDTH_LONG = 3,
    OPAL_WIDTH_TOKEN = 4,
};

enum opal_key_type {
    OPAL_INCLUDED = 0,
    OPAL_KEYRING = 1,
};

enum opal_lock_flags {
    OPAL_SAVE_FOR_LOCK = 1,
};

enum opal_lock_state {
    OPAL_RO = 1,
    OPAL_RW = 2,
    OPAL_LK = 4,
};

enum opal_mbr {
    OPAL_MBR_ENABLE = 0,
    OPAL_MBR_DISABLE = 1,
};

enum opal_mbr_done_flag {
    OPAL_MBR_NOT_DONE = 0,
    OPAL_MBR_DONE = 1,
};

enum opal_method {
    OPAL_PROPERTIES = 0,
    OPAL_STARTSESSION = 1,
    OPAL_REVERT = 2,
    OPAL_ACTIVATE = 3,
    OPAL_EGET = 4,
    OPAL_ESET = 5,
    OPAL_NEXT = 6,
    OPAL_EAUTHENTICATE = 7,
    OPAL_GETACL = 8,
    OPAL_GENKEY = 9,
    OPAL_REVERTSP = 10,
    OPAL_GET = 11,
    OPAL_SET = 12,
    OPAL_AUTHENTICATE = 13,
    OPAL_RANDOM = 14,
    OPAL_ERASE = 15,
};

enum opal_parameter {
    OPAL_SUM_SET_LIST = 393216,
};

enum opal_response_token {
    OPAL_DTA_TOKENID_BYTESTRING = 224,
    OPAL_DTA_TOKENID_SINT = 225,
    OPAL_DTA_TOKENID_UINT = 226,
    OPAL_DTA_TOKENID_TOKEN = 227,
    OPAL_DTA_TOKENID_INVALID = 0,
};

enum opal_revert_lsp_opts {
    OPAL_PRESERVE = 1,
};

enum opal_revertlsp {
    OPAL_KEEP_GLOBAL_RANGE_KEY = 393216,
};

enum opal_table_ops {
    OPAL_READ_TABLE = 0,
    OPAL_WRITE_TABLE = 1,
};

enum opal_token {
    OPAL_TRUE = 1,
    OPAL_FALSE = 0,
    OPAL_BOOLEAN_EXPR = 3,
    OPAL_TABLE = 0,
    OPAL_STARTROW = 1,
    OPAL_ENDROW = 2,
    OPAL_STARTCOLUMN = 3,
    OPAL_ENDCOLUMN = 4,
    OPAL_VALUES = 1,
    OPAL_TABLE_UID = 0,
    OPAL_TABLE_NAME = 1,
    OPAL_TABLE_COMMON = 2,
    OPAL_TABLE_TEMPLATE = 3,
    OPAL_TABLE_KIND = 4,
    OPAL_TABLE_COLUMN = 5,
    OPAL_TABLE_COLUMNS = 6,
    OPAL_TABLE_ROWS = 7,
    OPAL_TABLE_ROWS_FREE = 8,
    OPAL_TABLE_ROW_BYTES = 9,
    OPAL_TABLE_LASTID = 10,
    OPAL_TABLE_MIN = 11,
    OPAL_TABLE_MAX = 12,
    OPAL_PIN = 3,
    OPAL_RANGESTART = 3,
    OPAL_RANGELENGTH = 4,
    OPAL_READLOCKENABLED = 5,
    OPAL_WRITELOCKENABLED = 6,
    OPAL_READLOCKED = 7,
    OPAL_WRITELOCKED = 8,
    OPAL_ACTIVEKEY = 10,
    OPAL_LIFECYCLE = 6,
    OPAL_MAXRANGES = 4,
    OPAL_MBRENABLE = 1,
    OPAL_MBRDONE = 2,
    OPAL_HOSTPROPERTIES = 0,
    OPAL_STARTLIST = 240,
    OPAL_ENDLIST = 241,
    OPAL_STARTNAME = 242,
    OPAL_ENDNAME = 243,
    OPAL_CALL = 248,
    OPAL_ENDOFDATA = 249,
    OPAL_ENDOFSESSION = 250,
    OPAL_STARTTRANSACTON = 251,
    OPAL_ENDTRANSACTON = 252,
    OPAL_EMPTYATOM = 255,
    OPAL_WHERE = 0,
};

enum opal_uid {
    OPAL_SMUID_UID = 0,
    OPAL_THISSP_UID = 1,
    OPAL_ADMINSP_UID = 2,
    OPAL_LOCKINGSP_UID = 3,
    OPAL_ENTERPRISE_LOCKINGSP_UID = 4,
    OPAL_ANYBODY_UID = 5,
    OPAL_SID_UID = 6,
    OPAL_ADMIN1_UID = 7,
    OPAL_USER1_UID = 8,
    OPAL_USER2_UID = 9,
    OPAL_PSID_UID = 10,
    OPAL_ENTERPRISE_BANDMASTER0_UID = 11,
    OPAL_ENTERPRISE_ERASEMASTER_UID = 12,
    OPAL_TABLE_TABLE = 13,
    OPAL_LOCKINGRANGE_GLOBAL = 14,
    OPAL_LOCKINGRANGE_ACE_START_TO_KEY = 15,
    OPAL_LOCKINGRANGE_ACE_RDLOCKED = 16,
    OPAL_LOCKINGRANGE_ACE_WRLOCKED = 17,
    OPAL_MBRCONTROL = 18,
    OPAL_MBR = 19,
    OPAL_AUTHORITY_TABLE = 20,
    OPAL_C_PIN_TABLE = 21,
    OPAL_LOCKING_INFO_TABLE = 22,
    OPAL_ENTERPRISE_LOCKING_INFO_TABLE = 23,
    OPAL_DATASTORE = 24,
    OPAL_C_PIN_MSID = 25,
    OPAL_C_PIN_SID = 26,
    OPAL_C_PIN_ADMIN1 = 27,
    OPAL_HALF_UID_AUTHORITY_OBJ_REF = 28,
    OPAL_HALF_UID_BOOLEAN_ACE = 29,
    OPAL_UID_HEXFF = 30,
};

enum opal_user {
    OPAL_ADMIN1 = 0,
    OPAL_USER1 = 1,
    OPAL_USER2 = 2,
    OPAL_USER3 = 3,
    OPAL_USER4 = 4,
    OPAL_USER5 = 5,
    OPAL_USER6 = 6,
    OPAL_USER7 = 7,
    OPAL_USER8 = 8,
    OPAL_USER9 = 9,
};

enum opp_table_access {
    OPP_TABLE_ACCESS_UNKNOWN = 0,
    OPP_TABLE_ACCESS_EXCLUSIVE = 1,
    OPP_TABLE_ACCESS_SHARED = 2,
};

enum owner_state {
    OWNER_NULL = 1,
    OWNER_WRITER = 2,
    OWNER_READER = 4,
    OWNER_NONSPINNABLE = 8,
};

enum packet_sock_flags {
    PACKET_SOCK_ORIGDEV = 0,
    PACKET_SOCK_AUXDATA = 1,
    PACKET_SOCK_TX_HAS_OFF = 2,
    PACKET_SOCK_TP_LOSS = 3,
    PACKET_SOCK_RUNNING = 4,
    PACKET_SOCK_PRESSURE = 5,
    PACKET_SOCK_QDISC_BYPASS = 6,
};

enum packing_op {
    PACK = 0,
    UNPACK = 1,
};

enum page_memcg_data_flags {
    MEMCG_DATA_OBJEXTS = 1,
    MEMCG_DATA_KMEM = 2,
    __NR_MEMCG_DATA_FLAGS = 4,
};

enum page_size_enum {
    __PAGE_SIZE = 4096,
};

enum page_walk_action {
    ACTION_SUBTREE = 0,
    ACTION_CONTINUE = 1,
    ACTION_AGAIN = 2,
};

enum page_walk_lock {
    PGWALK_RDLOCK = 0,
    PGWALK_WRLOCK = 1,
    PGWALK_WRLOCK_VERIFY = 2,
};

enum pageblock_bits {
    PB_migrate = 0,
    PB_migrate_end = 2,
    PB_migrate_skip = 3,
    NR_PAGEBLOCK_BITS = 4,
};

enum pageflags {
    PG_locked = 0,
    PG_writeback = 1,
    PG_referenced = 2,
    PG_uptodate = 3,
    PG_dirty = 4,
    PG_lru = 5,
    PG_head = 6,
    PG_waiters = 7,
    PG_active = 8,
    PG_workingset = 9,
    PG_owner_priv_1 = 10,
    PG_owner_2 = 11,
    PG_arch_1 = 12,
    PG_reserved = 13,
    PG_private = 14,
    PG_private_2 = 15,
    PG_reclaim = 16,
    PG_swapbacked = 17,
    PG_unevictable = 18,
    PG_dropbehind = 19,
    PG_mlocked = 20,
    PG_arch_2 = 21,
    PG_arch_3 = 22,
    __NR_PAGEFLAGS = 23,
    PG_readahead = 16,
    PG_swapcache = 10,
    PG_checked = 10,
    PG_anon_exclusive = 11,
    PG_mappedtodisk = 11,
    PG_fscache = 15,
    PG_pinned = 10,
    PG_savepinned = 4,
    PG_foreign = 10,
    PG_xen_remapped = 10,
    PG_isolated = 16,
    PG_reported = 3,
    PG_has_hwpoisoned = 8,
    PG_large_rmappable = 9,
    PG_partially_mapped = 16,
};

enum pagetype {
    PGTY_buddy = 240,
    PGTY_offline = 241,
    PGTY_table = 242,
    PGTY_guard = 243,
    PGTY_hugetlb = 244,
    PGTY_slab = 245,
    PGTY_zsmalloc = 246,
    PGTY_unaccepted = 247,
    PGTY_mapcount_underflow = 255,
};

enum partition_cmd {
    partcmd_enable = 0,
    partcmd_enablei = 1,
    partcmd_disable = 2,
    partcmd_update = 3,
    partcmd_invalidate = 4,
};

enum passtype {
    PASS_SCAN = 0,
    PASS_REVOKE = 1,
    PASS_REPLAY = 2,
};

enum path_flags {
    PATH_IS_DIR = 1,
    PATH_SOCK_COND = 2,
    PATH_CONNECT_PATH = 4,
    PATH_CHROOT_REL = 8,
    PATH_CHROOT_NSCONNECT = 16,
    PATH_CONNECT_IPC_PATH = 32,
    PATH_DELEGATE_DELETED = 65536,
    PATH_MEDIATE_DELETED = 131072,
};

enum pce_status {
    PCE_STATUS_NONE = 0,
    PCE_STATUS_ACQUIRED = 1,
    PCE_STATUS_PREPARED = 2,
    PCE_STATUS_ENABLED = 3,
    PCE_STATUS_ERROR = 4,
};

enum pci_bar_type {
    pci_bar_unknown = 0,
    pci_bar_io = 1,
    pci_bar_mem32 = 2,
    pci_bar_mem64 = 3,
};

enum pci_bus_flags {
    PCI_BUS_FLAGS_NO_MSI = 1,
    PCI_BUS_FLAGS_NO_MMRBC = 2,
    PCI_BUS_FLAGS_NO_AERSID = 4,
    PCI_BUS_FLAGS_NO_EXTCFG = 8,
};

enum pci_bus_speed {
    PCI_SPEED_33MHz = 0,
    PCI_SPEED_66MHz = 1,
    PCI_SPEED_66MHz_PCIX = 2,
    PCI_SPEED_100MHz_PCIX = 3,
    PCI_SPEED_133MHz_PCIX = 4,
    PCI_SPEED_66MHz_PCIX_ECC = 5,
    PCI_SPEED_100MHz_PCIX_ECC = 6,
    PCI_SPEED_133MHz_PCIX_ECC = 7,
    PCI_SPEED_66MHz_PCIX_266 = 9,
    PCI_SPEED_100MHz_PCIX_266 = 10,
    PCI_SPEED_133MHz_PCIX_266 = 11,
    AGP_UNKNOWN = 12,
    AGP_1X = 13,
    AGP_2X = 14,
    AGP_4X = 15,
    AGP_8X = 16,
    PCI_SPEED_66MHz_PCIX_533 = 17,
    PCI_SPEED_100MHz_PCIX_533 = 18,
    PCI_SPEED_133MHz_PCIX_533 = 19,
    PCIE_SPEED_2_5GT = 20,
    PCIE_SPEED_5_0GT = 21,
    PCIE_SPEED_8_0GT = 22,
    PCIE_SPEED_16_0GT = 23,
    PCIE_SPEED_32_0GT = 24,
    PCIE_SPEED_64_0GT = 25,
    PCI_SPEED_UNKNOWN = 255,
};

enum pci_dev_flags {
    PCI_DEV_FLAGS_MSI_INTX_DISABLE_BUG = 1,
    PCI_DEV_FLAGS_NO_D3 = 2,
    PCI_DEV_FLAGS_ASSIGNED = 4,
    PCI_DEV_FLAGS_ACS_ENABLED_QUIRK = 8,
    PCI_DEV_FLAG_PCIE_BRIDGE_ALIAS = 32,
    PCI_DEV_FLAGS_NO_BUS_RESET = 64,
    PCI_DEV_FLAGS_NO_PM_RESET = 128,
    PCI_DEV_FLAGS_VPD_REF_F0 = 256,
    PCI_DEV_FLAGS_BRIDGE_XLATE_ROOT = 512,
    PCI_DEV_FLAGS_NO_FLR_RESET = 1024,
    PCI_DEV_FLAGS_NO_RELAXED_ORDERING = 2048,
    PCI_DEV_FLAGS_HAS_MSI_MASKING = 4096,
    PCI_DEV_FLAGS_MSIX_TOUCH_ENTRY_DATA_FIRST = 8192,
};

enum pci_ers_result {
    PCI_ERS_RESULT_NONE = 1,
    PCI_ERS_RESULT_CAN_RECOVER = 2,
    PCI_ERS_RESULT_NEED_RESET = 3,
    PCI_ERS_RESULT_DISCONNECT = 4,
    PCI_ERS_RESULT_RECOVERED = 5,
    PCI_ERS_RESULT_NO_AER_DRIVER = 6,
};

enum pci_fixup_pass {
    pci_fixup_early = 0,
    pci_fixup_header = 1,
    pci_fixup_final = 2,
    pci_fixup_enable = 3,
    pci_fixup_resume = 4,
    pci_fixup_suspend = 5,
    pci_fixup_resume_early = 6,
    pci_fixup_suspend_late = 7,
};

enum pci_mmap_api {
    PCI_MMAP_SYSFS = 0,
    PCI_MMAP_PROCFS = 1,
};

enum pci_mmap_state {
    pci_mmap_io = 0,
    pci_mmap_mem = 1,
};

enum pci_p2pdma_map_type {
    PCI_P2PDMA_MAP_UNKNOWN = 0,
    PCI_P2PDMA_MAP_NOT_SUPPORTED = 1,
    PCI_P2PDMA_MAP_BUS_ADDR = 2,
    PCI_P2PDMA_MAP_THRU_HOST_BRIDGE = 3,
};

enum pcie_bus_config_types {
    PCIE_BUS_TUNE_OFF = 0,
    PCIE_BUS_DEFAULT = 1,
    PCIE_BUS_SAFE = 2,
    PCIE_BUS_PERFORMANCE = 3,
    PCIE_BUS_PEER2PEER = 4,
};

enum pcie_link_width {
    PCIE_LNK_WIDTH_RESRV = 0,
    PCIE_LNK_X1 = 1,
    PCIE_LNK_X2 = 2,
    PCIE_LNK_X4 = 4,
    PCIE_LNK_X8 = 8,
    PCIE_LNK_X12 = 12,
    PCIE_LNK_X16 = 16,
    PCIE_LNK_X32 = 32,
    PCIE_LNK_WIDTH_UNKNOWN = 255,
};

enum pcie_reset_state {
    pcie_deassert_reset = 1,
    pcie_warm_reset = 2,
    pcie_hot_reset = 3,
};

enum pcie_soc_base {
    GENERIC = 0,
    BCM2711 = 1,
    BCM4908 = 2,
    BCM7278 = 3,
    BCM7425 = 4,
    BCM7435 = 5,
    BCM7712 = 6,
};

enum pcim_addr_devres_type {
    PCIM_ADDR_DEVRES_TYPE_INVALID = 0,
    PCIM_ADDR_DEVRES_TYPE_REGION = 1,
    PCIM_ADDR_DEVRES_TYPE_REGION_MAPPING = 2,
    PCIM_ADDR_DEVRES_TYPE_MAPPING = 3,
};

enum pcpu_fc {
    PCPU_FC_AUTO = 0,
    PCPU_FC_EMBED = 1,
    PCPU_FC_PAGE = 2,
    PCPU_FC_NR = 3,
};

enum pedit_cmd {
    TCA_PEDIT_KEY_EX_CMD_SET = 0,
    TCA_PEDIT_KEY_EX_CMD_ADD = 1,
    __PEDIT_CMD_MAX = 2,
};

enum pedit_header_type {
    TCA_PEDIT_KEY_EX_HDR_TYPE_NETWORK = 0,
    TCA_PEDIT_KEY_EX_HDR_TYPE_ETH = 1,
    TCA_PEDIT_KEY_EX_HDR_TYPE_IP4 = 2,
    TCA_PEDIT_KEY_EX_HDR_TYPE_IP6 = 3,
    TCA_PEDIT_KEY_EX_HDR_TYPE_TCP = 4,
    TCA_PEDIT_KEY_EX_HDR_TYPE_UDP = 5,
    __PEDIT_HDR_TYPE_MAX = 6,
};

enum peer_app_attr {
    DCB_ATTR_CEE_PEER_APP_UNSPEC = 0,
    DCB_ATTR_CEE_PEER_APP_INFO = 1,
    DCB_ATTR_CEE_PEER_APP = 2,
    __DCB_ATTR_CEE_PEER_APP_MAX = 3,
};

enum perf_addr_filter_action_t {
    PERF_ADDR_FILTER_ACTION_STOP = 0,
    PERF_ADDR_FILTER_ACTION_START = 1,
    PERF_ADDR_FILTER_ACTION_FILTER = 2,
};

enum perf_bpf_event_type {
    PERF_BPF_EVENT_UNKNOWN = 0,
    PERF_BPF_EVENT_PROG_LOAD = 1,
    PERF_BPF_EVENT_PROG_UNLOAD = 2,
    PERF_BPF_EVENT_MAX = 3,
};

enum perf_branch_sample_type {
    PERF_SAMPLE_BRANCH_USER = 1,
    PERF_SAMPLE_BRANCH_KERNEL = 2,
    PERF_SAMPLE_BRANCH_HV = 4,
    PERF_SAMPLE_BRANCH_ANY = 8,
    PERF_SAMPLE_BRANCH_ANY_CALL = 16,
    PERF_SAMPLE_BRANCH_ANY_RETURN = 32,
    PERF_SAMPLE_BRANCH_IND_CALL = 64,
    PERF_SAMPLE_BRANCH_ABORT_TX = 128,
    PERF_SAMPLE_BRANCH_IN_TX = 256,
    PERF_SAMPLE_BRANCH_NO_TX = 512,
    PERF_SAMPLE_BRANCH_COND = 1024,
    PERF_SAMPLE_BRANCH_CALL_STACK = 2048,
    PERF_SAMPLE_BRANCH_IND_JUMP = 4096,
    PERF_SAMPLE_BRANCH_CALL = 8192,
    PERF_SAMPLE_BRANCH_NO_FLAGS = 16384,
    PERF_SAMPLE_BRANCH_NO_CYCLES = 32768,
    PERF_SAMPLE_BRANCH_TYPE_SAVE = 65536,
    PERF_SAMPLE_BRANCH_HW_INDEX = 131072,
    PERF_SAMPLE_BRANCH_PRIV_SAVE = 262144,
    PERF_SAMPLE_BRANCH_COUNTERS = 524288,
    PERF_SAMPLE_BRANCH_MAX = 1048576,
};

enum perf_branch_sample_type_shift {
    PERF_SAMPLE_BRANCH_USER_SHIFT = 0,
    PERF_SAMPLE_BRANCH_KERNEL_SHIFT = 1,
    PERF_SAMPLE_BRANCH_HV_SHIFT = 2,
    PERF_SAMPLE_BRANCH_ANY_SHIFT = 3,
    PERF_SAMPLE_BRANCH_ANY_CALL_SHIFT = 4,
    PERF_SAMPLE_BRANCH_ANY_RETURN_SHIFT = 5,
    PERF_SAMPLE_BRANCH_IND_CALL_SHIFT = 6,
    PERF_SAMPLE_BRANCH_ABORT_TX_SHIFT = 7,
    PERF_SAMPLE_BRANCH_IN_TX_SHIFT = 8,
    PERF_SAMPLE_BRANCH_NO_TX_SHIFT = 9,
    PERF_SAMPLE_BRANCH_COND_SHIFT = 10,
    PERF_SAMPLE_BRANCH_CALL_STACK_SHIFT = 11,
    PERF_SAMPLE_BRANCH_IND_JUMP_SHIFT = 12,
    PERF_SAMPLE_BRANCH_CALL_SHIFT = 13,
    PERF_SAMPLE_BRANCH_NO_FLAGS_SHIFT = 14,
    PERF_SAMPLE_BRANCH_NO_CYCLES_SHIFT = 15,
    PERF_SAMPLE_BRANCH_TYPE_SAVE_SHIFT = 16,
    PERF_SAMPLE_BRANCH_HW_INDEX_SHIFT = 17,
    PERF_SAMPLE_BRANCH_PRIV_SAVE_SHIFT = 18,
    PERF_SAMPLE_BRANCH_COUNTERS_SHIFT = 19,
    PERF_SAMPLE_BRANCH_MAX_SHIFT = 20,
};

enum perf_callchain_context {
    PERF_CONTEXT_HV = 18446744073709551584ULL,
    PERF_CONTEXT_KERNEL = 18446744073709551488ULL,
    PERF_CONTEXT_USER = 18446744073709551104ULL,
    PERF_CONTEXT_GUEST = 18446744073709549568ULL,
    PERF_CONTEXT_GUEST_KERNEL = 18446744073709549440ULL,
    PERF_CONTEXT_GUEST_USER = 18446744073709549056ULL,
    PERF_CONTEXT_MAX = 18446744073709547521ULL,
};

enum perf_event_arm_regs {
    PERF_REG_ARM64_X0 = 0,
    PERF_REG_ARM64_X1 = 1,
    PERF_REG_ARM64_X2 = 2,
    PERF_REG_ARM64_X3 = 3,
    PERF_REG_ARM64_X4 = 4,
    PERF_REG_ARM64_X5 = 5,
    PERF_REG_ARM64_X6 = 6,
    PERF_REG_ARM64_X7 = 7,
    PERF_REG_ARM64_X8 = 8,
    PERF_REG_ARM64_X9 = 9,
    PERF_REG_ARM64_X10 = 10,
    PERF_REG_ARM64_X11 = 11,
    PERF_REG_ARM64_X12 = 12,
    PERF_REG_ARM64_X13 = 13,
    PERF_REG_ARM64_X14 = 14,
    PERF_REG_ARM64_X15 = 15,
    PERF_REG_ARM64_X16 = 16,
    PERF_REG_ARM64_X17 = 17,
    PERF_REG_ARM64_X18 = 18,
    PERF_REG_ARM64_X19 = 19,
    PERF_REG_ARM64_X20 = 20,
    PERF_REG_ARM64_X21 = 21,
    PERF_REG_ARM64_X22 = 22,
    PERF_REG_ARM64_X23 = 23,
    PERF_REG_ARM64_X24 = 24,
    PERF_REG_ARM64_X25 = 25,
    PERF_REG_ARM64_X26 = 26,
    PERF_REG_ARM64_X27 = 27,
    PERF_REG_ARM64_X28 = 28,
    PERF_REG_ARM64_X29 = 29,
    PERF_REG_ARM64_LR = 30,
    PERF_REG_ARM64_SP = 31,
    PERF_REG_ARM64_PC = 32,
    PERF_REG_ARM64_MAX = 33,
    PERF_REG_ARM64_VG = 46,
    PERF_REG_ARM64_EXTENDED_MAX = 47,
};

enum perf_event_ioc_flags {
    PERF_IOC_FLAG_GROUP = 1,
};

enum perf_event_read_format {
    PERF_FORMAT_TOTAL_TIME_ENABLED = 1,
    PERF_FORMAT_TOTAL_TIME_RUNNING = 2,
    PERF_FORMAT_ID = 4,
    PERF_FORMAT_GROUP = 8,
    PERF_FORMAT_LOST = 16,
    PERF_FORMAT_MAX = 32,
};

enum perf_event_sample_format {
    PERF_SAMPLE_IP = 1,
    PERF_SAMPLE_TID = 2,
    PERF_SAMPLE_TIME = 4,
    PERF_SAMPLE_ADDR = 8,
    PERF_SAMPLE_READ = 16,
    PERF_SAMPLE_CALLCHAIN = 32,
    PERF_SAMPLE_ID = 64,
    PERF_SAMPLE_CPU = 128,
    PERF_SAMPLE_PERIOD = 256,
    PERF_SAMPLE_STREAM_ID = 512,
    PERF_SAMPLE_RAW = 1024,
    PERF_SAMPLE_BRANCH_STACK = 2048,
    PERF_SAMPLE_REGS_USER = 4096,
    PERF_SAMPLE_STACK_USER = 8192,
    PERF_SAMPLE_WEIGHT = 16384,
    PERF_SAMPLE_DATA_SRC = 32768,
    PERF_SAMPLE_IDENTIFIER = 65536,
    PERF_SAMPLE_TRANSACTION = 131072,
    PERF_SAMPLE_REGS_INTR = 262144,
    PERF_SAMPLE_PHYS_ADDR = 524288,
    PERF_SAMPLE_AUX = 1048576,
    PERF_SAMPLE_CGROUP = 2097152,
    PERF_SAMPLE_DATA_PAGE_SIZE = 4194304,
    PERF_SAMPLE_CODE_PAGE_SIZE = 8388608,
    PERF_SAMPLE_WEIGHT_STRUCT = 16777216,
    PERF_SAMPLE_MAX = 33554432,
};

enum perf_event_state {
    PERF_EVENT_STATE_DEAD = -4,
    PERF_EVENT_STATE_EXIT = -3,
    PERF_EVENT_STATE_ERROR = -2,
    PERF_EVENT_STATE_OFF = -1,
    PERF_EVENT_STATE_INACTIVE = 0,
    PERF_EVENT_STATE_ACTIVE = 1,
};

enum perf_event_task_context {
    perf_invalid_context = -1,
    perf_hw_context = 0,
    perf_sw_context = 1,
    perf_nr_task_contexts = 2,
};

enum perf_event_type {
    PERF_RECORD_MMAP = 1,
    PERF_RECORD_LOST = 2,
    PERF_RECORD_COMM = 3,
    PERF_RECORD_EXIT = 4,
    PERF_RECORD_THROTTLE = 5,
    PERF_RECORD_UNTHROTTLE = 6,
    PERF_RECORD_FORK = 7,
    PERF_RECORD_READ = 8,
    PERF_RECORD_SAMPLE = 9,
    PERF_RECORD_MMAP2 = 10,
    PERF_RECORD_AUX = 11,
    PERF_RECORD_ITRACE_START = 12,
    PERF_RECORD_LOST_SAMPLES = 13,
    PERF_RECORD_SWITCH = 14,
    PERF_RECORD_SWITCH_CPU_WIDE = 15,
    PERF_RECORD_NAMESPACES = 16,
    PERF_RECORD_KSYMBOL = 17,
    PERF_RECORD_BPF_EVENT = 18,
    PERF_RECORD_CGROUP = 19,
    PERF_RECORD_TEXT_POKE = 20,
    PERF_RECORD_AUX_OUTPUT_HW_ID = 21,
    PERF_RECORD_MAX = 22,
};

enum perf_hw_cache_id {
    PERF_COUNT_HW_CACHE_L1D = 0,
    PERF_COUNT_HW_CACHE_L1I = 1,
    PERF_COUNT_HW_CACHE_LL = 2,
    PERF_COUNT_HW_CACHE_DTLB = 3,
    PERF_COUNT_HW_CACHE_ITLB = 4,
    PERF_COUNT_HW_CACHE_BPU = 5,
    PERF_COUNT_HW_CACHE_NODE = 6,
    PERF_COUNT_HW_CACHE_MAX = 7,
};

enum perf_hw_cache_op_id {
    PERF_COUNT_HW_CACHE_OP_READ = 0,
    PERF_COUNT_HW_CACHE_OP_WRITE = 1,
    PERF_COUNT_HW_CACHE_OP_PREFETCH = 2,
    PERF_COUNT_HW_CACHE_OP_MAX = 3,
};

enum perf_hw_cache_op_result_id {
    PERF_COUNT_HW_CACHE_RESULT_ACCESS = 0,
    PERF_COUNT_HW_CACHE_RESULT_MISS = 1,
    PERF_COUNT_HW_CACHE_RESULT_MAX = 2,
};

enum perf_hw_id {
    PERF_COUNT_HW_CPU_CYCLES = 0,
    PERF_COUNT_HW_INSTRUCTIONS = 1,
    PERF_COUNT_HW_CACHE_REFERENCES = 2,
    PERF_COUNT_HW_CACHE_MISSES = 3,
    PERF_COUNT_HW_BRANCH_INSTRUCTIONS = 4,
    PERF_COUNT_HW_BRANCH_MISSES = 5,
    PERF_COUNT_HW_BUS_CYCLES = 6,
    PERF_COUNT_HW_STALLED_CYCLES_FRONTEND = 7,
    PERF_COUNT_HW_STALLED_CYCLES_BACKEND = 8,
    PERF_COUNT_HW_REF_CPU_CYCLES = 9,
    PERF_COUNT_HW_MAX = 10,
};

enum perf_pmu_scope {
    PERF_PMU_SCOPE_NONE = 0,
    PERF_PMU_SCOPE_CORE = 1,
    PERF_PMU_SCOPE_DIE = 2,
    PERF_PMU_SCOPE_CLUSTER = 3,
    PERF_PMU_SCOPE_PKG = 4,
    PERF_PMU_SCOPE_SYS_WIDE = 5,
    PERF_PMU_MAX_SCOPE = 6,
};

enum perf_probe_config {
    PERF_PROBE_CONFIG_IS_RETPROBE = 1,
    PERF_UPROBE_REF_CTR_OFFSET_BITS = 32,
    PERF_UPROBE_REF_CTR_OFFSET_SHIFT = 32,
};

enum perf_record_ksymbol_type {
    PERF_RECORD_KSYMBOL_TYPE_UNKNOWN = 0,
    PERF_RECORD_KSYMBOL_TYPE_BPF = 1,
    PERF_RECORD_KSYMBOL_TYPE_OOL = 2,
    PERF_RECORD_KSYMBOL_TYPE_MAX = 3,
};

enum perf_sample_regs_abi {
    PERF_SAMPLE_REGS_ABI_NONE = 0,
    PERF_SAMPLE_REGS_ABI_32 = 1,
    PERF_SAMPLE_REGS_ABI_64 = 2,
};

enum perf_sw_ids {
    PERF_COUNT_SW_CPU_CLOCK = 0,
    PERF_COUNT_SW_TASK_CLOCK = 1,
    PERF_COUNT_SW_PAGE_FAULTS = 2,
    PERF_COUNT_SW_CONTEXT_SWITCHES = 3,
    PERF_COUNT_SW_CPU_MIGRATIONS = 4,
    PERF_COUNT_SW_PAGE_FAULTS_MIN = 5,
    PERF_COUNT_SW_PAGE_FAULTS_MAJ = 6,
    PERF_COUNT_SW_ALIGNMENT_FAULTS = 7,
    PERF_COUNT_SW_EMULATION_FAULTS = 8,
    PERF_COUNT_SW_DUMMY = 9,
    PERF_COUNT_SW_BPF_OUTPUT = 10,
    PERF_COUNT_SW_CGROUP_SWITCHES = 11,
    PERF_COUNT_SW_MAX = 12,
};

enum perf_type_id {
    PERF_TYPE_HARDWARE = 0,
    PERF_TYPE_SOFTWARE = 1,
    PERF_TYPE_TRACEPOINT = 2,
    PERF_TYPE_HW_CACHE = 3,
    PERF_TYPE_RAW = 4,
    PERF_TYPE_BREAKPOINT = 5,
    PERF_TYPE_MAX = 6,
};

enum pgdat_flags {
    PGDAT_DIRTY = 0,
    PGDAT_WRITEBACK = 1,
    PGDAT_RECLAIM_LOCKED = 2,
};

enum pgt_entry {
    NORMAL_PMD = 0,
    HPAGE_PMD = 1,
    NORMAL_PUD = 2,
    HPAGE_PUD = 3,
};

enum phy_led_modes {
    PHY_LED_ACTIVE_HIGH = 0,
    PHY_LED_ACTIVE_LOW = 1,
    PHY_LED_INACTIVE_HIGH_IMPEDANCE = 2,
    __PHY_LED_MODES_NUM = 3,
};

enum phy_media {
    PHY_MEDIA_DEFAULT = 0,
    PHY_MEDIA_SR = 1,
    PHY_MEDIA_DAC = 2,
};

enum phy_mode {
    PHY_MODE_INVALID = 0,
    PHY_MODE_USB_HOST = 1,
    PHY_MODE_USB_HOST_LS = 2,
    PHY_MODE_USB_HOST_FS = 3,
    PHY_MODE_USB_HOST_HS = 4,
    PHY_MODE_USB_HOST_SS = 5,
    PHY_MODE_USB_DEVICE = 6,
    PHY_MODE_USB_DEVICE_LS = 7,
    PHY_MODE_USB_DEVICE_FS = 8,
    PHY_MODE_USB_DEVICE_HS = 9,
    PHY_MODE_USB_DEVICE_SS = 10,
    PHY_MODE_USB_OTG = 11,
    PHY_MODE_UFS_HS_A = 12,
    PHY_MODE_UFS_HS_B = 13,
    PHY_MODE_PCIE = 14,
    PHY_MODE_ETHERNET = 15,
    PHY_MODE_MIPI_DPHY = 16,
    PHY_MODE_SATA = 17,
    PHY_MODE_LVDS = 18,
    PHY_MODE_DP = 19,
};

enum phy_state {
    PHY_DOWN = 0,
    PHY_READY = 1,
    PHY_HALTED = 2,
    PHY_ERROR = 3,
    PHY_UP = 4,
    PHY_RUNNING = 5,
    PHY_NOLINK = 6,
    PHY_CABLETEST = 7,
};

enum phy_state_work {
    PHY_STATE_WORK_NONE = 0,
    PHY_STATE_WORK_ANEG = 1,
    PHY_STATE_WORK_SUSPEND = 2,
};

enum phy_tunable_id {
    ETHTOOL_PHY_ID_UNSPEC = 0,
    ETHTOOL_PHY_DOWNSHIFT = 1,
    ETHTOOL_PHY_FAST_LINK_DOWN = 2,
    ETHTOOL_PHY_EDPD = 3,
    __ETHTOOL_PHY_TUNABLE_COUNT = 4,
};

enum phy_upstream {
    PHY_UPSTREAM_MAC = 0,
    PHY_UPSTREAM_PHY = 1,
};

enum phylink_op_type {
    PHYLINK_NETDEV = 0,
    PHYLINK_DEV = 1,
};

enum pid_type {
    PIDTYPE_PID = 0,
    PIDTYPE_TGID = 1,
    PIDTYPE_PGID = 2,
    PIDTYPE_SID = 3,
    PIDTYPE_MAX = 4,
};

enum pidcg_event {
    PIDCG_MAX = 0,
    PIDCG_FORKFAIL = 1,
    NR_PIDCG_EVENTS = 2,
};

enum pin_config_param {
    PIN_CONFIG_BIAS_BUS_HOLD = 0,
    PIN_CONFIG_BIAS_DISABLE = 1,
    PIN_CONFIG_BIAS_HIGH_IMPEDANCE = 2,
    PIN_CONFIG_BIAS_PULL_DOWN = 3,
    PIN_CONFIG_BIAS_PULL_PIN_DEFAULT = 4,
    PIN_CONFIG_BIAS_PULL_UP = 5,
    PIN_CONFIG_DRIVE_OPEN_DRAIN = 6,
    PIN_CONFIG_DRIVE_OPEN_SOURCE = 7,
    PIN_CONFIG_DRIVE_PUSH_PULL = 8,
    PIN_CONFIG_DRIVE_STRENGTH = 9,
    PIN_CONFIG_DRIVE_STRENGTH_UA = 10,
    PIN_CONFIG_INPUT_DEBOUNCE = 11,
    PIN_CONFIG_INPUT_ENABLE = 12,
    PIN_CONFIG_INPUT_SCHMITT = 13,
    PIN_CONFIG_INPUT_SCHMITT_ENABLE = 14,
    PIN_CONFIG_INPUT_SCHMITT_UV = 15,
    PIN_CONFIG_MODE_LOW_POWER = 16,
    PIN_CONFIG_MODE_PWM = 17,
    PIN_CONFIG_OUTPUT = 18,
    PIN_CONFIG_OUTPUT_ENABLE = 19,
    PIN_CONFIG_OUTPUT_IMPEDANCE_OHMS = 20,
    PIN_CONFIG_PERSIST_STATE = 21,
    PIN_CONFIG_POWER_SOURCE = 22,
    PIN_CONFIG_SKEW_DELAY = 23,
    PIN_CONFIG_SLEEP_HARDWARE_STATE = 24,
    PIN_CONFIG_SLEW_RATE = 25,
    PIN_CONFIG_END = 127,
    PIN_CONFIG_MAX = 255,
};

enum pinctrl_map_type {
    PIN_MAP_TYPE_INVALID = 0,
    PIN_MAP_TYPE_DUMMY_STATE = 1,
    PIN_MAP_TYPE_MUX_GROUP = 2,
    PIN_MAP_TYPE_CONFIGS_PIN = 3,
    PIN_MAP_TYPE_CONFIGS_GROUP = 4,
};

enum pkcs7_actions {
    ACT_pkcs7_check_content_type = 0,
    ACT_pkcs7_extract_cert = 1,
    ACT_pkcs7_note_OID = 2,
    ACT_pkcs7_note_certificate_list = 3,
    ACT_pkcs7_note_content = 4,
    ACT_pkcs7_note_data = 5,
    ACT_pkcs7_note_signed_info = 6,
    ACT_pkcs7_note_signeddata_version = 7,
    ACT_pkcs7_note_signerinfo_version = 8,
    ACT_pkcs7_sig_note_authenticated_attr = 9,
    ACT_pkcs7_sig_note_digest_algo = 10,
    ACT_pkcs7_sig_note_issuer = 11,
    ACT_pkcs7_sig_note_pkey_algo = 12,
    ACT_pkcs7_sig_note_serial = 13,
    ACT_pkcs7_sig_note_set_of_authattrs = 14,
    ACT_pkcs7_sig_note_signature = 15,
    ACT_pkcs7_sig_note_skid = 16,
    NR__pkcs7_actions = 17,
};

enum pkey_id_type {
    PKEY_ID_PGP = 0,
    PKEY_ID_X509 = 1,
    PKEY_ID_PKCS7 = 2,
};

enum pkt_hash_types {
    PKT_HASH_TYPE_NONE = 0,
    PKT_HASH_TYPE_L2 = 1,
    PKT_HASH_TYPE_L3 = 2,
    PKT_HASH_TYPE_L4 = 3,
};

enum pkvm_component_id {
    PKVM_ID_HOST = 0,
    PKVM_ID_HYP = 1,
    PKVM_ID_FFA = 2,
};

enum pkvm_page_state {
    PKVM_PAGE_OWNED = 0,
    PKVM_PAGE_SHARED_OWNED = 1,
    PKVM_PAGE_SHARED_BORROWED = 2,
    __PKVM_PAGE_RESERVED = 3,
    PKVM_NOPAGE = 4,
};

enum pl011_rs485_tx_state {
    OFF = 0,
    WAIT_AFTER_RTS = 1,
    SEND = 2,
    WAIT_AFTER_SEND = 3,
};

enum pm_qos_flags_status {
    PM_QOS_FLAGS_UNDEFINED = -1,
    PM_QOS_FLAGS_NONE = 0,
    PM_QOS_FLAGS_SOME = 1,
    PM_QOS_FLAGS_ALL = 2,
};

enum pm_qos_req_action {
    PM_QOS_ADD_REQ = 0,
    PM_QOS_UPDATE_REQ = 1,
    PM_QOS_REMOVE_REQ = 2,
};

enum pm_qos_type {
    PM_QOS_UNITIALIZED = 0,
    PM_QOS_MAX = 1,
    PM_QOS_MIN = 2,
};

enum policy_opt {
    Opt_measure = 0,
    Opt_dont_measure = 1,
    Opt_appraise = 2,
    Opt_dont_appraise = 3,
    Opt_audit = 4,
    Opt_hash___3 = 5,
    Opt_dont_hash = 6,
    Opt_obj_user = 7,
    Opt_obj_role = 8,
    Opt_obj_type = 9,
    Opt_subj_user = 10,
    Opt_subj_role = 11,
    Opt_subj_type = 12,
    Opt_func = 13,
    Opt_mask = 14,
    Opt_fsmagic = 15,
    Opt_fsname = 16,
    Opt_fsuuid = 17,
    Opt_uid_eq = 18,
    Opt_euid_eq = 19,
    Opt_gid_eq = 20,
    Opt_egid_eq = 21,
    Opt_fowner_eq = 22,
    Opt_fgroup_eq = 23,
    Opt_uid_gt = 24,
    Opt_euid_gt = 25,
    Opt_gid_gt = 26,
    Opt_egid_gt = 27,
    Opt_fowner_gt = 28,
    Opt_fgroup_gt = 29,
    Opt_uid_lt = 30,
    Opt_euid_lt = 31,
    Opt_gid_lt = 32,
    Opt_egid_lt = 33,
    Opt_fowner_lt = 34,
    Opt_fgroup_lt = 35,
    Opt_digest_type = 36,
    Opt_appraise_type = 37,
    Opt_appraise_flag = 38,
    Opt_appraise_algos = 39,
    Opt_permit_directio = 40,
    Opt_pcr = 41,
    Opt_template = 42,
    Opt_keyrings = 43,
    Opt_label = 44,
    Opt_err___8 = 45,
};

enum policy_rule_list {
    IMA_DEFAULT_POLICY = 1,
    IMA_CUSTOM_POLICY = 2,
};

enum policy_types {
    ORIGINAL_TCB = 1,
    DEFAULT_TCB = 2,
};

enum poll_time_type {
    PT_TIMEVAL = 0,
    PT_OLD_TIMEVAL = 1,
    PT_TIMESPEC = 2,
    PT_OLD_TIMESPEC = 3,
};

enum pool_workqueue_stats {
    PWQ_STAT_STARTED = 0,
    PWQ_STAT_COMPLETED = 1,
    PWQ_STAT_CPU_TIME = 2,
    PWQ_STAT_CPU_INTENSIVE = 3,
    PWQ_STAT_CM_WAKEUP = 4,
    PWQ_STAT_REPATRIATED = 5,
    PWQ_STAT_MAYDAY = 6,
    PWQ_STAT_RESCUED = 7,
    PWQ_NR_STATS = 8,
};

enum port_pkey_state {
    IB_PORT_PKEY_NOT_VALID = 0,
    IB_PORT_PKEY_VALID = 1,
    IB_PORT_PKEY_LISTED = 2,
};

enum positive_aop_returns {
    AOP_WRITEPAGE_ACTIVATE = 524288,
    AOP_TRUNCATED_PAGE = 524289,
};

enum posix_timer_state {
    POSIX_TIMER_DISARMED = 0,
    POSIX_TIMER_ARMED = 1,
    POSIX_TIMER_REQUEUE_PENDING = 2,
};

enum power_supply_charge_behaviour {
    POWER_SUPPLY_CHARGE_BEHAVIOUR_AUTO = 0,
    POWER_SUPPLY_CHARGE_BEHAVIOUR_INHIBIT_CHARGE = 1,
    POWER_SUPPLY_CHARGE_BEHAVIOUR_FORCE_DISCHARGE = 2,
};

enum power_supply_charge_type {
    POWER_SUPPLY_CHARGE_TYPE_UNKNOWN = 0,
    POWER_SUPPLY_CHARGE_TYPE_NONE = 1,
    POWER_SUPPLY_CHARGE_TYPE_TRICKLE = 2,
    POWER_SUPPLY_CHARGE_TYPE_FAST = 3,
    POWER_SUPPLY_CHARGE_TYPE_STANDARD = 4,
    POWER_SUPPLY_CHARGE_TYPE_ADAPTIVE = 5,
    POWER_SUPPLY_CHARGE_TYPE_CUSTOM = 6,
    POWER_SUPPLY_CHARGE_TYPE_LONGLIFE = 7,
    POWER_SUPPLY_CHARGE_TYPE_BYPASS = 8,
};

enum power_supply_notifier_events {
    PSY_EVENT_PROP_CHANGED = 0,
};

enum power_supply_property {
    POWER_SUPPLY_PROP_STATUS = 0,
    POWER_SUPPLY_PROP_CHARGE_TYPE = 1,
    POWER_SUPPLY_PROP_CHARGE_TYPES = 2,
    POWER_SUPPLY_PROP_HEALTH = 3,
    POWER_SUPPLY_PROP_PRESENT = 4,
    POWER_SUPPLY_PROP_ONLINE = 5,
    POWER_SUPPLY_PROP_AUTHENTIC = 6,
    POWER_SUPPLY_PROP_TECHNOLOGY = 7,
    POWER_SUPPLY_PROP_CYCLE_COUNT = 8,
    POWER_SUPPLY_PROP_VOLTAGE_MAX = 9,
    POWER_SUPPLY_PROP_VOLTAGE_MIN = 10,
    POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN = 11,
    POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN = 12,
    POWER_SUPPLY_PROP_VOLTAGE_NOW = 13,
    POWER_SUPPLY_PROP_VOLTAGE_AVG = 14,
    POWER_SUPPLY_PROP_VOLTAGE_OCV = 15,
    POWER_SUPPLY_PROP_VOLTAGE_BOOT = 16,
    POWER_SUPPLY_PROP_CURRENT_MAX = 17,
    POWER_SUPPLY_PROP_CURRENT_NOW = 18,
    POWER_SUPPLY_PROP_CURRENT_AVG = 19,
    POWER_SUPPLY_PROP_CURRENT_BOOT = 20,
    POWER_SUPPLY_PROP_POWER_NOW = 21,
    POWER_SUPPLY_PROP_POWER_AVG = 22,
    POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN = 23,
    POWER_SUPPLY_PROP_CHARGE_EMPTY_DESIGN = 24,
    POWER_SUPPLY_PROP_CHARGE_FULL = 25,
    POWER_SUPPLY_PROP_CHARGE_EMPTY = 26,
    POWER_SUPPLY_PROP_CHARGE_NOW = 27,
    POWER_SUPPLY_PROP_CHARGE_AVG = 28,
    POWER_SUPPLY_PROP_CHARGE_COUNTER = 29,
    POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT = 30,
    POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX = 31,
    POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE = 32,
    POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX = 33,
    POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT = 34,
    POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT_MAX = 35,
    POWER_SUPPLY_PROP_CHARGE_CONTROL_START_THRESHOLD = 36,
    POWER_SUPPLY_PROP_CHARGE_CONTROL_END_THRESHOLD = 37,
    POWER_SUPPLY_PROP_CHARGE_BEHAVIOUR = 38,
    POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT = 39,
    POWER_SUPPLY_PROP_INPUT_VOLTAGE_LIMIT = 40,
    POWER_SUPPLY_PROP_INPUT_POWER_LIMIT = 41,
    POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN = 42,
    POWER_SUPPLY_PROP_ENERGY_EMPTY_DESIGN = 43,
    POWER_SUPPLY_PROP_ENERGY_FULL = 44,
    POWER_SUPPLY_PROP_ENERGY_EMPTY = 45,
    POWER_SUPPLY_PROP_ENERGY_NOW = 46,
    POWER_SUPPLY_PROP_ENERGY_AVG = 47,
    POWER_SUPPLY_PROP_CAPACITY = 48,
    POWER_SUPPLY_PROP_CAPACITY_ALERT_MIN = 49,
    POWER_SUPPLY_PROP_CAPACITY_ALERT_MAX = 50,
    POWER_SUPPLY_PROP_CAPACITY_ERROR_MARGIN = 51,
    POWER_SUPPLY_PROP_CAPACITY_LEVEL = 52,
    POWER_SUPPLY_PROP_TEMP = 53,
    POWER_SUPPLY_PROP_TEMP_MAX = 54,
    POWER_SUPPLY_PROP_TEMP_MIN = 55,
    POWER_SUPPLY_PROP_TEMP_ALERT_MIN = 56,
    POWER_SUPPLY_PROP_TEMP_ALERT_MAX = 57,
    POWER_SUPPLY_PROP_TEMP_AMBIENT = 58,
    POWER_SUPPLY_PROP_TEMP_AMBIENT_ALERT_MIN = 59,
    POWER_SUPPLY_PROP_TEMP_AMBIENT_ALERT_MAX = 60,
    POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW = 61,
    POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG = 62,
    POWER_SUPPLY_PROP_TIME_TO_FULL_NOW = 63,
    POWER_SUPPLY_PROP_TIME_TO_FULL_AVG = 64,
    POWER_SUPPLY_PROP_TYPE = 65,
    POWER_SUPPLY_PROP_USB_TYPE = 66,
    POWER_SUPPLY_PROP_SCOPE = 67,
    POWER_SUPPLY_PROP_PRECHARGE_CURRENT = 68,
    POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT = 69,
    POWER_SUPPLY_PROP_CALIBRATE = 70,
    POWER_SUPPLY_PROP_MANUFACTURE_YEAR = 71,
    POWER_SUPPLY_PROP_MANUFACTURE_MONTH = 72,
    POWER_SUPPLY_PROP_MANUFACTURE_DAY = 73,
    POWER_SUPPLY_PROP_MODEL_NAME = 74,
    POWER_SUPPLY_PROP_MANUFACTURER = 75,
    POWER_SUPPLY_PROP_SERIAL_NUMBER = 76,
};

enum power_supply_type {
    POWER_SUPPLY_TYPE_UNKNOWN = 0,
    POWER_SUPPLY_TYPE_BATTERY = 1,
    POWER_SUPPLY_TYPE_UPS = 2,
    POWER_SUPPLY_TYPE_MAINS = 3,
    POWER_SUPPLY_TYPE_USB = 4,
    POWER_SUPPLY_TYPE_USB_DCP = 5,
    POWER_SUPPLY_TYPE_USB_CDP = 6,
    POWER_SUPPLY_TYPE_USB_ACA = 7,
    POWER_SUPPLY_TYPE_USB_TYPE_C = 8,
    POWER_SUPPLY_TYPE_USB_PD = 9,
    POWER_SUPPLY_TYPE_USB_PD_DRP = 10,
    POWER_SUPPLY_TYPE_APPLE_BRICK_ID = 11,
    POWER_SUPPLY_TYPE_WIRELESS = 12,
};

enum power_supply_usb_type {
    POWER_SUPPLY_USB_TYPE_UNKNOWN = 0,
    POWER_SUPPLY_USB_TYPE_SDP = 1,
    POWER_SUPPLY_USB_TYPE_DCP = 2,
    POWER_SUPPLY_USB_TYPE_CDP = 3,
    POWER_SUPPLY_USB_TYPE_ACA = 4,
    POWER_SUPPLY_USB_TYPE_C = 5,
    POWER_SUPPLY_USB_TYPE_PD = 6,
    POWER_SUPPLY_USB_TYPE_PD_DRP = 7,
    POWER_SUPPLY_USB_TYPE_PD_PPS = 8,
    POWER_SUPPLY_USB_TYPE_APPLE_BRICK_ID = 9,
};

enum pr_status {
    PR_STS_SUCCESS = 0,
    PR_STS_IOERR = 2,
    PR_STS_RESERVATION_CONFLICT = 24,
    PR_STS_RETRY_PATH_FAILURE = 917504,
    PR_STS_PATH_FAST_FAILED = 983040,
    PR_STS_PATH_FAILED = 65536,
};

enum pr_type {
    PR_WRITE_EXCLUSIVE = 1,
    PR_EXCLUSIVE_ACCESS = 2,
    PR_WRITE_EXCLUSIVE_REG_ONLY = 3,
    PR_EXCLUSIVE_ACCESS_REG_ONLY = 4,
    PR_WRITE_EXCLUSIVE_ALL_REGS = 5,
    PR_EXCLUSIVE_ACCESS_ALL_REGS = 6,
};

enum prep_dispatch {
    PREP_DISPATCH_OK = 0,
    PREP_DISPATCH_NO_TAG = 1,
    PREP_DISPATCH_NO_BUDGET = 2,
};

enum print_line_t {
    TRACE_TYPE_PARTIAL_LINE = 0,
    TRACE_TYPE_HANDLED = 1,
    TRACE_TYPE_UNHANDLED = 2,
    TRACE_TYPE_NO_CONSUME = 3,
};

enum printk_info_flags {
    LOG_FORCE_CON = 1,
    LOG_NEWLINE = 2,
    LOG_CONT = 8,
};

enum prio_policy {
    POLICY_NO_CHANGE = 0,
    POLICY_PROMOTE_TO_RT = 1,
    POLICY_RESTRICT_TO_BE = 2,
    POLICY_ALL_TO_IDLE = 3,
    POLICY_NONE_TO_RT = 4,
};

enum priv_stack_mode {
    PRIV_STACK_UNKNOWN = 0,
    NO_PRIV_STACK = 1,
    PRIV_STACK_ADAPTIVE = 2,
};

enum probe_insn {
    INSN_REJECTED = 0,
    INSN_GOOD_NO_SLOT = 1,
    INSN_GOOD = 2,
};

enum probe_print_type {
    PROBE_PRINT_NORMAL = 0,
    PROBE_PRINT_RETURN = 1,
    PROBE_PRINT_EVENT = 2,
};

enum probe_type {
    PROBE_DEFAULT_STRATEGY = 0,
    PROBE_PREFER_ASYNCHRONOUS = 1,
    PROBE_FORCE_SYNCHRONOUS = 2,
};

enum proc_cn_event {
    PROC_EVENT_NONE = 0,
    PROC_EVENT_FORK = 1,
    PROC_EVENT_EXEC = 2,
    PROC_EVENT_UID = 4,
    PROC_EVENT_GID = 64,
    PROC_EVENT_SID = 128,
    PROC_EVENT_PTRACE = 256,
    PROC_EVENT_COMM = 512,
    PROC_EVENT_NONZERO_EXIT = 536870912,
    PROC_EVENT_COREDUMP = 1073741824,
    PROC_EVENT_EXIT = 2147483648,
};

enum proc_hidepid {
    HIDEPID_OFF = 0,
    HIDEPID_NO_ACCESS = 1,
    HIDEPID_INVISIBLE = 2,
    HIDEPID_NOT_PTRACEABLE = 4,
};

enum proc_mem_force {
    PROC_MEM_FORCE_ALWAYS = 0,
    PROC_MEM_FORCE_PTRACE = 1,
    PROC_MEM_FORCE_NEVER = 2,
};

enum proc_param {
    Opt_gid___6 = 0,
    Opt_hidepid = 1,
    Opt_subset = 2,
};

enum proc_pidonly {
    PROC_PIDONLY_OFF = 0,
    PROC_PIDONLY_ON = 1,
};

enum procmap_query_flags {
    PROCMAP_QUERY_VMA_READABLE = 1,
    PROCMAP_QUERY_VMA_WRITABLE = 2,
    PROCMAP_QUERY_VMA_EXECUTABLE = 4,
    PROCMAP_QUERY_VMA_SHARED = 8,
    PROCMAP_QUERY_COVERING_OR_NEXT_VMA = 16,
    PROCMAP_QUERY_FILE_BACKED_VMA = 32,
};

enum profile_mode {
    APPARMOR_ENFORCE = 0,
    APPARMOR_COMPLAIN = 1,
    APPARMOR_KILL = 2,
    APPARMOR_UNCONFINED = 3,
    APPARMOR_USER = 4,
};

enum prs_errcode {
    PERR_NONE = 0,
    PERR_INVCPUS = 1,
    PERR_INVPARENT = 2,
    PERR_NOTPART = 3,
    PERR_NOTEXCL = 4,
    PERR_NOCPUS = 5,
    PERR_HOTPLUG = 6,
    PERR_CPUSEMPTY = 7,
    PERR_HKEEPING = 8,
    PERR_ACCESS = 9,
    PERR_REMOTE = 10,
};

enum pse_pi_pairset_pinout {
    ALTERNATIVE_A = 0,
    ALTERNATIVE_B = 1,
};

enum psi_aggregators {
    PSI_AVGS = 0,
    PSI_POLL = 1,
    NR_PSI_AGGREGATORS = 2,
};

enum psi_res {
    PSI_IO = 0,
    PSI_MEM = 1,
    PSI_CPU = 2,
    NR_PSI_RESOURCES = 3,
};

enum psi_states {
    PSI_IO_SOME = 0,
    PSI_IO_FULL = 1,
    PSI_MEM_SOME = 2,
    PSI_MEM_FULL = 3,
    PSI_CPU_SOME = 4,
    PSI_CPU_FULL = 5,
    PSI_NONIDLE = 6,
    NR_PSI_STATES = 7,
};

enum psi_task_count {
    NR_IOWAIT = 0,
    NR_MEMSTALL = 1,
    NR_RUNNING = 2,
    NR_MEMSTALL_RUNNING = 3,
    NR_PSI_TASK_COUNTS = 4,
};

enum pstore_type_id {
    PSTORE_TYPE_DMESG = 0,
    PSTORE_TYPE_MCE = 1,
    PSTORE_TYPE_CONSOLE = 2,
    PSTORE_TYPE_FTRACE = 3,
    PSTORE_TYPE_PPC_RTAS = 4,
    PSTORE_TYPE_PPC_OF = 5,
    PSTORE_TYPE_PPC_COMMON = 6,
    PSTORE_TYPE_PMSG = 7,
    PSTORE_TYPE_PPC_OPAL = 8,
    PSTORE_TYPE_MAX = 9,
};

enum ptp_clock_events {
    PTP_CLOCK_ALARM = 0,
    PTP_CLOCK_EXTTS = 1,
    PTP_CLOCK_EXTOFF = 2,
    PTP_CLOCK_PPS = 3,
    PTP_CLOCK_PPSUSR = 4,
};

enum ptp_pin_function {
    PTP_PF_NONE = 0,
    PTP_PF_EXTTS = 1,
    PTP_PF_PEROUT = 2,
    PTP_PF_PHYSYNC = 3,
};

enum ptrace_syscall_dir {
    PTRACE_SYSCALL_ENTER = 0,
    PTRACE_SYSCALL_EXIT = 1,
};

enum pubkey_algo {
    PUBKEY_ALGO_RSA = 0,
    PUBKEY_ALGO_MAX = 1,
};

enum pwm_polarity {
    PWM_POLARITY_NORMAL = 0,
    PWM_POLARITY_INVERSED = 1,
};

enum qdisc_class_ops_flags {
    QDISC_CLASS_OPS_DOIT_UNLOCKED = 1,
};

enum qdisc_state2_t {
    __QDISC_STATE2_RUNNING = 0,
};

enum qdisc_state_t {
    __QDISC_STATE_SCHED = 0,
    __QDISC_STATE_DEACTIVATED = 1,
    __QDISC_STATE_MISSED = 2,
    __QDISC_STATE_DRAINING = 3,
};

enum quota_type {
    USRQUOTA = 0,
    GRPQUOTA = 1,
    PRJQUOTA = 2,
};

enum ramfs_param {
    Opt_mode___5 = 0,
};

enum rc_driver_type {
    RC_DRIVER_SCANCODE = 0,
    RC_DRIVER_IR_RAW = 1,
    RC_DRIVER_IR_RAW_TX = 2,
};

enum rc_filter_type {
    RC_FILTER_NORMAL = 0,
    RC_FILTER_WAKEUP = 1,
    RC_FILTER_MAX = 2,
};

enum rc_proto {
    RC_PROTO_UNKNOWN = 0,
    RC_PROTO_OTHER = 1,
    RC_PROTO_RC5 = 2,
    RC_PROTO_RC5X_20 = 3,
    RC_PROTO_RC5_SZ = 4,
    RC_PROTO_JVC = 5,
    RC_PROTO_SONY12 = 6,
    RC_PROTO_SONY15 = 7,
    RC_PROTO_SONY20 = 8,
    RC_PROTO_NEC = 9,
    RC_PROTO_NECX = 10,
    RC_PROTO_NEC32 = 11,
    RC_PROTO_SANYO = 12,
    RC_PROTO_MCIR2_KBD = 13,
    RC_PROTO_MCIR2_MSE = 14,
    RC_PROTO_RC6_0 = 15,
    RC_PROTO_RC6_6A_20 = 16,
    RC_PROTO_RC6_6A_24 = 17,
    RC_PROTO_RC6_6A_32 = 18,
    RC_PROTO_RC6_MCE = 19,
    RC_PROTO_SHARP = 20,
    RC_PROTO_XMP = 21,
    RC_PROTO_CEC = 22,
    RC_PROTO_IMON = 23,
    RC_PROTO_RCMM12 = 24,
    RC_PROTO_RCMM24 = 25,
    RC_PROTO_RCMM32 = 26,
    RC_PROTO_XBOX_DVD = 27,
    RC_PROTO_MAX = 27,
};

enum rdma_ah_attr_type {
    RDMA_AH_ATTR_TYPE_UNDEFINED = 0,
    RDMA_AH_ATTR_TYPE_IB = 1,
    RDMA_AH_ATTR_TYPE_ROCE = 2,
    RDMA_AH_ATTR_TYPE_OPA = 3,
};

enum rdma_driver_id {
    RDMA_DRIVER_UNKNOWN = 0,
    RDMA_DRIVER_MLX5 = 1,
    RDMA_DRIVER_MLX4 = 2,
    RDMA_DRIVER_CXGB3 = 3,
    RDMA_DRIVER_CXGB4 = 4,
    RDMA_DRIVER_MTHCA = 5,
    RDMA_DRIVER_BNXT_RE = 6,
    RDMA_DRIVER_OCRDMA = 7,
    RDMA_DRIVER_NES = 8,
    RDMA_DRIVER_I40IW = 9,
    RDMA_DRIVER_IRDMA = 9,
    RDMA_DRIVER_VMW_PVRDMA = 10,
    RDMA_DRIVER_QEDR = 11,
    RDMA_DRIVER_HNS = 12,
    RDMA_DRIVER_USNIC = 13,
    RDMA_DRIVER_RXE = 14,
    RDMA_DRIVER_HFI1 = 15,
    RDMA_DRIVER_QIB = 16,
    RDMA_DRIVER_EFA = 17,
    RDMA_DRIVER_SIW = 18,
    RDMA_DRIVER_ERDMA = 19,
    RDMA_DRIVER_MANA = 20,
};

enum rdma_link_layer {
    IB_LINK_LAYER_UNSPECIFIED = 0,
    IB_LINK_LAYER_INFINIBAND = 1,
    IB_LINK_LAYER_ETHERNET = 2,
};

enum rdma_netdev_t {
    RDMA_NETDEV_OPA_VNIC = 0,
    RDMA_NETDEV_IPOIB = 1,
};

enum rdma_nl_counter_mask {
    RDMA_COUNTER_MASK_QP_TYPE = 1,
    RDMA_COUNTER_MASK_PID = 2,
};

enum rdma_nl_counter_mode {
    RDMA_COUNTER_MODE_NONE = 0,
    RDMA_COUNTER_MODE_AUTO = 1,
    RDMA_COUNTER_MODE_MANUAL = 2,
    RDMA_COUNTER_MODE_MAX = 3,
};

enum rdma_nl_dev_type {
    RDMA_DEVICE_TYPE_SMI = 1,
};

enum rdma_nl_name_assign_type {
    RDMA_NAME_ASSIGN_TYPE_UNKNOWN = 0,
    RDMA_NAME_ASSIGN_TYPE_USER = 1,
};

enum rdma_restrack_type {
    RDMA_RESTRACK_PD = 0,
    RDMA_RESTRACK_CQ = 1,
    RDMA_RESTRACK_QP = 2,
    RDMA_RESTRACK_CM_ID = 3,
    RDMA_RESTRACK_MR = 4,
    RDMA_RESTRACK_CTX = 5,
    RDMA_RESTRACK_COUNTER = 6,
    RDMA_RESTRACK_SRQ = 7,
    RDMA_RESTRACK_MAX = 8,
};

enum rdmacg_file_type {
    RDMACG_RESOURCE_TYPE_MAX = 0,
    RDMACG_RESOURCE_TYPE_STAT = 1,
};

enum rdmacg_resource_type {
    RDMACG_RESOURCE_HCA_HANDLE = 0,
    RDMACG_RESOURCE_HCA_OBJECT = 1,
    RDMACG_RESOURCE_MAX = 2,
};

enum reboot_mode {
    REBOOT_UNDEFINED = -1,
    REBOOT_COLD = 0,
    REBOOT_WARM = 1,
    REBOOT_HARD = 2,
    REBOOT_SOFT = 3,
    REBOOT_GPIO = 4,
};

enum reboot_type {
    BOOT_TRIPLE = 116,
    BOOT_KBD = 107,
    BOOT_BIOS = 98,
    BOOT_ACPI = 97,
    BOOT_EFI = 101,
    BOOT_CF9_FORCE = 112,
    BOOT_CF9_SAFE = 113,
};

enum ref_state_type {
    REF_TYPE_PTR = 1,
    REF_TYPE_IRQ = 2,
    REF_TYPE_LOCK = 3,
};

enum refcount_saturation_type {
    REFCOUNT_ADD_NOT_ZERO_OVF = 0,
    REFCOUNT_ADD_OVF = 1,
    REFCOUNT_ADD_UAF = 2,
    REFCOUNT_SUB_UAF = 3,
    REFCOUNT_DEC_LEAK = 4,
};

enum reg_arg_type {
    SRC_OP = 0,
    DST_OP = 1,
    DST_OP_NO_MARK = 2,
};

enum regcache_type {
    REGCACHE_NONE = 0,
    REGCACHE_RBTREE = 1,
    REGCACHE_FLAT = 2,
    REGCACHE_MAPLE = 3,
};

enum regex_type {
    MATCH_FULL = 0,
    MATCH_FRONT_ONLY = 1,
    MATCH_MIDDLE_ONLY = 2,
    MATCH_END_ONLY = 3,
    MATCH_GLOB = 4,
    MATCH_INDEX = 5,
};

enum regmap_endian {
    REGMAP_ENDIAN_DEFAULT = 0,
    REGMAP_ENDIAN_BIG = 1,
    REGMAP_ENDIAN_LITTLE = 2,
    REGMAP_ENDIAN_NATIVE = 3,
};

enum regulator_active_discharge {
    REGULATOR_ACTIVE_DISCHARGE_DEFAULT = 0,
    REGULATOR_ACTIVE_DISCHARGE_DISABLE = 1,
    REGULATOR_ACTIVE_DISCHARGE_ENABLE = 2,
};

enum regulator_detection_severity {
    REGULATOR_SEVERITY_PROT = 0,
    REGULATOR_SEVERITY_ERR = 1,
    REGULATOR_SEVERITY_WARN = 2,
};

enum regulator_get_type {
    NORMAL_GET = 0,
    EXCLUSIVE_GET = 1,
    OPTIONAL_GET = 2,
    MAX_GET_TYPE = 3,
};

enum regulator_status {
    REGULATOR_STATUS_OFF = 0,
    REGULATOR_STATUS_ON = 1,
    REGULATOR_STATUS_ERROR = 2,
    REGULATOR_STATUS_FAST = 3,
    REGULATOR_STATUS_NORMAL = 4,
    REGULATOR_STATUS_IDLE = 5,
    REGULATOR_STATUS_STANDBY = 6,
    REGULATOR_STATUS_BYPASS = 7,
    REGULATOR_STATUS_UNDEFINED = 8,
};

enum regulator_type {
    REGULATOR_VOLTAGE = 0,
    REGULATOR_CURRENT = 1,
};

enum release_type {
    leaf_only = 0,
    whole_subtree = 1,
};

enum req_flag_bits {
    __REQ_FAILFAST_DEV = 8,
    __REQ_FAILFAST_TRANSPORT = 9,
    __REQ_FAILFAST_DRIVER = 10,
    __REQ_SYNC = 11,
    __REQ_META = 12,
    __REQ_PRIO = 13,
    __REQ_NOMERGE = 14,
    __REQ_IDLE = 15,
    __REQ_INTEGRITY = 16,
    __REQ_FUA = 17,
    __REQ_PREFLUSH = 18,
    __REQ_RAHEAD = 19,
    __REQ_BACKGROUND = 20,
    __REQ_NOWAIT = 21,
    __REQ_POLLED = 22,
    __REQ_ALLOC_CACHE = 23,
    __REQ_SWAP = 24,
    __REQ_DRV = 25,
    __REQ_FS_PRIVATE = 26,
    __REQ_ATOMIC = 27,
    __REQ_NOUNMAP = 28,
    __REQ_NR_BITS = 29,
};

enum req_op {
    REQ_OP_READ = 0,
    REQ_OP_WRITE = 1,
    REQ_OP_FLUSH = 2,
    REQ_OP_DISCARD = 3,
    REQ_OP_SECURE_ERASE = 5,
    REQ_OP_ZONE_APPEND = 7,
    REQ_OP_WRITE_ZEROES = 9,
    REQ_OP_ZONE_OPEN = 10,
    REQ_OP_ZONE_CLOSE = 11,
    REQ_OP_ZONE_FINISH = 12,
    REQ_OP_ZONE_RESET = 13,
    REQ_OP_ZONE_RESET_ALL = 15,
    REQ_OP_DRV_IN = 34,
    REQ_OP_DRV_OUT = 35,
    REQ_OP_LAST = 36,
};

enum resctrl_conf_type {
    CDP_NONE = 0,
    CDP_CODE = 1,
    CDP_DATA = 2,
};

enum reset_control_flags {
    RESET_CONTROL_EXCLUSIVE = 4,
    RESET_CONTROL_EXCLUSIVE_DEASSERTED = 12,
    RESET_CONTROL_EXCLUSIVE_RELEASED = 0,
    RESET_CONTROL_SHARED = 1,
    RESET_CONTROL_SHARED_DEASSERTED = 9,
    RESET_CONTROL_OPTIONAL_EXCLUSIVE = 6,
    RESET_CONTROL_OPTIONAL_EXCLUSIVE_DEASSERTED = 14,
    RESET_CONTROL_OPTIONAL_EXCLUSIVE_RELEASED = 2,
    RESET_CONTROL_OPTIONAL_SHARED = 3,
    RESET_CONTROL_OPTIONAL_SHARED_DEASSERTED = 11,
};

enum resolve_mode {
    RESOLVE_TBD = 0,
    RESOLVE_PTR = 1,
    RESOLVE_STRUCT_OR_ARRAY = 2,
};

enum ring_buffer_flags {
    RB_FL_OVERWRITE = 1,
};

enum ring_buffer_type {
    RINGBUF_TYPE_DATA_TYPE_LEN_MAX = 28,
    RINGBUF_TYPE_PADDING = 29,
    RINGBUF_TYPE_TIME_EXTEND = 30,
    RINGBUF_TYPE_TIME_STAMP = 31,
};

enum ripas {
    RSI_RIPAS_EMPTY = 0,
    RSI_RIPAS_RAM = 1,
    RSI_RIPAS_DESTROYED = 2,
    RSI_RIPAS_DEV = 3,
};

enum rlimit_type {
    UCOUNT_RLIMIT_NPROC = 0,
    UCOUNT_RLIMIT_MSGQUEUE = 1,
    UCOUNT_RLIMIT_SIGPENDING = 2,
    UCOUNT_RLIMIT_MEMLOCK = 3,
    UCOUNT_RLIMIT_COUNTS = 4,
};

enum rmap_level {
    RMAP_LEVEL_PTE = 0,
    RMAP_LEVEL_PMD = 1,
};

enum rmp_flags {
    RMP_LOCKED = 1,
    RMP_USE_SHARED_ZEROPAGE = 2,
};

enum rmqueue_mode {
    RMQUEUE_NORMAL = 0,
    RMQUEUE_CMA = 1,
    RMQUEUE_CLAIM = 2,
    RMQUEUE_STEAL = 3,
};

enum rp_check {
    RP_CHECK_CALL = 0,
    RP_CHECK_CHAIN_CALL = 1,
    RP_CHECK_RET = 2,
};

enum rpc_display_format_t {
    RPC_DISPLAY_ADDR = 0,
    RPC_DISPLAY_PORT = 1,
    RPC_DISPLAY_PROTO = 2,
    RPC_DISPLAY_HEX_ADDR = 3,
    RPC_DISPLAY_HEX_PORT = 4,
    RPC_DISPLAY_NETID = 5,
    RPC_DISPLAY_MAX = 6,
};

enum rpi_firmware_clk_id {
    RPI_FIRMWARE_EMMC_CLK_ID = 1,
    RPI_FIRMWARE_UART_CLK_ID = 2,
    RPI_FIRMWARE_ARM_CLK_ID = 3,
    RPI_FIRMWARE_CORE_CLK_ID = 4,
    RPI_FIRMWARE_V3D_CLK_ID = 5,
    RPI_FIRMWARE_H264_CLK_ID = 6,
    RPI_FIRMWARE_ISP_CLK_ID = 7,
    RPI_FIRMWARE_SDRAM_CLK_ID = 8,
    RPI_FIRMWARE_PIXEL_CLK_ID = 9,
    RPI_FIRMWARE_PWM_CLK_ID = 10,
    RPI_FIRMWARE_HEVC_CLK_ID = 11,
    RPI_FIRMWARE_EMMC2_CLK_ID = 12,
    RPI_FIRMWARE_M2MC_CLK_ID = 13,
    RPI_FIRMWARE_PIXEL_BVB_CLK_ID = 14,
    RPI_FIRMWARE_VEC_CLK_ID = 15,
    RPI_FIRMWARE_DISP_CLK_ID = 16,
    RPI_FIRMWARE_NUM_CLK_ID = 17,
};

enum rpi_firmware_property_status {
    RPI_FIRMWARE_STATUS_REQUEST = 0,
    RPI_FIRMWARE_STATUS_SUCCESS = 2147483648,
    RPI_FIRMWARE_STATUS_ERROR = 2147483649,
};

enum rpi_firmware_property_tag {
    RPI_FIRMWARE_PROPERTY_END = 0,
    RPI_FIRMWARE_GET_FIRMWARE_REVISION = 1,
    RPI_FIRMWARE_GET_FIRMWARE_VARIANT = 2,
    RPI_FIRMWARE_GET_FIRMWARE_HASH = 3,
    RPI_FIRMWARE_SET_CURSOR_INFO = 32784,
    RPI_FIRMWARE_SET_CURSOR_STATE = 32785,
    RPI_FIRMWARE_GET_BOARD_MODEL = 65537,
    RPI_FIRMWARE_GET_BOARD_REVISION = 65538,
    RPI_FIRMWARE_GET_BOARD_MAC_ADDRESS = 65539,
    RPI_FIRMWARE_GET_BOARD_SERIAL = 65540,
    RPI_FIRMWARE_GET_ARM_MEMORY = 65541,
    RPI_FIRMWARE_GET_VC_MEMORY = 65542,
    RPI_FIRMWARE_GET_CLOCKS = 65543,
    RPI_FIRMWARE_GET_POWER_STATE = 131073,
    RPI_FIRMWARE_GET_TIMING = 131074,
    RPI_FIRMWARE_SET_POWER_STATE = 163841,
    RPI_FIRMWARE_GET_CLOCK_STATE = 196609,
    RPI_FIRMWARE_GET_CLOCK_RATE = 196610,
    RPI_FIRMWARE_GET_VOLTAGE = 196611,
    RPI_FIRMWARE_GET_MAX_CLOCK_RATE = 196612,
    RPI_FIRMWARE_GET_MAX_VOLTAGE = 196613,
    RPI_FIRMWARE_GET_TEMPERATURE = 196614,
    RPI_FIRMWARE_GET_MIN_CLOCK_RATE = 196615,
    RPI_FIRMWARE_GET_MIN_VOLTAGE = 196616,
    RPI_FIRMWARE_GET_TURBO = 196617,
    RPI_FIRMWARE_GET_MAX_TEMPERATURE = 196618,
    RPI_FIRMWARE_GET_STC = 196619,
    RPI_FIRMWARE_ALLOCATE_MEMORY = 196620,
    RPI_FIRMWARE_LOCK_MEMORY = 196621,
    RPI_FIRMWARE_UNLOCK_MEMORY = 196622,
    RPI_FIRMWARE_RELEASE_MEMORY = 196623,
    RPI_FIRMWARE_EXECUTE_CODE = 196624,
    RPI_FIRMWARE_EXECUTE_QPU = 196625,
    RPI_FIRMWARE_SET_ENABLE_QPU = 196626,
    RPI_FIRMWARE_GET_DISPMANX_RESOURCE_MEM_HANDLE = 196628,
    RPI_FIRMWARE_GET_EDID_BLOCK = 196640,
    RPI_FIRMWARE_GET_CUSTOMER_OTP = 196641,
    RPI_FIRMWARE_GET_EDID_BLOCK_DISPLAY = 196643,
    RPI_FIRMWARE_GET_DOMAIN_STATE = 196656,
    RPI_FIRMWARE_GET_THROTTLED = 196678,
    RPI_FIRMWARE_GET_CLOCK_MEASURED = 196679,
    RPI_FIRMWARE_NOTIFY_REBOOT = 196680,
    RPI_FIRMWARE_SET_CLOCK_STATE = 229377,
    RPI_FIRMWARE_SET_CLOCK_RATE = 229378,
    RPI_FIRMWARE_SET_VOLTAGE = 229379,
    RPI_FIRMWARE_SET_TURBO = 229385,
    RPI_FIRMWARE_SET_CUSTOMER_OTP = 229409,
    RPI_FIRMWARE_SET_DOMAIN_STATE = 229424,
    RPI_FIRMWARE_GET_GPIO_STATE = 196673,
    RPI_FIRMWARE_SET_GPIO_STATE = 229441,
    RPI_FIRMWARE_SET_SDHOST_CLOCK = 229442,
    RPI_FIRMWARE_GET_GPIO_CONFIG = 196675,
    RPI_FIRMWARE_SET_GPIO_CONFIG = 229443,
    RPI_FIRMWARE_GET_PERIPH_REG = 196677,
    RPI_FIRMWARE_SET_PERIPH_REG = 229445,
    RPI_FIRMWARE_GET_POE_HAT_VAL = 196681,
    RPI_FIRMWARE_SET_POE_HAT_VAL = 229449,
    RPI_FIRMWARE_SET_POE_HAT_VAL_OLD = 196688,
    RPI_FIRMWARE_NOTIFY_XHCI_RESET = 196696,
    RPI_FIRMWARE_GET_REBOOT_FLAGS = 196708,
    RPI_FIRMWARE_SET_REBOOT_FLAGS = 229476,
    RPI_FIRMWARE_NOTIFY_DISPLAY_DONE = 196710,
    RPI_FIRMWARE_GET_SW_UART = 196746,
    RPI_FIRMWARE_SET_SW_UART = 229514,
    RPI_FIRMWARE_FRAMEBUFFER_ALLOCATE = 262145,
    RPI_FIRMWARE_FRAMEBUFFER_BLANK = 262146,
    RPI_FIRMWARE_FRAMEBUFFER_GET_PHYSICAL_WIDTH_HEIGHT = 262147,
    RPI_FIRMWARE_FRAMEBUFFER_GET_VIRTUAL_WIDTH_HEIGHT = 262148,
    RPI_FIRMWARE_FRAMEBUFFER_GET_DEPTH = 262149,
    RPI_FIRMWARE_FRAMEBUFFER_GET_PIXEL_ORDER = 262150,
    RPI_FIRMWARE_FRAMEBUFFER_GET_ALPHA_MODE = 262151,
    RPI_FIRMWARE_FRAMEBUFFER_GET_PITCH = 262152,
    RPI_FIRMWARE_FRAMEBUFFER_GET_VIRTUAL_OFFSET = 262153,
    RPI_FIRMWARE_FRAMEBUFFER_GET_OVERSCAN = 262154,
    RPI_FIRMWARE_FRAMEBUFFER_GET_PALETTE = 262155,
    RPI_FIRMWARE_FRAMEBUFFER_GET_LAYER = 262156,
    RPI_FIRMWARE_FRAMEBUFFER_GET_TRANSFORM = 262157,
    RPI_FIRMWARE_FRAMEBUFFER_GET_VSYNC = 262158,
    RPI_FIRMWARE_FRAMEBUFFER_GET_TOUCHBUF = 262159,
    RPI_FIRMWARE_FRAMEBUFFER_GET_GPIOVIRTBUF = 262160,
    RPI_FIRMWARE_FRAMEBUFFER_RELEASE = 294913,
    RPI_FIRMWARE_FRAMEBUFFER_GET_DISPLAY_ID = 262166,
    RPI_FIRMWARE_FRAMEBUFFER_SET_DISPLAY_NUM = 294931,
    RPI_FIRMWARE_FRAMEBUFFER_GET_NUM_DISPLAYS = 262163,
    RPI_FIRMWARE_FRAMEBUFFER_GET_DISPLAY_SETTINGS = 262164,
    RPI_FIRMWARE_FRAMEBUFFER_TEST_PHYSICAL_WIDTH_HEIGHT = 278531,
    RPI_FIRMWARE_FRAMEBUFFER_TEST_VIRTUAL_WIDTH_HEIGHT = 278532,
    RPI_FIRMWARE_FRAMEBUFFER_TEST_DEPTH = 278533,
    RPI_FIRMWARE_FRAMEBUFFER_TEST_PIXEL_ORDER = 278534,
    RPI_FIRMWARE_FRAMEBUFFER_TEST_ALPHA_MODE = 278535,
    RPI_FIRMWARE_FRAMEBUFFER_TEST_VIRTUAL_OFFSET = 278537,
    RPI_FIRMWARE_FRAMEBUFFER_TEST_OVERSCAN = 278538,
    RPI_FIRMWARE_FRAMEBUFFER_TEST_PALETTE = 278539,
    RPI_FIRMWARE_FRAMEBUFFER_TEST_LAYER = 278540,
    RPI_FIRMWARE_FRAMEBUFFER_TEST_TRANSFORM = 278541,
    RPI_FIRMWARE_FRAMEBUFFER_TEST_VSYNC = 278542,
    RPI_FIRMWARE_FRAMEBUFFER_SET_PHYSICAL_WIDTH_HEIGHT = 294915,
    RPI_FIRMWARE_FRAMEBUFFER_SET_VIRTUAL_WIDTH_HEIGHT = 294916,
    RPI_FIRMWARE_FRAMEBUFFER_SET_DEPTH = 294917,
    RPI_FIRMWARE_FRAMEBUFFER_SET_PIXEL_ORDER = 294918,
    RPI_FIRMWARE_FRAMEBUFFER_SET_ALPHA_MODE = 294919,
    RPI_FIRMWARE_FRAMEBUFFER_SET_PITCH = 294920,
    RPI_FIRMWARE_FRAMEBUFFER_SET_VIRTUAL_OFFSET = 294921,
    RPI_FIRMWARE_FRAMEBUFFER_SET_OVERSCAN = 294922,
    RPI_FIRMWARE_FRAMEBUFFER_SET_PALETTE = 294923,
    RPI_FIRMWARE_FRAMEBUFFER_SET_TOUCHBUF = 294943,
    RPI_FIRMWARE_FRAMEBUFFER_SET_GPIOVIRTBUF = 294944,
    RPI_FIRMWARE_FRAMEBUFFER_SET_VSYNC = 294926,
    RPI_FIRMWARE_FRAMEBUFFER_SET_LAYER = 294924,
    RPI_FIRMWARE_FRAMEBUFFER_SET_TRANSFORM = 294925,
    RPI_FIRMWARE_FRAMEBUFFER_SET_BACKLIGHT = 294927,
    RPI_FIRMWARE_VCHIQ_INIT = 294928,
    RPI_FIRMWARE_SET_PLANE = 294933,
    RPI_FIRMWARE_GET_DISPLAY_TIMING = 262167,
    RPI_FIRMWARE_SET_TIMING = 294935,
    RPI_FIRMWARE_GET_DISPLAY_CFG = 262168,
    RPI_FIRMWARE_SET_DISPLAY_POWER = 294937,
    RPI_FIRMWARE_GET_COMMAND_LINE = 327681,
    RPI_FIRMWARE_GET_DMA_CHANNELS = 393217,
};

enum rpm_request {
    RPM_REQ_NONE = 0,
    RPM_REQ_IDLE = 1,
    RPM_REQ_SUSPEND = 2,
    RPM_REQ_AUTOSUSPEND = 3,
    RPM_REQ_RESUME = 4,
};

enum rpm_status {
    RPM_INVALID = -1,
    RPM_ACTIVE = 0,
    RPM_RESUMING = 1,
    RPM_SUSPENDED = 2,
    RPM_SUSPENDING = 3,
};

enum rq_end_io_ret {
    RQ_END_IO_NONE = 0,
    RQ_END_IO_FREE = 1,
};

enum rq_qos_id {
    RQ_QOS_WBT = 0,
    RQ_QOS_LATENCY = 1,
    RQ_QOS_COST = 2,
};

enum rqf_flags {
    __RQF_STARTED = 0,
    __RQF_FLUSH_SEQ = 1,
    __RQF_MIXED_MERGE = 2,
    __RQF_DONTPREP = 3,
    __RQF_SCHED_TAGS = 4,
    __RQF_USE_SCHED = 5,
    __RQF_FAILED = 6,
    __RQF_QUIET = 7,
    __RQF_IO_STAT = 8,
    __RQF_PM = 9,
    __RQF_HASHED = 10,
    __RQF_STATS = 11,
    __RQF_SPECIAL_PAYLOAD = 12,
    __RQF_ZONE_WRITE_PLUGGING = 13,
    __RQF_TIMED_OUT = 14,
    __RQF_RESV = 15,
    __RQF_BITS = 16,
};

enum rsaprivkey_actions {
    ACT_rsa_get_d = 0,
    ACT_rsa_get_dp = 1,
    ACT_rsa_get_dq = 2,
    ACT_rsa_get_e = 3,
    ACT_rsa_get_n = 4,
    ACT_rsa_get_p = 5,
    ACT_rsa_get_q = 6,
    ACT_rsa_get_qinv = 7,
    NR__rsaprivkey_actions = 8,
};

enum rsapubkey_actions {
    ACT_rsa_get_e___2 = 0,
    ACT_rsa_get_n___2 = 1,
    NR__rsapubkey_actions = 2,
};

enum rseq_cpu_id_state {
    RSEQ_CPU_ID_UNINITIALIZED = -1,
    RSEQ_CPU_ID_REGISTRATION_FAILED = -2,
};

enum rseq_cs_flags {
    RSEQ_CS_FLAG_NO_RESTART_ON_PREEMPT = 1,
    RSEQ_CS_FLAG_NO_RESTART_ON_SIGNAL = 2,
    RSEQ_CS_FLAG_NO_RESTART_ON_MIGRATE = 4,
};

enum rseq_cs_flags_bit {
    RSEQ_CS_FLAG_NO_RESTART_ON_PREEMPT_BIT = 0,
    RSEQ_CS_FLAG_NO_RESTART_ON_SIGNAL_BIT = 1,
    RSEQ_CS_FLAG_NO_RESTART_ON_MIGRATE_BIT = 2,
};

enum rseq_event_mask_bits {
    RSEQ_EVENT_PREEMPT_BIT = 0,
    RSEQ_EVENT_SIGNAL_BIT = 1,
    RSEQ_EVENT_MIGRATE_BIT = 2,
};

enum rseq_flags {
    RSEQ_FLAG_UNREGISTER = 1,
};

enum rt6_nud_state {
    RT6_NUD_FAIL_HARD = -3,
    RT6_NUD_FAIL_PROBE = -2,
    RT6_NUD_FAIL_DO_RR = -1,
    RT6_NUD_SUCCEED = 1,
};

enum rt_class_t {
    RT_TABLE_UNSPEC = 0,
    RT_TABLE_COMPAT = 252,
    RT_TABLE_DEFAULT = 253,
    RT_TABLE_MAIN = 254,
    RT_TABLE_LOCAL = 255,
    RT_TABLE_MAX = 4294967295,
};

enum rt_scope_t {
    RT_SCOPE_UNIVERSE = 0,
    RT_SCOPE_SITE = 200,
    RT_SCOPE_LINK = 253,
    RT_SCOPE_HOST = 254,
    RT_SCOPE_NOWHERE = 255,
};

enum rtattr_type_t {
    RTA_UNSPEC = 0,
    RTA_DST = 1,
    RTA_SRC = 2,
    RTA_IIF = 3,
    RTA_OIF = 4,
    RTA_GATEWAY = 5,
    RTA_PRIORITY = 6,
    RTA_PREFSRC = 7,
    RTA_METRICS = 8,
    RTA_MULTIPATH = 9,
    RTA_PROTOINFO = 10,
    RTA_FLOW = 11,
    RTA_CACHEINFO = 12,
    RTA_SESSION = 13,
    RTA_MP_ALGO = 14,
    RTA_TABLE = 15,
    RTA_MARK = 16,
    RTA_MFC_STATS = 17,
    RTA_VIA = 18,
    RTA_NEWDST = 19,
    RTA_PREF = 20,
    RTA_ENCAP_TYPE = 21,
    RTA_ENCAP = 22,
    RTA_EXPIRES = 23,
    RTA_PAD = 24,
    RTA_UID = 25,
    RTA_TTL_PROPAGATE = 26,
    RTA_IP_PROTO = 27,
    RTA_SPORT = 28,
    RTA_DPORT = 29,
    RTA_NH_ID = 30,
    RTA_FLOWLABEL = 31,
    __RTA_MAX = 32,
};

enum rtmutex_chainwalk {
    RT_MUTEX_MIN_CHAINWALK = 0,
    RT_MUTEX_FULL_CHAINWALK = 1,
};

enum rtnetlink_groups {
    RTNLGRP_NONE = 0,
    RTNLGRP_LINK = 1,
    RTNLGRP_NOTIFY = 2,
    RTNLGRP_NEIGH = 3,
    RTNLGRP_TC = 4,
    RTNLGRP_IPV4_IFADDR = 5,
    RTNLGRP_IPV4_MROUTE = 6,
    RTNLGRP_IPV4_ROUTE = 7,
    RTNLGRP_IPV4_RULE = 8,
    RTNLGRP_IPV6_IFADDR = 9,
    RTNLGRP_IPV6_MROUTE = 10,
    RTNLGRP_IPV6_ROUTE = 11,
    RTNLGRP_IPV6_IFINFO = 12,
    RTNLGRP_DECnet_IFADDR = 13,
    RTNLGRP_NOP2 = 14,
    RTNLGRP_DECnet_ROUTE = 15,
    RTNLGRP_DECnet_RULE = 16,
    RTNLGRP_NOP4 = 17,
    RTNLGRP_IPV6_PREFIX = 18,
    RTNLGRP_IPV6_RULE = 19,
    RTNLGRP_ND_USEROPT = 20,
    RTNLGRP_PHONET_IFADDR = 21,
    RTNLGRP_PHONET_ROUTE = 22,
    RTNLGRP_DCB = 23,
    RTNLGRP_IPV4_NETCONF = 24,
    RTNLGRP_IPV6_NETCONF = 25,
    RTNLGRP_MDB = 26,
    RTNLGRP_MPLS_ROUTE = 27,
    RTNLGRP_NSID = 28,
    RTNLGRP_MPLS_NETCONF = 29,
    RTNLGRP_IPV4_MROUTE_R = 30,
    RTNLGRP_IPV6_MROUTE_R = 31,
    RTNLGRP_NEXTHOP = 32,
    RTNLGRP_BRVLAN = 33,
    RTNLGRP_MCTP_IFADDR = 34,
    RTNLGRP_TUNNEL = 35,
    RTNLGRP_STATS = 36,
    RTNLGRP_IPV4_MCADDR = 37,
    RTNLGRP_IPV6_MCADDR = 38,
    RTNLGRP_IPV6_ACADDR = 39,
    __RTNLGRP_MAX = 40,
};

enum rtnl_kinds {
    RTNL_KIND_NEW = 0,
    RTNL_KIND_DEL = 1,
    RTNL_KIND_GET = 2,
    RTNL_KIND_SET = 3,
};

enum rtnl_link_flags {
    RTNL_FLAG_DOIT_UNLOCKED = 1,
    RTNL_FLAG_BULK_DEL_SUPPORTED = 2,
    RTNL_FLAG_DUMP_UNLOCKED = 4,
    RTNL_FLAG_DUMP_SPLIT_NLM_DONE = 8,
};

enum rw_hint {
    WRITE_LIFE_NOT_SET = 0,
    WRITE_LIFE_NONE = 1,
    WRITE_LIFE_SHORT = 2,
    WRITE_LIFE_MEDIUM = 3,
    WRITE_LIFE_LONG = 4,
    WRITE_LIFE_EXTREME = 5,
} __attribute__((mode(byte)));

enum rwsem_waiter_type {
    RWSEM_WAITING_FOR_WRITE = 0,
    RWSEM_WAITING_FOR_READ = 1,
};

enum rwsem_wake_type {
    RWSEM_WAKE_ANY = 0,
    RWSEM_WAKE_READERS = 1,
    RWSEM_WAKE_READ_OWNED = 2,
};

enum rx_handler_result {
    RX_HANDLER_CONSUMED = 0,
    RX_HANDLER_ANOTHER = 1,
    RX_HANDLER_EXACT = 2,
    RX_HANDLER_PASS = 3,
};

typedef enum rx_handler_result rx_handler_result_t;

enum s_alloc {
    sa_rootdomain = 0,
    sa_sd = 1,
    sa_sd_storage = 2,
    sa_none = 3,
};

enum sam_status {
    SAM_STAT_GOOD = 0,
    SAM_STAT_CHECK_CONDITION = 2,
    SAM_STAT_CONDITION_MET = 4,
    SAM_STAT_BUSY = 8,
    SAM_STAT_INTERMEDIATE = 16,
    SAM_STAT_INTERMEDIATE_CONDITION_MET = 20,
    SAM_STAT_RESERVATION_CONFLICT = 24,
    SAM_STAT_COMMAND_TERMINATED = 34,
    SAM_STAT_TASK_SET_FULL = 40,
    SAM_STAT_ACA_ACTIVE = 48,
    SAM_STAT_TASK_ABORTED = 64,
};

enum scale_freq_source {
    SCALE_FREQ_SOURCE_CPUFREQ = 0,
    SCALE_FREQ_SOURCE_ARCH = 1,
    SCALE_FREQ_SOURCE_CPPC = 2,
    SCALE_FREQ_SOURCE_VIRT = 3,
};

enum scan_balance {
    SCAN_EQUAL = 0,
    SCAN_FRACT = 1,
    SCAN_ANON = 2,
    SCAN_FILE = 3,
};

enum scan_result {
    SCAN_FAIL = 0,
    SCAN_SUCCEED = 1,
    SCAN_PMD_NULL = 2,
    SCAN_PMD_NONE = 3,
    SCAN_PMD_MAPPED = 4,
    SCAN_EXCEED_NONE_PTE = 5,
    SCAN_EXCEED_SWAP_PTE = 6,
    SCAN_EXCEED_SHARED_PTE = 7,
    SCAN_PTE_NON_PRESENT = 8,
    SCAN_PTE_UFFD_WP = 9,
    SCAN_PTE_MAPPED_HUGEPAGE = 10,
    SCAN_PAGE_RO = 11,
    SCAN_LACK_REFERENCED_PAGE = 12,
    SCAN_PAGE_NULL = 13,
    SCAN_SCAN_ABORT = 14,
    SCAN_PAGE_COUNT = 15,
    SCAN_PAGE_LRU = 16,
    SCAN_PAGE_LOCK = 17,
    SCAN_PAGE_ANON = 18,
    SCAN_PAGE_COMPOUND = 19,
    SCAN_ANY_PROCESS = 20,
    SCAN_VMA_NULL = 21,
    SCAN_VMA_CHECK = 22,
    SCAN_ADDRESS_RANGE = 23,
    SCAN_DEL_PAGE_LRU = 24,
    SCAN_ALLOC_HUGE_PAGE_FAIL = 25,
    SCAN_CGROUP_CHARGE_FAIL = 26,
    SCAN_TRUNCATED = 27,
    SCAN_PAGE_HAS_PRIVATE = 28,
    SCAN_STORE_FAILED = 29,
    SCAN_COPY_MC = 30,
    SCAN_PAGE_FILLED = 31,
};

enum sched_tunable_scaling {
    SCHED_TUNABLESCALING_NONE = 0,
    SCHED_TUNABLESCALING_LOG = 1,
    SCHED_TUNABLESCALING_LINEAR = 2,
    SCHED_TUNABLESCALING_END = 3,
};

enum scrub_type {
    SCRUB_UNKNOWN = 0,
    SCRUB_NONE = 1,
    SCRUB_SW_PROG = 2,
    SCRUB_SW_SRC = 3,
    SCRUB_SW_PROG_SRC = 4,
    SCRUB_SW_TUNABLE = 5,
    SCRUB_HW_PROG = 6,
    SCRUB_HW_SRC = 7,
    SCRUB_HW_PROG_SRC = 8,
    SCRUB_HW_TUNABLE = 9,
};

enum scsi_cmnd_submitter {
    SUBMITTED_BY_BLOCK_LAYER = 0,
    SUBMITTED_BY_SCSI_ERROR_HANDLER = 1,
    SUBMITTED_BY_SCSI_RESET_IOCTL = 2,
} __attribute__((mode(byte)));

enum scsi_device_event {
    SDEV_EVT_MEDIA_CHANGE = 1,
    SDEV_EVT_INQUIRY_CHANGE_REPORTED = 2,
    SDEV_EVT_CAPACITY_CHANGE_REPORTED = 3,
    SDEV_EVT_SOFT_THRESHOLD_REACHED_REPORTED = 4,
    SDEV_EVT_MODE_PARAMETER_CHANGE_REPORTED = 5,
    SDEV_EVT_LUN_CHANGE_REPORTED = 6,
    SDEV_EVT_ALUA_STATE_CHANGE_REPORTED = 7,
    SDEV_EVT_POWER_ON_RESET_OCCURRED = 8,
    SDEV_EVT_FIRST = 1,
    SDEV_EVT_LAST = 8,
    SDEV_EVT_MAXBITS = 9,
};

enum scsi_device_state {
    SDEV_CREATED = 1,
    SDEV_RUNNING = 2,
    SDEV_CANCEL = 3,
    SDEV_DEL = 4,
    SDEV_QUIESCE = 5,
    SDEV_OFFLINE = 6,
    SDEV_TRANSPORT_OFFLINE = 7,
    SDEV_BLOCK = 8,
    SDEV_CREATED_BLOCK = 9,
};

enum scsi_devinfo_key {
    SCSI_DEVINFO_GLOBAL = 0,
    SCSI_DEVINFO_SPI = 1,
};

enum scsi_disposition {
    NEEDS_RETRY = 8193,
    SUCCESS = 8194,
    FAILED = 8195,
    QUEUED = 8196,
    SOFT_ERROR = 8197,
    ADD_TO_MLQUEUE = 8198,
    TIMEOUT_ERROR = 8199,
    SCSI_RETURN_NOT_HANDLED = 8200,
    FAST_IO_FAIL = 8201,
};

enum scsi_host_guard_type {
    SHOST_DIX_GUARD_CRC = 1,
    SHOST_DIX_GUARD_IP = 2,
};

enum scsi_host_prot_capabilities {
    SHOST_DIF_TYPE1_PROTECTION = 1,
    SHOST_DIF_TYPE2_PROTECTION = 2,
    SHOST_DIF_TYPE3_PROTECTION = 4,
    SHOST_DIX_TYPE0_PROTECTION = 8,
    SHOST_DIX_TYPE1_PROTECTION = 16,
    SHOST_DIX_TYPE2_PROTECTION = 32,
    SHOST_DIX_TYPE3_PROTECTION = 64,
};

enum scsi_host_state {
    SHOST_CREATED = 1,
    SHOST_RUNNING = 2,
    SHOST_CANCEL = 3,
    SHOST_DEL = 4,
    SHOST_RECOVERY = 5,
    SHOST_CANCEL_RECOVERY = 6,
    SHOST_DEL_RECOVERY = 7,
};

enum scsi_host_status {
    DID_OK = 0,
    DID_NO_CONNECT = 1,
    DID_BUS_BUSY = 2,
    DID_TIME_OUT = 3,
    DID_BAD_TARGET = 4,
    DID_ABORT = 5,
    DID_PARITY = 6,
    DID_ERROR = 7,
    DID_RESET = 8,
    DID_BAD_INTR = 9,
    DID_PASSTHROUGH = 10,
    DID_SOFT_ERROR = 11,
    DID_IMM_RETRY = 12,
    DID_REQUEUE = 13,
    DID_TRANSPORT_DISRUPTED = 14,
    DID_TRANSPORT_FAILFAST = 15,
    DID_TRANSPORT_MARGINAL = 20,
};

enum scsi_ml_status {
    SCSIML_STAT_OK = 0,
    SCSIML_STAT_RESV_CONFLICT = 1,
    SCSIML_STAT_NOSPC = 2,
    SCSIML_STAT_MED_ERROR = 3,
    SCSIML_STAT_TGT_FAILURE = 4,
    SCSIML_STAT_DL_TIMEOUT = 5,
};

enum scsi_msg_byte {
    COMMAND_COMPLETE = 0,
    EXTENDED_MESSAGE = 1,
    SAVE_POINTERS = 2,
    RESTORE_POINTERS = 3,
    DISCONNECT = 4,
    INITIATOR_ERROR = 5,
    ABORT_TASK_SET = 6,
    MESSAGE_REJECT = 7,
    NOP = 8,
    MSG_PARITY_ERROR = 9,
    LINKED_CMD_COMPLETE = 10,
    LINKED_FLG_CMD_COMPLETE = 11,
    TARGET_RESET = 12,
    ABORT_TASK = 13,
    CLEAR_TASK_SET = 14,
    INITIATE_RECOVERY = 15,
    RELEASE_RECOVERY = 16,
    TERMINATE_IO_PROC = 17,
    CLEAR_ACA = 22,
    LOGICAL_UNIT_RESET = 23,
    SIMPLE_QUEUE_TAG = 32,
    HEAD_OF_QUEUE_TAG = 33,
    ORDERED_QUEUE_TAG = 34,
    IGNORE_WIDE_RESIDUE = 35,
    ACA = 36,
    QAS_REQUEST = 85,
    BUS_DEVICE_RESET = 12,
    ABORT = 6,
};

enum scsi_pr_type {
    SCSI_PR_WRITE_EXCLUSIVE = 1,
    SCSI_PR_EXCLUSIVE_ACCESS = 3,
    SCSI_PR_WRITE_EXCLUSIVE_REG_ONLY = 5,
    SCSI_PR_EXCLUSIVE_ACCESS_REG_ONLY = 6,
    SCSI_PR_WRITE_EXCLUSIVE_ALL_REGS = 7,
    SCSI_PR_EXCLUSIVE_ACCESS_ALL_REGS = 8,
};

enum scsi_prot_flags {
    SCSI_PROT_TRANSFER_PI = 1,
    SCSI_PROT_GUARD_CHECK = 2,
    SCSI_PROT_REF_CHECK = 4,
    SCSI_PROT_REF_INCREMENT = 8,
    SCSI_PROT_IP_CHECKSUM = 16,
};

enum scsi_prot_operations {
    SCSI_PROT_NORMAL = 0,
    SCSI_PROT_READ_INSERT = 1,
    SCSI_PROT_WRITE_STRIP = 2,
    SCSI_PROT_READ_STRIP = 3,
    SCSI_PROT_WRITE_INSERT = 4,
    SCSI_PROT_READ_PASS = 5,
    SCSI_PROT_WRITE_PASS = 6,
};

enum scsi_scan_mode {
    SCSI_SCAN_INITIAL = 0,
    SCSI_SCAN_RESCAN = 1,
    SCSI_SCAN_MANUAL = 2,
};

enum scsi_target_state {
    STARGET_CREATED = 1,
    STARGET_RUNNING = 2,
    STARGET_REMOVE = 3,
    STARGET_CREATED_REMOVE = 4,
    STARGET_DEL = 5,
};

enum scsi_timeout_action {
    SCSI_EH_DONE = 0,
    SCSI_EH_RESET_TIMER = 1,
    SCSI_EH_NOT_HANDLED = 2,
};

enum scsi_timeouts {
    SCSI_DEFAULT_EH_TIMEOUT = 10000,
};

enum scsi_vpd_parameters {
    SCSI_VPD_HEADER_SIZE = 4,
    SCSI_VPD_LIST_SIZE = 36,
};

enum sctp_cid {
    SCTP_CID_DATA = 0,
    SCTP_CID_INIT = 1,
    SCTP_CID_INIT_ACK = 2,
    SCTP_CID_SACK = 3,
    SCTP_CID_HEARTBEAT = 4,
    SCTP_CID_HEARTBEAT_ACK = 5,
    SCTP_CID_ABORT = 6,
    SCTP_CID_SHUTDOWN = 7,
    SCTP_CID_SHUTDOWN_ACK = 8,
    SCTP_CID_ERROR = 9,
    SCTP_CID_COOKIE_ECHO = 10,
    SCTP_CID_COOKIE_ACK = 11,
    SCTP_CID_ECN_ECNE = 12,
    SCTP_CID_ECN_CWR = 13,
    SCTP_CID_SHUTDOWN_COMPLETE = 14,
    SCTP_CID_AUTH = 15,
    SCTP_CID_I_DATA = 64,
    SCTP_CID_FWD_TSN = 192,
    SCTP_CID_ASCONF = 193,
    SCTP_CID_I_FWD_TSN = 194,
    SCTP_CID_ASCONF_ACK = 128,
    SCTP_CID_RECONF = 130,
    SCTP_CID_PAD = 132,
};

enum sctp_conntrack {
    SCTP_CONNTRACK_NONE = 0,
    SCTP_CONNTRACK_CLOSED = 1,
    SCTP_CONNTRACK_COOKIE_WAIT = 2,
    SCTP_CONNTRACK_COOKIE_ECHOED = 3,
    SCTP_CONNTRACK_ESTABLISHED = 4,
    SCTP_CONNTRACK_SHUTDOWN_SENT = 5,
    SCTP_CONNTRACK_SHUTDOWN_RECD = 6,
    SCTP_CONNTRACK_SHUTDOWN_ACK_SENT = 7,
    SCTP_CONNTRACK_HEARTBEAT_SENT = 8,
    SCTP_CONNTRACK_HEARTBEAT_ACKED = 9,
    SCTP_CONNTRACK_MAX = 10,
};

enum sctp_endpoint_type {
    SCTP_EP_TYPE_SOCKET = 0,
    SCTP_EP_TYPE_ASSOCIATION = 1,
};

enum sctp_event_timeout {
    SCTP_EVENT_TIMEOUT_NONE = 0,
    SCTP_EVENT_TIMEOUT_T1_COOKIE = 1,
    SCTP_EVENT_TIMEOUT_T1_INIT = 2,
    SCTP_EVENT_TIMEOUT_T2_SHUTDOWN = 3,
    SCTP_EVENT_TIMEOUT_T3_RTX = 4,
    SCTP_EVENT_TIMEOUT_T4_RTO = 5,
    SCTP_EVENT_TIMEOUT_T5_SHUTDOWN_GUARD = 6,
    SCTP_EVENT_TIMEOUT_HEARTBEAT = 7,
    SCTP_EVENT_TIMEOUT_RECONF = 8,
    SCTP_EVENT_TIMEOUT_PROBE = 9,
    SCTP_EVENT_TIMEOUT_SACK = 10,
    SCTP_EVENT_TIMEOUT_AUTOCLOSE = 11,
};

enum sctp_msg_flags {
    MSG_NOTIFICATION = 32768,
};

enum sctp_param {
    SCTP_PARAM_HEARTBEAT_INFO = 256,
    SCTP_PARAM_IPV4_ADDRESS = 1280,
    SCTP_PARAM_IPV6_ADDRESS = 1536,
    SCTP_PARAM_STATE_COOKIE = 1792,
    SCTP_PARAM_UNRECOGNIZED_PARAMETERS = 2048,
    SCTP_PARAM_COOKIE_PRESERVATIVE = 2304,
    SCTP_PARAM_HOST_NAME_ADDRESS = 2816,
    SCTP_PARAM_SUPPORTED_ADDRESS_TYPES = 3072,
    SCTP_PARAM_ECN_CAPABLE = 128,
    SCTP_PARAM_RANDOM = 640,
    SCTP_PARAM_CHUNKS = 896,
    SCTP_PARAM_HMAC_ALGO = 1152,
    SCTP_PARAM_SUPPORTED_EXT = 2176,
    SCTP_PARAM_FWD_TSN_SUPPORT = 192,
    SCTP_PARAM_ADD_IP = 448,
    SCTP_PARAM_DEL_IP = 704,
    SCTP_PARAM_ERR_CAUSE = 960,
    SCTP_PARAM_SET_PRIMARY = 1216,
    SCTP_PARAM_SUCCESS_REPORT = 1472,
    SCTP_PARAM_ADAPTATION_LAYER_IND = 1728,
    SCTP_PARAM_RESET_OUT_REQUEST = 3328,
    SCTP_PARAM_RESET_IN_REQUEST = 3584,
    SCTP_PARAM_RESET_TSN_REQUEST = 3840,
    SCTP_PARAM_RESET_RESPONSE = 4096,
    SCTP_PARAM_RESET_ADD_OUT_STREAMS = 4352,
    SCTP_PARAM_RESET_ADD_IN_STREAMS = 4608,
};

enum sctp_scope {
    SCTP_SCOPE_GLOBAL = 0,
    SCTP_SCOPE_PRIVATE = 1,
    SCTP_SCOPE_LINK = 2,
    SCTP_SCOPE_LOOPBACK = 3,
    SCTP_SCOPE_UNUSABLE = 4,
};

enum sctp_socket_type {
    SCTP_SOCKET_UDP = 0,
    SCTP_SOCKET_UDP_HIGH_BANDWIDTH = 1,
    SCTP_SOCKET_TCP = 2,
};

enum sctp_state {
    SCTP_STATE_CLOSED = 0,
    SCTP_STATE_COOKIE_WAIT = 1,
    SCTP_STATE_COOKIE_ECHOED = 2,
    SCTP_STATE_ESTABLISHED = 3,
    SCTP_STATE_SHUTDOWN_PENDING = 4,
    SCTP_STATE_SHUTDOWN_SENT = 5,
    SCTP_STATE_SHUTDOWN_RECEIVED = 6,
    SCTP_STATE_SHUTDOWN_ACK_SENT = 7,
};

enum scx_consts {
    SCX_DSP_DFL_MAX_BATCH = 32,
    SCX_DSP_MAX_LOOPS = 32,
    SCX_WATCHDOG_MAX_TIMEOUT = 30000,
    SCX_EXIT_BT_LEN = 64,
    SCX_EXIT_MSG_LEN = 1024,
    SCX_EXIT_DUMP_DFL_LEN = 32768,
    SCX_CPUPERF_ONE = 1024,
    SCX_OPS_TASK_ITER_BATCH = 32,
};

enum scx_cpu_preempt_reason {
    SCX_CPU_PREEMPT_RT = 0,
    SCX_CPU_PREEMPT_DL = 1,
    SCX_CPU_PREEMPT_STOP = 2,
    SCX_CPU_PREEMPT_UNKNOWN = 3,
};

enum scx_deq_flags {
    SCX_DEQ_SLEEP = 1ULL,
    SCX_DEQ_CORE_SCHED_EXEC = 4294967296ULL,
};

enum scx_dsq_id_flags {
    SCX_DSQ_FLAG_BUILTIN = 9223372036854775808ULL,
    SCX_DSQ_FLAG_LOCAL_ON = 4611686018427387904ULL,
    SCX_DSQ_INVALID = 9223372036854775808ULL,
    SCX_DSQ_GLOBAL = 9223372036854775809ULL,
    SCX_DSQ_LOCAL = 9223372036854775810ULL,
    SCX_DSQ_LOCAL_ON = 13835058055282163712ULL,
    SCX_DSQ_LOCAL_CPU_MASK = 4294967295ULL,
};

enum scx_dsq_iter_flags {
    SCX_DSQ_ITER_REV = 65536,
    __SCX_DSQ_ITER_HAS_SLICE = 1073741824,
    __SCX_DSQ_ITER_HAS_VTIME = 2147483648,
    __SCX_DSQ_ITER_USER_FLAGS = 65536,
    __SCX_DSQ_ITER_ALL_FLAGS = 3221291008,
};

enum scx_dsq_lnode_flags {
    SCX_DSQ_LNODE_ITER_CURSOR = 1,
    __SCX_DSQ_LNODE_PRIV_SHIFT = 16,
};

enum scx_enq_flags {
    SCX_ENQ_WAKEUP = 1ULL,
    SCX_ENQ_HEAD = 16ULL,
    SCX_ENQ_CPU_SELECTED = 1024ULL,
    SCX_ENQ_PREEMPT = 4294967296ULL,
    SCX_ENQ_REENQ = 1099511627776ULL,
    SCX_ENQ_LAST = 2199023255552ULL,
    __SCX_ENQ_INTERNAL_MASK = 18374686479671623680ULL,
    SCX_ENQ_CLEAR_OPSS = 72057594037927936ULL,
    SCX_ENQ_DSQ_PRIQ = 144115188075855872ULL,
};

enum scx_ent_dsq_flags {
    SCX_TASK_DSQ_ON_PRIQ = 1,
};

enum scx_ent_flags {
    SCX_TASK_QUEUED = 1,
    SCX_TASK_RESET_RUNNABLE_AT = 4,
    SCX_TASK_DEQD_FOR_SLEEP = 8,
    SCX_TASK_STATE_SHIFT = 8,
    SCX_TASK_STATE_BITS = 2,
    SCX_TASK_STATE_MASK = 768,
    SCX_TASK_CURSOR = -2147483648,
};

enum scx_exit_code {
    SCX_ECODE_RSN_HOTPLUG = 4294967296ULL,
    SCX_ECODE_ACT_RESTART = 281474976710656ULL,
};

enum scx_exit_kind {
    SCX_EXIT_NONE = 0,
    SCX_EXIT_DONE = 1,
    SCX_EXIT_UNREG = 64,
    SCX_EXIT_UNREG_BPF = 65,
    SCX_EXIT_UNREG_KERN = 66,
    SCX_EXIT_SYSRQ = 67,
    SCX_EXIT_ERROR = 1024,
    SCX_EXIT_ERROR_BPF = 1025,
    SCX_EXIT_ERROR_STALL = 1026,
};

enum scx_kf_mask {
    SCX_KF_UNLOCKED = 0,
    SCX_KF_CPU_RELEASE = 1,
    SCX_KF_DISPATCH = 2,
    SCX_KF_ENQUEUE = 4,
    SCX_KF_SELECT_CPU = 8,
    SCX_KF_REST = 16,
    __SCX_KF_RQ_LOCKED = 31,
    __SCX_KF_TERMINAL = 28,
};

enum scx_kick_flags {
    SCX_KICK_IDLE = 1,
    SCX_KICK_PREEMPT = 2,
    SCX_KICK_WAIT = 4,
};

enum scx_opi {
    SCX_OPI_BEGIN = 0,
    SCX_OPI_NORMAL_BEGIN = 0,
    SCX_OPI_NORMAL_END = 29,
    SCX_OPI_CPU_HOTPLUG_BEGIN = 29,
    SCX_OPI_CPU_HOTPLUG_END = 31,
    SCX_OPI_END = 31,
};

enum scx_ops_enable_state {
    SCX_OPS_ENABLING = 0,
    SCX_OPS_ENABLED = 1,
    SCX_OPS_DISABLING = 2,
    SCX_OPS_DISABLED = 3,
};

enum scx_ops_flags {
    SCX_OPS_KEEP_BUILTIN_IDLE = 1,
    SCX_OPS_ENQ_LAST = 2,
    SCX_OPS_ENQ_EXITING = 4,
    SCX_OPS_SWITCH_PARTIAL = 8,
    SCX_OPS_ENQ_MIGRATION_DISABLED = 16,
    SCX_OPS_HAS_CGROUP_WEIGHT = 65536,
    SCX_OPS_ALL_FLAGS = 65567,
};

enum scx_ops_state {
    SCX_OPSS_NONE = 0,
    SCX_OPSS_QUEUEING = 1,
    SCX_OPSS_QUEUED = 2,
    SCX_OPSS_DISPATCHING = 3,
    SCX_OPSS_QSEQ_SHIFT = 2,
};

enum scx_pick_idle_cpu_flags {
    SCX_PICK_IDLE_CORE = 1,
};

enum scx_public_consts {
    SCX_OPS_NAME_LEN = 128ULL,
    SCX_SLICE_DFL = 20000000ULL,
    SCX_SLICE_INF = 18446744073709551615ULL,
};

enum scx_rq_flags {
    SCX_RQ_ONLINE = 1,
    SCX_RQ_CAN_STOP_TICK = 2,
    SCX_RQ_BAL_PENDING = 4,
    SCX_RQ_BAL_KEEP = 8,
    SCX_RQ_BYPASSING = 16,
    SCX_RQ_CLK_VALID = 32,
    SCX_RQ_IN_WAKEUP = 65536,
    SCX_RQ_IN_BALANCE = 131072,
};

enum scx_task_state {
    SCX_TASK_NONE = 0,
    SCX_TASK_INIT = 1,
    SCX_TASK_READY = 2,
    SCX_TASK_ENABLED = 3,
    SCX_TASK_NR_STATES = 4,
};

enum scx_tg_flags {
    SCX_TG_ONLINE = 1,
    SCX_TG_INITED = 2,
};

enum scx_wake_flags {
    SCX_WAKE_FORK = 4,
    SCX_WAKE_TTWU = 8,
    SCX_WAKE_SYNC = 16,
};

enum sd_uhs2_operation {
    UHS2_PHY_INIT = 0,
    UHS2_SET_CONFIG = 1,
    UHS2_ENABLE_INT = 2,
    UHS2_DISABLE_INT = 3,
    UHS2_ENABLE_CLK = 4,
    UHS2_DISABLE_CLK = 5,
    UHS2_CHECK_DORMANT = 6,
    UHS2_SET_IOS = 7,
};

enum sdhci_cookie {
    COOKIE_UNMAPPED = 0,
    COOKIE_PRE_MAPPED = 1,
    COOKIE_MAPPED = 2,
};

enum sdhci_reset_reason {
    SDHCI_RESET_FOR_INIT = 0,
    SDHCI_RESET_FOR_REQUEST_ERROR = 1,
    SDHCI_RESET_FOR_REQUEST_ERROR_DATA_ONLY = 2,
    SDHCI_RESET_FOR_TUNING_ABORT = 3,
    SDHCI_RESET_FOR_CARD_REMOVED = 4,
    SDHCI_RESET_FOR_CQE_RECOVERY = 5,
};

enum seg6_end_dt_mode {
    DT_INVALID_MODE = -22,
    DT_LEGACY_MODE = 0,
    DT_VRF_MODE = 1,
};

enum seg6_local_flv_action {
    SEG6_LOCAL_FLV_ACT_UNSPEC = 0,
    SEG6_LOCAL_FLV_ACT_END = 1,
    SEG6_LOCAL_FLV_ACT_PSP = 2,
    SEG6_LOCAL_FLV_ACT_USP = 3,
    SEG6_LOCAL_FLV_ACT_USD = 4,
    __SEG6_LOCAL_FLV_ACT_MAX = 5,
};

enum seg6_local_pktinfo {
    SEG6_LOCAL_PKTINFO_NOHDR = 0,
    SEG6_LOCAL_PKTINFO_SL_ZERO = 1,
    SEG6_LOCAL_PKTINFO_SL_ONE = 2,
    SEG6_LOCAL_PKTINFO_SL_MORE = 3,
    __SEG6_LOCAL_PKTINFO_MAX = 4,
};

enum sel_inos {
    SEL_ROOT_INO = 2,
    SEL_LOAD = 3,
    SEL_ENFORCE = 4,
    SEL_CONTEXT = 5,
    SEL_ACCESS = 6,
    SEL_CREATE = 7,
    SEL_RELABEL = 8,
    SEL_USER = 9,
    SEL_POLICYVERS = 10,
    SEL_COMMIT_BOOLS = 11,
    SEL_MLS = 12,
    SEL_DISABLE = 13,
    SEL_MEMBER = 14,
    SEL_CHECKREQPROT = 15,
    SEL_COMPAT_NET = 16,
    SEL_REJECT_UNKNOWN = 17,
    SEL_DENY_UNKNOWN = 18,
    SEL_STATUS = 19,
    SEL_POLICY = 20,
    SEL_VALIDATE_TRANS = 21,
    SEL_INO_NEXT = 22,
};

enum selinux_nlgroups {
    SELNLGRP_NONE = 0,
    SELNLGRP_AVC = 1,
    __SELNLGRP_MAX = 2,
};

enum serdev_parity {
    SERDEV_PARITY_NONE = 0,
    SERDEV_PARITY_EVEN = 1,
    SERDEV_PARITY_ODD = 2,
};

enum set_event_iter_type {
    SET_EVENT_FILE = 0,
    SET_EVENT_MOD = 1,
};

enum setid_type {
    UID = 0,
    GID = 1,
};

enum sgp_type {
    SGP_READ = 0,
    SGP_NOALLOC = 1,
    SGP_CACHE = 2,
    SGP_WRITE = 3,
    SGP_FALLOC = 4,
};

enum shmem_param {
    Opt_gid___7 = 0,
    Opt_huge = 1,
    Opt_mode___6 = 2,
    Opt_mpol = 3,
    Opt_nr_blocks = 4,
    Opt_nr_inodes___2 = 5,
    Opt_size___2 = 6,
    Opt_uid___6 = 7,
    Opt_inode32 = 8,
    Opt_inode64 = 9,
    Opt_noswap = 10,
    Opt_quota___2 = 11,
    Opt_usrquota___2 = 12,
    Opt_grpquota___2 = 13,
    Opt_usrquota_block_hardlimit = 14,
    Opt_usrquota_inode_hardlimit = 15,
    Opt_grpquota_block_hardlimit = 16,
    Opt_grpquota_inode_hardlimit = 17,
    Opt_casefold_version = 18,
    Opt_casefold = 19,
    Opt_strict_encoding = 20,
};

enum sid_policy_type {
    SIDPOL_DEFAULT = 0,
    SIDPOL_CONSTRAINED = 1,
    SIDPOL_ALLOWED = 2,
};

enum sig_handler {
    HANDLER_CURRENT = 0,
    HANDLER_SIG_DFL = 1,
    HANDLER_EXIT = 2,
};

enum siginfo_layout {
    SIL_KILL = 0,
    SIL_TIMER = 1,
    SIL_POLL = 2,
    SIL_FAULT = 3,
    SIL_FAULT_TRAPNO = 4,
    SIL_FAULT_MCEERR = 5,
    SIL_FAULT_BNDERR = 6,
    SIL_FAULT_PKUERR = 7,
    SIL_FAULT_PERF_EVENT = 8,
    SIL_CHLD = 9,
    SIL_RT = 10,
    SIL_SYS = 11,
};

enum sk_action {
    SK_DROP = 0,
    SK_PASS = 1,
};

enum sk_pacing {
    SK_PACING_NONE = 0,
    SK_PACING_NEEDED = 1,
    SK_PACING_FQ = 2,
};

enum sk_psock_state_bits {
    SK_PSOCK_TX_ENABLED = 0,
    SK_PSOCK_RX_STRP_ENABLED = 1,
};

enum sk_rst_reason {
    SK_RST_REASON_NOT_SPECIFIED = 0,
    SK_RST_REASON_NO_SOCKET = 1,
    SK_RST_REASON_TCP_INVALID_ACK_SEQUENCE = 2,
    SK_RST_REASON_TCP_RFC7323_PAWS = 3,
    SK_RST_REASON_TCP_TOO_OLD_ACK = 4,
    SK_RST_REASON_TCP_ACK_UNSENT_DATA = 5,
    SK_RST_REASON_TCP_FLAGS = 6,
    SK_RST_REASON_TCP_OLD_ACK = 7,
    SK_RST_REASON_TCP_ABORT_ON_DATA = 8,
    SK_RST_REASON_TCP_TIMEWAIT_SOCKET = 9,
    SK_RST_REASON_INVALID_SYN = 10,
    SK_RST_REASON_TCP_ABORT_ON_CLOSE = 11,
    SK_RST_REASON_TCP_ABORT_ON_LINGER = 12,
    SK_RST_REASON_TCP_ABORT_ON_MEMORY = 13,
    SK_RST_REASON_TCP_STATE = 14,
    SK_RST_REASON_TCP_KEEPALIVE_TIMEOUT = 15,
    SK_RST_REASON_TCP_DISCONNECT_WITH_DATA = 16,
    SK_RST_REASON_MPTCP_RST_EUNSPEC = 17,
    SK_RST_REASON_MPTCP_RST_EMPTCP = 18,
    SK_RST_REASON_MPTCP_RST_ERESOURCE = 19,
    SK_RST_REASON_MPTCP_RST_EPROHIBIT = 20,
    SK_RST_REASON_MPTCP_RST_EWQ2BIG = 21,
    SK_RST_REASON_MPTCP_RST_EBADPERF = 22,
    SK_RST_REASON_MPTCP_RST_EMIDDLEBOX = 23,
    SK_RST_REASON_ERROR = 24,
    SK_RST_REASON_MAX = 25,
};

enum skb_drop_reason {
    SKB_NOT_DROPPED_YET = 0,
    SKB_CONSUMED = 1,
    SKB_DROP_REASON_NOT_SPECIFIED = 2,
    SKB_DROP_REASON_NO_SOCKET = 3,
    SKB_DROP_REASON_SOCKET_CLOSE = 4,
    SKB_DROP_REASON_SOCKET_FILTER = 5,
    SKB_DROP_REASON_SOCKET_RCVBUFF = 6,
    SKB_DROP_REASON_UNIX_DISCONNECT = 7,
    SKB_DROP_REASON_UNIX_SKIP_OOB = 8,
    SKB_DROP_REASON_PKT_TOO_SMALL = 9,
    SKB_DROP_REASON_TCP_CSUM = 10,
    SKB_DROP_REASON_UDP_CSUM = 11,
    SKB_DROP_REASON_NETFILTER_DROP = 12,
    SKB_DROP_REASON_OTHERHOST = 13,
    SKB_DROP_REASON_IP_CSUM = 14,
    SKB_DROP_REASON_IP_INHDR = 15,
    SKB_DROP_REASON_IP_RPFILTER = 16,
    SKB_DROP_REASON_UNICAST_IN_L2_MULTICAST = 17,
    SKB_DROP_REASON_XFRM_POLICY = 18,
    SKB_DROP_REASON_IP_NOPROTO = 19,
    SKB_DROP_REASON_PROTO_MEM = 20,
    SKB_DROP_REASON_TCP_AUTH_HDR = 21,
    SKB_DROP_REASON_TCP_MD5NOTFOUND = 22,
    SKB_DROP_REASON_TCP_MD5UNEXPECTED = 23,
    SKB_DROP_REASON_TCP_MD5FAILURE = 24,
    SKB_DROP_REASON_TCP_AONOTFOUND = 25,
    SKB_DROP_REASON_TCP_AOUNEXPECTED = 26,
    SKB_DROP_REASON_TCP_AOKEYNOTFOUND = 27,
    SKB_DROP_REASON_TCP_AOFAILURE = 28,
    SKB_DROP_REASON_SOCKET_BACKLOG = 29,
    SKB_DROP_REASON_TCP_FLAGS = 30,
    SKB_DROP_REASON_TCP_ABORT_ON_DATA = 31,
    SKB_DROP_REASON_TCP_ZEROWINDOW = 32,
    SKB_DROP_REASON_TCP_OLD_DATA = 33,
    SKB_DROP_REASON_TCP_OVERWINDOW = 34,
    SKB_DROP_REASON_TCP_OFOMERGE = 35,
    SKB_DROP_REASON_TCP_RFC7323_PAWS = 36,
    SKB_DROP_REASON_TCP_RFC7323_PAWS_ACK = 37,
    SKB_DROP_REASON_TCP_OLD_SEQUENCE = 38,
    SKB_DROP_REASON_TCP_INVALID_SEQUENCE = 39,
    SKB_DROP_REASON_TCP_INVALID_ACK_SEQUENCE = 40,
    SKB_DROP_REASON_TCP_RESET = 41,
    SKB_DROP_REASON_TCP_INVALID_SYN = 42,
    SKB_DROP_REASON_TCP_CLOSE = 43,
    SKB_DROP_REASON_TCP_FASTOPEN = 44,
    SKB_DROP_REASON_TCP_OLD_ACK = 45,
    SKB_DROP_REASON_TCP_TOO_OLD_ACK = 46,
    SKB_DROP_REASON_TCP_ACK_UNSENT_DATA = 47,
    SKB_DROP_REASON_TCP_OFO_QUEUE_PRUNE = 48,
    SKB_DROP_REASON_TCP_OFO_DROP = 49,
    SKB_DROP_REASON_IP_OUTNOROUTES = 50,
    SKB_DROP_REASON_BPF_CGROUP_EGRESS = 51,
    SKB_DROP_REASON_IPV6DISABLED = 52,
    SKB_DROP_REASON_NEIGH_CREATEFAIL = 53,
    SKB_DROP_REASON_NEIGH_FAILED = 54,
    SKB_DROP_REASON_NEIGH_QUEUEFULL = 55,
    SKB_DROP_REASON_NEIGH_DEAD = 56,
    SKB_DROP_REASON_TC_EGRESS = 57,
    SKB_DROP_REASON_SECURITY_HOOK = 58,
    SKB_DROP_REASON_QDISC_DROP = 59,
    SKB_DROP_REASON_QDISC_OVERLIMIT = 60,
    SKB_DROP_REASON_QDISC_CONGESTED = 61,
    SKB_DROP_REASON_CAKE_FLOOD = 62,
    SKB_DROP_REASON_FQ_BAND_LIMIT = 63,
    SKB_DROP_REASON_FQ_HORIZON_LIMIT = 64,
    SKB_DROP_REASON_FQ_FLOW_LIMIT = 65,
    SKB_DROP_REASON_CPU_BACKLOG = 66,
    SKB_DROP_REASON_XDP = 67,
    SKB_DROP_REASON_TC_INGRESS = 68,
    SKB_DROP_REASON_UNHANDLED_PROTO = 69,
    SKB_DROP_REASON_SKB_CSUM = 70,
    SKB_DROP_REASON_SKB_GSO_SEG = 71,
    SKB_DROP_REASON_SKB_UCOPY_FAULT = 72,
    SKB_DROP_REASON_DEV_HDR = 73,
    SKB_DROP_REASON_DEV_READY = 74,
    SKB_DROP_REASON_FULL_RING = 75,
    SKB_DROP_REASON_NOMEM = 76,
    SKB_DROP_REASON_HDR_TRUNC = 77,
    SKB_DROP_REASON_TAP_FILTER = 78,
    SKB_DROP_REASON_TAP_TXFILTER = 79,
    SKB_DROP_REASON_ICMP_CSUM = 80,
    SKB_DROP_REASON_INVALID_PROTO = 81,
    SKB_DROP_REASON_IP_INADDRERRORS = 82,
    SKB_DROP_REASON_IP_INNOROUTES = 83,
    SKB_DROP_REASON_IP_LOCAL_SOURCE = 84,
    SKB_DROP_REASON_IP_INVALID_SOURCE = 85,
    SKB_DROP_REASON_IP_LOCALNET = 86,
    SKB_DROP_REASON_IP_INVALID_DEST = 87,
    SKB_DROP_REASON_PKT_TOO_BIG = 88,
    SKB_DROP_REASON_DUP_FRAG = 89,
    SKB_DROP_REASON_FRAG_REASM_TIMEOUT = 90,
    SKB_DROP_REASON_FRAG_TOO_FAR = 91,
    SKB_DROP_REASON_TCP_MINTTL = 92,
    SKB_DROP_REASON_IPV6_BAD_EXTHDR = 93,
    SKB_DROP_REASON_IPV6_NDISC_FRAG = 94,
    SKB_DROP_REASON_IPV6_NDISC_HOP_LIMIT = 95,
    SKB_DROP_REASON_IPV6_NDISC_BAD_CODE = 96,
    SKB_DROP_REASON_IPV6_NDISC_BAD_OPTIONS = 97,
    SKB_DROP_REASON_IPV6_NDISC_NS_OTHERHOST = 98,
    SKB_DROP_REASON_QUEUE_PURGE = 99,
    SKB_DROP_REASON_TC_COOKIE_ERROR = 100,
    SKB_DROP_REASON_PACKET_SOCK_ERROR = 101,
    SKB_DROP_REASON_TC_CHAIN_NOTFOUND = 102,
    SKB_DROP_REASON_TC_RECLASSIFY_LOOP = 103,
    SKB_DROP_REASON_VXLAN_INVALID_HDR = 104,
    SKB_DROP_REASON_VXLAN_VNI_NOT_FOUND = 105,
    SKB_DROP_REASON_MAC_INVALID_SOURCE = 106,
    SKB_DROP_REASON_VXLAN_ENTRY_EXISTS = 107,
    SKB_DROP_REASON_NO_TX_TARGET = 108,
    SKB_DROP_REASON_IP_TUNNEL_ECN = 109,
    SKB_DROP_REASON_TUNNEL_TXINFO = 110,
    SKB_DROP_REASON_LOCAL_MAC = 111,
    SKB_DROP_REASON_ARP_PVLAN_DISABLE = 112,
    SKB_DROP_REASON_MAC_IEEE_MAC_CONTROL = 113,
    SKB_DROP_REASON_BRIDGE_INGRESS_STP_STATE = 114,
    SKB_DROP_REASON_MAX = 115,
    SKB_DROP_REASON_SUBSYS_MASK = 4294901760,
};

enum skb_drop_reason_subsys {
    SKB_DROP_REASON_SUBSYS_CORE = 0,
    SKB_DROP_REASON_SUBSYS_MAC80211_UNUSABLE = 1,
    SKB_DROP_REASON_SUBSYS_MAC80211_MONITOR = 2,
    SKB_DROP_REASON_SUBSYS_OPENVSWITCH = 3,
    SKB_DROP_REASON_SUBSYS_NUM = 4,
};

enum skb_ext_id {
    SKB_EXT_BRIDGE_NF = 0,
    SKB_EXT_SEC_PATH = 1,
    SKB_EXT_MPTCP = 2,
    SKB_EXT_NUM = 3,
};

enum skb_state {
    illegal = 0,
    tx_start = 1,
    tx_done = 2,
    rx_start = 3,
    rx_done = 4,
    rx_cleanup = 5,
    unlink_start = 6,
};

enum skb_tstamp_type {
    SKB_CLOCK_REALTIME = 0,
    SKB_CLOCK_MONOTONIC = 1,
    SKB_CLOCK_TAI = 2,
    __SKB_CLOCK_MAX = 2,
};

enum sknetlink_groups {
    SKNLGRP_NONE = 0,
    SKNLGRP_INET_TCP_DESTROY = 1,
    SKNLGRP_INET_UDP_DESTROY = 2,
    SKNLGRP_INET6_TCP_DESTROY = 3,
    SKNLGRP_INET6_UDP_DESTROY = 4,
    __SKNLGRP_MAX = 5,
};

enum slab_stat_type {
    SL_ALL = 0,
    SL_PARTIAL = 1,
    SL_CPU = 2,
    SL_OBJECTS = 3,
    SL_TOTAL = 4,
};

enum slab_state {
    DOWN = 0,
    PARTIAL = 1,
    UP = 2,
    FULL = 3,
};

enum smbios_attr_enum {
    SMBIOS_ATTR_NONE = 0,
    SMBIOS_ATTR_LABEL_SHOW = 1,
    SMBIOS_ATTR_INSTANCE_SHOW = 2,
};

enum smk_inos {
    SMK_ROOT_INO = 2,
    SMK_LOAD = 3,
    SMK_CIPSO = 4,
    SMK_DOI = 5,
    SMK_DIRECT = 6,
    SMK_AMBIENT = 7,
    SMK_NET4ADDR = 8,
    SMK_ONLYCAP = 9,
    SMK_LOGGING = 10,
    SMK_LOAD_SELF = 11,
    SMK_ACCESSES = 12,
    SMK_MAPPED = 13,
    SMK_LOAD2 = 14,
    SMK_LOAD_SELF2 = 15,
    SMK_ACCESS2 = 16,
    SMK_CIPSO2 = 17,
    SMK_REVOKE_SUBJ = 18,
    SMK_CHANGE_RULE = 19,
    SMK_SYSLOG = 20,
    SMK_PTRACE = 21,
    SMK_NET6ADDR = 23,
    SMK_RELABEL_SELF = 24,
};

enum snoop_when {
    SUBMIT = 0,
    COMPLETE = 1,
};

enum sock_flags {
    SOCK_DEAD = 0,
    SOCK_DONE = 1,
    SOCK_URGINLINE = 2,
    SOCK_KEEPOPEN = 3,
    SOCK_LINGER = 4,
    SOCK_DESTROY = 5,
    SOCK_BROADCAST = 6,
    SOCK_TIMESTAMP = 7,
    SOCK_ZAPPED = 8,
    SOCK_USE_WRITE_QUEUE = 9,
    SOCK_DBG = 10,
    SOCK_RCVTSTAMP = 11,
    SOCK_RCVTSTAMPNS = 12,
    SOCK_LOCALROUTE = 13,
    SOCK_MEMALLOC = 14,
    SOCK_TIMESTAMPING_RX_SOFTWARE = 15,
    SOCK_FASYNC = 16,
    SOCK_RXQ_OVFL = 17,
    SOCK_ZEROCOPY = 18,
    SOCK_WIFI_STATUS = 19,
    SOCK_NOFCS = 20,
    SOCK_FILTER_LOCKED = 21,
    SOCK_SELECT_ERR_QUEUE = 22,
    SOCK_RCU_FREE = 23,
    SOCK_TXTIME = 24,
    SOCK_XDP = 25,
    SOCK_TSTAMP_NEW = 26,
    SOCK_RCVMARK = 27,
    SOCK_RCVPRIORITY = 28,
};

enum sock_shutdown_cmd {
    SHUT_RD = 0,
    SHUT_WR = 1,
    SHUT_RDWR = 2,
};

enum sock_type {
    SOCK_STREAM = 1,
    SOCK_DGRAM = 2,
    SOCK_RAW = 3,
    SOCK_RDM = 4,
    SOCK_SEQPACKET = 5,
    SOCK_DCCP = 6,
    SOCK_PACKET = 10,
};

enum special_kfunc_type {
    KF_bpf_obj_new_impl = 0,
    KF_bpf_obj_drop_impl = 1,
    KF_bpf_refcount_acquire_impl = 2,
    KF_bpf_list_push_front_impl = 3,
    KF_bpf_list_push_back_impl = 4,
    KF_bpf_list_pop_front = 5,
    KF_bpf_list_pop_back = 6,
    KF_bpf_cast_to_kern_ctx = 7,
    KF_bpf_rdonly_cast = 8,
    KF_bpf_rcu_read_lock = 9,
    KF_bpf_rcu_read_unlock = 10,
    KF_bpf_rbtree_remove = 11,
    KF_bpf_rbtree_add_impl = 12,
    KF_bpf_rbtree_first = 13,
    KF_bpf_dynptr_from_skb = 14,
    KF_bpf_dynptr_from_xdp = 15,
    KF_bpf_dynptr_slice = 16,
    KF_bpf_dynptr_slice_rdwr = 17,
    KF_bpf_dynptr_clone = 18,
    KF_bpf_percpu_obj_new_impl = 19,
    KF_bpf_percpu_obj_drop_impl = 20,
    KF_bpf_throw = 21,
    KF_bpf_wq_set_callback_impl = 22,
    KF_bpf_preempt_disable = 23,
    KF_bpf_preempt_enable = 24,
    KF_bpf_iter_css_task_new = 25,
    KF_bpf_session_cookie = 26,
    KF_bpf_get_kmem_cache = 27,
    KF_bpf_local_irq_save = 28,
    KF_bpf_local_irq_restore = 29,
    KF_bpf_iter_num_new = 30,
    KF_bpf_iter_num_next = 31,
    KF_bpf_iter_num_destroy = 32,
};

enum spectre_v4_policy {
    SPECTRE_V4_POLICY_MITIGATION_DYNAMIC = 0,
    SPECTRE_V4_POLICY_MITIGATION_ENABLED = 1,
    SPECTRE_V4_POLICY_MITIGATION_DISABLED = 2,
};

enum spi_mem_data_dir {
    SPI_MEM_NO_DATA = 0,
    SPI_MEM_DATA_IN = 1,
    SPI_MEM_DATA_OUT = 2,
};

enum squashfs_param {
    Opt_errors___3 = 0,
    Opt_threads = 1,
};

enum stat_group {
    STAT_READ = 0,
    STAT_WRITE = 1,
    STAT_DISCARD = 2,
    STAT_FLUSH = 3,
    NR_STAT_GROUPS = 4,
};

enum stat_item {
    ALLOC_FASTPATH = 0,
    ALLOC_SLOWPATH = 1,
    FREE_FASTPATH = 2,
    FREE_SLOWPATH = 3,
    FREE_FROZEN = 4,
    FREE_ADD_PARTIAL = 5,
    FREE_REMOVE_PARTIAL = 6,
    ALLOC_FROM_PARTIAL = 7,
    ALLOC_SLAB = 8,
    ALLOC_REFILL = 9,
    ALLOC_NODE_MISMATCH = 10,
    FREE_SLAB = 11,
    CPUSLAB_FLUSH = 12,
    DEACTIVATE_FULL = 13,
    DEACTIVATE_EMPTY = 14,
    DEACTIVATE_TO_HEAD = 15,
    DEACTIVATE_TO_TAIL = 16,
    DEACTIVATE_REMOTE_FREES = 17,
    DEACTIVATE_BYPASS = 18,
    ORDER_FALLBACK = 19,
    CMPXCHG_DOUBLE_CPU_FAIL = 20,
    CMPXCHG_DOUBLE_FAIL = 21,
    CPU_PARTIAL_ALLOC = 22,
    CPU_PARTIAL_FREE = 23,
    CPU_PARTIAL_NODE = 24,
    CPU_PARTIAL_DRAIN = 25,
    NR_SLUB_STAT_ITEMS = 26,
};

enum state {
    Start = 0,
    Collect = 1,
    GotHeader = 2,
    SkipIt = 3,
    GotName = 4,
    CopyFile = 5,
    GotSymlink = 6,
    Reset = 7,
};

enum stmpe_block {
    STMPE_BLOCK_GPIO = 1,
    STMPE_BLOCK_KEYPAD = 2,
    STMPE_BLOCK_TOUCHSCREEN = 4,
    STMPE_BLOCK_ADC = 8,
    STMPE_BLOCK_PWM = 16,
    STMPE_BLOCK_ROTATOR = 32,
};

enum stmpe_partnum {
    STMPE610 = 0,
    STMPE801 = 1,
    STMPE811 = 2,
    STMPE1600 = 3,
    STMPE1601 = 4,
    STMPE1801 = 5,
    STMPE2401 = 6,
    STMPE2403 = 7,
    STMPE_NBR_PARTS = 8,
};

enum store_type {
    wr_invalid = 0,
    wr_new_root = 1,
    wr_store_root = 2,
    wr_exact_fit = 3,
    wr_spanning_store = 4,
    wr_split_store = 5,
    wr_rebalance = 6,
    wr_append = 7,
    wr_node_store = 8,
    wr_slot_store = 9,
};

enum string_size_units {
    STRING_UNITS_10 = 0,
    STRING_UNITS_2 = 1,
    STRING_UNITS_MASK = 1,
    STRING_UNITS_NO_SPACE = 1073741824,
    STRING_UNITS_NO_BYTES = 2147483648,
};

enum subpixel_order {
    SubPixelUnknown = 0,
    SubPixelHorizontalRGB = 1,
    SubPixelHorizontalBGR = 2,
    SubPixelVerticalRGB = 3,
    SubPixelVerticalBGR = 4,
    SubPixelNone = 5,
};

enum sum_check_bits {
    SUM_CHECK_P = 0,
    SUM_CHECK_Q = 1,
};

enum sum_check_flags {
    SUM_CHECK_P_RESULT = 1,
    SUM_CHECK_Q_RESULT = 2,
};

enum support_mode {
    ALLOW_LEGACY = 0,
    DENY_LEGACY = 1,
};

enum svc_auth_status {
    SVC_GARBAGE = 1,
    SVC_SYSERR = 2,
    SVC_VALID = 3,
    SVC_NEGATIVE = 4,
    SVC_OK = 5,
    SVC_DROP = 6,
    SVC_CLOSE = 7,
    SVC_DENIED = 8,
    SVC_PENDING = 9,
    SVC_COMPLETE = 10,
};

enum swap_cluster_flags {
    CLUSTER_FLAG_NONE = 0,
    CLUSTER_FLAG_FREE = 1,
    CLUSTER_FLAG_NONFULL = 2,
    CLUSTER_FLAG_FRAG = 3,
    CLUSTER_FLAG_USABLE = 3,
    CLUSTER_FLAG_FULL = 4,
    CLUSTER_FLAG_DISCARD = 5,
    CLUSTER_FLAG_MAX = 6,
};

enum switch_power_state {
    DRM_SWITCH_POWER_ON = 0,
    DRM_SWITCH_POWER_OFF = 1,
    DRM_SWITCH_POWER_CHANGING = 2,
    DRM_SWITCH_POWER_DYNAMIC_OFF = 3,
};

enum switchdev_attr_id {
    SWITCHDEV_ATTR_ID_UNDEFINED = 0,
    SWITCHDEV_ATTR_ID_PORT_STP_STATE = 1,
    SWITCHDEV_ATTR_ID_PORT_MST_STATE = 2,
    SWITCHDEV_ATTR_ID_PORT_BRIDGE_FLAGS = 3,
    SWITCHDEV_ATTR_ID_PORT_PRE_BRIDGE_FLAGS = 4,
    SWITCHDEV_ATTR_ID_PORT_MROUTER = 5,
    SWITCHDEV_ATTR_ID_BRIDGE_AGEING_TIME = 6,
    SWITCHDEV_ATTR_ID_BRIDGE_VLAN_FILTERING = 7,
    SWITCHDEV_ATTR_ID_BRIDGE_VLAN_PROTOCOL = 8,
    SWITCHDEV_ATTR_ID_BRIDGE_MC_DISABLED = 9,
    SWITCHDEV_ATTR_ID_BRIDGE_MROUTER = 10,
    SWITCHDEV_ATTR_ID_BRIDGE_MST = 11,
    SWITCHDEV_ATTR_ID_MRP_PORT_ROLE = 12,
    SWITCHDEV_ATTR_ID_VLAN_MSTI = 13,
};

enum switchdev_notifier_type {
    SWITCHDEV_FDB_ADD_TO_BRIDGE = 1,
    SWITCHDEV_FDB_DEL_TO_BRIDGE = 2,
    SWITCHDEV_FDB_ADD_TO_DEVICE = 3,
    SWITCHDEV_FDB_DEL_TO_DEVICE = 4,
    SWITCHDEV_FDB_OFFLOADED = 5,
    SWITCHDEV_FDB_FLUSH_TO_BRIDGE = 6,
    SWITCHDEV_PORT_OBJ_ADD = 7,
    SWITCHDEV_PORT_OBJ_DEL = 8,
    SWITCHDEV_PORT_ATTR_SET = 9,
    SWITCHDEV_VXLAN_FDB_ADD_TO_BRIDGE = 10,
    SWITCHDEV_VXLAN_FDB_DEL_TO_BRIDGE = 11,
    SWITCHDEV_VXLAN_FDB_ADD_TO_DEVICE = 12,
    SWITCHDEV_VXLAN_FDB_DEL_TO_DEVICE = 13,
    SWITCHDEV_VXLAN_FDB_OFFLOADED = 14,
    SWITCHDEV_BRPORT_OFFLOADED = 15,
    SWITCHDEV_BRPORT_UNOFFLOADED = 16,
    SWITCHDEV_BRPORT_REPLAY = 17,
};

enum switchdev_obj_id {
    SWITCHDEV_OBJ_ID_UNDEFINED = 0,
    SWITCHDEV_OBJ_ID_PORT_VLAN = 1,
    SWITCHDEV_OBJ_ID_PORT_MDB = 2,
    SWITCHDEV_OBJ_ID_HOST_MDB = 3,
    SWITCHDEV_OBJ_ID_MRP = 4,
    SWITCHDEV_OBJ_ID_RING_TEST_MRP = 5,
    SWITCHDEV_OBJ_ID_RING_ROLE_MRP = 6,
    SWITCHDEV_OBJ_ID_RING_STATE_MRP = 7,
    SWITCHDEV_OBJ_ID_IN_TEST_MRP = 8,
    SWITCHDEV_OBJ_ID_IN_ROLE_MRP = 9,
    SWITCHDEV_OBJ_ID_IN_STATE_MRP = 10,
};

enum sys_off_mode {
    SYS_OFF_MODE_POWER_OFF_PREPARE = 0,
    SYS_OFF_MODE_POWER_OFF = 1,
    SYS_OFF_MODE_RESTART_PREPARE = 2,
    SYS_OFF_MODE_RESTART = 3,
};

enum sysctl_writes_mode {
    SYSCTL_WRITES_LEGACY = -1,
    SYSCTL_WRITES_WARN = 0,
    SYSCTL_WRITES_STRICT = 1,
};

enum system_states {
    SYSTEM_BOOTING = 0,
    SYSTEM_SCHEDULING = 1,
    SYSTEM_FREEING_INITMEM = 2,
    SYSTEM_RUNNING = 3,
    SYSTEM_HALT = 4,
    SYSTEM_POWER_OFF = 5,
    SYSTEM_RESTART = 6,
    SYSTEM_SUSPEND = 7,
};

enum t10_dif_type {
    T10_PI_TYPE0_PROTECTION = 0,
    T10_PI_TYPE1_PROTECTION = 1,
    T10_PI_TYPE2_PROTECTION = 2,
    T10_PI_TYPE3_PROTECTION = 3,
};

enum task_work_notify_mode {
    TWA_NONE = 0,
    TWA_RESUME = 1,
    TWA_SIGNAL = 2,
    TWA_SIGNAL_NO_IPI = 3,
    TWA_NMI_CURRENT = 4,
};

enum tc_fifo_command {
    TC_FIFO_REPLACE = 0,
    TC_FIFO_DESTROY = 1,
    TC_FIFO_STATS = 2,
};

enum tc_link_layer {
    TC_LINKLAYER_UNAWARE = 0,
    TC_LINKLAYER_ETHERNET = 1,
    TC_LINKLAYER_ATM = 2,
};

enum tc_mq_command {
    TC_MQ_CREATE = 0,
    TC_MQ_DESTROY = 1,
    TC_MQ_STATS = 2,
    TC_MQ_GRAFT = 3,
};

enum tc_root_command {
    TC_ROOT_GRAFT = 0,
};

enum tc_setup_type {
    TC_QUERY_CAPS = 0,
    TC_SETUP_QDISC_MQPRIO = 1,
    TC_SETUP_CLSU32 = 2,
    TC_SETUP_CLSFLOWER = 3,
    TC_SETUP_CLSMATCHALL = 4,
    TC_SETUP_CLSBPF = 5,
    TC_SETUP_BLOCK = 6,
    TC_SETUP_QDISC_CBS = 7,
    TC_SETUP_QDISC_RED = 8,
    TC_SETUP_QDISC_PRIO = 9,
    TC_SETUP_QDISC_MQ = 10,
    TC_SETUP_QDISC_ETF = 11,
    TC_SETUP_ROOT_QDISC = 12,
    TC_SETUP_QDISC_GRED = 13,
    TC_SETUP_QDISC_TAPRIO = 14,
    TC_SETUP_FT = 15,
    TC_SETUP_QDISC_ETS = 16,
    TC_SETUP_QDISC_TBF = 17,
    TC_SETUP_QDISC_FIFO = 18,
    TC_SETUP_QDISC_HTB = 19,
    TC_SETUP_ACT = 20,
};

enum tca_id {
    TCA_ID_UNSPEC = 0,
    TCA_ID_POLICE = 1,
    TCA_ID_GACT = 5,
    TCA_ID_IPT = 6,
    TCA_ID_PEDIT = 7,
    TCA_ID_MIRRED = 8,
    TCA_ID_NAT = 9,
    TCA_ID_XT = 10,
    TCA_ID_SKBEDIT = 11,
    TCA_ID_VLAN = 12,
    TCA_ID_BPF = 13,
    TCA_ID_CONNMARK = 14,
    TCA_ID_SKBMOD = 15,
    TCA_ID_CSUM = 16,
    TCA_ID_TUNNEL_KEY = 17,
    TCA_ID_SIMP = 22,
    TCA_ID_IFE = 25,
    TCA_ID_SAMPLE = 26,
    TCA_ID_CTINFO = 27,
    TCA_ID_MPLS = 28,
    TCA_ID_CT = 29,
    TCA_ID_GATE = 30,
    __TCA_ID_MAX = 255,
};

enum tcf_proto_ops_flags {
    TCF_PROTO_OPS_DOIT_UNLOCKED = 1,
};

enum tcp_ca_ack_event_flags {
    CA_ACK_SLOWPATH = 1,
    CA_ACK_WIN_UPDATE = 2,
    CA_ACK_ECE = 4,
};

enum tcp_ca_event {
    CA_EVENT_TX_START = 0,
    CA_EVENT_CWND_RESTART = 1,
    CA_EVENT_COMPLETE_CWR = 2,
    CA_EVENT_LOSS = 3,
    CA_EVENT_ECN_NO_CE = 4,
    CA_EVENT_ECN_IS_CE = 5,
};

enum tcp_ca_state {
    TCP_CA_Open = 0,
    TCP_CA_Disorder = 1,
    TCP_CA_CWR = 2,
    TCP_CA_Recovery = 3,
    TCP_CA_Loss = 4,
};

enum tcp_chrono {
    TCP_CHRONO_UNSPEC = 0,
    TCP_CHRONO_BUSY = 1,
    TCP_CHRONO_RWND_LIMITED = 2,
    TCP_CHRONO_SNDBUF_LIMITED = 3,
    __TCP_CHRONO_MAX = 4,
};

enum tcp_conntrack {
    TCP_CONNTRACK_NONE = 0,
    TCP_CONNTRACK_SYN_SENT = 1,
    TCP_CONNTRACK_SYN_RECV = 2,
    TCP_CONNTRACK_ESTABLISHED = 3,
    TCP_CONNTRACK_FIN_WAIT = 4,
    TCP_CONNTRACK_CLOSE_WAIT = 5,
    TCP_CONNTRACK_LAST_ACK = 6,
    TCP_CONNTRACK_TIME_WAIT = 7,
    TCP_CONNTRACK_CLOSE = 8,
    TCP_CONNTRACK_LISTEN = 9,
    TCP_CONNTRACK_MAX = 10,
    TCP_CONNTRACK_IGNORE = 11,
    TCP_CONNTRACK_RETRANS = 12,
    TCP_CONNTRACK_UNACK = 13,
    TCP_CONNTRACK_TIMEOUT_MAX = 14,
};

enum tcp_fastopen_client_fail {
    TFO_STATUS_UNSPEC = 0,
    TFO_COOKIE_UNAVAILABLE = 1,
    TFO_DATA_NOT_ACKED = 2,
    TFO_SYN_RETRANSMITTED = 3,
};

enum tcp_metric_index {
    TCP_METRIC_RTT = 0,
    TCP_METRIC_RTTVAR = 1,
    TCP_METRIC_SSTHRESH = 2,
    TCP_METRIC_CWND = 3,
    TCP_METRIC_REORDERING = 4,
    TCP_METRIC_RTT_US = 5,
    TCP_METRIC_RTTVAR_US = 6,
    __TCP_METRIC_MAX = 7,
};

enum tcp_queue {
    TCP_FRAG_IN_WRITE_QUEUE = 0,
    TCP_FRAG_IN_RTX_QUEUE = 1,
};

enum tcp_seq_states {
    TCP_SEQ_STATE_LISTENING = 0,
    TCP_SEQ_STATE_ESTABLISHED = 1,
};

enum tcp_skb_cb_sacked_flags {
    TCPCB_SACKED_ACKED = 1,
    TCPCB_SACKED_RETRANS = 2,
    TCPCB_LOST = 4,
    TCPCB_TAGBITS = 7,
    TCPCB_REPAIRED = 16,
    TCPCB_EVER_RETRANS = 128,
    TCPCB_RETRANS = 146,
};

enum tcp_synack_type {
    TCP_SYNACK_NORMAL = 0,
    TCP_SYNACK_FASTOPEN = 1,
    TCP_SYNACK_COOKIE = 2,
};

enum tcp_tw_status {
    TCP_TW_SUCCESS = 0,
    TCP_TW_RST = 1,
    TCP_TW_ACK = 2,
    TCP_TW_SYN = 3,
};

enum tcpa_event_types {
    PREBOOT = 0,
    POST_CODE = 1,
    UNUSED = 2,
    NO_ACTION = 3,
    SEPARATOR = 4,
    ACTION = 5,
    EVENT_TAG = 6,
    SCRTM_CONTENTS = 7,
    SCRTM_VERSION = 8,
    CPU_MICROCODE = 9,
    PLATFORM_CONFIG_FLAGS = 10,
    TABLE_OF_DEVICES = 11,
    COMPACT_HASH = 12,
    IPL = 13,
    IPL_PARTITION_DATA = 14,
    NONHOST_CODE = 15,
    NONHOST_CONFIG = 16,
    NONHOST_INFO = 17,
};

enum tcpa_pc_event_ids {
    SMBIOS = 1,
    BIS_CERT = 2,
    POST_BIOS_ROM = 3,
    ESCD = 4,
    CMOS = 5,
    NVRAM = 6,
    OPTION_ROM_EXEC = 7,
    OPTION_ROM_CONFIG = 8,
    OPTION_ROM_MICROCODE = 10,
    S_CRTM_VERSION = 11,
    S_CRTM_CONTENTS = 12,
    POST_CONTENTS = 13,
    HOST_TABLE_OF_DEVICES = 14,
};

enum tcx_action_base {
    TCX_NEXT = -1,
    TCX_PASS = 0,
    TCX_DROP = 2,
    TCX_REDIRECT = 7,
};

enum tg_state_flags {
    THROTL_TG_PENDING = 1,
    THROTL_TG_WAS_EMPTY = 2,
    THROTL_TG_CANCELING = 4,
};

enum thermal_device_mode {
    THERMAL_DEVICE_DISABLED = 0,
    THERMAL_DEVICE_ENABLED = 1,
};

enum thermal_genl_attr {
    THERMAL_GENL_ATTR_UNSPEC = 0,
    THERMAL_GENL_ATTR_TZ = 1,
    THERMAL_GENL_ATTR_TZ_ID = 2,
    THERMAL_GENL_ATTR_TZ_TEMP = 3,
    THERMAL_GENL_ATTR_TZ_TRIP = 4,
    THERMAL_GENL_ATTR_TZ_TRIP_ID = 5,
    THERMAL_GENL_ATTR_TZ_TRIP_TYPE = 6,
    THERMAL_GENL_ATTR_TZ_TRIP_TEMP = 7,
    THERMAL_GENL_ATTR_TZ_TRIP_HYST = 8,
    THERMAL_GENL_ATTR_TZ_MODE = 9,
    THERMAL_GENL_ATTR_TZ_NAME = 10,
    THERMAL_GENL_ATTR_TZ_CDEV_WEIGHT = 11,
    THERMAL_GENL_ATTR_TZ_GOV = 12,
    THERMAL_GENL_ATTR_TZ_GOV_NAME = 13,
    THERMAL_GENL_ATTR_CDEV = 14,
    THERMAL_GENL_ATTR_CDEV_ID = 15,
    THERMAL_GENL_ATTR_CDEV_CUR_STATE = 16,
    THERMAL_GENL_ATTR_CDEV_MAX_STATE = 17,
    THERMAL_GENL_ATTR_CDEV_NAME = 18,
    THERMAL_GENL_ATTR_GOV_NAME = 19,
    THERMAL_GENL_ATTR_CPU_CAPABILITY = 20,
    THERMAL_GENL_ATTR_CPU_CAPABILITY_ID = 21,
    THERMAL_GENL_ATTR_CPU_CAPABILITY_PERFORMANCE = 22,
    THERMAL_GENL_ATTR_CPU_CAPABILITY_EFFICIENCY = 23,
    THERMAL_GENL_ATTR_THRESHOLD = 24,
    THERMAL_GENL_ATTR_THRESHOLD_TEMP = 25,
    THERMAL_GENL_ATTR_THRESHOLD_DIRECTION = 26,
    THERMAL_GENL_ATTR_TZ_PREV_TEMP = 27,
    __THERMAL_GENL_ATTR_MAX = 28,
};

enum thermal_genl_cmd {
    THERMAL_GENL_CMD_UNSPEC = 0,
    THERMAL_GENL_CMD_TZ_GET_ID = 1,
    THERMAL_GENL_CMD_TZ_GET_TRIP = 2,
    THERMAL_GENL_CMD_TZ_GET_TEMP = 3,
    THERMAL_GENL_CMD_TZ_GET_GOV = 4,
    THERMAL_GENL_CMD_TZ_GET_MODE = 5,
    THERMAL_GENL_CMD_CDEV_GET = 6,
    THERMAL_GENL_CMD_THRESHOLD_GET = 7,
    THERMAL_GENL_CMD_THRESHOLD_ADD = 8,
    THERMAL_GENL_CMD_THRESHOLD_DELETE = 9,
    THERMAL_GENL_CMD_THRESHOLD_FLUSH = 10,
    __THERMAL_GENL_CMD_MAX = 11,
};

enum thermal_genl_event {
    THERMAL_GENL_EVENT_UNSPEC = 0,
    THERMAL_GENL_EVENT_TZ_CREATE = 1,
    THERMAL_GENL_EVENT_TZ_DELETE = 2,
    THERMAL_GENL_EVENT_TZ_DISABLE = 3,
    THERMAL_GENL_EVENT_TZ_ENABLE = 4,
    THERMAL_GENL_EVENT_TZ_TRIP_UP = 5,
    THERMAL_GENL_EVENT_TZ_TRIP_DOWN = 6,
    THERMAL_GENL_EVENT_TZ_TRIP_CHANGE = 7,
    THERMAL_GENL_EVENT_TZ_TRIP_ADD = 8,
    THERMAL_GENL_EVENT_TZ_TRIP_DELETE = 9,
    THERMAL_GENL_EVENT_CDEV_ADD = 10,
    THERMAL_GENL_EVENT_CDEV_DELETE = 11,
    THERMAL_GENL_EVENT_CDEV_STATE_UPDATE = 12,
    THERMAL_GENL_EVENT_TZ_GOV_CHANGE = 13,
    THERMAL_GENL_EVENT_CPU_CAPABILITY_CHANGE = 14,
    THERMAL_GENL_EVENT_THRESHOLD_ADD = 15,
    THERMAL_GENL_EVENT_THRESHOLD_DELETE = 16,
    THERMAL_GENL_EVENT_THRESHOLD_FLUSH = 17,
    THERMAL_GENL_EVENT_THRESHOLD_UP = 18,
    THERMAL_GENL_EVENT_THRESHOLD_DOWN = 19,
    __THERMAL_GENL_EVENT_MAX = 20,
};

enum thermal_genl_multicast_groups {
    THERMAL_GENL_SAMPLING_GROUP = 0,
    THERMAL_GENL_EVENT_GROUP = 1,
    THERMAL_GENL_MAX_GROUP = 1,
};

enum thermal_genl_sampling {
    THERMAL_GENL_SAMPLING_TEMP = 0,
    __THERMAL_GENL_SAMPLING_MAX = 1,
};

enum thermal_notify_event {
    THERMAL_EVENT_UNSPECIFIED = 0,
    THERMAL_EVENT_TEMP_SAMPLE = 1,
    THERMAL_TRIP_VIOLATED = 2,
    THERMAL_TRIP_CHANGED = 3,
    THERMAL_DEVICE_DOWN = 4,
    THERMAL_DEVICE_UP = 5,
    THERMAL_DEVICE_POWER_CAPABILITY_CHANGED = 6,
    THERMAL_TABLE_CHANGED = 7,
    THERMAL_EVENT_KEEP_ALIVE = 8,
    THERMAL_TZ_BIND_CDEV = 9,
    THERMAL_TZ_UNBIND_CDEV = 10,
    THERMAL_INSTANCE_WEIGHT_CHANGED = 11,
    THERMAL_TZ_RESUME = 12,
    THERMAL_TZ_ADD_THRESHOLD = 13,
    THERMAL_TZ_DEL_THRESHOLD = 14,
    THERMAL_TZ_FLUSH_THRESHOLDS = 15,
};

enum thermal_trend {
    THERMAL_TREND_STABLE = 0,
    THERMAL_TREND_RAISING = 1,
    THERMAL_TREND_DROPPING = 2,
};

enum thermal_trip_type {
    THERMAL_TRIP_ACTIVE = 0,
    THERMAL_TRIP_PASSIVE = 1,
    THERMAL_TRIP_HOT = 2,
    THERMAL_TRIP_CRITICAL = 3,
};

enum tick_broadcast_mode {
    TICK_BROADCAST_OFF = 0,
    TICK_BROADCAST_ON = 1,
    TICK_BROADCAST_FORCE = 2,
};

enum tick_broadcast_state {
    TICK_BROADCAST_EXIT = 0,
    TICK_BROADCAST_ENTER = 1,
};

enum tick_dep_bits {
    TICK_DEP_BIT_POSIX_TIMER = 0,
    TICK_DEP_BIT_PERF_EVENTS = 1,
    TICK_DEP_BIT_SCHED = 2,
    TICK_DEP_BIT_CLOCK_UNSTABLE = 3,
    TICK_DEP_BIT_RCU = 4,
    TICK_DEP_BIT_RCU_EXP = 5,
};

enum tick_device_mode {
    TICKDEV_MODE_PERIODIC = 0,
    TICKDEV_MODE_ONESHOT = 1,
};

enum timekeeping_adv_mode {
    TK_ADV_TICK = 0,
    TK_ADV_FREQ = 1,
};

enum timespec_type {
    TT_NONE = 0,
    TT_NATIVE = 1,
    TT_COMPAT = 2,
};

enum tk_offsets {
    TK_OFFS_REAL = 0,
    TK_OFFS_BOOT = 1,
    TK_OFFS_TAI = 2,
    TK_OFFS_MAX = 3,
};

enum tlb_flush_reason {
    TLB_FLUSH_ON_TASK_SWITCH = 0,
    TLB_REMOTE_SHOOTDOWN = 1,
    TLB_LOCAL_SHOOTDOWN = 2,
    TLB_LOCAL_MM_SHOOTDOWN = 3,
    TLB_REMOTE_SEND_IPI = 4,
    TLB_REMOTE_WRONG_CPU = 5,
    NR_TLB_FLUSH_REASONS = 6,
};

enum tls_offload_ctx_dir {
    TLS_OFFLOAD_CTX_DIR_RX = 0,
    TLS_OFFLOAD_CTX_DIR_TX = 1,
};

enum tomoyo_acl_entry_type_index {
    TOMOYO_TYPE_PATH_ACL = 0,
    TOMOYO_TYPE_PATH2_ACL = 1,
    TOMOYO_TYPE_PATH_NUMBER_ACL = 2,
    TOMOYO_TYPE_MKDEV_ACL = 3,
    TOMOYO_TYPE_MOUNT_ACL = 4,
    TOMOYO_TYPE_INET_ACL = 5,
    TOMOYO_TYPE_UNIX_ACL = 6,
    TOMOYO_TYPE_ENV_ACL = 7,
    TOMOYO_TYPE_MANUAL_TASK_ACL = 8,
};

enum tomoyo_conditions_index {
    TOMOYO_TASK_UID = 0,
    TOMOYO_TASK_EUID = 1,
    TOMOYO_TASK_SUID = 2,
    TOMOYO_TASK_FSUID = 3,
    TOMOYO_TASK_GID = 4,
    TOMOYO_TASK_EGID = 5,
    TOMOYO_TASK_SGID = 6,
    TOMOYO_TASK_FSGID = 7,
    TOMOYO_TASK_PID = 8,
    TOMOYO_TASK_PPID = 9,
    TOMOYO_EXEC_ARGC = 10,
    TOMOYO_EXEC_ENVC = 11,
    TOMOYO_TYPE_IS_SOCKET = 12,
    TOMOYO_TYPE_IS_SYMLINK = 13,
    TOMOYO_TYPE_IS_FILE = 14,
    TOMOYO_TYPE_IS_BLOCK_DEV = 15,
    TOMOYO_TYPE_IS_DIRECTORY = 16,
    TOMOYO_TYPE_IS_CHAR_DEV = 17,
    TOMOYO_TYPE_IS_FIFO = 18,
    TOMOYO_MODE_SETUID = 19,
    TOMOYO_MODE_SETGID = 20,
    TOMOYO_MODE_STICKY = 21,
    TOMOYO_MODE_OWNER_READ = 22,
    TOMOYO_MODE_OWNER_WRITE = 23,
    TOMOYO_MODE_OWNER_EXECUTE = 24,
    TOMOYO_MODE_GROUP_READ = 25,
    TOMOYO_MODE_GROUP_WRITE = 26,
    TOMOYO_MODE_GROUP_EXECUTE = 27,
    TOMOYO_MODE_OTHERS_READ = 28,
    TOMOYO_MODE_OTHERS_WRITE = 29,
    TOMOYO_MODE_OTHERS_EXECUTE = 30,
    TOMOYO_EXEC_REALPATH = 31,
    TOMOYO_SYMLINK_TARGET = 32,
    TOMOYO_PATH1_UID = 33,
    TOMOYO_PATH1_GID = 34,
    TOMOYO_PATH1_INO = 35,
    TOMOYO_PATH1_MAJOR = 36,
    TOMOYO_PATH1_MINOR = 37,
    TOMOYO_PATH1_PERM = 38,
    TOMOYO_PATH1_TYPE = 39,
    TOMOYO_PATH1_DEV_MAJOR = 40,
    TOMOYO_PATH1_DEV_MINOR = 41,
    TOMOYO_PATH2_UID = 42,
    TOMOYO_PATH2_GID = 43,
    TOMOYO_PATH2_INO = 44,
    TOMOYO_PATH2_MAJOR = 45,
    TOMOYO_PATH2_MINOR = 46,
    TOMOYO_PATH2_PERM = 47,
    TOMOYO_PATH2_TYPE = 48,
    TOMOYO_PATH2_DEV_MAJOR = 49,
    TOMOYO_PATH2_DEV_MINOR = 50,
    TOMOYO_PATH1_PARENT_UID = 51,
    TOMOYO_PATH1_PARENT_GID = 52,
    TOMOYO_PATH1_PARENT_INO = 53,
    TOMOYO_PATH1_PARENT_PERM = 54,
    TOMOYO_PATH2_PARENT_UID = 55,
    TOMOYO_PATH2_PARENT_GID = 56,
    TOMOYO_PATH2_PARENT_INO = 57,
    TOMOYO_PATH2_PARENT_PERM = 58,
    TOMOYO_MAX_CONDITION_KEYWORD = 59,
    TOMOYO_NUMBER_UNION = 60,
    TOMOYO_NAME_UNION = 61,
    TOMOYO_ARGV_ENTRY = 62,
    TOMOYO_ENVP_ENTRY = 63,
};

enum tomoyo_domain_info_flags_index {
    TOMOYO_DIF_QUOTA_WARNED = 0,
    TOMOYO_DIF_TRANSITION_FAILED = 1,
    TOMOYO_MAX_DOMAIN_INFO_FLAGS = 2,
};

enum tomoyo_grant_log {
    TOMOYO_GRANTLOG_AUTO = 0,
    TOMOYO_GRANTLOG_NO = 1,
    TOMOYO_GRANTLOG_YES = 2,
};

enum tomoyo_group_id {
    TOMOYO_PATH_GROUP = 0,
    TOMOYO_NUMBER_GROUP = 1,
    TOMOYO_ADDRESS_GROUP = 2,
    TOMOYO_MAX_GROUP = 3,
};

enum tomoyo_mac_category_index {
    TOMOYO_MAC_CATEGORY_FILE = 0,
    TOMOYO_MAC_CATEGORY_NETWORK = 1,
    TOMOYO_MAC_CATEGORY_MISC = 2,
    TOMOYO_MAX_MAC_CATEGORY_INDEX = 3,
};

enum tomoyo_mac_index {
    TOMOYO_MAC_FILE_EXECUTE = 0,
    TOMOYO_MAC_FILE_OPEN = 1,
    TOMOYO_MAC_FILE_CREATE = 2,
    TOMOYO_MAC_FILE_UNLINK = 3,
    TOMOYO_MAC_FILE_GETATTR = 4,
    TOMOYO_MAC_FILE_MKDIR = 5,
    TOMOYO_MAC_FILE_RMDIR = 6,
    TOMOYO_MAC_FILE_MKFIFO = 7,
    TOMOYO_MAC_FILE_MKSOCK = 8,
    TOMOYO_MAC_FILE_TRUNCATE = 9,
    TOMOYO_MAC_FILE_SYMLINK = 10,
    TOMOYO_MAC_FILE_MKBLOCK = 11,
    TOMOYO_MAC_FILE_MKCHAR = 12,
    TOMOYO_MAC_FILE_LINK = 13,
    TOMOYO_MAC_FILE_RENAME = 14,
    TOMOYO_MAC_FILE_CHMOD = 15,
    TOMOYO_MAC_FILE_CHOWN = 16,
    TOMOYO_MAC_FILE_CHGRP = 17,
    TOMOYO_MAC_FILE_IOCTL = 18,
    TOMOYO_MAC_FILE_CHROOT = 19,
    TOMOYO_MAC_FILE_MOUNT = 20,
    TOMOYO_MAC_FILE_UMOUNT = 21,
    TOMOYO_MAC_FILE_PIVOT_ROOT = 22,
    TOMOYO_MAC_NETWORK_INET_STREAM_BIND = 23,
    TOMOYO_MAC_NETWORK_INET_STREAM_LISTEN = 24,
    TOMOYO_MAC_NETWORK_INET_STREAM_CONNECT = 25,
    TOMOYO_MAC_NETWORK_INET_DGRAM_BIND = 26,
    TOMOYO_MAC_NETWORK_INET_DGRAM_SEND = 27,
    TOMOYO_MAC_NETWORK_INET_RAW_BIND = 28,
    TOMOYO_MAC_NETWORK_INET_RAW_SEND = 29,
    TOMOYO_MAC_NETWORK_UNIX_STREAM_BIND = 30,
    TOMOYO_MAC_NETWORK_UNIX_STREAM_LISTEN = 31,
    TOMOYO_MAC_NETWORK_UNIX_STREAM_CONNECT = 32,
    TOMOYO_MAC_NETWORK_UNIX_DGRAM_BIND = 33,
    TOMOYO_MAC_NETWORK_UNIX_DGRAM_SEND = 34,
    TOMOYO_MAC_NETWORK_UNIX_SEQPACKET_BIND = 35,
    TOMOYO_MAC_NETWORK_UNIX_SEQPACKET_LISTEN = 36,
    TOMOYO_MAC_NETWORK_UNIX_SEQPACKET_CONNECT = 37,
    TOMOYO_MAC_ENVIRON = 38,
    TOMOYO_MAX_MAC_INDEX = 39,
};

enum tomoyo_memory_stat_type {
    TOMOYO_MEMORY_POLICY = 0,
    TOMOYO_MEMORY_AUDIT = 1,
    TOMOYO_MEMORY_QUERY = 2,
    TOMOYO_MAX_MEMORY_STAT = 3,
};

enum tomoyo_mkdev_acl_index {
    TOMOYO_TYPE_MKBLOCK = 0,
    TOMOYO_TYPE_MKCHAR = 1,
    TOMOYO_MAX_MKDEV_OPERATION = 2,
};

enum tomoyo_mode_index {
    TOMOYO_CONFIG_DISABLED = 0,
    TOMOYO_CONFIG_LEARNING = 1,
    TOMOYO_CONFIG_PERMISSIVE = 2,
    TOMOYO_CONFIG_ENFORCING = 3,
    TOMOYO_CONFIG_MAX_MODE = 4,
    TOMOYO_CONFIG_WANT_REJECT_LOG = 64,
    TOMOYO_CONFIG_WANT_GRANT_LOG = 128,
    TOMOYO_CONFIG_USE_DEFAULT = 255,
};

enum tomoyo_network_acl_index {
    TOMOYO_NETWORK_BIND = 0,
    TOMOYO_NETWORK_LISTEN = 1,
    TOMOYO_NETWORK_CONNECT = 2,
    TOMOYO_NETWORK_SEND = 3,
    TOMOYO_MAX_NETWORK_OPERATION = 4,
};

enum tomoyo_path2_acl_index {
    TOMOYO_TYPE_LINK = 0,
    TOMOYO_TYPE_RENAME = 1,
    TOMOYO_TYPE_PIVOT_ROOT = 2,
    TOMOYO_MAX_PATH2_OPERATION = 3,
};

enum tomoyo_path_acl_index {
    TOMOYO_TYPE_EXECUTE = 0,
    TOMOYO_TYPE_READ = 1,
    TOMOYO_TYPE_WRITE = 2,
    TOMOYO_TYPE_APPEND = 3,
    TOMOYO_TYPE_UNLINK = 4,
    TOMOYO_TYPE_GETATTR = 5,
    TOMOYO_TYPE_RMDIR = 6,
    TOMOYO_TYPE_TRUNCATE = 7,
    TOMOYO_TYPE_SYMLINK = 8,
    TOMOYO_TYPE_CHROOT = 9,
    TOMOYO_TYPE_UMOUNT = 10,
    TOMOYO_MAX_PATH_OPERATION = 11,
};

enum tomoyo_path_number_acl_index {
    TOMOYO_TYPE_CREATE = 0,
    TOMOYO_TYPE_MKDIR = 1,
    TOMOYO_TYPE_MKFIFO = 2,
    TOMOYO_TYPE_MKSOCK = 3,
    TOMOYO_TYPE_IOCTL = 4,
    TOMOYO_TYPE_CHMOD = 5,
    TOMOYO_TYPE_CHOWN = 6,
    TOMOYO_TYPE_CHGRP = 7,
    TOMOYO_MAX_PATH_NUMBER_OPERATION = 8,
};

enum tomoyo_path_stat_index {
    TOMOYO_PATH1 = 0,
    TOMOYO_PATH1_PARENT = 1,
    TOMOYO_PATH2 = 2,
    TOMOYO_PATH2_PARENT = 3,
    TOMOYO_MAX_PATH_STAT = 4,
};

enum tomoyo_policy_id {
    TOMOYO_ID_GROUP = 0,
    TOMOYO_ID_ADDRESS_GROUP = 1,
    TOMOYO_ID_PATH_GROUP = 2,
    TOMOYO_ID_NUMBER_GROUP = 3,
    TOMOYO_ID_TRANSITION_CONTROL = 4,
    TOMOYO_ID_AGGREGATOR = 5,
    TOMOYO_ID_MANAGER = 6,
    TOMOYO_ID_CONDITION = 7,
    TOMOYO_ID_NAME = 8,
    TOMOYO_ID_ACL = 9,
    TOMOYO_ID_DOMAIN = 10,
    TOMOYO_MAX_POLICY = 11,
};

enum tomoyo_policy_stat_type {
    TOMOYO_STAT_POLICY_UPDATES = 0,
    TOMOYO_STAT_POLICY_LEARNING = 1,
    TOMOYO_STAT_POLICY_PERMISSIVE = 2,
    TOMOYO_STAT_POLICY_ENFORCING = 3,
    TOMOYO_MAX_POLICY_STAT = 4,
};

enum tomoyo_pref_index {
    TOMOYO_PREF_MAX_AUDIT_LOG = 0,
    TOMOYO_PREF_MAX_LEARNING_ENTRY = 1,
    TOMOYO_MAX_PREF = 2,
};

enum tomoyo_securityfs_interface_index {
    TOMOYO_DOMAINPOLICY = 0,
    TOMOYO_EXCEPTIONPOLICY = 1,
    TOMOYO_PROCESS_STATUS = 2,
    TOMOYO_STAT = 3,
    TOMOYO_AUDIT = 4,
    TOMOYO_VERSION = 5,
    TOMOYO_PROFILE = 6,
    TOMOYO_QUERY = 7,
    TOMOYO_MANAGER = 8,
};

enum tomoyo_special_mount {
    TOMOYO_MOUNT_BIND = 0,
    TOMOYO_MOUNT_MOVE = 1,
    TOMOYO_MOUNT_REMOUNT = 2,
    TOMOYO_MOUNT_MAKE_UNBINDABLE = 3,
    TOMOYO_MOUNT_MAKE_PRIVATE = 4,
    TOMOYO_MOUNT_MAKE_SLAVE = 5,
    TOMOYO_MOUNT_MAKE_SHARED = 6,
    TOMOYO_MAX_SPECIAL_MOUNT = 7,
};

enum tomoyo_transition_type {
    TOMOYO_TRANSITION_CONTROL_NO_RESET = 0,
    TOMOYO_TRANSITION_CONTROL_RESET = 1,
    TOMOYO_TRANSITION_CONTROL_NO_INITIALIZE = 2,
    TOMOYO_TRANSITION_CONTROL_INITIALIZE = 3,
    TOMOYO_TRANSITION_CONTROL_NO_KEEP = 4,
    TOMOYO_TRANSITION_CONTROL_KEEP = 5,
    TOMOYO_MAX_TRANSITION_TYPE = 6,
};

enum tomoyo_value_type {
    TOMOYO_VALUE_TYPE_INVALID = 0,
    TOMOYO_VALUE_TYPE_DECIMAL = 1,
    TOMOYO_VALUE_TYPE_OCTAL = 2,
    TOMOYO_VALUE_TYPE_HEXADECIMAL = 3,
};

enum tp_func_state {
    TP_FUNC_0 = 0,
    TP_FUNC_1 = 1,
    TP_FUNC_2 = 2,
    TP_FUNC_N = 3,
};

enum tp_transition_sync {
    TP_TRANSITION_SYNC_1_0_1 = 0,
    TP_TRANSITION_SYNC_N_2_1 = 1,
    _NR_TP_TRANSITION_SYNC = 2,
};

enum tpacket_versions {
    TPACKET_V1 = 0,
    TPACKET_V2 = 1,
    TPACKET_V3 = 2,
};

enum tph_mem_type {
    TPH_MEM_TYPE_VM = 0,
    TPH_MEM_TYPE_PM = 1,
};

enum tpm2_capabilities {
    TPM2_CAP_HANDLES = 1,
    TPM2_CAP_COMMANDS = 2,
    TPM2_CAP_PCRS = 5,
    TPM2_CAP_TPM_PROPERTIES = 6,
};

enum tpm2_cc_attrs {
    TPM2_CC_ATTR_CHANDLES = 25,
    TPM2_CC_ATTR_RHANDLE = 28,
    TPM2_CC_ATTR_VENDOR = 29,
};

enum tpm2_command_codes {
    TPM2_CC_FIRST = 287,
    TPM2_CC_HIERARCHY_CONTROL = 289,
    TPM2_CC_HIERARCHY_CHANGE_AUTH = 297,
    TPM2_CC_CREATE_PRIMARY = 305,
    TPM2_CC_SEQUENCE_COMPLETE = 318,
    TPM2_CC_SELF_TEST = 323,
    TPM2_CC_STARTUP = 324,
    TPM2_CC_SHUTDOWN = 325,
    TPM2_CC_NV_READ = 334,
    TPM2_CC_CREATE = 339,
    TPM2_CC_LOAD = 343,
    TPM2_CC_SEQUENCE_UPDATE = 348,
    TPM2_CC_UNSEAL = 350,
    TPM2_CC_CONTEXT_LOAD = 353,
    TPM2_CC_CONTEXT_SAVE = 354,
    TPM2_CC_FLUSH_CONTEXT = 357,
    TPM2_CC_READ_PUBLIC = 371,
    TPM2_CC_START_AUTH_SESS = 374,
    TPM2_CC_VERIFY_SIGNATURE = 375,
    TPM2_CC_GET_CAPABILITY = 378,
    TPM2_CC_GET_RANDOM = 379,
    TPM2_CC_PCR_READ = 382,
    TPM2_CC_PCR_EXTEND = 386,
    TPM2_CC_EVENT_SEQUENCE_COMPLETE = 389,
    TPM2_CC_HASH_SEQUENCE_START = 390,
    TPM2_CC_CREATE_LOADED = 401,
    TPM2_CC_LAST = 403,
};

enum tpm2_const {
    TPM2_PLATFORM_PCR = 24,
    TPM2_PCR_SELECT_MIN = 3,
};

enum tpm2_handle_types {
    TPM2_HT_HMAC_SESSION = 33554432,
    TPM2_HT_POLICY_SESSION = 50331648,
    TPM2_HT_TRANSIENT = 2147483648,
};

enum tpm2_object_attributes {
    TPM2_OA_FIXED_TPM = 2,
    TPM2_OA_ST_CLEAR = 4,
    TPM2_OA_FIXED_PARENT = 16,
    TPM2_OA_SENSITIVE_DATA_ORIGIN = 32,
    TPM2_OA_USER_WITH_AUTH = 64,
    TPM2_OA_ADMIN_WITH_POLICY = 128,
    TPM2_OA_NO_DA = 1024,
    TPM2_OA_ENCRYPTED_DUPLICATION = 2048,
    TPM2_OA_RESTRICTED = 65536,
    TPM2_OA_DECRYPT = 131072,
    TPM2_OA_SIGN = 262144,
};

enum tpm2_permanent_handles {
    TPM2_RH_NULL = 1073741831,
    TPM2_RS_PW = 1073741833,
};

enum tpm2_properties {
    TPM_PT_TOTAL_COMMANDS = 297,
};

enum tpm2_return_codes {
    TPM2_RC_SUCCESS = 0,
    TPM2_RC_HASH = 131,
    TPM2_RC_HANDLE = 139,
    TPM2_RC_INTEGRITY = 159,
    TPM2_RC_INITIALIZE = 256,
    TPM2_RC_FAILURE = 257,
    TPM2_RC_DISABLED = 288,
    TPM2_RC_UPGRADE = 301,
    TPM2_RC_COMMAND_CODE = 323,
    TPM2_RC_TESTING = 2314,
    TPM2_RC_REFERENCE_H0 = 2320,
    TPM2_RC_RETRY = 2338,
    TPM2_RC_SESSION_MEMORY = 2307,
};

enum tpm2_session_attributes {
    TPM2_SA_CONTINUE_SESSION = 1,
    TPM2_SA_AUDIT_EXCLUSIVE = 2,
    TPM2_SA_AUDIT_RESET = 8,
    TPM2_SA_DECRYPT = 32,
    TPM2_SA_ENCRYPT = 64,
    TPM2_SA_AUDIT = 128,
};

enum tpm2_startup_types {
    TPM2_SU_CLEAR = 0,
    TPM2_SU_STATE = 1,
};

enum tpm2_structures {
    TPM2_ST_NO_SESSIONS = 32769,
    TPM2_ST_SESSIONS = 32770,
    TPM2_ST_CREATION = 32801,
};

enum tpm2_timeouts {
    TPM2_TIMEOUT_A = 750,
    TPM2_TIMEOUT_B = 4000,
    TPM2_TIMEOUT_C = 200,
    TPM2_TIMEOUT_D = 30,
    TPM2_DURATION_SHORT = 20,
    TPM2_DURATION_MEDIUM = 750,
    TPM2_DURATION_LONG = 2000,
    TPM2_DURATION_LONG_LONG = 300000,
    TPM2_DURATION_DEFAULT = 120000,
};

enum tpm2key_actions {
    ACT_tpm2_key_parent = 0,
    ACT_tpm2_key_priv = 1,
    ACT_tpm2_key_pub = 2,
    ACT_tpm2_key_type = 3,
    NR__tpm2key_actions = 4,
};

enum tpm_algorithms {
    TPM_ALG_ERROR = 0,
    TPM_ALG_SHA1 = 4,
    TPM_ALG_AES = 6,
    TPM_ALG_KEYEDHASH = 8,
    TPM_ALG_SHA256 = 11,
    TPM_ALG_SHA384 = 12,
    TPM_ALG_SHA512 = 13,
    TPM_ALG_NULL = 16,
    TPM_ALG_SM3_256 = 18,
    TPM_ALG_ECC = 35,
    TPM_ALG_CFB = 67,
};

enum tpm_buf_flags {
    TPM_BUF_OVERFLOW = 1,
    TPM_BUF_TPM2B = 2,
    TPM_BUF_BOUNDARY_ERROR = 4,
};

enum tpm_capabilities {
    TPM_CAP_FLAG = 4,
    TPM_CAP_PROP = 5,
    TPM_CAP_VERSION_1_1 = 6,
    TPM_CAP_VERSION_1_2 = 26,
};

enum tpm_chip_flags {
    TPM_CHIP_FLAG_BOOTSTRAPPED = 1,
    TPM_CHIP_FLAG_TPM2 = 2,
    TPM_CHIP_FLAG_IRQ = 4,
    TPM_CHIP_FLAG_VIRTUAL = 8,
    TPM_CHIP_FLAG_HAVE_TIMEOUTS = 16,
    TPM_CHIP_FLAG_ALWAYS_POWERED = 32,
    TPM_CHIP_FLAG_FIRMWARE_POWER_MANAGED = 64,
    TPM_CHIP_FLAG_FIRMWARE_UPGRADE = 128,
    TPM_CHIP_FLAG_SUSPENDED = 256,
    TPM_CHIP_FLAG_HWRNG_DISABLED = 512,
    TPM_CHIP_FLAG_DISABLE = 1024,
};

enum tpm_duration {
    TPM_SHORT = 0,
    TPM_MEDIUM = 1,
    TPM_LONG = 2,
    TPM_LONG_LONG = 3,
    TPM_UNDEFINED = 4,
    TPM_NUM_DURATIONS = 4,
};

enum tpm_pcrs {
    TPM_PCR0 = 0,
    TPM_PCR8 = 8,
    TPM_PCR10 = 10,
};

enum tpm_sub_capabilities {
    TPM_CAP_PROP_PCR = 257,
    TPM_CAP_PROP_MANUFACTURER = 259,
    TPM_CAP_FLAG_PERM = 264,
    TPM_CAP_FLAG_VOL = 265,
    TPM_CAP_PROP_OWNER = 273,
    TPM_CAP_PROP_TIS_TIMEOUT = 277,
    TPM_CAP_PROP_TIS_DURATION = 288,
};

enum tpm_timeout {
    TPM_TIMEOUT = 5,
    TPM_TIMEOUT_RETRY = 100,
    TPM_TIMEOUT_RANGE_US = 300,
    TPM_TIMEOUT_POLL = 1,
    TPM_TIMEOUT_USECS_MIN = 100,
    TPM_TIMEOUT_USECS_MAX = 500,
};

enum trace_flag_type {
    TRACE_FLAG_IRQS_OFF = 1,
    TRACE_FLAG_NEED_RESCHED_LAZY = 2,
    TRACE_FLAG_NEED_RESCHED = 4,
    TRACE_FLAG_HARDIRQ = 8,
    TRACE_FLAG_SOFTIRQ = 16,
    TRACE_FLAG_PREEMPT_RESCHED = 32,
    TRACE_FLAG_NMI = 64,
    TRACE_FLAG_BH_OFF = 128,
};

enum trace_iter_flags {
    TRACE_FILE_LAT_FMT = 1,
    TRACE_FILE_ANNOTATE = 2,
    TRACE_FILE_TIME_IN_NS = 4,
};

enum trace_iterator_bits {
    TRACE_ITER_PRINT_PARENT_BIT = 0,
    TRACE_ITER_SYM_OFFSET_BIT = 1,
    TRACE_ITER_SYM_ADDR_BIT = 2,
    TRACE_ITER_VERBOSE_BIT = 3,
    TRACE_ITER_RAW_BIT = 4,
    TRACE_ITER_HEX_BIT = 5,
    TRACE_ITER_BIN_BIT = 6,
    TRACE_ITER_BLOCK_BIT = 7,
    TRACE_ITER_FIELDS_BIT = 8,
    TRACE_ITER_PRINTK_BIT = 9,
    TRACE_ITER_ANNOTATE_BIT = 10,
    TRACE_ITER_USERSTACKTRACE_BIT = 11,
    TRACE_ITER_SYM_USEROBJ_BIT = 12,
    TRACE_ITER_PRINTK_MSGONLY_BIT = 13,
    TRACE_ITER_CONTEXT_INFO_BIT = 14,
    TRACE_ITER_LATENCY_FMT_BIT = 15,
    TRACE_ITER_RECORD_CMD_BIT = 16,
    TRACE_ITER_RECORD_TGID_BIT = 17,
    TRACE_ITER_OVERWRITE_BIT = 18,
    TRACE_ITER_STOP_ON_FREE_BIT = 19,
    TRACE_ITER_IRQ_INFO_BIT = 20,
    TRACE_ITER_MARKERS_BIT = 21,
    TRACE_ITER_EVENT_FORK_BIT = 22,
    TRACE_ITER_TRACE_PRINTK_BIT = 23,
    TRACE_ITER_PAUSE_ON_TRACE_BIT = 24,
    TRACE_ITER_HASH_PTR_BIT = 25,
    TRACE_ITER_FUNCTION_BIT = 26,
    TRACE_ITER_FUNC_FORK_BIT = 27,
    TRACE_ITER_DISPLAY_GRAPH_BIT = 28,
    TRACE_ITER_STACKTRACE_BIT = 29,
    TRACE_ITER_LAST_BIT = 30,
};

enum trace_iterator_flags {
    TRACE_ITER_PRINT_PARENT = 1,
    TRACE_ITER_SYM_OFFSET = 2,
    TRACE_ITER_SYM_ADDR = 4,
    TRACE_ITER_VERBOSE = 8,
    TRACE_ITER_RAW = 16,
    TRACE_ITER_HEX = 32,
    TRACE_ITER_BIN = 64,
    TRACE_ITER_BLOCK = 128,
    TRACE_ITER_FIELDS = 256,
    TRACE_ITER_PRINTK = 512,
    TRACE_ITER_ANNOTATE = 1024,
    TRACE_ITER_USERSTACKTRACE = 2048,
    TRACE_ITER_SYM_USEROBJ = 4096,
    TRACE_ITER_PRINTK_MSGONLY = 8192,
    TRACE_ITER_CONTEXT_INFO = 16384,
    TRACE_ITER_LATENCY_FMT = 32768,
    TRACE_ITER_RECORD_CMD = 65536,
    TRACE_ITER_RECORD_TGID = 131072,
    TRACE_ITER_OVERWRITE = 262144,
    TRACE_ITER_STOP_ON_FREE = 524288,
    TRACE_ITER_IRQ_INFO = 1048576,
    TRACE_ITER_MARKERS = 2097152,
    TRACE_ITER_EVENT_FORK = 4194304,
    TRACE_ITER_TRACE_PRINTK = 8388608,
    TRACE_ITER_PAUSE_ON_TRACE = 16777216,
    TRACE_ITER_HASH_PTR = 33554432,
    TRACE_ITER_FUNCTION = 67108864,
    TRACE_ITER_FUNC_FORK = 134217728,
    TRACE_ITER_DISPLAY_GRAPH = 268435456,
    TRACE_ITER_STACKTRACE = 536870912,
};

enum trace_reg {
    TRACE_REG_REGISTER = 0,
    TRACE_REG_UNREGISTER = 1,
    TRACE_REG_PERF_REGISTER = 2,
    TRACE_REG_PERF_UNREGISTER = 3,
    TRACE_REG_PERF_OPEN = 4,
    TRACE_REG_PERF_CLOSE = 5,
    TRACE_REG_PERF_ADD = 6,
    TRACE_REG_PERF_DEL = 7,
};

enum trace_type {
    __TRACE_FIRST_TYPE = 0,
    TRACE_FN = 1,
    TRACE_CTX = 2,
    TRACE_WAKE = 3,
    TRACE_STACK = 4,
    TRACE_PRINT = 5,
    TRACE_BPRINT = 6,
    TRACE_MMIO_RW = 7,
    TRACE_MMIO_MAP = 8,
    TRACE_BRANCH = 9,
    TRACE_GRAPH_RET = 10,
    TRACE_GRAPH_ENT = 11,
    TRACE_GRAPH_RETADDR_ENT = 12,
    TRACE_USER_STACK = 13,
    TRACE_BLK = 14,
    TRACE_BPUTS = 15,
    TRACE_HWLAT = 16,
    TRACE_OSNOISE = 17,
    TRACE_TIMERLAT = 18,
    TRACE_RAW_DATA = 19,
    TRACE_FUNC_REPEATS = 20,
    __TRACE_LAST_TYPE = 21,
};

enum track_item {
    TRACK_ALLOC = 0,
    TRACK_FREE = 1,
};

enum trans_regime {
    TR_EL10 = 0,
    TR_EL20 = 1,
    TR_EL2 = 2,
};

enum translation_map {
    LAT1_MAP = 0,
    GRAF_MAP = 1,
    IBMPC_MAP = 2,
    USER_MAP = 3,
    FIRST_MAP = 0,
    LAST_MAP = 3,
};

enum transparent_hugepage_flag {
    TRANSPARENT_HUGEPAGE_UNSUPPORTED = 0,
    TRANSPARENT_HUGEPAGE_FLAG = 1,
    TRANSPARENT_HUGEPAGE_REQ_MADV_FLAG = 2,
    TRANSPARENT_HUGEPAGE_DEFRAG_DIRECT_FLAG = 3,
    TRANSPARENT_HUGEPAGE_DEFRAG_KSWAPD_FLAG = 4,
    TRANSPARENT_HUGEPAGE_DEFRAG_KSWAPD_OR_MADV_FLAG = 5,
    TRANSPARENT_HUGEPAGE_DEFRAG_REQ_MADV_FLAG = 6,
    TRANSPARENT_HUGEPAGE_DEFRAG_KHUGEPAGED_FLAG = 7,
    TRANSPARENT_HUGEPAGE_USE_ZERO_PAGE_FLAG = 8,
};

enum trap_behaviour {
    BEHAVE_HANDLE_LOCALLY = 0,
    BEHAVE_FORWARD_READ = 1,
    BEHAVE_FORWARD_WRITE = 2,
    BEHAVE_FORWARD_RW = 3,
    BEHAVE_FORWARD_IN_HOST_EL0 = 4,
};

enum tsq_enum {
    TSQ_THROTTLED = 0,
    TSQ_QUEUED = 1,
    TCP_TSQ_DEFERRED = 2,
    TCP_WRITE_TIMER_DEFERRED = 3,
    TCP_DELACK_TIMER_DEFERRED = 4,
    TCP_MTU_REDUCED_DEFERRED = 5,
    TCP_ACK_DEFERRED = 6,
};

enum tsq_flags {
    TSQF_THROTTLED = 1,
    TSQF_QUEUED = 2,
    TCPF_TSQ_DEFERRED = 4,
    TCPF_WRITE_TIMER_DEFERRED = 8,
    TCPF_DELACK_TIMER_DEFERRED = 16,
    TCPF_MTU_REDUCED_DEFERRED = 32,
    TCPF_ACK_DEFERRED = 64,
};

enum ttu_flags {
    TTU_SPLIT_HUGE_PMD = 4,
    TTU_IGNORE_MLOCK = 8,
    TTU_SYNC = 16,
    TTU_HWPOISON = 32,
    TTU_BATCH_FLUSH = 64,
    TTU_RMAP_LOCKED = 128,
};

enum tty_flow_change {
    TTY_FLOW_NO_CHANGE = 0,
    TTY_THROTTLE_SAFE = 1,
    TTY_UNTHROTTLE_SAFE = 2,
};

enum tunable_id {
    ETHTOOL_ID_UNSPEC = 0,
    ETHTOOL_RX_COPYBREAK = 1,
    ETHTOOL_TX_COPYBREAK = 2,
    ETHTOOL_PFC_PREVENTION_TOUT = 3,
    ETHTOOL_TX_COPYBREAK_BUF_SIZE = 4,
    __ETHTOOL_TUNABLE_COUNT = 5,
};

enum tunable_type_id {
    ETHTOOL_TUNABLE_UNSPEC = 0,
    ETHTOOL_TUNABLE_U8 = 1,
    ETHTOOL_TUNABLE_U16 = 2,
    ETHTOOL_TUNABLE_U32 = 3,
    ETHTOOL_TUNABLE_U64 = 4,
    ETHTOOL_TUNABLE_STRING = 5,
    ETHTOOL_TUNABLE_S8 = 6,
    ETHTOOL_TUNABLE_S16 = 7,
    ETHTOOL_TUNABLE_S32 = 8,
    ETHTOOL_TUNABLE_S64 = 9,
};

enum txtime_flags {
    SOF_TXTIME_DEADLINE_MODE = 1,
    SOF_TXTIME_REPORT_ERRORS = 2,
    SOF_TXTIME_FLAGS_LAST = 2,
    SOF_TXTIME_FLAGS_MASK = 3,
};

enum uart_pm_state {
    UART_PM_STATE_ON = 0,
    UART_PM_STATE_OFF = 3,
    UART_PM_STATE_UNDEFINED = 4,
};

enum uclamp_id {
    UCLAMP_MIN = 0,
    UCLAMP_MAX = 1,
    UCLAMP_CNT = 2,
};

enum ucount_type {
    UCOUNT_USER_NAMESPACES = 0,
    UCOUNT_PID_NAMESPACES = 1,
    UCOUNT_UTS_NAMESPACES = 2,
    UCOUNT_IPC_NAMESPACES = 3,
    UCOUNT_NET_NAMESPACES = 4,
    UCOUNT_MNT_NAMESPACES = 5,
    UCOUNT_CGROUP_NAMESPACES = 6,
    UCOUNT_TIME_NAMESPACES = 7,
    UCOUNT_INOTIFY_INSTANCES = 8,
    UCOUNT_INOTIFY_WATCHES = 9,
    UCOUNT_FANOTIFY_GROUPS = 10,
    UCOUNT_FANOTIFY_MARKS = 11,
    UCOUNT_COUNTS = 12,
};

enum udp_conntrack {
    UDP_CT_UNREPLIED = 0,
    UDP_CT_REPLIED = 1,
    UDP_CT_MAX = 2,
};

enum udp_parsable_tunnel_type {
    UDP_TUNNEL_TYPE_VXLAN = 1,
    UDP_TUNNEL_TYPE_GENEVE = 2,
    UDP_TUNNEL_TYPE_VXLAN_GPE = 4,
};

enum udp_tunnel_nic_info_flags {
    UDP_TUNNEL_NIC_INFO_MAY_SLEEP = 1,
    UDP_TUNNEL_NIC_INFO_OPEN_ONLY = 2,
    UDP_TUNNEL_NIC_INFO_IPV4_ONLY = 4,
    UDP_TUNNEL_NIC_INFO_STATIC_IANA_VXLAN = 8,
};

enum umh_disable_depth {
    UMH_ENABLED = 0,
    UMH_FREEZING = 1,
    UMH_DISABLED = 2,
};

enum umount_tree_flags {
    UMOUNT_SYNC = 1,
    UMOUNT_PROPAGATE = 2,
    UMOUNT_CONNECTED = 4,
};

enum unix_vertex_index {
    UNIX_VERTEX_INDEX_MARK1 = 0,
    UNIX_VERTEX_INDEX_MARK2 = 1,
    UNIX_VERTEX_INDEX_START = 2,
};

enum uprobe_task_state {
    UTASK_RUNNING = 0,
    UTASK_SSTEP = 1,
    UTASK_SSTEP_ACK = 2,
    UTASK_SSTEP_TRAPPED = 3,
};

enum usb3_link_state {
    USB3_LPM_U0 = 0,
    USB3_LPM_U1 = 1,
    USB3_LPM_U2 = 2,
    USB3_LPM_U3 = 3,
};

enum usb_charger_state {
    USB_CHARGER_DEFAULT = 0,
    USB_CHARGER_PRESENT = 1,
    USB_CHARGER_ABSENT = 2,
};

enum usb_charger_type {
    UNKNOWN_TYPE = 0,
    SDP_TYPE = 1,
    DCP_TYPE = 2,
    CDP_TYPE = 3,
    ACA_TYPE = 4,
};

enum usb_dev_authorize_policy {
    USB_DEVICE_AUTHORIZE_NONE = 0,
    USB_DEVICE_AUTHORIZE_ALL = 1,
    USB_DEVICE_AUTHORIZE_INTERNAL = 2,
};

enum usb_device_speed {
    USB_SPEED_UNKNOWN = 0,
    USB_SPEED_LOW = 1,
    USB_SPEED_FULL = 2,
    USB_SPEED_HIGH = 3,
    USB_SPEED_WIRELESS = 4,
    USB_SPEED_SUPER = 5,
    USB_SPEED_SUPER_PLUS = 6,
};

enum usb_device_state {
    USB_STATE_NOTATTACHED = 0,
    USB_STATE_ATTACHED = 1,
    USB_STATE_POWERED = 2,
    USB_STATE_RECONNECTING = 3,
    USB_STATE_UNAUTHENTICATED = 4,
    USB_STATE_DEFAULT = 5,
    USB_STATE_ADDRESS = 6,
    USB_STATE_CONFIGURED = 7,
    USB_STATE_SUSPENDED = 8,
};

enum usb_dr_mode {
    USB_DR_MODE_UNKNOWN = 0,
    USB_DR_MODE_HOST = 1,
    USB_DR_MODE_PERIPHERAL = 2,
    USB_DR_MODE_OTG = 3,
};

enum usb_interface_condition {
    USB_INTERFACE_UNBOUND = 0,
    USB_INTERFACE_BINDING = 1,
    USB_INTERFACE_BOUND = 2,
    USB_INTERFACE_UNBINDING = 3,
};

enum usb_led_event {
    USB_LED_EVENT_HOST = 0,
    USB_LED_EVENT_GADGET = 1,
};

enum usb_link_tunnel_mode {
    USB_LINK_UNKNOWN = 0,
    USB_LINK_NATIVE = 1,
    USB_LINK_TUNNELED = 2,
};

enum usb_otg_state {
    OTG_STATE_UNDEFINED = 0,
    OTG_STATE_B_IDLE = 1,
    OTG_STATE_B_SRP_INIT = 2,
    OTG_STATE_B_PERIPHERAL = 3,
    OTG_STATE_B_WAIT_ACON = 4,
    OTG_STATE_B_HOST = 5,
    OTG_STATE_A_IDLE = 6,
    OTG_STATE_A_WAIT_VRISE = 7,
    OTG_STATE_A_WAIT_BCON = 8,
    OTG_STATE_A_HOST = 9,
    OTG_STATE_A_SUSPEND = 10,
    OTG_STATE_A_PERIPHERAL = 11,
    OTG_STATE_A_WAIT_VFALL = 12,
    OTG_STATE_A_VBUS_ERR = 13,
};

enum usb_phy_events {
    USB_EVENT_NONE = 0,
    USB_EVENT_VBUS = 1,
    USB_EVENT_ID = 2,
    USB_EVENT_CHARGER = 3,
    USB_EVENT_ENUMERATED = 4,
};

enum usb_phy_interface {
    USBPHY_INTERFACE_MODE_UNKNOWN = 0,
    USBPHY_INTERFACE_MODE_UTMI = 1,
    USBPHY_INTERFACE_MODE_UTMIW = 2,
    USBPHY_INTERFACE_MODE_ULPI = 3,
    USBPHY_INTERFACE_MODE_SERIAL = 4,
    USBPHY_INTERFACE_MODE_HSIC = 5,
};

enum usb_phy_type {
    USB_PHY_TYPE_UNDEFINED = 0,
    USB_PHY_TYPE_USB2 = 1,
    USB_PHY_TYPE_USB3 = 2,
};

enum usb_port_connect_type {
    USB_PORT_CONNECT_TYPE_UNKNOWN = 0,
    USB_PORT_CONNECT_TYPE_HOT_PLUG = 1,
    USB_PORT_CONNECT_TYPE_HARD_WIRED = 2,
    USB_PORT_NOT_USED = 3,
};

enum usb_ssp_rate {
    USB_SSP_GEN_UNKNOWN = 0,
    USB_SSP_GEN_2x1 = 1,
    USB_SSP_GEN_1x2 = 2,
    USB_SSP_GEN_2x2 = 3,
};

enum usb_wireless_status {
    USB_WIRELESS_STATUS_NA = 0,
    USB_WIRELESS_STATUS_DISCONNECTED = 1,
    USB_WIRELESS_STATUS_CONNECTED = 2,
};

enum user_reg_flag {
    USER_EVENT_REG_PERSIST = 1,
    USER_EVENT_REG_MULTI_FORMAT = 2,
    USER_EVENT_REG_MAX = 4,
};

enum utf16_endian {
    UTF16_HOST_ENDIAN = 0,
    UTF16_LITTLE_ENDIAN = 1,
    UTF16_BIG_ENDIAN = 2,
};

enum utf8_normalization {
    UTF8_NFDI = 0,
    UTF8_NFDICF = 1,
    UTF8_NMAX = 2,
};

enum uts_proc {
    UTS_PROC_ARCH = 0,
    UTS_PROC_OSTYPE = 1,
    UTS_PROC_OSRELEASE = 2,
    UTS_PROC_VERSION = 3,
    UTS_PROC_HOSTNAME = 4,
    UTS_PROC_DOMAINNAME = 5,
};

enum vc_ctl_state {
    ESnormal = 0,
    ESesc = 1,
    ESsquare = 2,
    ESgetpars = 3,
    ESfunckey = 4,
    EShash = 5,
    ESsetG0 = 6,
    ESsetG1 = 7,
    ESpercent = 8,
    EScsiignore = 9,
    ESnonstd = 10,
    ESpalette = 11,
    ESosc = 12,
    ESANSI_first = 12,
    ESapc = 13,
    ESpm = 14,
    ESdcs = 15,
    ESANSI_last = 15,
};

enum vc_intensity {
    VCI_HALF_BRIGHT = 0,
    VCI_NORMAL = 1,
    VCI_BOLD = 2,
    VCI_MASK = 3,
};

enum vchiq_bulk_dir {
    VCHIQ_BULK_TRANSMIT = 0,
    VCHIQ_BULK_RECEIVE = 1,
};

enum vchiq_bulk_mode {
    VCHIQ_BULK_MODE_CALLBACK = 0,
    VCHIQ_BULK_MODE_BLOCKING = 1,
    VCHIQ_BULK_MODE_NOCALLBACK = 2,
    VCHIQ_BULK_MODE_WAITING = 3,
};

enum vchiq_connstate {
    VCHIQ_CONNSTATE_DISCONNECTED = 0,
    VCHIQ_CONNSTATE_CONNECTING = 1,
    VCHIQ_CONNSTATE_CONNECTED = 2,
    VCHIQ_CONNSTATE_PAUSING = 3,
    VCHIQ_CONNSTATE_PAUSE_SENT = 4,
    VCHIQ_CONNSTATE_PAUSED = 5,
    VCHIQ_CONNSTATE_RESUMING = 6,
    VCHIQ_CONNSTATE_PAUSE_TIMEOUT = 7,
    VCHIQ_CONNSTATE_RESUME_TIMEOUT = 8,
};

enum vchiq_reason {
    VCHIQ_SERVICE_OPENED = 0,
    VCHIQ_SERVICE_CLOSED = 1,
    VCHIQ_MESSAGE_AVAILABLE = 2,
    VCHIQ_BULK_TRANSMIT_DONE = 3,
    VCHIQ_BULK_RECEIVE_DONE = 4,
    VCHIQ_BULK_TRANSMIT_ABORTED = 5,
    VCHIQ_BULK_RECEIVE_ABORTED = 6,
};

enum vchiq_service_option {
    VCHIQ_SERVICE_OPTION_AUTOCLOSE = 0,
    VCHIQ_SERVICE_OPTION_SLOT_QUOTA = 1,
    VCHIQ_SERVICE_OPTION_MESSAGE_QUOTA = 2,
    VCHIQ_SERVICE_OPTION_SYNCHRONOUS = 3,
    VCHIQ_SERVICE_OPTION_TRACE = 4,
};

enum vcpu_sysreg {
    __INVALID_SYSREG__ = 0,
    MPIDR_EL1 = 1,
    CLIDR_EL1 = 2,
    CSSELR_EL1 = 3,
    TPIDR_EL0 = 4,
    TPIDRRO_EL0 = 5,
    TPIDR_EL1 = 6,
    CNTKCTL_EL1 = 7,
    PAR_EL1 = 8,
    MDCCINT_EL1 = 9,
    OSLSR_EL1 = 10,
    DISR_EL1 = 11,
    PMCR_EL0 = 12,
    PMSELR_EL0 = 13,
    PMEVCNTR0_EL0 = 14,
    PMEVCNTR30_EL0 = 44,
    PMCCNTR_EL0 = 45,
    PMEVTYPER0_EL0 = 46,
    PMEVTYPER30_EL0 = 76,
    PMCCFILTR_EL0 = 77,
    PMCNTENSET_EL0 = 78,
    PMINTENSET_EL1 = 79,
    PMOVSSET_EL0 = 80,
    PMUSERENR_EL0 = 81,
    APIAKEYLO_EL1 = 82,
    APIAKEYHI_EL1 = 83,
    APIBKEYLO_EL1 = 84,
    APIBKEYHI_EL1 = 85,
    APDAKEYLO_EL1 = 86,
    APDAKEYHI_EL1 = 87,
    APDBKEYLO_EL1 = 88,
    APDBKEYHI_EL1 = 89,
    APGAKEYLO_EL1 = 90,
    APGAKEYHI_EL1 = 91,
    RGSR_EL1 = 92,
    GCR_EL1 = 93,
    TFSRE0_EL1 = 94,
    POR_EL0 = 95,
    SVCR = 96,
    FPMR = 97,
    DACR32_EL2 = 98,
    IFSR32_EL2 = 99,
    FPEXC32_EL2 = 100,
    DBGVCR32_EL2 = 101,
    SCTLR_EL2 = 102,
    ACTLR_EL2 = 103,
    CPTR_EL2 = 104,
    HACR_EL2 = 105,
    ZCR_EL2 = 106,
    TTBR0_EL2 = 107,
    TTBR1_EL2 = 108,
    TCR_EL2 = 109,
    PIRE0_EL2 = 110,
    PIR_EL2 = 111,
    POR_EL2 = 112,
    SPSR_EL2 = 113,
    ELR_EL2 = 114,
    AFSR0_EL2 = 115,
    AFSR1_EL2 = 116,
    ESR_EL2 = 117,
    FAR_EL2 = 118,
    HPFAR_EL2 = 119,
    MAIR_EL2 = 120,
    AMAIR_EL2 = 121,
    VBAR_EL2 = 122,
    RVBAR_EL2 = 123,
    CONTEXTIDR_EL2 = 124,
    SP_EL2 = 125,
    CNTHP_CTL_EL2 = 126,
    CNTHP_CVAL_EL2 = 127,
    CNTHV_CTL_EL2 = 128,
    CNTHV_CVAL_EL2 = 129,
    __SANITISED_REG_START__ = 130,
    __after___SANITISED_REG_START__ = 129,
    TCR2_EL2 = 130,
    MDCR_EL2 = 131,
    CNTHCTL_EL2 = 132,
    __VNCR_START__ = 133,
    __after___VNCR_START__ = 132,
    __before_SCTLR_EL1 = 133,
    SCTLR_EL1 = 167,
    __after_SCTLR_EL1 = 167,
    __before_ACTLR_EL1 = 168,
    ACTLR_EL1 = 168,
    __after_ACTLR_EL1 = 168,
    __before_CPACR_EL1 = 169,
    CPACR_EL1 = 165,
    __after_CPACR_EL1 = 168,
    __before_ZCR_EL1 = 169,
    ZCR_EL1 = 193,
    __after_ZCR_EL1 = 193,
    __before_TTBR0_EL1 = 194,
    TTBR0_EL1 = 197,
    __after_TTBR0_EL1 = 197,
    __before_TTBR1_EL1 = 198,
    TTBR1_EL1 = 199,
    __after_TTBR1_EL1 = 199,
    __before_TCR_EL1 = 200,
    TCR_EL1 = 169,
    __after_TCR_EL1 = 199,
    __before_TCR2_EL1 = 200,
    TCR2_EL1 = 211,
    __after_TCR2_EL1 = 211,
    __before_ESR_EL1 = 212,
    ESR_EL1 = 172,
    __after_ESR_EL1 = 211,
    __before_AFSR0_EL1 = 212,
    AFSR0_EL1 = 170,
    __after_AFSR0_EL1 = 211,
    __before_AFSR1_EL1 = 212,
    AFSR1_EL1 = 171,
    __after_AFSR1_EL1 = 211,
    __before_FAR_EL1 = 212,
    FAR_EL1 = 201,
    __after_FAR_EL1 = 211,
    __before_MAIR_EL1 = 212,
    MAIR_EL1 = 173,
    __after_MAIR_EL1 = 211,
    __before_VBAR_EL1 = 212,
    VBAR_EL1 = 207,
    __after_VBAR_EL1 = 211,
    __before_CONTEXTIDR_EL1 = 212,
    CONTEXTIDR_EL1 = 166,
    __after_CONTEXTIDR_EL1 = 211,
    __before_AMAIR_EL1 = 212,
    AMAIR_EL1 = 174,
    __after_AMAIR_EL1 = 211,
    __before_MDSCR_EL1 = 212,
    MDSCR_EL1 = 176,
    __after_MDSCR_EL1 = 211,
    __before_ELR_EL1 = 212,
    ELR_EL1 = 203,
    __after_ELR_EL1 = 211,
    __before_SP_EL1 = 212,
    SP_EL1 = 205,
    __after_SP_EL1 = 211,
    __before_SPSR_EL1 = 212,
    SPSR_EL1 = 177,
    __after_SPSR_EL1 = 211,
    __before_TFSR_EL1 = 212,
    TFSR_EL1 = 183,
    __after_TFSR_EL1 = 211,
    __before_VPIDR_EL2 = 212,
    VPIDR_EL2 = 150,
    __after_VPIDR_EL2 = 211,
    __before_VMPIDR_EL2 = 212,
    VMPIDR_EL2 = 143,
    __after_VMPIDR_EL2 = 211,
    __before_HCR_EL2 = 212,
    HCR_EL2 = 148,
    __after_HCR_EL2 = 211,
    __before_HSTR_EL2 = 212,
    HSTR_EL2 = 149,
    __after_HSTR_EL2 = 211,
    __before_VTTBR_EL2 = 212,
    VTTBR_EL2 = 137,
    __after_VTTBR_EL2 = 211,
    __before_VTCR_EL2 = 212,
    VTCR_EL2 = 141,
    __after_VTCR_EL2 = 211,
    __before_TPIDR_EL2 = 212,
    TPIDR_EL2 = 151,
    __after_TPIDR_EL2 = 211,
    __before_HCRX_EL2 = 212,
    HCRX_EL2 = 153,
    __after_HCRX_EL2 = 211,
    __before_PIR_EL1 = 212,
    PIR_EL1 = 217,
    __after_PIR_EL1 = 217,
    __before_PIRE0_EL1 = 218,
    PIRE0_EL1 = 215,
    __after_PIRE0_EL1 = 217,
    __before_POR_EL1 = 218,
    POR_EL1 = 218,
    __after_POR_EL1 = 218,
    __before_HFGRTR_EL2 = 219,
    HFGRTR_EL2 = 188,
    __after_HFGRTR_EL2 = 218,
    __before_HFGWTR_EL2 = 219,
    HFGWTR_EL2 = 189,
    __after_HFGWTR_EL2 = 218,
    __before_HFGITR_EL2 = 219,
    HFGITR_EL2 = 190,
    __after_HFGITR_EL2 = 218,
    __before_HDFGRTR_EL2 = 219,
    HDFGRTR_EL2 = 191,
    __after_HDFGRTR_EL2 = 218,
    __before_HDFGWTR_EL2 = 219,
    HDFGWTR_EL2 = 192,
    __after_HDFGWTR_EL2 = 218,
    __before_HAFGRTR_EL2 = 219,
    HAFGRTR_EL2 = 194,
    __after_HAFGRTR_EL2 = 218,
    __before_CNTVOFF_EL2 = 219,
    CNTVOFF_EL2 = 145,
    __after_CNTVOFF_EL2 = 218,
    __before_CNTV_CVAL_EL0 = 219,
    CNTV_CVAL_EL0 = 178,
    __after_CNTV_CVAL_EL0 = 218,
    __before_CNTV_CTL_EL0 = 219,
    CNTV_CTL_EL0 = 179,
    __after_CNTV_CTL_EL0 = 218,
    __before_CNTP_CVAL_EL0 = 219,
    CNTP_CVAL_EL0 = 180,
    __after_CNTP_CVAL_EL0 = 218,
    __before_CNTP_CTL_EL0 = 219,
    CNTP_CTL_EL0 = 181,
    __after_CNTP_CTL_EL0 = 218,
    __before_ICH_HCR_EL2 = 219,
    ICH_HCR_EL2 = 285,
    __after_ICH_HCR_EL2 = 285,
    NR_SYS_REGS = 286,
};

enum vdso_abi {
    VDSO_ABI_AA64 = 0,
    VDSO_ABI_AA32 = 1,
};

enum vdso_clock_mode {
    VDSO_CLOCKMODE_NONE = 0,
    VDSO_CLOCKMODE_ARCHTIMER = 1,
    VDSO_CLOCKMODE_ARCHTIMER_NOCOMPAT = 2,
    VDSO_CLOCKMODE_MAX = 3,
    VDSO_CLOCKMODE_TIMENS = 2147483647,
};

enum vec_type {
    ARM64_VEC_SVE = 0,
    ARM64_VEC_SME = 1,
    ARM64_VEC_MAX = 2,
};

enum verifier_phase {
    CHECK_META = 0,
    CHECK_TYPE = 1,
};

enum vesa_blank_mode {
    VESA_NO_BLANKING = 0,
    VESA_VSYNC_SUSPEND = 1,
    VESA_HSYNC_SUSPEND = 2,
    VESA_POWERDOWN = 3,
    VESA_BLANK_MAX = 3,
};

enum vgic_irq_config {
    VGIC_CONFIG_EDGE = 0,
    VGIC_CONFIG_LEVEL = 1,
};

enum vgic_type {
    VGIC_V2 = 0,
    VGIC_V3 = 1,
};

enum vhost_task_flags {
    VHOST_TASK_FLAGS_STOP = 0,
    VHOST_TASK_FLAGS_KILLED = 1,
};

enum visit_state {
    NOT_VISITED = 0,
    VISITED = 1,
    RESOLVED = 2,
};

enum vlan_flags {
    VLAN_FLAG_REORDER_HDR = 1,
    VLAN_FLAG_GVRP = 2,
    VLAN_FLAG_LOOSE_BINDING = 4,
    VLAN_FLAG_MVRP = 8,
    VLAN_FLAG_BRIDGE_BINDING = 16,
};

enum vlan_protos {
    VLAN_PROTO_8021Q = 0,
    VLAN_PROTO_8021AD = 1,
    VLAN_PROTO_NUM = 2,
};

enum vm_event_item {
    PGPGIN = 0,
    PGPGOUT = 1,
    PSWPIN = 2,
    PSWPOUT = 3,
    PGALLOC_DMA = 4,
    PGALLOC_DMA32 = 5,
    PGALLOC_NORMAL = 6,
    PGALLOC_MOVABLE = 7,
    ALLOCSTALL_DMA = 8,
    ALLOCSTALL_DMA32 = 9,
    ALLOCSTALL_NORMAL = 10,
    ALLOCSTALL_MOVABLE = 11,
    PGSCAN_SKIP_DMA = 12,
    PGSCAN_SKIP_DMA32 = 13,
    PGSCAN_SKIP_NORMAL = 14,
    PGSCAN_SKIP_MOVABLE = 15,
    PGFREE = 16,
    PGACTIVATE = 17,
    PGDEACTIVATE = 18,
    PGLAZYFREE = 19,
    PGFAULT = 20,
    PGMAJFAULT = 21,
    PGLAZYFREED = 22,
    PGREFILL = 23,
    PGREUSE = 24,
    PGSTEAL_KSWAPD = 25,
    PGSTEAL_DIRECT = 26,
    PGSTEAL_KHUGEPAGED = 27,
    PGSCAN_KSWAPD = 28,
    PGSCAN_DIRECT = 29,
    PGSCAN_KHUGEPAGED = 30,
    PGSCAN_DIRECT_THROTTLE = 31,
    PGSCAN_ANON = 32,
    PGSCAN_FILE = 33,
    PGSTEAL_ANON = 34,
    PGSTEAL_FILE = 35,
    PGINODESTEAL = 36,
    SLABS_SCANNED = 37,
    KSWAPD_INODESTEAL = 38,
    KSWAPD_LOW_WMARK_HIT_QUICKLY = 39,
    KSWAPD_HIGH_WMARK_HIT_QUICKLY = 40,
    PAGEOUTRUN = 41,
    PGROTATED = 42,
    DROP_PAGECACHE = 43,
    DROP_SLAB = 44,
    OOM_KILL = 45,
    PGMIGRATE_SUCCESS = 46,
    PGMIGRATE_FAIL = 47,
    THP_MIGRATION_SUCCESS = 48,
    THP_MIGRATION_FAIL = 49,
    THP_MIGRATION_SPLIT = 50,
    COMPACTMIGRATE_SCANNED = 51,
    COMPACTFREE_SCANNED = 52,
    COMPACTISOLATED = 53,
    COMPACTSTALL = 54,
    COMPACTFAIL = 55,
    COMPACTSUCCESS = 56,
    KCOMPACTD_WAKE = 57,
    KCOMPACTD_MIGRATE_SCANNED = 58,
    KCOMPACTD_FREE_SCANNED = 59,
    HTLB_BUDDY_PGALLOC = 60,
    HTLB_BUDDY_PGALLOC_FAIL = 61,
    CMA_ALLOC_SUCCESS = 62,
    CMA_ALLOC_FAIL = 63,
    UNEVICTABLE_PGCULLED = 64,
    UNEVICTABLE_PGSCANNED = 65,
    UNEVICTABLE_PGRESCUED = 66,
    UNEVICTABLE_PGMLOCKED = 67,
    UNEVICTABLE_PGMUNLOCKED = 68,
    UNEVICTABLE_PGCLEARED = 69,
    UNEVICTABLE_PGSTRANDED = 70,
    THP_FAULT_ALLOC = 71,
    THP_FAULT_FALLBACK = 72,
    THP_FAULT_FALLBACK_CHARGE = 73,
    THP_COLLAPSE_ALLOC = 74,
    THP_COLLAPSE_ALLOC_FAILED = 75,
    THP_FILE_ALLOC = 76,
    THP_FILE_FALLBACK = 77,
    THP_FILE_FALLBACK_CHARGE = 78,
    THP_FILE_MAPPED = 79,
    THP_SPLIT_PAGE = 80,
    THP_SPLIT_PAGE_FAILED = 81,
    THP_DEFERRED_SPLIT_PAGE = 82,
    THP_UNDERUSED_SPLIT_PAGE = 83,
    THP_SPLIT_PMD = 84,
    THP_SCAN_EXCEED_NONE_PTE = 85,
    THP_SCAN_EXCEED_SWAP_PTE = 86,
    THP_SCAN_EXCEED_SHARED_PTE = 87,
    THP_ZERO_PAGE_ALLOC = 88,
    THP_ZERO_PAGE_ALLOC_FAILED = 89,
    THP_SWPOUT = 90,
    THP_SWPOUT_FALLBACK = 91,
    BALLOON_INFLATE = 92,
    BALLOON_DEFLATE = 93,
    BALLOON_MIGRATE = 94,
    SWAP_RA = 95,
    SWAP_RA_HIT = 96,
    SWPIN_ZERO = 97,
    SWPOUT_ZERO = 98,
    ZSWPIN = 99,
    ZSWPOUT = 100,
    ZSWPWB = 101,
    NR_VM_EVENT_ITEMS = 102,
};

enum vm_fault_reason {
    VM_FAULT_OOM = 1,
    VM_FAULT_SIGBUS = 2,
    VM_FAULT_MAJOR = 4,
    VM_FAULT_HWPOISON = 16,
    VM_FAULT_HWPOISON_LARGE = 32,
    VM_FAULT_SIGSEGV = 64,
    VM_FAULT_NOPAGE = 256,
    VM_FAULT_LOCKED = 512,
    VM_FAULT_RETRY = 1024,
    VM_FAULT_FALLBACK = 2048,
    VM_FAULT_DONE_COW = 4096,
    VM_FAULT_NEEDDSYNC = 8192,
    VM_FAULT_COMPLETED = 16384,
    VM_FAULT_HINDEX_MASK = 983040,
};

enum vm_stat_item {
    NR_DIRTY_THRESHOLD = 0,
    NR_DIRTY_BG_THRESHOLD = 1,
    NR_MEMMAP_PAGES = 2,
    NR_MEMMAP_BOOT_PAGES = 3,
    NR_VM_STAT_ITEMS = 4,
};

enum vma_merge_flags {
    VMG_FLAG_DEFAULT = 0,
    VMG_FLAG_JUST_EXPAND = 1,
};

enum vma_merge_state {
    VMA_MERGE_START = 0,
    VMA_MERGE_ERROR_NOMEM = 1,
    VMA_MERGE_NOMERGE = 2,
    VMA_MERGE_SUCCESS = 3,
};

enum vma_resv_mode {
    VMA_NEEDS_RESV = 0,
    VMA_COMMIT_RESV = 1,
    VMA_END_RESV = 2,
    VMA_ADD_RESV = 3,
    VMA_DEL_RESV = 4,
};

enum vmpressure_levels {
    VMPRESSURE_LOW = 0,
    VMPRESSURE_MEDIUM = 1,
    VMPRESSURE_CRITICAL = 2,
    VMPRESSURE_NUM_LEVELS = 3,
};

enum vmpressure_modes {
    VMPRESSURE_NO_PASSTHROUGH = 0,
    VMPRESSURE_HIERARCHY = 1,
    VMPRESSURE_LOCAL = 2,
    VMPRESSURE_NUM_MODES = 3,
};

enum vmscan_throttle_state {
    VMSCAN_THROTTLE_WRITEBACK = 0,
    VMSCAN_THROTTLE_ISOLATED = 1,
    VMSCAN_THROTTLE_NOPROGRESS = 2,
    VMSCAN_THROTTLE_CONGESTED = 3,
    NR_VMSCAN_THROTTLE = 4,
};

enum vtime_state {
    VTIME_INACTIVE = 0,
    VTIME_IDLE = 1,
    VTIME_SYS = 2,
    VTIME_USER = 3,
    VTIME_GUEST = 4,
};

enum vvar_pages {
    VVAR_DATA_PAGE_OFFSET = 0,
    VVAR_TIMENS_PAGE_OFFSET = 1,
    VVAR_NR_PAGES = 2,
};

enum watch_meta_notification_subtype {
    WATCH_META_REMOVAL_NOTIFICATION = 0,
    WATCH_META_LOSS_NOTIFICATION = 1,
};

enum watch_notification_type {
    WATCH_TYPE_META = 0,
    WATCH_TYPE_KEY_NOTIFY = 1,
    WATCH_TYPE__NR = 2,
};

enum wb_reason {
    WB_REASON_BACKGROUND = 0,
    WB_REASON_VMSCAN = 1,
    WB_REASON_SYNC = 2,
    WB_REASON_PERIODIC = 3,
    WB_REASON_LAPTOP_TIMER = 4,
    WB_REASON_FS_FREE_SPACE = 5,
    WB_REASON_FORKER_THREAD = 6,
    WB_REASON_FOREIGN_FLUSH = 7,
    WB_REASON_MAX = 8,
};

enum wb_stat_item {
    WB_RECLAIMABLE = 0,
    WB_WRITEBACK = 1,
    WB_DIRTIED = 2,
    WB_WRITTEN = 3,
    NR_WB_STAT_ITEMS = 4,
};

enum wb_state {
    WB_registered = 0,
    WB_writeback_running = 1,
    WB_has_dirty_io = 2,
    WB_start_all = 3,
};

enum wbt_flags {
    WBT_TRACKED = 1,
    WBT_READ = 2,
    WBT_SWAP = 4,
    WBT_DISCARD = 8,
    WBT_NR_BITS = 4,
};

enum wiphy_flags {
    WIPHY_FLAG_SUPPORTS_EXT_KEK_KCK = 1,
    WIPHY_FLAG_SUPPORTS_MLO = 2,
    WIPHY_FLAG_SPLIT_SCAN_6GHZ = 4,
    WIPHY_FLAG_NETNS_OK = 8,
    WIPHY_FLAG_PS_ON_BY_DEFAULT = 16,
    WIPHY_FLAG_4ADDR_AP = 32,
    WIPHY_FLAG_4ADDR_STATION = 64,
    WIPHY_FLAG_CONTROL_PORT_PROTOCOL = 128,
    WIPHY_FLAG_IBSS_RSN = 256,
    WIPHY_FLAG_DISABLE_WEXT = 512,
    WIPHY_FLAG_MESH_AUTH = 1024,
    WIPHY_FLAG_SUPPORTS_EXT_KCK_32 = 2048,
    WIPHY_FLAG_SUPPORTS_NSTR_NONPRIMARY = 4096,
    WIPHY_FLAG_SUPPORTS_FW_ROAM = 8192,
    WIPHY_FLAG_AP_UAPSD = 16384,
    WIPHY_FLAG_SUPPORTS_TDLS = 32768,
    WIPHY_FLAG_TDLS_EXTERNAL_SETUP = 65536,
    WIPHY_FLAG_HAVE_AP_SME = 131072,
    WIPHY_FLAG_REPORTS_OBSS = 262144,
    WIPHY_FLAG_AP_PROBE_RESP_OFFLOAD = 524288,
    WIPHY_FLAG_OFFCHAN_TX = 1048576,
    WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL = 2097152,
    WIPHY_FLAG_SUPPORTS_5_10_MHZ = 4194304,
    WIPHY_FLAG_HAS_CHANNEL_SWITCH = 8388608,
    WIPHY_FLAG_NOTIFY_REGDOM_BY_DRIVER = 16777216,
    WIPHY_FLAG_CHANNEL_CHANGE_ON_BEACON = 33554432,
};

enum work_bits {
    WORK_STRUCT_PENDING_BIT = 0,
    WORK_STRUCT_INACTIVE_BIT = 1,
    WORK_STRUCT_PWQ_BIT = 2,
    WORK_STRUCT_LINKED_BIT = 3,
    WORK_STRUCT_FLAG_BITS = 4,
    WORK_STRUCT_COLOR_SHIFT = 4,
    WORK_STRUCT_COLOR_BITS = 4,
    WORK_STRUCT_PWQ_SHIFT = 8,
    WORK_OFFQ_FLAG_SHIFT = 4,
    WORK_OFFQ_BH_BIT = 4,
    WORK_OFFQ_FLAG_END = 5,
    WORK_OFFQ_FLAG_BITS = 1,
    WORK_OFFQ_DISABLE_SHIFT = 5,
    WORK_OFFQ_DISABLE_BITS = 16,
    WORK_OFFQ_POOL_SHIFT = 21,
    WORK_OFFQ_LEFT = 43,
    WORK_OFFQ_POOL_BITS = 31,
};

enum work_cancel_flags {
    WORK_CANCEL_DELAYED = 1,
    WORK_CANCEL_DISABLE = 2,
};

enum work_flags {
    WORK_STRUCT_PENDING = 1,
    WORK_STRUCT_INACTIVE = 2,
    WORK_STRUCT_PWQ = 4,
    WORK_STRUCT_LINKED = 8,
    WORK_STRUCT_STATIC = 0,
};

enum worker_flags {
    WORKER_DIE = 2,
    WORKER_IDLE = 4,
    WORKER_PREP = 8,
    WORKER_CPU_INTENSIVE = 64,
    WORKER_UNBOUND = 128,
    WORKER_REBOUND = 256,
    WORKER_NOT_RUNNING = 456,
};

enum worker_pool_flags {
    POOL_BH = 1,
    POOL_MANAGER_ACTIVE = 2,
    POOL_DISASSOCIATED = 4,
    POOL_BH_DRAINING = 8,
};

enum wq_affn_scope {
    WQ_AFFN_DFL = 0,
    WQ_AFFN_CPU = 1,
    WQ_AFFN_SMT = 2,
    WQ_AFFN_CACHE = 3,
    WQ_AFFN_NUMA = 4,
    WQ_AFFN_SYSTEM = 5,
    WQ_AFFN_NR_TYPES = 6,
};

enum wq_consts {
    WQ_MAX_ACTIVE = 2048,
    WQ_UNBOUND_MAX_ACTIVE = 2048,
    WQ_DFL_ACTIVE = 1024,
    WQ_DFL_MIN_ACTIVE = 8,
};

enum wq_flags {
    WQ_BH = 1,
    WQ_UNBOUND = 2,
    WQ_FREEZABLE = 4,
    WQ_MEM_RECLAIM = 8,
    WQ_HIGHPRI = 16,
    WQ_CPU_INTENSIVE = 32,
    WQ_SYSFS = 64,
    WQ_POWER_EFFICIENT = 128,
    __WQ_DESTROYING = 32768,
    __WQ_DRAINING = 65536,
    __WQ_ORDERED = 131072,
    __WQ_LEGACY = 262144,
    __WQ_BH_ALLOWS = 17,
};

enum wq_internal_consts {
    NR_STD_WORKER_POOLS = 2,
    UNBOUND_POOL_HASH_ORDER = 6,
    BUSY_WORKER_HASH_ORDER = 6,
    MAX_IDLE_WORKERS_RATIO = 4,
    IDLE_WORKER_TIMEOUT = 300000,
    MAYDAY_INITIAL_TIMEOUT = 10,
    MAYDAY_INTERVAL = 100,
    CREATE_COOLDOWN = 1000,
    RESCUER_NICE_LEVEL = -20,
    HIGHPRI_NICE_LEVEL = -20,
    WQ_NAME_LEN = 32,
    WORKER_ID_LEN = 42,
};

enum wq_misc_consts {
    WORK_NR_COLORS = 16,
    WORK_CPU_UNBOUND = 256,
    WORK_BUSY_PENDING = 1,
    WORK_BUSY_RUNNING = 2,
    WORKER_DESC_LEN = 32,
};

enum writeback_sync_modes {
    WB_SYNC_NONE = 0,
    WB_SYNC_ALL = 1,
};

enum x509_actions {
    ACT_x509_extract_key_data = 0,
    ACT_x509_extract_name_segment = 1,
    ACT_x509_note_OID = 2,
    ACT_x509_note_issuer = 3,
    ACT_x509_note_not_after = 4,
    ACT_x509_note_not_before = 5,
    ACT_x509_note_params = 6,
    ACT_x509_note_serial = 7,
    ACT_x509_note_sig_algo = 8,
    ACT_x509_note_signature = 9,
    ACT_x509_note_subject = 10,
    ACT_x509_note_tbs_certificate = 11,
    ACT_x509_process_extension = 12,
    NR__x509_actions = 13,
};

enum x509_akid_actions {
    ACT_x509_akid_note_kid = 0,
    ACT_x509_akid_note_name = 1,
    ACT_x509_akid_note_serial = 2,
    ACT_x509_extract_name_segment___2 = 3,
    ACT_x509_note_OID___2 = 4,
    NR__x509_akid_actions = 5,
};

enum xa_lock_type {
    XA_LOCK_IRQ = 1,
    XA_LOCK_BH = 2,
};

enum xdp_action {
    XDP_ABORTED = 0,
    XDP_DROP = 1,
    XDP_PASS = 2,
    XDP_TX = 3,
    XDP_REDIRECT = 4,
};

enum xdp_buff_flags {
    XDP_FLAGS_HAS_FRAGS = 1,
    XDP_FLAGS_FRAGS_PF_MEMALLOC = 2,
};

enum xdp_mem_type {
    MEM_TYPE_PAGE_SHARED = 0,
    MEM_TYPE_PAGE_ORDER0 = 1,
    MEM_TYPE_PAGE_POOL = 2,
    MEM_TYPE_XSK_BUFF_POOL = 3,
    MEM_TYPE_MAX = 4,
};

enum xdp_rss_hash_type {
    XDP_RSS_L3_IPV4 = 1,
    XDP_RSS_L3_IPV6 = 2,
    XDP_RSS_L3_DYNHDR = 4,
    XDP_RSS_L4 = 8,
    XDP_RSS_L4_TCP = 16,
    XDP_RSS_L4_UDP = 32,
    XDP_RSS_L4_SCTP = 64,
    XDP_RSS_L4_IPSEC = 128,
    XDP_RSS_L4_ICMP = 256,
    XDP_RSS_TYPE_NONE = 0,
    XDP_RSS_TYPE_L2 = 0,
    XDP_RSS_TYPE_L3_IPV4 = 1,
    XDP_RSS_TYPE_L3_IPV6 = 2,
    XDP_RSS_TYPE_L3_IPV4_OPT = 5,
    XDP_RSS_TYPE_L3_IPV6_EX = 6,
    XDP_RSS_TYPE_L4_ANY = 8,
    XDP_RSS_TYPE_L4_IPV4_TCP = 25,
    XDP_RSS_TYPE_L4_IPV4_UDP = 41,
    XDP_RSS_TYPE_L4_IPV4_SCTP = 73,
    XDP_RSS_TYPE_L4_IPV4_IPSEC = 137,
    XDP_RSS_TYPE_L4_IPV4_ICMP = 265,
    XDP_RSS_TYPE_L4_IPV6_TCP = 26,
    XDP_RSS_TYPE_L4_IPV6_UDP = 42,
    XDP_RSS_TYPE_L4_IPV6_SCTP = 74,
    XDP_RSS_TYPE_L4_IPV6_IPSEC = 138,
    XDP_RSS_TYPE_L4_IPV6_ICMP = 266,
    XDP_RSS_TYPE_L4_IPV6_TCP_EX = 30,
    XDP_RSS_TYPE_L4_IPV6_UDP_EX = 46,
    XDP_RSS_TYPE_L4_IPV6_SCTP_EX = 78,
};

enum xdp_rx_metadata {
    XDP_METADATA_KFUNC_RX_TIMESTAMP = 0,
    XDP_METADATA_KFUNC_RX_HASH = 1,
    XDP_METADATA_KFUNC_RX_VLAN_TAG = 2,
    MAX_XDP_METADATA_KFUNC = 3,
};

enum xen_domain_type {
    XEN_NATIVE = 0,
    XEN_PV_DOMAIN = 1,
    XEN_HVM_DOMAIN = 2,
};

enum xfrm_ae_ftype_t {
    XFRM_AE_UNSPEC = 0,
    XFRM_AE_RTHR = 1,
    XFRM_AE_RVAL = 2,
    XFRM_AE_LVAL = 4,
    XFRM_AE_ETHR = 8,
    XFRM_AE_CR = 16,
    XFRM_AE_CE = 32,
    XFRM_AE_CU = 64,
    __XFRM_AE_MAX = 65,
};

enum xfrm_attr_type_t {
    XFRMA_UNSPEC = 0,
    XFRMA_ALG_AUTH = 1,
    XFRMA_ALG_CRYPT = 2,
    XFRMA_ALG_COMP = 3,
    XFRMA_ENCAP = 4,
    XFRMA_TMPL = 5,
    XFRMA_SA = 6,
    XFRMA_POLICY = 7,
    XFRMA_SEC_CTX = 8,
    XFRMA_LTIME_VAL = 9,
    XFRMA_REPLAY_VAL = 10,
    XFRMA_REPLAY_THRESH = 11,
    XFRMA_ETIMER_THRESH = 12,
    XFRMA_SRCADDR = 13,
    XFRMA_COADDR = 14,
    XFRMA_LASTUSED = 15,
    XFRMA_POLICY_TYPE = 16,
    XFRMA_MIGRATE = 17,
    XFRMA_ALG_AEAD = 18,
    XFRMA_KMADDRESS = 19,
    XFRMA_ALG_AUTH_TRUNC = 20,
    XFRMA_MARK = 21,
    XFRMA_TFCPAD = 22,
    XFRMA_REPLAY_ESN_VAL = 23,
    XFRMA_SA_EXTRA_FLAGS = 24,
    XFRMA_PROTO = 25,
    XFRMA_ADDRESS_FILTER = 26,
    XFRMA_PAD = 27,
    XFRMA_OFFLOAD_DEV = 28,
    XFRMA_SET_MARK = 29,
    XFRMA_SET_MARK_MASK = 30,
    XFRMA_IF_ID = 31,
    XFRMA_MTIMER_THRESH = 32,
    XFRMA_SA_DIR = 33,
    XFRMA_NAT_KEEPALIVE_INTERVAL = 34,
    XFRMA_SA_PCPU = 35,
    XFRMA_IPTFS_DROP_TIME = 36,
    XFRMA_IPTFS_REORDER_WINDOW = 37,
    XFRMA_IPTFS_DONT_FRAG = 38,
    XFRMA_IPTFS_INIT_DELAY = 39,
    XFRMA_IPTFS_MAX_QSIZE = 40,
    XFRMA_IPTFS_PKT_SIZE = 41,
    __XFRMA_MAX = 42,
};

enum xfrm_nlgroups {
    XFRMNLGRP_NONE = 0,
    XFRMNLGRP_ACQUIRE = 1,
    XFRMNLGRP_EXPIRE = 2,
    XFRMNLGRP_SA = 3,
    XFRMNLGRP_POLICY = 4,
    XFRMNLGRP_AEVENTS = 5,
    XFRMNLGRP_REPORT = 6,
    XFRMNLGRP_MIGRATE = 7,
    XFRMNLGRP_MAPPING = 8,
    __XFRMNLGRP_MAX = 9,
};

enum xfrm_pol_inexact_candidate_type {
    XFRM_POL_CAND_BOTH = 0,
    XFRM_POL_CAND_SADDR = 1,
    XFRM_POL_CAND_DADDR = 2,
    XFRM_POL_CAND_ANY = 3,
    XFRM_POL_CAND_MAX = 4,
};

enum xfrm_replay_mode {
    XFRM_REPLAY_MODE_LEGACY = 0,
    XFRM_REPLAY_MODE_BMP = 1,
    XFRM_REPLAY_MODE_ESN = 2,
};

enum xfrm_sa_dir {
    XFRM_SA_DIR_IN = 1,
    XFRM_SA_DIR_OUT = 2,
};

enum xhci_cancelled_td_status {
    TD_DIRTY = 0,
    TD_HALTED = 1,
    TD_CLEARING_CACHE = 2,
    TD_CLEARING_CACHE_DEFERRED = 3,
    TD_CLEARED = 4,
};

enum xhci_ep_reset_type {
    EP_HARD_RESET = 0,
    EP_SOFT_RESET = 1,
};

enum xhci_overhead_type {
    LS_OVERHEAD_TYPE = 0,
    FS_OVERHEAD_TYPE = 1,
    HS_OVERHEAD_TYPE = 2,
};

enum xhci_ring_type {
    TYPE_CTRL = 0,
    TYPE_ISOC = 1,
    TYPE_BULK = 2,
    TYPE_INTR = 3,
    TYPE_STREAM = 4,
    TYPE_COMMAND = 5,
    TYPE_EVENT = 6,
};

enum xhci_setup_dev {
    SETUP_CONTEXT_ONLY = 0,
    SETUP_CONTEXT_ADDRESS = 1,
};

enum xprtsec_policies {
    RPC_XPRTSEC_NONE = 0,
    RPC_XPRTSEC_TLS_ANON = 1,
    RPC_XPRTSEC_TLS_X509 = 2,
};

enum xps_map_type {
    XPS_CPUS = 0,
    XPS_RXQS = 1,
    XPS_MAPS_MAX = 2,
};

enum xz_check {
    XZ_CHECK_NONE = 0,
    XZ_CHECK_CRC32 = 1,
    XZ_CHECK_CRC64 = 4,
    XZ_CHECK_SHA256 = 10,
};

enum xz_mode {
    XZ_SINGLE = 0,
    XZ_PREALLOC = 1,
    XZ_DYNALLOC = 2,
};

enum xz_ret {
    XZ_OK = 0,
    XZ_STREAM_END = 1,
    XZ_UNSUPPORTED_CHECK = 2,
    XZ_MEM_ERROR = 3,
    XZ_MEMLIMIT_ERROR = 4,
    XZ_FORMAT_ERROR = 5,
    XZ_OPTIONS_ERROR = 6,
    XZ_DATA_ERROR = 7,
    XZ_BUF_ERROR = 8,
};

enum zbc_zone_alignment_method {
    ZBC_CONSTANT_ZONE_LENGTH = 1,
    ZBC_CONSTANT_ZONE_START_OFFSET = 8,
};

enum zbc_zone_cond {
    ZBC_ZONE_COND_NO_WP = 0,
    ZBC_ZONE_COND_EMPTY = 1,
    ZBC_ZONE_COND_IMP_OPEN = 2,
    ZBC_ZONE_COND_EXP_OPEN = 3,
    ZBC_ZONE_COND_CLOSED = 4,
    ZBC_ZONE_COND_READONLY = 13,
    ZBC_ZONE_COND_FULL = 14,
    ZBC_ZONE_COND_OFFLINE = 15,
};

enum zbc_zone_type {
    ZBC_ZONE_TYPE_CONV = 1,
    ZBC_ZONE_TYPE_SEQWRITE_REQ = 2,
    ZBC_ZONE_TYPE_SEQWRITE_PREF = 3,
    ZBC_ZONE_TYPE_SEQ_OR_BEFORE_REQ = 4,
    ZBC_ZONE_TYPE_GAP = 5,
};

enum zone_flags {
    ZONE_BOOSTED_WATERMARK = 0,
    ZONE_RECLAIM_ACTIVE = 1,
    ZONE_BELOW_HIGH = 2,
};

enum zone_stat_item {
    NR_FREE_PAGES = 0,
    NR_ZONE_LRU_BASE = 1,
    NR_ZONE_INACTIVE_ANON = 1,
    NR_ZONE_ACTIVE_ANON = 2,
    NR_ZONE_INACTIVE_FILE = 3,
    NR_ZONE_ACTIVE_FILE = 4,
    NR_ZONE_UNEVICTABLE = 5,
    NR_ZONE_WRITE_PENDING = 6,
    NR_MLOCK = 7,
    NR_BOUNCE = 8,
    NR_ZSPAGES = 9,
    NR_FREE_CMA_PAGES = 10,
    NR_VM_ZONE_STAT_ITEMS = 11,
};

enum zone_type {
    ZONE_DMA = 0,
    ZONE_DMA32 = 1,
    ZONE_NORMAL = 2,
    ZONE_MOVABLE = 3,
    __MAX_NR_ZONES = 4,
};

enum zone_watermarks {
    WMARK_MIN = 0,
    WMARK_LOW = 1,
    WMARK_HIGH = 2,
    WMARK_PROMO = 3,
    NR_WMARK = 4,
};

enum zpool_mapmode {
    ZPOOL_MM_RW = 0,
    ZPOOL_MM_RO = 1,
    ZPOOL_MM_WO = 2,
    ZPOOL_MM_DEFAULT = 0,
};

enum zswap_init_type {
    ZSWAP_UNINIT = 0,
    ZSWAP_INIT_SUCCEED = 1,
    ZSWAP_INIT_FAILED = 2,
};

typedef _Bool bool;

typedef __int128 s_max;

typedef __int128 unsigned __u128;

typedef __u128 u128;

typedef u128 freelist_full_t;

typedef freelist_full_t pcp_op_T__;

typedef __int128 unsigned u_max;

typedef const char (* const ethnl_string_array_t)[32];

typedef int __kernel_clockid_t;

typedef int __kernel_daddr_t;

typedef int __kernel_ipc_pid_t;

typedef int __kernel_key_t;

typedef int __kernel_mqd_t;

typedef int __kernel_pid_t;

typedef int __kernel_rwf_t;

typedef int __kernel_timer_t;

typedef int __s32;

typedef int class_get_unused_fd_t;

typedef __kernel_clockid_t clockid_t;

typedef __s32 s32;

typedef s32 compat_clock_t;

typedef s32 compat_daddr_t;

typedef s32 compat_int_t;

typedef s32 compat_key_t;

typedef s32 compat_long_t;

typedef s32 compat_off_t;

typedef s32 compat_pid_t;

typedef s32 compat_ssize_t;

typedef s32 compat_timer_t;

typedef int cydp_t;

typedef s32 dma_cookie_t;

typedef int ext4_grpblk_t;

typedef int folio_walk_flags_t;

typedef int fpb_t;

typedef int fpi_t;

typedef int initcall_entry_t;

typedef s32 int32_t;

typedef int32_t key_serial_t;

typedef __kernel_key_t key_t;

typedef int mpi_size_t;

typedef __kernel_mqd_t mqd_t;

typedef s32 old_time32_t;

typedef int pci_power_t;

typedef __kernel_pid_t pid_t;

typedef int rmap_t;

typedef __kernel_rwf_t rwf_t;

typedef __s32 sctp_assoc_t;

typedef int suspend_state_t;

typedef __kernel_timer_t timer_t;

typedef const int tracepoint_ptr_t;

typedef long int __kernel_long_t;

typedef __kernel_long_t __kernel_clock_t;

typedef __kernel_long_t __kernel_off_t;

typedef __kernel_long_t __kernel_old_time_t;

typedef __kernel_long_t __kernel_ptrdiff_t;

typedef __kernel_long_t __kernel_ssize_t;

typedef __kernel_long_t __kernel_suseconds_t;

typedef __kernel_clock_t clock_t;

typedef long int intptr_t;

typedef long int mpi_limb_signed_t;

typedef __kernel_off_t off_t;

typedef volatile long int prel64_t;

typedef __kernel_ptrdiff_t ptrdiff_t;

typedef __kernel_ssize_t ssize_t;

typedef __kernel_suseconds_t suseconds_t;

typedef long long int __s64;

typedef __s64 Elf64_Sxword;

typedef long long int __kernel_loff_t;

typedef long long int __kernel_time64_t;

typedef __s64 s64;

typedef s64 compat_loff_t;

typedef s64 compat_s64;

typedef s64 int64_t;

typedef s64 ktime_t;

typedef __kernel_loff_t loff_t;

typedef long long int qsize_t;

typedef __s64 time64_t;

typedef long long unsigned int __u64;

typedef __u64 Elf64_Addr;

typedef __u64 Elf64_Off;

typedef __u64 Elf64_Xword;

typedef __u64 u64;

typedef u64 uint64_t;

typedef uint64_t U64;

typedef U64 ZSTD_VecMask;

typedef __u64 __addrpair;

typedef __u64 __be64;

typedef __u64 __le64;

typedef u64 acpi_io_address;

typedef u64 arm_lpae_iopte;

typedef u64 async_cookie_t;

typedef __u64 blist_flags_t;

typedef u64 blkcnt_t;

typedef u64 compat_u64;

typedef u64 dma_addr_t;

typedef u64 efi_physical_addr_t;

typedef long long unsigned int ext4_fsblk_t;

typedef __be64 fdt64_t;

typedef u64 gfn_t;

typedef u64 gpa_t;

typedef u64 hfn_t;

typedef u64 hpa_t;

typedef u64 io_req_flags_t;

typedef hfn_t kvm_pfn_t;

typedef u64 kvm_pte_t;

typedef kvm_pte_t *kvm_pteref_t;

typedef long long unsigned int llu;

typedef u64 netdev_features_t;

typedef u64 p4dval_t;

typedef u64 pci_bus_addr_t;

typedef u64 pgdval_t;

typedef u64 phys_addr_t;

typedef u64 pmdval_t;

typedef u64 pteval_t;

typedef u64 pudval_t;

typedef phys_addr_t resource_size_t;

typedef u64 sci_t;

typedef u64 sector_t;

typedef __u64 timeu64_t;

typedef u64 u_int64_t;

typedef u64 upf_t;

typedef uint64_t vli_type;

typedef long unsigned int __kernel_ulong_t;

typedef __kernel_ulong_t __kernel_size_t;

typedef __kernel_size_t size_t;

typedef size_t HUF_CElt;

typedef long unsigned int mpi_limb_t;

typedef mpi_limb_t UWtype;

typedef __kernel_ulong_t aio_context_t;

typedef long unsigned int cycles_t;

typedef long unsigned int efi_status_t;

typedef long unsigned int elf_greg_t;

typedef elf_greg_t elf_gregset_t[34];

typedef long unsigned int hva_t;

typedef __kernel_ulong_t ino_t;

typedef long unsigned int irq_hw_number_t;

typedef long unsigned int kernel_ulong_t;

typedef long unsigned int kimage_entry_t;

typedef mpi_limb_t *mpi_ptr_t;

typedef long unsigned int netmem_ref;

typedef long unsigned int old_sigset_t;

typedef long unsigned int perf_trace_t[1024];

typedef long unsigned int pte_marker;

typedef long unsigned int uLong;

typedef long unsigned int uintptr_t;

typedef long unsigned int ulg;

typedef long unsigned int ulong;

typedef uintptr_t uptrval;

typedef long unsigned int vm_flags_t;

typedef short int __s16;

typedef __s16 s16;

typedef s16 int16_t;

typedef int16_t S16;

typedef short unsigned int __u16;

typedef __u16 Elf32_Half;

typedef __u16 Elf64_Half;

typedef short unsigned int ush;

typedef ush Pos;

typedef __u16 u16;

typedef u16 uint16_t;

typedef uint16_t U16;

typedef __u16 __be16;

typedef u16 __compat_gid16_t;

typedef u16 __compat_gid_t;

typedef u16 __compat_uid16_t;

typedef u16 __compat_uid_t;

typedef short unsigned int __kernel_gid16_t;

typedef short unsigned int __kernel_old_gid_t;

typedef short unsigned int __kernel_old_uid_t;

typedef short unsigned int __kernel_sa_family_t;

typedef short unsigned int __kernel_uid16_t;

typedef __u16 __le16;

typedef __u16 __sum16;

typedef __u16 __virtio16;

typedef u16 access_mask_t;

typedef __u16 comp_t;

typedef u16 compat_ipc_pid_t;

typedef u16 compat_mode_t;

typedef u16 compat_ushort_t;

typedef u16 efi_char16_t;

typedef __kernel_gid16_t gid16_t;

typedef u16 layer_mask_t;

typedef short unsigned int mifi_t;

typedef __kernel_old_gid_t old_gid_t;

typedef __kernel_old_uid_t old_uid_t;

typedef short unsigned int pci_bus_flags_t;

typedef short unsigned int pci_dev_flags_t;

typedef __u16 port_id;

typedef __kernel_sa_family_t sa_family_t;

typedef u16 u_int16_t;

typedef short unsigned int u_short;

typedef u16 ucs2_char_t;

typedef __kernel_uid16_t uid16_t;

typedef __u16 uio_meta_flags_t;

typedef short unsigned int umode_t;

typedef short unsigned int ushort;

typedef short unsigned int vifi_t;

typedef u16 wchar_t;

typedef signed char __s8;

typedef __s8 s8;

typedef unsigned char __u8;

typedef __u8 u8;

typedef u8 uint8_t;

typedef uint8_t BYTE;

typedef unsigned char Byte;

typedef uint8_t U8;

typedef u8 blk_status_t;

typedef unsigned char cc_t;

typedef u8 dscp_t;

typedef u8 efi_bool_t;

typedef unsigned char u8___2;

typedef unsigned char u_char;

typedef u8 u_int8_t;

typedef unsigned char uch;

typedef const unsigned char utf8leaf_t;

typedef const unsigned char utf8trie_t;

typedef unsigned int __u32;

typedef __u32 Elf32_Addr;

typedef __u32 Elf32_Off;

typedef __u32 Elf32_Word;

typedef __u32 Elf64_Word;

typedef unsigned int FSE_CTable;

typedef unsigned int FSE_DTable;

typedef __u32 u32;

typedef u32 uint32_t;

typedef uint32_t U32;

typedef U32 HUF_DTable;

typedef unsigned int IPos;

typedef unsigned int UHWtype;

typedef __u32 __be32;

typedef u32 __compat_gid32_t;

typedef u32 __compat_uid32_t;

typedef u32 __kernel_dev_t;

typedef unsigned int __kernel_gid32_t;

typedef unsigned int __kernel_gid_t;

typedef unsigned int __kernel_mode_t;

typedef unsigned int __kernel_old_dev_t;

typedef unsigned int __kernel_uid32_t;

typedef unsigned int __kernel_uid_t;

typedef __u32 __le32;

typedef unsigned int __poll_t;

typedef __u32 __portpair;

typedef __u32 __wsum;

typedef u32 acpi_object_type;

typedef unsigned int blk_features_t;

typedef unsigned int blk_flags_t;

typedef unsigned int blk_insert_t;

typedef unsigned int blk_mode_t;

typedef __u32 blk_mq_req_flags_t;

typedef __u32 blk_opf_t;

typedef unsigned int blk_qc_t;

typedef u32 compat_aio_context_t;

typedef u32 compat_caddr_t;

typedef u32 compat_dev_t;

typedef unsigned int compat_elf_greg_t;

typedef compat_elf_greg_t compat_elf_gregset_t[18];

typedef u32 compat_ino_t;

typedef u32 compat_old_sigset_t;

typedef u32 compat_sigset_word;

typedef u32 compat_size_t;

typedef u32 compat_uint_t;

typedef u32 compat_ulong_t;

typedef u32 compat_uptr_t;

typedef u32 depot_flags_t;

typedef u32 depot_stack_handle_t;

typedef __kernel_dev_t dev_t;

typedef uint32_t drbg_flag_t;

typedef unsigned int drm_magic_t;

typedef u32 efi_cc_event_algorithm_bitmap_t;

typedef u32 efi_cc_event_log_bitmap_t;

typedef u32 efi_cc_event_log_format_t;

typedef u32 efi_cc_mr_index_t;

typedef u32 efi_tcg2_event_log_format;

typedef u32 errseq_t;

typedef unsigned int ext4_group_t;

typedef __u32 ext4_lblk_t;

typedef __be32 fdt32_t;

typedef unsigned int fgf_t;

typedef unsigned int fmode_t;

typedef unsigned int fop_flags_t;

typedef unsigned int gfp_t;

typedef __kernel_gid32_t gid_t;

typedef __u32 if_mask;

typedef unsigned int ioasid_t;

typedef unsigned int iov_iter_extraction_t;

typedef unsigned int isolate_mode_t;

typedef unsigned int kasan_vmalloc_flags_t;

typedef uint32_t key_perm_t;

typedef __le32 kprobe_opcode_t;

typedef unsigned int mmc_pm_flag_t;

typedef __kernel_mode_t mode_t;

typedef u32 nlink_t;

typedef u32 note_buf_t[106];

typedef unsigned int pci_channel_state_t;

typedef unsigned int pci_ers_result_t;

typedef unsigned int pgtbl_mod_mask;

typedef u32 phandle;

typedef unsigned int pipe_index_t;

typedef unsigned int pkvm_handle_t;

typedef __kernel_uid32_t projid_t;

typedef __kernel_uid32_t qid_t;

typedef U32 rankValCol_t[13];

typedef __u32 req_flags_t;

typedef u32 rpc_authflavor_t;

typedef unsigned int sk_buff_data_t;

typedef unsigned int slab_flags_t;

typedef unsigned int speed_t;

typedef u32 ssci_t;

typedef unsigned int t_key;

typedef unsigned int tcflag_t;

typedef unsigned int tid_t;

typedef unsigned int uInt;

typedef unsigned int u_int;

typedef u32 u_int32_t;

typedef unsigned int uffd_flags_t;

typedef __kernel_uid32_t uid_t;

typedef unsigned int uint;

typedef u32 unicode_t;

typedef __le32 uprobe_opcode_t;

typedef unsigned int upstat_t;

typedef u32 usb_port_location_t;

typedef unsigned int vm_fault_t;

typedef unsigned int xa_mark_t;

typedef u32 xdp_features_t;

typedef unsigned int zap_flags_t;

typedef struct {
    size_t bitContainer;
    unsigned int bitPos;
    char *startPtr;
    char *ptr;
    char *endPtr;
} BIT_CStream_t;

typedef struct {
    size_t bitContainer;
    unsigned int bitsConsumed;
    const char *ptr;
    const char *start;
    const char *limitPtr;
} BIT_DStream_t;

typedef struct {
    BYTE maxTableLog;
    BYTE tableType;
    BYTE tableLog;
    BYTE reserved;
} DTableDesc;

typedef struct {
    ptrdiff_t value;
    const void *stateTable;
    const void *symbolTT;
    unsigned int stateLog;
} FSE_CState_t;

typedef struct {
    size_t state;
    const void *table;
} FSE_DState_t;

typedef struct {
    U16 tableLog;
    U16 fastMode;
} FSE_DTableHeader;

typedef struct {
    short int ncount[256];
    FSE_DTable dtable[0];
} FSE_DecompressWksp;

typedef struct {
    short unsigned int newState;
    unsigned char symbol;
    unsigned char nbBits;
} FSE_decode_t;

typedef struct {
    int deltaFindState;
    U32 deltaNbBits;
} FSE_symbolCompressionTransform;

typedef struct {
    size_t bitContainer[2];
    size_t bitPos[2];
    BYTE *startPtr;
    BYTE *ptr;
    BYTE *endPtr;
} HUF_CStream_t;

typedef struct {
    FSE_CTable CTable[59];
    U32 scratchBuffer[41];
    unsigned int count[13];
    S16 norm[13];
} HUF_CompressWeightsWksp;

typedef struct {
    BYTE nbBits;
    BYTE byte;
} HUF_DEltX1;

typedef struct {
    U16 sequence;
    BYTE nbBits;
    BYTE length;
} HUF_DEltX2;

typedef struct {
    U32 rankVal[13];
    U32 rankStart[13];
    U32 statsWksp[218];
    BYTE symbols[256];
    BYTE huffWeight[256];
} HUF_ReadDTableX1_Workspace;

typedef struct {
    BYTE symbol;
} sortedSymbol_t;

typedef struct {
    U32 rankVal[156];
    U32 rankStats[13];
    U32 rankStart0[15];
    sortedSymbol_t sortedSymbol[256];
    BYTE weightList[256];
    U32 calleeWksp[218];
} HUF_ReadDTableX2_Workspace;

typedef struct {
    HUF_CompressWeightsWksp wksp;
    BYTE bitsToWeight[13];
    BYTE huffWeight[255];
} HUF_WriteCTableWksp;

struct nodeElt_s {
    U32 count;
    U16 parent;
    BYTE byte;
    BYTE nbBits;
};

typedef struct nodeElt_s nodeElt;

typedef nodeElt huffNodeTable[512];

typedef struct {
    U16 base;
    U16 curr;
} rankPos;

typedef struct {
    huffNodeTable huffNodeTbl;
    rankPos rankPosition[192];
} HUF_buildCTable_wksp_tables;

typedef struct {
    unsigned int count[256];
    HUF_CElt CTable[257];
    union {
        HUF_buildCTable_wksp_tables buildCTable_wksp;
        HUF_WriteCTableWksp writeCTable_wksp;
        U32 hist_wksp[1024];
    } wksps;
} HUF_compress_tables_t;

struct buffer_head;

typedef struct {
    __le32 *p;
    __le32 key;
    struct buffer_head *bh;
} Indirect;

typedef struct {
    const uint8_t *externalDict;
    size_t extDictSize;
    const uint8_t *prefixEnd;
    size_t prefixSize;
} LZ4_streamDecode_t_internal;

typedef union {
    long long unsigned int table[4];
    LZ4_streamDecode_t_internal internal_donotuse;
} LZ4_streamDecode_t;

struct folio;

typedef struct {
    struct folio *v;
} Sector;

typedef struct {
    unsigned int offset;
    unsigned int litLength;
    unsigned int matchLength;
    unsigned int rep;
} ZSTD_Sequence;

typedef struct {
    int collectSequences;
    ZSTD_Sequence *seqStart;
    size_t seqIndex;
    size_t maxSequences;
} SeqCollector;

typedef struct {
    S16 norm[53];
    U32 wksp[285];
} ZSTD_BuildCTableWksp;

struct ZSTD_DDict_s;

typedef struct ZSTD_DDict_s ZSTD_DDict;

typedef struct {
    const ZSTD_DDict **ddictPtrTable;
    size_t ddictPtrTableSize;
    size_t ddictPtrCount;
} ZSTD_DDictHashSet;

struct seqDef_s;

typedef struct seqDef_s seqDef;

typedef struct {
    seqDef *sequencesStart;
    seqDef *sequences;
    BYTE *litStart;
    BYTE *lit;
    BYTE *llCode;
    BYTE *mlCode;
    BYTE *ofCode;
    size_t maxNbSeq;
    size_t maxNbLit;
    ZSTD_longLengthType_e longLengthType;
    U32 longLengthPos;
} seqStore_t;

typedef struct {
    symbolEncodingType_e hType;
    BYTE hufDesBuffer[128];
    size_t hufDesSize;
} ZSTD_hufCTablesMetadata_t;

typedef struct {
    symbolEncodingType_e llType;
    symbolEncodingType_e ofType;
    symbolEncodingType_e mlType;
    BYTE fseTablesBuffer[133];
    size_t fseTablesSize;
    size_t lastCountSize;
} ZSTD_fseCTablesMetadata_t;

typedef struct {
    ZSTD_hufCTablesMetadata_t hufMetadata;
    ZSTD_fseCTablesMetadata_t fseMetadata;
} ZSTD_entropyCTablesMetadata_t;

typedef struct {
    seqStore_t fullSeqStoreChunk;
    seqStore_t firstHalfSeqStore;
    seqStore_t secondHalfSeqStore;
    seqStore_t currSeqStore;
    seqStore_t nextSeqStore;
    U32 partitions[196];
    ZSTD_entropyCTablesMetadata_t entropyMetadata;
} ZSTD_blockSplitCtx;

typedef struct {
    HUF_CElt CTable[257];
    HUF_repeat repeatMode;
} ZSTD_hufCTables_t;

typedef struct {
    FSE_CTable offcodeCTable[193];
    FSE_CTable matchlengthCTable[363];
    FSE_CTable litlengthCTable[329];
    FSE_repeat offcode_repeatMode;
    FSE_repeat matchlength_repeatMode;
    FSE_repeat litlength_repeatMode;
} ZSTD_fseCTables_t;

typedef struct {
    ZSTD_hufCTables_t huf;
    ZSTD_fseCTables_t fse;
} ZSTD_entropyCTables_t;

typedef struct {
    ZSTD_entropyCTables_t entropy;
    U32 rep[3];
} ZSTD_compressedBlockState_t;

typedef struct {
    const BYTE *nextSrc;
    const BYTE *base;
    const BYTE *dictBase;
    U32 dictLimit;
    U32 lowLimit;
    U32 nbOverflowCorrections;
} ZSTD_window_t;

typedef struct {
    U32 off;
    U32 len;
} ZSTD_match_t;

typedef struct {
    int price;
    U32 off;
    U32 mlen;
    U32 litlen;
    U32 rep[3];
} ZSTD_optimal_t;

typedef struct {
    unsigned int *litFreq;
    unsigned int *litLengthFreq;
    unsigned int *matchLengthFreq;
    unsigned int *offCodeFreq;
    ZSTD_match_t *matchTable;
    ZSTD_optimal_t *priceTable;
    U32 litSum;
    U32 litLengthSum;
    U32 matchLengthSum;
    U32 offCodeSum;
    U32 litSumBasePrice;
    U32 litLengthSumBasePrice;
    U32 matchLengthSumBasePrice;
    U32 offCodeSumBasePrice;
    ZSTD_OptPrice_e priceType;
    const ZSTD_entropyCTables_t *symbolCosts;
    ZSTD_paramSwitch_e literalCompressionMode;
} optState_t;

typedef struct {
    unsigned int windowLog;
    unsigned int chainLog;
    unsigned int hashLog;
    unsigned int searchLog;
    unsigned int minMatch;
    unsigned int targetLength;
    ZSTD_strategy strategy;
} ZSTD_compressionParameters;

typedef struct {
    U32 offset;
    U32 litLength;
    U32 matchLength;
} rawSeq;

typedef struct {
    rawSeq *seq;
    size_t pos;
    size_t posInSequence;
    size_t size;
    size_t capacity;
} rawSeqStore_t;

struct ZSTD_matchState_t;

typedef struct ZSTD_matchState_t ZSTD_matchState_t;

struct ZSTD_matchState_t {
    ZSTD_window_t window;
    U32 loadedDictEnd;
    U32 nextToUpdate;
    U32 hashLog3;
    U32 rowHashLog;
    U16 *tagTable;
    U32 hashCache[8];
    U32 *hashTable;
    U32 *hashTable3;
    U32 *chainTable;
    U32 forceNonContiguous;
    int dedicatedDictSearch;
    optState_t opt;
    const ZSTD_matchState_t *dictMatchState;
    ZSTD_compressionParameters cParams;
    const rawSeqStore_t *ldmSeqStore;
};

typedef struct {
    ZSTD_compressedBlockState_t *prevCBlock;
    ZSTD_compressedBlockState_t *nextCBlock;
    ZSTD_matchState_t matchState;
} ZSTD_blockState_t;

typedef struct {
    size_t error;
    int lowerBound;
    int upperBound;
} ZSTD_bounds;

typedef struct {
    U32 f1c;
    U32 f1d;
    U32 f7b;
    U32 f7c;
} ZSTD_cpuid_t;

typedef void * (*ZSTD_allocFunction)(void *, size_t);

typedef void (*ZSTD_freeFunction)(void *, void *);

typedef struct {
    ZSTD_allocFunction customAlloc;
    ZSTD_freeFunction customFree;
    void *opaque;
} ZSTD_customMem;

typedef struct {
    void *workspace;
    void *workspaceEnd;
    void *objectEnd;
    void *tableEnd;
    void *tableValidEnd;
    void *allocStart;
    BYTE allocFailed;
    int workspaceOversizedDuration;
    ZSTD_cwksp_alloc_phase_e phase;
    ZSTD_cwksp_static_alloc_e isStatic;
} ZSTD_cwksp;

typedef struct {
    U16 nextState;
    BYTE nbAdditionalBits;
    BYTE nbBits;
    U32 baseValue;
} ZSTD_seqSymbol;

typedef struct {
    ZSTD_seqSymbol LLTable[513];
    ZSTD_seqSymbol OFTable[257];
    ZSTD_seqSymbol MLTable[513];
    HUF_DTable hufTable[4097];
    U32 rep[3];
    U32 workspace[157];
} ZSTD_entropyDTables_t;

typedef struct {
    long long unsigned int frameContentSize;
    long long unsigned int windowSize;
    unsigned int blockSizeMax;
    ZSTD_frameType_e frameType;
    unsigned int headerSize;
    unsigned int dictID;
    unsigned int checksumFlag;
} ZSTD_frameHeader;

typedef struct {
    int contentSizeFlag;
    int checksumFlag;
    int noDictIDFlag;
} ZSTD_frameParameters;

typedef struct {
    long long unsigned int ingested;
    long long unsigned int consumed;
    long long unsigned int produced;
    long long unsigned int flushed;
    unsigned int currentJobID;
    unsigned int nbActiveWorkers;
} ZSTD_frameProgression;

typedef struct {
    size_t compressedSize;
    long long unsigned int decompressedBound;
} ZSTD_frameSizeInfo;

typedef struct {
    size_t state;
    const ZSTD_seqSymbol *table;
} ZSTD_fseState;

struct ZSTD_CDict_s;

typedef struct ZSTD_CDict_s ZSTD_CDict;

typedef struct {
    void *dictBuffer;
    const void *dict;
    size_t dictSize;
    ZSTD_dictContentType_e dictContentType;
    ZSTD_CDict *cdict;
} ZSTD_localDict;

typedef struct {
    rawSeqStore_t seqStore;
    U32 startPosInBlock;
    U32 endPosInBlock;
    U32 offset;
} ZSTD_optLdm_t;

typedef struct {
    ZSTD_compressionParameters cParams;
    ZSTD_frameParameters fParams;
} ZSTD_parameters;

typedef struct {
    U32 fastMode;
    U32 tableLog;
} ZSTD_seqSymbol_header;

typedef struct {
    U32 litLength;
    U32 matchLength;
} ZSTD_sequenceLength;

typedef struct {
    U32 idx;
    U32 posInSequence;
    size_t posInSrc;
} ZSTD_sequencePosition;

typedef struct {
    U32 LLtype;
    U32 Offtype;
    U32 MLtype;
    size_t size;
    size_t lastCountSize;
} ZSTD_symbolEncodingTypeStats_t;

typedef struct {
    long unsigned int fds_bits[16];
} __kernel_fd_set;

typedef struct {
    int val[2];
} __kernel_fsid_t;

typedef struct {
    U32 tableTime;
    U32 decode256Time;
} algo_time_t;

typedef struct {
    s64 counter;
} atomic64_t;

typedef atomic64_t atomic_long_t;

typedef struct {
    int counter;
} atomic_t;

typedef struct {
    char ax25_call[7];
} ax25_address;

struct hlist_node {
    struct hlist_node *next;
    struct hlist_node **pprev;
};

struct timer_list {
    struct hlist_node entry;
    long unsigned int expires;
    void (*function)(struct timer_list *);
    u32 flags;
};

typedef struct {
    char slave;
    struct timer_list slave_timer;
    short unsigned int slave_timeout;
} ax25_dama_info;

typedef struct {
    blockType_e blockType;
    U32 lastBlock;
    U32 origSize;
} blockProperties_t;

typedef struct {
    union {
        void *kernel;
        void *user;
    };
    bool is_kernel: 1;
} sockptr_t;

typedef sockptr_t bpfptr_t;

struct permanent_flags_t {
    __be16 tag;
    u8 disable;
    u8 ownership;
    u8 deactivated;
    u8 readPubek;
    u8 disableOwnerClear;
    u8 allowMaintenance;
    u8 physicalPresenceLifetimeLock;
    u8 physicalPresenceHWEnable;
    u8 physicalPresenceCMDEnable;
    u8 CEKPUsed;
    u8 TPMpost;
    u8 TPMpostLock;
    u8 FIPS;
    u8 operator;
    u8 enableRevokeEK;
    u8 nvLocked;
    u8 readSRKPub;
    u8 tpmEstablished;
    u8 maintenanceDone;
    u8 disableFullDALogicInfo;
};

struct stclear_flags_t {
    __be16 tag;
    u8 deactivated;
    u8 disableForceClear;
    u8 physicalPresence;
    u8 physicalPresenceLock;
    u8 bGlobalLock;
} __attribute__((packed));

struct tpm1_version {
    u8 major;
    u8 minor;
    u8 rev_major;
    u8 rev_minor;
};

struct tpm1_version2 {
    __be16 tag;
    struct tpm1_version version;
};

struct timeout_t {
    __be32 a;
    __be32 b;
    __be32 c;
    __be32 d;
};

struct duration_t {
    __be32 tpm_short;
    __be32 tpm_medium;
    __be32 tpm_long;
};

typedef union {
    struct permanent_flags_t perm_flags;
    struct stclear_flags_t stclear_flags;
    __u8 owned;
    __be32 num_pcrs;
    struct tpm1_version version1;
    struct tpm1_version2 version2;
    __be32 manufacturer_id;
    struct timeout_t timeout;
    struct duration_t duration;
} cap_t;

typedef struct {
    unsigned int interval;
    unsigned int timeout;
} cisco_proto;

typedef struct {
    void *lock;
} class_cpus_read_lock_t;

struct rq;

typedef struct {
    struct rq *lock;
    struct rq *lock2;
} class_double_rq_lock_t;

typedef struct {
    void *lock;
    long unsigned int flags;
} class_irqsave_t;

typedef struct {
    void *lock;
} class_jump_label_lock_t;

typedef struct {
    void *lock;
} class_preempt_notrace_t;

typedef struct {
    void *lock;
} class_preempt_t;

struct raw_spinlock;

typedef struct raw_spinlock raw_spinlock_t;

typedef struct {
    raw_spinlock_t *lock;
} class_raw_spinlock_irq_t;

typedef struct {
    raw_spinlock_t *lock;
    long unsigned int flags;
} class_raw_spinlock_irqsave_t;

typedef struct {
    raw_spinlock_t *lock;
} class_raw_spinlock_t;

typedef struct {
    void *lock;
} class_rcu_t;

typedef struct {
    void *lock;
} class_rcu_tasks_trace_t;

struct qspinlock {
    union {
        atomic_t val;
        struct {
            u8 locked;
            u8 pending;
        };
        struct {
            u16 locked_pending;
            u16 tail;
        };
    };
};

typedef struct qspinlock arch_spinlock_t;

struct qrwlock {
    union {
        atomic_t cnts;
        struct {
            u8 wlocked;
            u8 __lstate[3];
        };
    };
    arch_spinlock_t wait_lock;
};

typedef struct qrwlock arch_rwlock_t;

typedef struct {
    arch_rwlock_t raw_lock;
} rwlock_t;

typedef struct {
    rwlock_t *lock;
    long unsigned int flags;
} class_read_lock_irqsave_t;

struct pin_cookie {};

struct rq_flags {
    long unsigned int flags;
    struct pin_cookie cookie;
    unsigned int clock_update_flags;
};

typedef struct {
    struct rq *lock;
    struct rq_flags rf;
} class_rq_lock_irq_t;

typedef struct {
    struct rq *lock;
    struct rq_flags rf;
} class_rq_lock_irqsave_t;

typedef struct {
    struct rq *lock;
    struct rq_flags rf;
} class_rq_lock_t;

struct spinlock;

typedef struct spinlock spinlock_t;

typedef struct {
    spinlock_t *lock;
} class_spinlock_irq_t;

typedef struct {
    spinlock_t *lock;
    long unsigned int flags;
} class_spinlock_irqsave_t;

typedef struct {
    spinlock_t *lock;
} class_spinlock_t;

struct srcu_struct;

typedef struct {
    struct srcu_struct *lock;
    int idx;
} class_srcu_t;

struct task_struct;

typedef struct {
    struct task_struct *lock;
    struct rq *rq;
    struct rq_flags rf;
} class_task_rq_lock_t;

typedef struct {
    rwlock_t *lock;
} class_write_lock_irq_t;

typedef struct {
    rwlock_t *lock;
    long unsigned int flags;
} class_write_lock_irqsave_t;

typedef struct {
    unsigned char op;
    unsigned char bits;
    short unsigned int val;
} code;

typedef __kernel_fsid_t compat_fsid_t;

typedef struct {
    compat_sigset_word sig[2];
} compat_sigset_t;

typedef struct {
    long unsigned int bits[1];
} dma_cap_mask_t;

typedef struct {
    u64 length;
    u64 data;
} efi_capsule_block_desc_t;

typedef struct {
    __u8 b[16];
} guid_t;

typedef guid_t efi_guid_t;

typedef struct {
    efi_guid_t guid;
    u32 headersize;
    u32 flags;
    u32 imagesize;
} efi_capsule_header_t;

typedef struct {
    u8 major;
    u8 minor;
} efi_cc_version_t;

typedef struct {
    u8 type;
    u8 sub_type;
} efi_cc_type_t;

typedef struct {
    u8 size;
    efi_cc_version_t structure_version;
    efi_cc_version_t protocol_version;
    efi_cc_event_algorithm_bitmap_t hash_algorithm_bitmap;
    efi_cc_event_log_bitmap_t supported_event_logs;
    efi_cc_type_t cc_type;
} efi_cc_boot_service_cap_t;

typedef struct {
    efi_guid_t guid;
    u32 table;
} efi_config_table_32_t;

typedef struct {
    efi_guid_t guid;
    u64 table;
} efi_config_table_64_t;

typedef union {
    struct {
        efi_guid_t guid;
        void *table;
    };
    efi_config_table_32_t mixed_mode;
} efi_config_table_t;

typedef struct {
    efi_guid_t guid;
    long unsigned int *ptr;
    const char name[16];
} efi_config_table_type_t;

typedef struct {
    u16 year;
    u8 month;
    u8 day;
    u8 hour;
    u8 minute;
    u8 second;
    u8 pad1;
    u32 nanosecond;
    s16 timezone;
    u8 daylight;
    u8 pad2;
} efi_time_t;

typedef struct {
    u64 size;
    u64 file_size;
    u64 phys_size;
    efi_time_t create_time;
    efi_time_t last_access_time;
    efi_time_t modification_time;
    __u64 attribute;
    efi_char16_t filename[0];
} efi_file_info_t;

typedef struct {
    u32 red_mask;
    u32 green_mask;
    u32 blue_mask;
    u32 reserved_mask;
} efi_pixel_bitmask_t;

typedef struct {
    u32 version;
    u32 horizontal_resolution;
    u32 vertical_resolution;
    int pixel_format;
    efi_pixel_bitmask_t pixel_information;
    u32 pixels_per_scan_line;
} efi_graphics_output_mode_info_t;

typedef struct {
    u16 scan_code;
    efi_char16_t unicode_char;
} efi_input_key_t;

typedef struct {
    u32 attributes;
    u16 file_path_list_length;
    u8 variable_data[0];
} __attribute__((packed)) efi_load_option_t;

struct efi_generic_dev_path;

typedef struct efi_generic_dev_path efi_device_path_protocol_t;

typedef struct {
    u32 attributes;
    u16 file_path_list_length;
    const efi_char16_t *description;
    const efi_device_path_protocol_t *file_path_list;
    u32 optional_data_size;
    const void *optional_data;
} efi_load_option_unpacked_t;

typedef void *efi_handle_t;

typedef struct {
    u64 signature;
    u32 revision;
    u32 headersize;
    u32 crc32;
    u32 reserved;
} efi_table_hdr_t;

typedef struct {
    u32 resolution;
    u32 accuracy;
    u8 sets_to_zero;
} efi_time_cap_t;

typedef efi_status_t efi_get_time_t(efi_time_t *, efi_time_cap_t *);

typedef efi_status_t efi_set_time_t(efi_time_t *);

typedef efi_status_t efi_get_wakeup_time_t(efi_bool_t *, efi_bool_t *, efi_time_t *);

typedef efi_status_t efi_set_wakeup_time_t(efi_bool_t, efi_time_t *);

typedef struct {
    u32 type;
    u32 pad;
    u64 phys_addr;
    u64 virt_addr;
    u64 num_pages;
    u64 attribute;
} efi_memory_desc_t;

typedef efi_status_t efi_set_virtual_address_map_t(long unsigned int, long unsigned int, u32, efi_memory_desc_t *);

typedef efi_status_t efi_get_variable_t(efi_char16_t *, efi_guid_t *, u32 *, long unsigned int *, void *);

typedef efi_status_t efi_get_next_variable_t(long unsigned int *, efi_char16_t *, efi_guid_t *);

typedef efi_status_t efi_set_variable_t(efi_char16_t *, efi_guid_t *, u32, long unsigned int, void *);

typedef efi_status_t efi_get_next_high_mono_count_t(u32 *);

typedef void efi_reset_system_t(int, efi_status_t, long unsigned int, efi_char16_t *);

typedef efi_status_t efi_update_capsule_t(efi_capsule_header_t **, long unsigned int, long unsigned int);

typedef efi_status_t efi_query_capsule_caps_t(efi_capsule_header_t **, long unsigned int, u64 *, int *);

typedef efi_status_t efi_query_variable_info_t(u32, u64 *, u64 *, u64 *);

typedef struct {
    efi_table_hdr_t hdr;
    u32 get_time;
    u32 set_time;
    u32 get_wakeup_time;
    u32 set_wakeup_time;
    u32 set_virtual_address_map;
    u32 convert_pointer;
    u32 get_variable;
    u32 get_next_variable;
    u32 set_variable;
    u32 get_next_high_mono_count;
    u32 reset_system;
    u32 update_capsule;
    u32 query_capsule_caps;
    u32 query_variable_info;
} efi_runtime_services_32_t;

typedef union {
    struct {
        efi_table_hdr_t hdr;
        efi_get_time_t *get_time;
        efi_set_time_t *set_time;
        efi_get_wakeup_time_t *get_wakeup_time;
        efi_set_wakeup_time_t *set_wakeup_time;
        efi_set_virtual_address_map_t *set_virtual_address_map;
        void *convert_pointer;
        efi_get_variable_t *get_variable;
        efi_get_next_variable_t *get_next_variable;
        efi_set_variable_t *set_variable;
        efi_get_next_high_mono_count_t *get_next_high_mono_count;
        efi_reset_system_t *reset_system;
        efi_update_capsule_t *update_capsule;
        efi_query_capsule_caps_t *query_capsule_caps;
        efi_query_variable_info_t *query_variable_info;
    };
    efi_runtime_services_32_t mixed_mode;
} efi_runtime_services_t;

typedef struct {
    efi_table_hdr_t hdr;
    u32 fw_vendor;
    u32 fw_revision;
    u32 con_in_handle;
    u32 con_in;
    u32 con_out_handle;
    u32 con_out;
    u32 stderr_handle;
    u32 stderr;
    u32 runtime;
    u32 boottime;
    u32 nr_tables;
    u32 tables;
} efi_system_table_32_t;

union efi_simple_text_input_protocol;

typedef union efi_simple_text_input_protocol efi_simple_text_input_protocol_t;

union efi_simple_text_output_protocol;

typedef union efi_simple_text_output_protocol efi_simple_text_output_protocol_t;

union efi_boot_services;

typedef union efi_boot_services efi_boot_services_t;

typedef union {
    struct {
        efi_table_hdr_t hdr;
        long unsigned int fw_vendor;
        u32 fw_revision;
        long unsigned int con_in_handle;
        efi_simple_text_input_protocol_t *con_in;
        long unsigned int con_out_handle;
        efi_simple_text_output_protocol_t *con_out;
        long unsigned int stderr_handle;
        long unsigned int stderr;
        efi_runtime_services_t *runtime;
        efi_boot_services_t *boottime;
        long unsigned int nr_tables;
        long unsigned int tables;
    };
    efi_system_table_32_t mixed_mode;
} efi_system_table_t;

typedef union {
    struct {
        u32 revision;
        efi_handle_t parent_handle;
        efi_system_table_t *system_table;
        efi_handle_t device_handle;
        void *file_path;
        void *reserved;
        u32 load_options_size;
        void *load_options;
        void *image_base;
        __u64 image_size;
        unsigned int image_code_type;
        unsigned int image_data_type;
        efi_status_t (*unload)(efi_handle_t);
    };
    struct {
        u32 revision;
        u32 parent_handle;
        u32 system_table;
        u32 device_handle;
        u32 file_path;
        u32 reserved;
        u32 load_options_size;
        u32 load_options;
        u32 image_base;
        __u64 image_size;
        u32 image_code_type;
        u32 image_data_type;
        u32 unload;
    } mixed_mode;
} efi_loaded_image_t;

typedef struct {
    u32 version;
    u32 num_entries;
    u32 desc_size;
    u32 flags;
    efi_memory_desc_t entry[0];
} efi_memory_attributes_table_t;

typedef struct {
    u32 read;
    u32 write;
} efi_pci_io_protocol_access_32_t;

typedef struct {
    void *read;
    void *write;
} efi_pci_io_protocol_access_t;

union efi_pci_io_protocol;

typedef union efi_pci_io_protocol efi_pci_io_protocol_t;

typedef efi_status_t (*efi_pci_io_protocol_cfg_t)(efi_pci_io_protocol_t *, EFI_PCI_IO_PROTOCOL_WIDTH, u32, long unsigned int, void *);

typedef struct {
    efi_pci_io_protocol_cfg_t read;
    efi_pci_io_protocol_cfg_t write;
} efi_pci_io_protocol_config_access_t;

typedef struct {
    u16 version;
    u16 length;
    u32 runtime_services_supported;
} efi_rt_properties_table_t;

typedef struct {
    __le16 e_tag;
    __le16 e_perm;
    __le32 e_id;
} ext4_acl_entry;

typedef struct {
    __le32 a_version;
} ext4_acl_header;

typedef __kernel_fd_set fd_set;

typedef struct {
    long unsigned int *in;
    long unsigned int *out;
    long unsigned int *ex;
    long unsigned int *res_in;
    long unsigned int *res_out;
    long unsigned int *res_ex;
} fd_set_bits;

typedef struct {
    atomic64_t refcnt;
} file_ref_t;

typedef struct {
    unsigned int t391;
    unsigned int t392;
    unsigned int n391;
    unsigned int n392;
    unsigned int n393;
    short unsigned int lmi;
    short unsigned int dce;
} fr_proto;

typedef struct {
    unsigned int dlci;
} fr_proto_pvc;

typedef struct {
    unsigned int dlci;
    char master[16];
} fr_proto_pvc_info;

typedef union {
    struct {
        void *freelist;
        long unsigned int counter;
    };
    freelist_full_t full;
} freelist_aba_t;

typedef struct {
    long unsigned int v;
} freeptr_t;

typedef struct {
    long unsigned int key[2];
} hsiphash_key_t;

typedef struct {
    unsigned int __softirq_pending;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
} irq_cpustat_t;

typedef struct {
    u64 val;
} kernel_cap_t;

typedef struct {
    gid_t val;
} kgid_t;

typedef struct {
    uid_t val;
} kuid_t;

typedef union {
    kuid_t uid;
    kgid_t gid;
} kid_t;

typedef struct {
    projid_t val;
} kprojid_t;

typedef struct {
    U32 offset;
    U32 checksum;
} ldmEntry_t;

typedef struct {
    const BYTE *split;
    U32 hash;
    U32 checksum;
    ldmEntry_t *bucket;
} ldmMatchCandidate_t;

typedef struct {
    ZSTD_paramSwitch_e enableLdm;
    U32 hashLog;
    U32 bucketSizeLog;
    U32 minMatchLength;
    U32 hashRateLog;
    U32 windowLog;
} ldmParams_t;

typedef struct {
    U64 rolling;
    U64 stopMask;
} ldmRollingHashState_t;

typedef struct {
    ZSTD_window_t window;
    ldmEntry_t *hashTable;
    U32 loadedDictEnd;
    BYTE *bucketOffsets;
    size_t splitIndices[64];
    ldmMatchCandidate_t matchCandidates[64];
} ldmState_t;

typedef struct {
    atomic_long_t a;
} local_t;

typedef struct {
    local_t a;
} local64_t;

typedef struct {} local_lock_t;

typedef struct {} lockdep_map_p;

struct refcount_struct {
    atomic_t refs;
};

typedef struct refcount_struct refcount_t;

typedef struct {
    atomic64_t id;
    void *sigpage;
    refcount_t pinned;
    void *vdso;
    long unsigned int flags;
    u8 pkey_allocation_map;
} mm_context_t;

typedef struct {} netdevice_tracker;

typedef struct {} netns_tracker;

typedef struct {
    char data[8];
} nfs4_verifier;

typedef struct {
    long unsigned int bits[1];
} nodemask_t;

typedef struct {
    pgdval_t pgd;
} pgd_t;

typedef struct {
    pgd_t pgd;
} p4d_t;

typedef struct {
    u64 pme;
} pagemap_entry_t;

typedef struct {
    u64 val;
} pfn_t;

typedef struct {
    pteval_t pgprot;
} pgprot_t;

typedef struct {
    pmdval_t pmd;
} pmd_t;

struct net;

typedef struct {
    struct net *net;
} possible_net_t;

typedef struct {
    pteval_t pte;
} pte_t;

typedef struct {
    pudval_t pud;
} pud_t;

typedef struct {
    short unsigned int encoding;
    short unsigned int parity;
} raw_hdlc_proto;

typedef struct {
    atomic_t refcnt;
} rcuref_t;

typedef struct {
    size_t written;
    size_t count;
    union {
        char *buf;
        void *data;
    } arg;
    int error;
} read_descriptor_t;

typedef union {
} release_pages_arg;

typedef struct {
    BIT_DStream_t DStream;
    ZSTD_fseState stateLL;
    ZSTD_fseState stateOffb;
    ZSTD_fseState stateML;
    size_t prevOffset[3];
} seqState_t;

typedef struct {
    U32 *splitLocations;
    size_t idx;
} seqStoreSplits;

typedef struct {
    size_t litLength;
    size_t matchLength;
    size_t offset;
} seq_t;

struct seqcount {
    unsigned int sequence;
};

typedef struct seqcount seqcount_t;

typedef struct {
    seqcount_t seqcount;
} seqcount_latch_t;

struct seqcount_spinlock {
    seqcount_t seqcount;
};

typedef struct seqcount_spinlock seqcount_spinlock_t;

struct raw_spinlock {
    arch_spinlock_t raw_lock;
};

struct spinlock {
    union {
        struct raw_spinlock rlock;
    };
};

typedef struct {
    seqcount_spinlock_t seqcount;
    spinlock_t lock;
} seqlock_t;

typedef struct {
    long unsigned int sig[1];
} sigset_t;

typedef struct {
    u64 key[2];
} siphash_key_t;

struct list_head {
    struct list_head *next;
    struct list_head *prev;
};

struct wait_queue_head {
    spinlock_t lock;
    struct list_head head;
};

typedef struct wait_queue_head wait_queue_head_t;

typedef struct {
    spinlock_t slock;
    int owned;
    wait_queue_head_t wq;
} socket_lock_t;

typedef struct {
    char *from;
    char *to;
} substring_t;

typedef struct {
    long unsigned int val;
} swp_entry_t;

typedef struct {
    unsigned int clock_rate;
    unsigned int clock_type;
    short unsigned int loopback;
} sync_serial_settings;

typedef struct {
    unsigned int clock_rate;
    unsigned int clock_type;
    short unsigned int loopback;
    unsigned int slot_map;
} te1_settings;

typedef struct {
    local64_t v;
} u64_stats_t;

typedef struct {
    u64 m_low;
    u64 m_high;
} uint128_t;

typedef struct {
    __u8 b[16];
} uuid_t;

typedef struct {
    gid_t val;
} vfsgid_t;

typedef struct {
    uid_t val;
} vfsuid_t;

typedef struct {
    short unsigned int dce;
    unsigned int modulo;
    unsigned int window;
    unsigned int t1;
    unsigned int t2;
    unsigned int n2;
} x25_hdlc_proto;

struct in6_addr {
    union {
        __u8 u6_addr8[16];
        __be16 u6_addr16[8];
        __be32 u6_addr32[4];
    } in6_u;
};

typedef union {
    __be32 a4;
    __be32 a6[4];
    struct in6_addr in6;
} xfrm_address_t;

typedef ZSTD_compressionParameters zstd_compression_parameters;

typedef ZSTD_customMem zstd_custom_mem;

typedef ZSTD_frameHeader zstd_frame_header;

typedef ZSTD_parameters zstd_parameters;

struct sk_buff;

struct sk_buff_list {
    struct sk_buff *next;
    struct sk_buff *prev;
};

struct sk_buff_head {
    union {
        struct {
            struct sk_buff *next;
            struct sk_buff *prev;
        };
        struct sk_buff_list list;
    };
    __u32 qlen;
    spinlock_t lock;
};

struct qdisc_skb_head {
    struct sk_buff *head;
    struct sk_buff *tail;
    __u32 qlen;
    spinlock_t lock;
};

struct u64_stats_sync {};

struct gnet_stats_basic_sync {
    u64_stats_t bytes;
    u64_stats_t packets;
    struct u64_stats_sync syncp;
};

struct gnet_stats_queue {
    __u32 qlen;
    __u32 backlog;
    __u32 drops;
    __u32 requeues;
    __u32 overlimits;
};

struct callback_head {
    struct callback_head *next;
    void (*func)(struct callback_head *);
};

struct lock_class_key {};

struct Qdisc_ops;

struct qdisc_size_table;

struct netdev_queue;

struct net_rate_estimator;

struct Qdisc {
    int (*enqueue)(struct sk_buff *, struct Qdisc *, struct sk_buff **);
    struct sk_buff * (*dequeue)(struct Qdisc *);
    unsigned int flags;
    u32 limit;
    const struct Qdisc_ops *ops;
    struct qdisc_size_table *stab;
    struct hlist_node hash;
    u32 handle;
    u32 parent;
    struct netdev_queue *dev_queue;
    struct net_rate_estimator *rate_est;
    struct gnet_stats_basic_sync *cpu_bstats;
    struct gnet_stats_queue *cpu_qstats;
    int pad;
    refcount_t refcnt;
    long: 64;
    long: 64;
    long: 64;
    struct sk_buff_head gso_skb;
    struct qdisc_skb_head q;
    struct gnet_stats_basic_sync bstats;
    struct gnet_stats_queue qstats;
    int owner;
    long unsigned int state;
    long unsigned int state2;
    struct Qdisc *next_sched;
    struct sk_buff_head skb_bad_txq;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    spinlock_t busylock;
    spinlock_t seqlock;
    struct callback_head rcu;
    netdevice_tracker dev_tracker;
    struct lock_class_key root_lock_key;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long int privdata[0];
};

struct Qdisc_class_common {
    u32 classid;
    unsigned int filter_cnt;
    struct hlist_node hnode;
};

struct hlist_head;

struct Qdisc_class_hash {
    struct hlist_head *hash;
    unsigned int hashsize;
    unsigned int hashmask;
    unsigned int hashelems;
};

struct tcmsg;

struct netlink_ext_ack;

struct nlattr;

struct qdisc_walker;

struct tcf_block;

struct gnet_dump;

struct Qdisc_class_ops {
    unsigned int flags;
    struct netdev_queue * (*select_queue)(struct Qdisc *, struct tcmsg *);
    int (*graft)(struct Qdisc *, long unsigned int, struct Qdisc *, struct Qdisc **, struct netlink_ext_ack *);
    struct Qdisc * (*leaf)(struct Qdisc *, long unsigned int);
    void (*qlen_notify)(struct Qdisc *, long unsigned int);
    long unsigned int (*find)(struct Qdisc *, u32);
    int (*change)(struct Qdisc *, u32, u32, struct nlattr **, long unsigned int *, struct netlink_ext_ack *);
    int (*delete)(struct Qdisc *, long unsigned int, struct netlink_ext_ack *);
    void (*walk)(struct Qdisc *, struct qdisc_walker *);
    struct tcf_block * (*tcf_block)(struct Qdisc *, long unsigned int, struct netlink_ext_ack *);
    long unsigned int (*bind_tcf)(struct Qdisc *, long unsigned int, u32);
    void (*unbind_tcf)(struct Qdisc *, long unsigned int);
    int (*dump)(struct Qdisc *, long unsigned int, struct sk_buff *, struct tcmsg *);
    int (*dump_stats)(struct Qdisc *, long unsigned int, struct gnet_dump *);
};

struct module;

struct Qdisc_ops {
    struct Qdisc_ops *next;
    const struct Qdisc_class_ops *cl_ops;
    char id[16];
    int priv_size;
    unsigned int static_flags;
    int (*enqueue)(struct sk_buff *, struct Qdisc *, struct sk_buff **);
    struct sk_buff * (*dequeue)(struct Qdisc *);
    struct sk_buff * (*peek)(struct Qdisc *);
    int (*init)(struct Qdisc *, struct nlattr *, struct netlink_ext_ack *);
    void (*reset)(struct Qdisc *);
    void (*destroy)(struct Qdisc *);
    int (*change)(struct Qdisc *, struct nlattr *, struct netlink_ext_ack *);
    void (*attach)(struct Qdisc *);
    int (*change_tx_queue_len)(struct Qdisc *, unsigned int);
    void (*change_real_num_tx)(struct Qdisc *, unsigned int);
    int (*dump)(struct Qdisc *, struct sk_buff *);
    int (*dump_stats)(struct Qdisc *, struct gnet_dump *);
    void (*ingress_block_set)(struct Qdisc *, u32);
    void (*egress_block_set)(struct Qdisc *, u32);
    u32 (*ingress_block_get)(struct Qdisc *);
    u32 (*egress_block_get)(struct Qdisc *);
    struct module *owner;
};

struct optimistic_spin_queue {
    atomic_t tail;
};

struct mutex {
    atomic_long_t owner;
    raw_spinlock_t wait_lock;
    struct optimistic_spin_queue osq;
    struct list_head wait_list;
};

struct kref {
    refcount_t refcount;
};

struct swait_queue_head {
    raw_spinlock_t lock;
    struct list_head task_list;
};

struct completion {
    unsigned int done;
    struct swait_queue_head wait;
};

struct blk_mq_queue_map {
    unsigned int *mq_map;
    unsigned int nr_queues;
    unsigned int queue_offset;
};

struct blk_mq_ops;

struct blk_mq_tags;

struct blk_mq_tag_set {
    const struct blk_mq_ops *ops;
    struct blk_mq_queue_map map[3];
    unsigned int nr_maps;
    unsigned int nr_hw_queues;
    unsigned int queue_depth;
    unsigned int reserved_tags;
    unsigned int cmd_size;
    int numa_node;
    unsigned int timeout;
    unsigned int flags;
    void *driver_data;
    struct blk_mq_tags **tags;
    struct blk_mq_tags *shared_tags;
    struct mutex tag_list_lock;
    struct list_head tag_list;
    struct srcu_struct *srcu;
};

struct kset;

struct kobj_type;

struct kernfs_node;

struct kobject {
    const char *name;
    struct list_head entry;
    struct kobject *parent;
    struct kset *kset;
    const struct kobj_type *ktype;
    struct kernfs_node *sd;
    struct kref kref;
    unsigned int state_initialized: 1;
    unsigned int state_in_sysfs: 1;
    unsigned int state_add_uevent_sent: 1;
    unsigned int state_remove_uevent_sent: 1;
    unsigned int uevent_suppress: 1;
};

struct dev_links_info {
    struct list_head suppliers;
    struct list_head consumers;
    struct list_head defer_sync;
    enum dl_dev_state status;
};

struct pm_message {
    int event;
};

typedef struct pm_message pm_message_t;

struct rb_node {
    long unsigned int __rb_parent_color;
    struct rb_node *rb_right;
    struct rb_node *rb_left;
};

struct timerqueue_node {
    struct rb_node node;
    ktime_t expires;
};

struct hrtimer_clock_base;

struct hrtimer {
    struct timerqueue_node node;
    ktime_t _softexpires;
    enum hrtimer_restart (*function)(struct hrtimer *);
    struct hrtimer_clock_base *base;
    u8 state;
    u8 is_rel;
    u8 is_soft;
    u8 is_hard;
};

struct work_struct;

typedef void (*work_func_t)(struct work_struct *);

struct work_struct {
    atomic_long_t data;
    struct list_head entry;
    work_func_t func;
};

struct wake_irq;

struct pm_subsys_data;

struct device;

struct dev_pm_qos;

struct dev_pm_info {
    pm_message_t power_state;
    bool can_wakeup: 1;
    bool async_suspend: 1;
    bool in_dpm_list: 1;
    bool is_prepared: 1;
    bool is_suspended: 1;
    bool is_noirq_suspended: 1;
    bool is_late_suspended: 1;
    bool no_pm: 1;
    bool early_init: 1;
    bool direct_complete: 1;
    u32 driver_flags;
    spinlock_t lock;
    bool should_wakeup: 1;
    struct hrtimer suspend_timer;
    u64 timer_expires;
    struct work_struct work;
    wait_queue_head_t wait_queue;
    struct wake_irq *wakeirq;
    atomic_t usage_count;
    atomic_t child_count;
    unsigned int disable_depth: 3;
    bool idle_notification: 1;
    bool request_pending: 1;
    bool deferred_resume: 1;
    bool needs_force_resume: 1;
    bool runtime_auto: 1;
    bool ignore_children: 1;
    bool no_callbacks: 1;
    bool irq_safe: 1;
    bool use_autosuspend: 1;
    bool timer_autosuspends: 1;
    bool memalloc_noio: 1;
    unsigned int links_count;
    enum rpm_request request;
    enum rpm_status runtime_status;
    enum rpm_status last_status;
    int runtime_error;
    int autosuspend_delay;
    u64 last_busy;
    u64 active_time;
    u64 suspended_time;
    u64 accounting_timestamp;
    struct pm_subsys_data *subsys_data;
    void (*set_latency_tolerance)(struct device *, s32);
    struct dev_pm_qos *qos;
};

struct irq_domain;

struct msi_device_data;

struct dev_msi_info {
    struct irq_domain *domain;
    struct msi_device_data *data;
};

struct dev_archdata {};

struct device_private;

struct device_type;

struct bus_type;

struct device_driver;

struct dev_pm_domain;

struct dev_pin_info;

struct bus_dma_region;

struct device_dma_parameters;

struct dma_coherent_mem;

struct cma;

struct io_tlb_mem;

struct device_node;

struct fwnode_handle;

struct class;

struct attribute_group;

struct iommu_group;

struct dev_iommu;

struct device_physical_location;

struct device {
    struct kobject kobj;
    struct device *parent;
    struct device_private *p;
    const char *init_name;
    const struct device_type *type;
    const struct bus_type *bus;
    struct device_driver *driver;
    void *platform_data;
    void *driver_data;
    struct mutex mutex;
    struct dev_links_info links;
    struct dev_pm_info power;
    struct dev_pm_domain *pm_domain;
    struct dev_pin_info *pins;
    struct dev_msi_info msi;
    u64 *dma_mask;
    u64 coherent_dma_mask;
    u64 bus_dma_limit;
    const struct bus_dma_region *dma_range_map;
    struct device_dma_parameters *dma_parms;
    struct list_head dma_pools;
    struct dma_coherent_mem *dma_mem;
    struct cma *cma_area;
    struct io_tlb_mem *dma_io_tlb_mem;
    struct dev_archdata archdata;
    struct device_node *of_node;
    struct fwnode_handle *fwnode;
    dev_t devt;
    u32 id;
    spinlock_t devres_lock;
    struct list_head devres_head;
    const struct class *class;
    const struct attribute_group **groups;
    void (*release)(struct device *);
    struct iommu_group *iommu_group;
    struct dev_iommu *iommu;
    struct device_physical_location *physical_location;
    enum device_removable removable;
    bool offline_disabled: 1;
    bool offline: 1;
    bool of_node_reused: 1;
    bool state_synced: 1;
    bool can_match: 1;
    bool dma_coherent: 1;
    bool dma_skip_sync: 1;
    bool dma_iommu: 1;
};

struct scsi_host_template;

struct scsi_transport_template;

struct workqueue_struct;

struct Scsi_Host {
    struct list_head __devices;
    struct list_head __targets;
    struct list_head starved_list;
    spinlock_t default_lock;
    spinlock_t *host_lock;
    struct mutex scan_mutex;
    struct list_head eh_abort_list;
    struct list_head eh_cmd_q;
    struct task_struct *ehandler;
    struct completion *eh_action;
    wait_queue_head_t host_wait;
    const struct scsi_host_template *hostt;
    struct scsi_transport_template *transportt;
    struct kref tagset_refcnt;
    struct completion tagset_freed;
    struct blk_mq_tag_set tag_set;
    atomic_t host_blocked;
    unsigned int host_failed;
    unsigned int host_eh_scheduled;
    unsigned int host_no;
    int eh_deadline;
    long unsigned int last_reset;
    unsigned int max_channel;
    unsigned int max_id;
    u64 max_lun;
    unsigned int unique_id;
    short unsigned int max_cmd_len;
    int this_id;
    int can_queue;
    short int cmd_per_lun;
    short unsigned int sg_tablesize;
    short unsigned int sg_prot_tablesize;
    unsigned int max_sectors;
    unsigned int opt_sectors;
    unsigned int max_segment_size;
    unsigned int dma_alignment;
    long unsigned int dma_boundary;
    long unsigned int virt_boundary_mask;
    unsigned int nr_hw_queues;
    unsigned int nr_maps;
    unsigned int active_mode: 2;
    unsigned int host_self_blocked: 1;
    unsigned int reverse_ordering: 1;
    unsigned int tmf_in_progress: 1;
    unsigned int async_scan: 1;
    unsigned int eh_noresume: 1;
    unsigned int no_write_same: 1;
    unsigned int host_tagset: 1;
    unsigned int queuecommand_may_block: 1;
    unsigned int short_inquiry: 1;
    unsigned int no_scsi2_lun_in_cdb: 1;
    unsigned int no_highmem: 1;
    struct workqueue_struct *work_q;
    struct workqueue_struct *tmf_work_q;
    unsigned int max_host_blocked;
    unsigned int prot_capabilities;
    unsigned char prot_guard_type;
    long unsigned int base;
    long unsigned int io_port;
    unsigned char n_io_port;
    unsigned char dma_channel;
    unsigned int irq;
    enum scsi_host_state shost_state;
    struct device shost_gendev;
    struct device shost_dev;
    void *shost_data;
    struct device *dma_dev;
    int rpm_autosuspend_delay;
    long unsigned int hostdata[0];
};

struct ZSTD_CCtx_params_s {
    ZSTD_format_e format;
    ZSTD_compressionParameters cParams;
    ZSTD_frameParameters fParams;
    int compressionLevel;
    int forceWindow;
    size_t targetCBlockSize;
    int srcSizeHint;
    ZSTD_dictAttachPref_e attachDictPref;
    ZSTD_paramSwitch_e literalCompressionMode;
    int nbWorkers;
    size_t jobSize;
    int overlapLog;
    int rsyncable;
    ldmParams_t ldmParams;
    int enableDedicatedDictSearch;
    ZSTD_bufferMode_e inBufferMode;
    ZSTD_bufferMode_e outBufferMode;
    ZSTD_sequenceFormat_e blockDelimiters;
    int validateSequences;
    ZSTD_paramSwitch_e useBlockSplitter;
    ZSTD_paramSwitch_e useRowMatchFinder;
    int deterministicRefPrefix;
    ZSTD_customMem customMem;
};

typedef struct ZSTD_CCtx_params_s ZSTD_CCtx_params;

struct xxh64_state {
    uint64_t total_len;
    uint64_t v1;
    uint64_t v2;
    uint64_t v3;
    uint64_t v4;
    uint64_t mem64[4];
    uint32_t memsize;
};

struct POOL_ctx_s;

typedef struct POOL_ctx_s ZSTD_threadPool;

struct ZSTD_inBuffer_s {
    const void *src;
    size_t size;
    size_t pos;
};

typedef struct ZSTD_inBuffer_s ZSTD_inBuffer;

struct ZSTD_prefixDict_s {
    const void *dict;
    size_t dictSize;
    ZSTD_dictContentType_e dictContentType;
};

typedef struct ZSTD_prefixDict_s ZSTD_prefixDict;

struct ZSTD_CCtx_s {
    ZSTD_compressionStage_e stage;
    int cParamsChanged;
    int bmi2;
    ZSTD_CCtx_params requestedParams;
    ZSTD_CCtx_params appliedParams;
    ZSTD_CCtx_params simpleApiParams;
    U32 dictID;
    size_t dictContentSize;
    ZSTD_cwksp workspace;
    size_t blockSize;
    long long unsigned int pledgedSrcSizePlusOne;
    long long unsigned int consumedSrcSize;
    long long unsigned int producedCSize;
    struct xxh64_state xxhState;
    ZSTD_customMem customMem;
    ZSTD_threadPool *pool;
    size_t staticSize;
    SeqCollector seqCollector;
    int isFirstBlock;
    int initialized;
    seqStore_t seqStore;
    ldmState_t ldmState;
    rawSeq *ldmSequences;
    size_t maxNbLdmSequences;
    rawSeqStore_t externSeqStore;
    ZSTD_blockState_t blockState;
    U32 *entropyWorkspace;
    ZSTD_buffered_policy_e bufferedPolicy;
    char *inBuff;
    size_t inBuffSize;
    size_t inToCompress;
    size_t inBuffPos;
    size_t inBuffTarget;
    char *outBuff;
    size_t outBuffSize;
    size_t outBuffContentSize;
    size_t outBuffFlushedSize;
    ZSTD_cStreamStage streamStage;
    U32 frameEnded;
    ZSTD_inBuffer expectedInBuffer;
    size_t expectedOutBufferSize;
    ZSTD_localDict localDict;
    const ZSTD_CDict *cdict;
    ZSTD_prefixDict prefixDict;
    ZSTD_blockSplitCtx blockSplitCtx;
};

typedef struct ZSTD_CCtx_s ZSTD_CCtx;

typedef ZSTD_CCtx ZSTD_CStream;

typedef ZSTD_CCtx zstd_cctx;

typedef ZSTD_CStream zstd_cstream;

struct ZSTD_CDict_s {
    const void *dictContent;
    size_t dictContentSize;
    ZSTD_dictContentType_e dictContentType;
    U32 *entropyWorkspace;
    ZSTD_cwksp workspace;
    ZSTD_matchState_t matchState;
    ZSTD_compressedBlockState_t cBlockState;
    ZSTD_customMem customMem;
    U32 dictID;
    int compressionLevel;
    ZSTD_paramSwitch_e useRowMatchFinder;
};

typedef ZSTD_CDict zstd_cdict;

struct ZSTD_outBuffer_s {
    void *dst;
    size_t size;
    size_t pos;
};

typedef struct ZSTD_outBuffer_s ZSTD_outBuffer;

struct ZSTD_DCtx_s {
    const ZSTD_seqSymbol *LLTptr;
    const ZSTD_seqSymbol *MLTptr;
    const ZSTD_seqSymbol *OFTptr;
    const HUF_DTable *HUFptr;
    ZSTD_entropyDTables_t entropy;
    U32 workspace[640];
    const void *previousDstEnd;
    const void *prefixStart;
    const void *virtualStart;
    const void *dictEnd;
    size_t expected;
    ZSTD_frameHeader fParams;
    U64 processedCSize;
    U64 decodedSize;
    blockType_e bType;
    ZSTD_dStage stage;
    U32 litEntropy;
    U32 fseEntropy;
    struct xxh64_state xxhState;
    size_t headerSize;
    ZSTD_format_e format;
    ZSTD_forceIgnoreChecksum_e forceIgnoreChecksum;
    U32 validateChecksum;
    const BYTE *litPtr;
    ZSTD_customMem customMem;
    size_t litSize;
    size_t rleSize;
    size_t staticSize;
    ZSTD_DDict *ddictLocal;
    const ZSTD_DDict *ddict;
    U32 dictID;
    int ddictIsCold;
    ZSTD_dictUses_e dictUses;
    ZSTD_DDictHashSet *ddictSet;
    ZSTD_refMultipleDDicts_e refMultipleDDicts;
    ZSTD_dStreamStage streamStage;
    char *inBuff;
    size_t inBuffSize;
    size_t inPos;
    size_t maxWindowSize;
    char *outBuff;
    size_t outBuffSize;
    size_t outStart;
    size_t outEnd;
    size_t lhSize;
    U32 hostageByte;
    int noForwardProgress;
    ZSTD_bufferMode_e outBufferMode;
    ZSTD_outBuffer expectedOutBuffer;
    BYTE *litBuffer;
    const BYTE *litBufferEnd;
    ZSTD_litLocation_e litBufferLocation;
    BYTE litExtraBuffer[65568];
    BYTE headerBuffer[18];
    size_t oversizedDuration;
};

typedef struct ZSTD_DCtx_s ZSTD_DCtx;

typedef ZSTD_DCtx ZSTD_DStream;

typedef ZSTD_DCtx zstd_dctx;

typedef ZSTD_DStream zstd_dstream;

struct ZSTD_DDict_s {
    void *dictBuffer;
    const void *dictContent;
    size_t dictSize;
    ZSTD_entropyDTables_t entropy;
    U32 dictID;
    U32 entropyPresent;
    ZSTD_customMem cMem;
};

typedef ZSTD_DDict zstd_ddict;

typedef ZSTD_inBuffer zstd_in_buffer;

typedef ZSTD_outBuffer zstd_out_buffer;

struct __aio_sigset {
    const sigset_t *sigmask;
    size_t sigsetsize;
};

struct __arch_ftrace_regs {
    long unsigned int regs[9];
    long unsigned int direct_tramp;
    long unsigned int fp;
    long unsigned int lr;
    long unsigned int sp;
    long unsigned int pc;
};

struct llist_node {
    struct llist_node *next;
};

struct __call_single_node {
    struct llist_node llist;
    union {
        unsigned int u_flags;
        atomic_t a_flags;
    };
    u16 src;
    u16 dst;
};

typedef void (*smp_call_func_t)(void *);

struct __call_single_data {
    struct __call_single_node node;
    smp_call_func_t func;
    void *info;
};

typedef struct __call_single_data call_single_data_t;

struct __compat_aio_sigset {
    compat_uptr_t sigmask;
    compat_size_t sigsetsize;
};

struct __compat_iw_event {
    __u16 len;
    __u16 cmd;
    union {
        compat_caddr_t pointer;
        struct {
            struct {} __empty_ptr_bytes;
            __u8 ptr_bytes[0];
        };
    };
};

struct drm_connector;

struct drm_connector_state;

struct __drm_connnectors_state {
    struct drm_connector *ptr;
    struct drm_connector_state *state;
    struct drm_connector_state *old_state;
    struct drm_connector_state *new_state;
    s32 *out_fence_ptr;
};

struct drm_crtc;

struct drm_crtc_state;

struct drm_crtc_commit;

struct __drm_crtcs_state {
    struct drm_crtc *ptr;
    struct drm_crtc_state *state;
    struct drm_crtc_state *old_state;
    struct drm_crtc_state *new_state;
    struct drm_crtc_commit *commit;
    s32 *out_fence_ptr;
    u64 last_vblank_count;
};

struct drm_plane;

struct drm_plane_state;

struct __drm_planes_state {
    struct drm_plane *ptr;
    struct drm_plane_state *state;
    struct drm_plane_state *old_state;
    struct drm_plane_state *new_state;
};

struct drm_private_obj;

struct drm_private_state;

struct __drm_private_objs_state {
    struct drm_private_obj *ptr;
    struct drm_private_state *state;
    struct drm_private_state *old_state;
    struct drm_private_state *new_state;
};

struct __extcon_info {
    unsigned int type;
    unsigned int id;
    const char *name;
};

struct __fat_dirent {
    long int d_ino;
    __kernel_off_t d_off;
    short unsigned int d_reclen;
    char d_name[256];
};

struct __fb_timings {
    u32 dclk;
    u32 hfreq;
    u32 vfreq;
    u32 hactive;
    u32 vactive;
    u32 hblank;
    u32 vblank;
    u32 htotal;
    u32 vtotal;
};

struct tracepoint;

struct __find_tracepoint_cb_data {
    const char *tp_name;
    struct tracepoint *tpoint;
    struct module *mod;
};

union __fpsimd_vreg {
    __int128 unsigned raw;
    struct {
        u64 lo;
        u64 hi;
    };
};

struct arm64_ftr_reg;

struct __ftr_reg_entry {
    u32 sys_id;
    struct arm64_ftr_reg *reg;
};

struct genradix_root;

struct __genradix {
    struct genradix_root *root;
};

struct pmu;

struct cgroup;

struct __group_key {
    int cpu;
    struct pmu *pmu;
    struct cgroup *cgroup;
};

struct __ip6_tnl_parm {
    char name[16];
    int link;
    __u8 proto;
    __u8 encap_limit;
    __u8 hop_limit;
    bool collect_md;
    __be32 flowinfo;
    __u32 flags;
    struct in6_addr laddr;
    struct in6_addr raddr;
    long unsigned int i_flags[1];
    long unsigned int o_flags[1];
    __be32 i_key;
    __be32 o_key;
    __u32 fwmark;
    __u32 index;
    __u8 erspan_ver;
    __u8 dir;
    __u16 hwid;
};

struct __kernel_timespec {
    __kernel_time64_t tv_sec;
    long long int tv_nsec;
};

struct __kernel_itimerspec {
    struct __kernel_timespec it_interval;
    struct __kernel_timespec it_value;
};

struct __kernel_old_timeval {
    __kernel_long_t tv_sec;
    __kernel_long_t tv_usec;
};

struct __kernel_old_itimerval {
    struct __kernel_old_timeval it_interval;
    struct __kernel_old_timeval it_value;
};

struct __kernel_old_timespec {
    __kernel_old_time_t tv_sec;
    long int tv_nsec;
};

struct __kernel_sock_timeval {
    __s64 tv_sec;
    __s64 tv_usec;
};

struct __kernel_sockaddr_storage {
    union {
        struct {
            __kernel_sa_family_t ss_family;
            char __data[126];
        };
        void *__align;
    };
};

struct __kernel_timex_timeval {
    __kernel_time64_t tv_sec;
    long long int tv_usec;
};

struct __kernel_timex {
    unsigned int modes;
    long long int offset;
    long long int freq;
    long long int maxerror;
    long long int esterror;
    int status;
    long long int constant;
    long long int precision;
    long long int tolerance;
    struct __kernel_timex_timeval time;
    long long int tick;
    long long int ppsfreq;
    long long int jitter;
    int shift;
    long long int stabil;
    long long int jitcnt;
    long long int calcnt;
    long long int errcnt;
    long long int stbcnt;
    int tai;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
};

struct __kfifo {
    unsigned int in;
    unsigned int out;
    unsigned int mask;
    unsigned int esize;
    void *data;
};

struct __ksymtab {
    long unsigned int value;
    const char *mod_name;
    long unsigned int mod_start;
    long unsigned int mod_end;
    const char *sec_name;
    long unsigned int sec_start;
    long unsigned int sec_end;
    const char *sym_name;
    long unsigned int sym_start;
    long unsigned int sym_end;
};

typedef struct __ksymtab kdb_symtab_t;

struct net_device;

struct __rt6_probe_work {
    struct work_struct work;
    struct in6_addr target;
    struct net_device *dev;
    netdevice_tracker dev_tracker;
};

union sigval {
    int sival_int;
    void *sival_ptr;
};

typedef union sigval sigval_t;

union __sifields {
    struct {
        __kernel_pid_t _pid;
        __kernel_uid32_t _uid;
    } _kill;
    struct {
        __kernel_timer_t _tid;
        int _overrun;
        sigval_t _sigval;
        int _sys_private;
    } _timer;
    struct {
        __kernel_pid_t _pid;
        __kernel_uid32_t _uid;
        sigval_t _sigval;
    } _rt;
    struct {
        __kernel_pid_t _pid;
        __kernel_uid32_t _uid;
        int _status;
        __kernel_clock_t _utime;
        __kernel_clock_t _stime;
    } _sigchld;
    struct {
        void *_addr;
        union {
            int _trapno;
            short int _addr_lsb;
            struct {
                char _dummy_bnd[8];
                void *_lower;
                void *_upper;
            } _addr_bnd;
            struct {
                char _dummy_pkey[8];
                __u32 _pkey;
            } _addr_pkey;
            struct {
                long unsigned int _data;
                __u32 _type;
                __u32 _flags;
            } _perf;
        };
    } _sigfault;
    struct {
        long int _band;
        int _fd;
    } _sigpoll;
    struct {
        void *_call_addr;
        int _syscall;
        unsigned int _arch;
    } _sigsys;
};

struct bpf_flow_keys;

struct bpf_sock;

struct __sk_buff {
    __u32 len;
    __u32 pkt_type;
    __u32 mark;
    __u32 queue_mapping;
    __u32 protocol;
    __u32 vlan_present;
    __u32 vlan_tci;
    __u32 vlan_proto;
    __u32 priority;
    __u32 ingress_ifindex;
    __u32 ifindex;
    __u32 tc_index;
    __u32 cb[5];
    __u32 hash;
    __u32 tc_classid;
    __u32 data;
    __u32 data_end;
    __u32 napi_id;
    __u32 family;
    __u32 remote_ip4;
    __u32 local_ip4;
    __u32 remote_ip6[4];
    __u32 local_ip6[4];
    __u32 remote_port;
    __u32 local_port;
    __u32 data_meta;
    union {
        struct bpf_flow_keys *flow_keys;
    };
    __u64 tstamp;
    __u32 wire_len;
    __u32 gso_segs;
    union {
        struct bpf_sock *sk;
    };
    __u32 gso_size;
    __u8 tstamp_type;
    __u64 hwtstamp;
};

struct dentry;

struct __track_dentry_update_args {
    struct dentry *dentry;
    int op;
};

struct __track_range_args {
    ext4_lblk_t start;
    ext4_lblk_t end;
};

union __u128_halves {
    u128 full;
    struct {
        u64 low;
        u64 high;
    };
};

struct __una_u32 {
    u32 x;
};

struct inode;

struct __uprobe_key {
    struct inode *inode;
    loff_t offset;
};

struct __user_cap_data_struct {
    __u32 effective;
    __u32 permitted;
    __u32 inheritable;
};

typedef struct __user_cap_data_struct *cap_user_data_t;

struct __user_cap_header_struct {
    __u32 version;
    int pid;
};

typedef struct __user_cap_header_struct *cap_user_header_t;

struct __va_list {
    void *__stack;
    void *__gr_top;
    void *__vr_top;
    int __gr_offs;
    int __vr_offs;
};

typedef struct __va_list va_list;

struct _aarch64_ctx {
    __u32 magic;
    __u32 size;
};

struct _bpf_dtab_netdev {
    struct net_device *dev;
};

struct jump_entry;

struct static_key_mod;

struct static_key {
    atomic_t enabled;
    union {
        long unsigned int type;
        struct jump_entry *entries;
        struct static_key_mod *next;
    };
};

struct static_key_true {
    struct static_key key;
};

struct static_key_false {
    struct static_key key;
};

struct _ddebug {
    const char *modname;
    const char *function;
    const char *filename;
    const char *format;
    unsigned int lineno: 18;
    unsigned int class_id: 6;
    unsigned int flags: 8;
    union {
        struct static_key_true dd_key_true;
        struct static_key_false dd_key_false;
    } key;
};

struct ddebug_class_map;

struct _ddebug_info {
    struct _ddebug *descs;
    struct ddebug_class_map *classes;
    unsigned int num_descs;
    unsigned int num_classes;
};

struct _flow_keys_digest_data {
    __be16 n_proto;
    u8 ip_proto;
    u8 padding;
    __be32 ports;
    __be32 src;
    __be32 dst;
};

struct _gpt_entry_attributes {
    u64 required_to_function: 1;
    u64 reserved: 47;
    u64 type_guid_specific: 16;
};

typedef struct _gpt_entry_attributes gpt_entry_attributes;

struct _gpt_entry {
    efi_guid_t partition_type_guid;
    efi_guid_t unique_partition_guid;
    __le64 starting_lba;
    __le64 ending_lba;
    gpt_entry_attributes attributes;
    __le16 partition_name[36];
};

typedef struct _gpt_entry gpt_entry;

struct _gpt_header {
    __le64 signature;
    __le32 revision;
    __le32 header_size;
    __le32 header_crc32;
    __le32 reserved1;
    __le64 my_lba;
    __le64 alternate_lba;
    __le64 first_usable_lba;
    __le64 last_usable_lba;
    efi_guid_t disk_guid;
    __le64 partition_entry_lba;
    __le32 num_partition_entries;
    __le32 sizeof_partition_entry;
    __le32 partition_entry_array_crc32;
} __attribute__((packed));

typedef struct _gpt_header gpt_header;

struct _gpt_mbr_record {
    u8 boot_indicator;
    u8 start_head;
    u8 start_sector;
    u8 start_track;
    u8 os_type;
    u8 end_head;
    u8 end_sector;
    u8 end_track;
    __le32 starting_lba;
    __le32 size_in_lba;
};

typedef struct _gpt_mbr_record gpt_mbr_record;

struct kvm_io_device_ops;

struct kvm_io_device {
    const struct kvm_io_device_ops *ops;
};

struct eventfd_ctx;

struct _ioeventfd {
    struct list_head list;
    u64 addr;
    int length;
    struct eventfd_ctx *eventfd;
    u64 datamatch;
    struct kvm_io_device dev;
    u8 bus_idx;
    bool wildcard;
};

struct _kdb_bp {
    long unsigned int bp_addr;
    unsigned int bp_free: 1;
    unsigned int bp_enabled: 1;
    unsigned int bp_type: 4;
    unsigned int bp_installed: 1;
    unsigned int bp_delay: 1;
    unsigned int bp_delayed: 1;
    unsigned int bph_length;
};

typedef struct _kdb_bp kdb_bp_t;

struct _kdbmsg {
    int km_diag;
    char *km_msg;
};

typedef struct _kdbmsg kdbmsg_t;

typedef int (*kdb_func_t)(int, const char **);

struct _kdbtab {
    char *name;
    kdb_func_t func;
    char *usage;
    char *help;
    short int minlen;
    kdb_cmdflags_t flags;
    struct list_head list_node;
};

typedef struct _kdbtab kdbtab_t;

struct kvm_stats_desc {
    __u32 flags;
    __s16 exponent;
    __u16 size;
    __u32 offset;
    __u32 bucket_size;
    char name[0];
};

struct _kvm_stats_desc {
    struct kvm_stats_desc desc;
    char name[48];
};

struct _legacy_mbr {
    u8 boot_code[440];
    __le32 unique_mbr_signature;
    __le16 unknown;
    gpt_mbr_record partition_record[4];
    __le16 signature;
} __attribute__((packed));

typedef struct _legacy_mbr legacy_mbr;

struct strp_msg {
    int full_len;
    int offset;
};

struct _strp_msg {
    struct strp_msg strp;
    int accum_len;
};

struct aa_policydb;

struct aa_attachment {
    const char *xmatch_str;
    struct aa_policydb *xmatch;
    unsigned int xmatch_len;
    int xattr_count;
    char **xattrs;
};

struct aa_audit_cache {
    spinlock_t lock;
    int size;
    struct list_head head;
};

struct vfsmount;

struct path {
    struct vfsmount *mnt;
    struct dentry *dentry;
};

struct lsm_network_audit;

struct lsm_ioctlop_audit;

struct file;

struct lsm_ibpkey_audit;

struct lsm_ibendport_audit;

struct smack_audit_data;

struct selinux_audit_data;

struct apparmor_audit_data;

struct common_audit_data {
    char type;
    union {
        struct path path;
        struct dentry *dentry;
        struct inode *inode;
        struct lsm_network_audit *net;
        int cap;
        int ipc_id;
        struct task_struct *tsk;
        struct {
            key_serial_t key;
            char *key_desc;
        } key_struct;
        char *kmod_name;
        struct lsm_ioctlop_audit *op;
        struct file *file;
        struct lsm_ibpkey_audit *ibpkey;
        struct lsm_ibendport_audit *ibendport;
        int reason;
        const char *anonclass;
        u16 nlmsg_type;
    } u;
    union {
        struct smack_audit_data *smack_audit_data;
        struct selinux_audit_data *selinux_audit_data;
        struct apparmor_audit_data *apparmor_audit_data;
    };
};

struct cred;

struct aa_label;

struct sock;

struct aa_profile;

struct apparmor_audit_data {
    u32 flags;
    int error;
    int type;
    u16 class;
    const char *op;
    const struct cred *subj_cred;
    struct aa_label *subj_label;
    const char *name;
    const char *info;
    u32 request;
    u32 denied;
    struct task_struct *subjtsk;
    union {
        struct {
            struct aa_label *peer;
            union {
                struct {
                    const char *target;
                    kuid_t ouid;
                } fs;
                struct {
                    int rlim;
                    long unsigned int max;
                } rlim;
                struct {
                    int signal;
                    int unmappedsig;
                };
                struct {
                    int type;
                    int protocol;
                    struct sock *peer_sk;
                    void *addr;
                    int addrlen;
                } net;
                struct {
                    const char *target;
                } ns;
                struct {
                    kuid_t fsuid;
                    kuid_t ouid;
                } mq;
            };
        };
        struct {
            struct aa_profile *profile;
            const char *ns;
            long int pos;
        } iface;
        struct {
            const char *src_name;
            const char *type;
            const char *trans;
            const char *data;
            long unsigned int flags;
        } mnt;
        struct {
            struct aa_label *target;
        } uring;
    };
    struct common_audit_data common;
};

struct aa_knotif {
    struct apparmor_audit_data *ad;
    struct list_head list;
    struct completion ready;
    u64 id;
    u16 ntype;
    u16 flags;
};

struct aa_audit_node {
    struct kref count;
    struct apparmor_audit_data data;
    struct list_head list;
    struct aa_knotif knotif;
};

struct aa_audit_rule {
    struct aa_label *label;
};

union aa_buffer {
    struct list_head list;
    struct {
        struct {} __empty_buffer;
        char buffer[0];
    };
};

struct aa_caps {
    kernel_cap_t allow;
    kernel_cap_t audit;
    kernel_cap_t denied;
    kernel_cap_t quiet;
    kernel_cap_t kill;
    kernel_cap_t extended;
};

struct rhash_head {
    struct rhash_head *next;
};

struct aa_data {
    char *key;
    u32 size;
    char *data;
    struct rhash_head head;
};

struct table_header;

struct aa_dfa {
    struct kref count;
    u16 flags;
    u32 max_oob;
    struct table_header *tables[8];
};

struct aa_ext {
    void *start;
    void *end;
    void *pos;
    u32 version;
};

struct aa_file_ctx {
    spinlock_t lock;
    struct aa_label *label;
    u32 allow;
};

struct aa_inode_sec {
    struct inode *inode;
    struct aa_label *label;
    u16 sclass;
    bool initialized;
    spinlock_t lock;
};

struct aa_proxy;

struct aa_ruleset;

struct aa_label {
    struct kref count;
    struct rb_node node;
    struct callback_head rcu;
    struct aa_proxy *proxy;
    char *hname;
    long int flags;
    u32 secid;
    int size;
    u64 mediates;
    union {
        struct {
            struct aa_profile *profile[2];
            struct {
                struct {} __empty_rules;
                struct aa_ruleset *rules[0];
            };
        };
        struct {
            struct {} __empty_vec;
            struct aa_profile *vec[0];
        };
    };
};

struct rb_root {
    struct rb_node *rb_node;
};

struct aa_labelset {
    rwlock_t lock;
    struct rb_root root;
};

struct aa_ns;

struct aa_listener {
    struct kref count;
    spinlock_t lock;
    wait_queue_head_t wait;
    struct list_head ns_proxies;
    struct list_head notifications;
    struct list_head pending;
    struct aa_ns *ns;
    struct aa_dfa *filter;
    u64 last_id;
    u32 mask;
    u32 flags;
};

struct aa_listener_proxy {
    struct aa_ns *ns;
    struct aa_listener *listener;
    struct list_head llist;
    struct list_head nslist;
};

struct aa_load_ent {
    struct list_head list;
    struct aa_profile *new;
    struct aa_profile *old;
    struct aa_profile *rename;
    const char *ns_name;
};

struct aa_loaddata {
    struct kref count;
    struct list_head list;
    struct work_struct work;
    struct dentry *dents[6];
    struct aa_ns *ns;
    char *name;
    size_t size;
    size_t compressed_size;
    long int revision;
    int abi;
    unsigned char *hash;
    char *data;
};

struct aa_local_cache {
    unsigned int hold;
    unsigned int count;
    struct list_head head;
};

struct aa_net_compat {
    u16 allow[46];
    u16 audit[46];
    u16 quiet[46];
};

struct aa_policy {
    const char *name;
    char *hname;
    struct list_head list;
    struct list_head profiles;
};

struct aa_ns_acct {
    int max_size;
    int max_count;
    int size;
    int count;
};

struct aa_ns {
    struct aa_policy base;
    struct aa_ns *parent;
    struct mutex lock;
    struct aa_ns_acct acct;
    struct aa_profile *unconfined;
    struct list_head sub_ns;
    atomic_t uniq_null;
    long int uniq_id;
    int level;
    long int revision;
    wait_queue_head_t wait;
    spinlock_t listener_lock;
    struct list_head listeners;
    struct aa_labelset labels;
    struct list_head rawdata_list;
    struct dentry *dents[13];
};

struct aa_perms {
    u32 allow;
    u32 deny;
    u32 subtree;
    u32 cond;
    u32 kill;
    u32 complain;
    u32 prompt;
    u32 audit;
    u32 quiet;
    u32 hide;
    u32 xindex;
    u32 tag;
    u32 label;
};

struct aa_str_table {
    int size;
    char **table;
};

struct aa_policydb {
    struct kref count;
    struct aa_dfa *dfa;
    struct {
        struct aa_perms *perms;
        u32 size;
    };
    struct aa_str_table trans;
    unsigned int start[33];
};

struct rhashtable;

struct aa_profile {
    struct aa_policy base;
    struct aa_profile *parent;
    struct aa_ns *ns;
    const char *rename;
    enum audit_mode audit;
    long int mode;
    u32 path_flags;
    int signal;
    const char *disconnected;
    const char *disconnected_ipc;
    struct aa_attachment attach;
    struct aa_net_compat *net_compat;
    struct aa_audit_cache learning_cache;
    struct aa_loaddata *rawdata;
    unsigned char *hash;
    char *dirname;
    struct dentry *dents[10];
    struct rhashtable *data;
    int n_rules;
    struct aa_label label;
};

struct aa_proxy {
    struct kref count;
    struct aa_label *label;
};

struct aa_revision {
    struct aa_ns *ns;
    long int last_read;
};

struct rlimit {
    __kernel_ulong_t rlim_cur;
    __kernel_ulong_t rlim_max;
};

struct aa_rlimit {
    unsigned int mask;
    struct rlimit limits[16];
};

struct aa_secmark;

struct aa_ruleset {
    int size;
    struct aa_policydb *policy;
    struct aa_policydb *file;
    struct aa_caps caps;
    struct aa_rlimit rlimits;
    int secmark_count;
    struct aa_secmark *secmark;
};

struct aa_secmark {
    u8 audit;
    u8 deny;
    u32 secid;
    char *label;
};

struct file_operations;

struct aa_sfs_entry {
    const char *name;
    struct dentry *dentry;
    umode_t mode;
    enum aa_sfs_type v_type;
    union {
        bool boolean;
        char *string;
        long unsigned int u64;
        struct aa_sfs_entry *files;
    } v;
    const struct file_operations *file_ops;
};

struct aa_sk_ctx {
    struct aa_label *label;
    struct aa_label *peer;
};

struct aa_task_ctx {
    struct aa_label *nnp;
    struct aa_label *onexec;
    struct aa_label *previous;
    u64 token;
};

struct aarch64_insn_patch {
    void **text_addrs;
    u32 *new_insns;
    int insn_cnt;
    atomic_t cpu_count;
};

struct seq_net_private {
    struct net *net;
    netns_tracker ns_tracker;
};

struct ac6_iter_state {
    struct seq_net_private p;
    struct net_device *dev;
};

struct access_masks {
    access_mask_t fs: 16;
    access_mask_t net: 2;
    access_mask_t scope: 2;
};

union access_masks_all {
    struct access_masks masks;
    u32 all;
};

struct access_report_info {
    struct callback_head work;
    const char *access;
    struct task_struct *target;
    struct task_struct *agent;
};

struct acct_v3 {
    char ac_flag;
    char ac_version;
    __u16 ac_tty;
    __u32 ac_exitcode;
    __u32 ac_uid;
    __u32 ac_gid;
    __u32 ac_pid;
    __u32 ac_ppid;
    __u32 ac_btime;
    __u32 ac_etime;
    comp_t ac_utime;
    comp_t ac_stime;
    comp_t ac_mem;
    comp_t ac_io;
    comp_t ac_rw;
    comp_t ac_minflt;
    comp_t ac_majflt;
    comp_t ac_swaps;
    char ac_comm[16];
};

typedef struct acct_v3 acct_t;

struct ack_sample {
    u32 pkts_acked;
    s32 rtt_us;
    u32 in_flight;
};

struct crypto_tfm;

struct cipher_alg {
    unsigned int cia_min_keysize;
    unsigned int cia_max_keysize;
    int (*cia_setkey)(struct crypto_tfm *, const u8 *, unsigned int);
    void (*cia_encrypt)(struct crypto_tfm *, u8 *, const u8 *);
    void (*cia_decrypt)(struct crypto_tfm *, u8 *, const u8 *);
};

struct compress_alg {
    int (*coa_compress)(struct crypto_tfm *, const u8 *, unsigned int, u8 *, unsigned int *);
    int (*coa_decompress)(struct crypto_tfm *, const u8 *, unsigned int, u8 *, unsigned int *);
};

struct crypto_type;

struct crypto_alg {
    struct list_head cra_list;
    struct list_head cra_users;
    u32 cra_flags;
    unsigned int cra_blocksize;
    unsigned int cra_ctxsize;
    unsigned int cra_alignmask;
    int cra_priority;
    refcount_t cra_refcnt;
    char cra_name[128];
    char cra_driver_name[128];
    const struct crypto_type *cra_type;
    union {
        struct cipher_alg cipher;
        struct compress_alg compress;
    } cra_u;
    int (*cra_init)(struct crypto_tfm *);
    void (*cra_exit)(struct crypto_tfm *);
    void (*cra_destroy)(struct crypto_alg *);
    struct module *cra_module;
};

struct comp_alg_common {
    struct crypto_alg base;
};

struct acomp_req;

struct scatterlist;

struct crypto_acomp;

struct acomp_alg {
    int (*compress)(struct acomp_req *);
    int (*decompress)(struct acomp_req *);
    void (*dst_free)(struct scatterlist *);
    int (*init)(struct crypto_acomp *);
    void (*exit)(struct crypto_acomp *);
    unsigned int reqsize;
    union {
        struct {
            struct crypto_alg base;
        };
        struct comp_alg_common calg;
    };
};

typedef void (*crypto_completion_t)(void *, int);

struct crypto_async_request {
    struct list_head list;
    crypto_completion_t complete;
    void *data;
    struct crypto_tfm *tfm;
    u32 flags;
};

struct acomp_req {
    struct crypto_async_request base;
    struct scatterlist *src;
    struct scatterlist *dst;
    unsigned int slen;
    unsigned int dlen;
    u32 flags;
    void *__ctx[0];
};

struct acpi_device_id {
    __u8 id[16];
    kernel_ulong_t driver_data;
    __u32 cls;
    __u32 cls_msk;
};

typedef void *acpi_handle;

union acpi_object {
    acpi_object_type type;
    struct {
        acpi_object_type type;
        u64 value;
    } integer;
    struct {
        acpi_object_type type;
        u32 length;
        char *pointer;
    } string;
    struct {
        acpi_object_type type;
        u32 length;
        u8 *pointer;
    } buffer;
    struct {
        acpi_object_type type;
        u32 count;
        union acpi_object *elements;
    } package;
    struct {
        acpi_object_type type;
        acpi_object_type actual_type;
        acpi_handle handle;
    } reference;
    struct {
        acpi_object_type type;
        u32 proc_id;
        acpi_io_address pblk_address;
        u32 pblk_length;
    } processor;
    struct {
        acpi_object_type type;
        u32 system_level;
        u32 resource_order;
    } power_resource;
};

struct acpi_table_header {
    char signature[4];
    u32 length;
    u8 revision;
    u8 checksum;
    char oem_id[6];
    char oem_table_id[8];
    u32 oem_revision;
    char asl_compiler_id[4];
    u32 asl_compiler_revision;
};

struct action_cache {
    long unsigned int allow_native[8];
    long unsigned int allow_compat[8];
};

struct hist_trigger_data;

struct tracing_map_elt;

struct trace_buffer;

struct ring_buffer_event;

struct action_data;

typedef void (*action_fn_t)(struct hist_trigger_data *, struct tracing_map_elt *, struct trace_buffer *, void *, struct ring_buffer_event *, void *, struct action_data *, u64 *);

typedef bool (*check_track_val_fn_t)(u64, u64);

struct synth_event;

struct hist_field;

struct action_data {
    enum handler_id handler;
    enum action_id action;
    char *action_name;
    action_fn_t fn;
    unsigned int n_params;
    char *params[64];
    unsigned int var_ref_idx[64];
    struct synth_event *synth_event;
    bool use_trace_keyword;
    char *synth_event_name;
    union {
        struct {
            char *event;
            char *event_system;
        } match_data;
        struct {
            char *var_str;
            struct hist_field *var_ref;
            struct hist_field *track_var;
            check_track_val_fn_t check_val;
            action_fn_t save_data;
        } track_data;
    };
};

struct action_devres {
    void *data;
    void (*action)(void *);
};

struct action_gate_entry {
    u8 gate_state;
    u32 interval;
    s32 ipv;
    s32 maxoctets;
};

struct addr_marker {
    long unsigned int start_address;
    char *name;
};

struct xarray {
    spinlock_t xa_lock;
    gfp_t xa_flags;
    void *xa_head;
};

struct rw_semaphore {
    atomic_long_t count;
    atomic_long_t owner;
    struct optimistic_spin_queue osq;
    raw_spinlock_t wait_lock;
    struct list_head wait_list;
};

struct rb_root_cached {
    struct rb_root rb_root;
    struct rb_node *rb_leftmost;
};

struct address_space_operations;

struct address_space {
    struct inode *host;
    struct xarray i_pages;
    struct rw_semaphore invalidate_lock;
    gfp_t gfp_mask;
    atomic_t i_mmap_writable;
    struct rb_root_cached i_mmap;
    long unsigned int nrpages;
    long unsigned int writeback_index;
    const struct address_space_operations *a_ops;
    long unsigned int flags;
    errseq_t wb_err;
    spinlock_t i_private_lock;
    struct list_head i_private_list;
    struct rw_semaphore i_mmap_rwsem;
    void *i_private_data;
};

struct page;

struct writeback_control;

struct readahead_control;

struct kiocb;

struct iov_iter;

struct swap_info_struct;

struct address_space_operations {
    int (*writepage)(struct page *, struct writeback_control *);
    int (*read_folio)(struct file *, struct folio *);
    int (*writepages)(struct address_space *, struct writeback_control *);
    bool (*dirty_folio)(struct address_space *, struct folio *);
    void (*readahead)(struct readahead_control *);
    int (*write_begin)(struct file *, struct address_space *, loff_t, unsigned int, struct folio **, void **);
    int (*write_end)(struct file *, struct address_space *, loff_t, unsigned int, unsigned int, struct folio *, void *);
    sector_t (*bmap)(struct address_space *, sector_t);
    void (*invalidate_folio)(struct folio *, size_t, size_t);
    bool (*release_folio)(struct folio *, gfp_t);
    void (*free_folio)(struct folio *);
    ssize_t (*direct_IO)(struct kiocb *, struct iov_iter *);
    int (*migrate_folio)(struct address_space *, struct folio *, struct folio *, enum migrate_mode);
    int (*launder_folio)(struct folio *);
    bool (*is_partially_uptodate)(struct folio *, size_t, size_t);
    void (*is_dirty_writeback)(struct folio *, bool *, bool *);
    int (*error_remove_folio)(struct address_space *, struct folio *);
    int (*swap_activate)(struct swap_info_struct *, struct file *, sector_t *);
    void (*swap_deactivate)(struct file *);
    int (*swap_rw)(struct kiocb *, struct iov_iter *);
};

struct crypto_aead;

struct aead_request;

struct aead_alg {
    int (*setkey)(struct crypto_aead *, const u8 *, unsigned int);
    int (*setauthsize)(struct crypto_aead *, unsigned int);
    int (*encrypt)(struct aead_request *);
    int (*decrypt)(struct aead_request *);
    int (*init)(struct crypto_aead *);
    void (*exit)(struct crypto_aead *);
    unsigned int ivsize;
    unsigned int maxauthsize;
    unsigned int chunksize;
    struct crypto_alg base;
};

struct crypto_template;

struct crypto_spawn;

struct crypto_instance {
    struct crypto_alg alg;
    struct crypto_template *tmpl;
    union {
        struct hlist_node list;
        struct crypto_spawn *spawns;
    };
    struct work_struct free_work;
    void *__ctx[0];
};

struct aead_instance {
    void (*free)(struct aead_instance *);
    union {
        struct {
            char head[64];
            struct crypto_instance base;
        } s;
        struct aead_alg alg;
    };
};

struct aead_request {
    struct crypto_async_request base;
    unsigned int assoclen;
    unsigned int cryptlen;
    u8 *iv;
    struct scatterlist *src;
    struct scatterlist *dst;
    void *__ctx[0];
};

struct pcie_tlp_log {
    u32 dw[4];
    u32 prefix[4];
};

struct aer_capability_regs {
    u32 header;
    u32 uncor_status;
    u32 uncor_mask;
    u32 uncor_severity;
    u32 cor_status;
    u32 cor_mask;
    u32 cap_control;
    struct pcie_tlp_log header_log;
    u32 root_command;
    u32 root_status;
    u16 cor_err_source;
    u16 uncor_err_source;
};

struct pci_dev;

struct aer_err_info {
    struct pci_dev *dev[5];
    int error_dev_num;
    unsigned int id: 16;
    unsigned int severity: 2;
    unsigned int __pad1: 5;
    unsigned int multi_error_valid: 1;
    unsigned int first_error: 5;
    unsigned int __pad2: 2;
    unsigned int tlp_header_valid: 1;
    unsigned int status;
    unsigned int mask;
    struct pcie_tlp_log tlp;
};

struct aer_err_source {
    u32 status;
    u32 id;
};

struct aer_rpc {
    struct pci_dev *rpd;
    struct {
        union {
            struct __kfifo kfifo;
            struct aer_err_source *type;
            const struct aer_err_source *const_type;
            char (*rectype)[0];
            struct aer_err_source *ptr;
            const struct aer_err_source *ptr_const;
        };
        struct aer_err_source buf[128];
    } aer_fifo;
};

struct aer_stats {
    u64 dev_cor_errs[16];
    u64 dev_fatal_errs[27];
    u64 dev_nonfatal_errs[27];
    u64 dev_total_cor_errs;
    u64 dev_total_fatal_errs;
    u64 dev_total_nonfatal_errs;
    u64 rootport_total_cor_errs;
    u64 rootport_total_fatal_errs;
    u64 rootport_total_nonfatal_errs;
};

struct cpumask;

struct affinity_context {
    const struct cpumask *new_mask;
    struct cpumask *user_mask;
    unsigned int flags;
};

struct aggregate_control {
    long int *aggregate;
    long int *local;
    long int *pending;
    long int *ppending;
    long int *cstat;
    long int *cstat_prev;
    int size;
};

struct component_master_ops;

struct component_match;

struct aggregate_device {
    struct list_head node;
    bool bound;
    const struct component_master_ops *ops;
    struct device *parent;
    struct component_match *match;
};

struct hash_alg_common {
    unsigned int digestsize;
    unsigned int statesize;
    struct crypto_alg base;
};

struct ahash_request;

struct crypto_ahash;

struct ahash_alg {
    int (*init)(struct ahash_request *);
    int (*update)(struct ahash_request *);
    int (*final)(struct ahash_request *);
    int (*finup)(struct ahash_request *);
    int (*digest)(struct ahash_request *);
    int (*export)(struct ahash_request *, void *);
    int (*import)(struct ahash_request *, const void *);
    int (*setkey)(struct crypto_ahash *, const u8 *, unsigned int);
    int (*init_tfm)(struct crypto_ahash *);
    void (*exit_tfm)(struct crypto_ahash *);
    int (*clone_tfm)(struct crypto_ahash *, struct crypto_ahash *);
    struct hash_alg_common halg;
};

struct ahash_instance {
    void (*free)(struct ahash_instance *);
    union {
        struct {
            char head[96];
            struct crypto_instance base;
        } s;
        struct ahash_alg alg;
    };
};

struct ahash_request {
    struct crypto_async_request base;
    unsigned int nbytes;
    struct scatterlist *src;
    u8 *result;
    void *priv;
    void *__ctx[0];
};

struct wait_page_queue;

struct kiocb {
    struct file *ki_filp;
    loff_t ki_pos;
    void (*ki_complete)(struct kiocb *, long int);
    void *private;
    int ki_flags;
    u16 ki_ioprio;
    union {
        struct wait_page_queue *ki_waitq;
        ssize_t (*dio_complete)(void *);
    };
};

struct fsync_iocb {
    struct file *file;
    struct work_struct work;
    bool datasync;
    struct cred *creds;
};

struct wait_queue_entry;

typedef int (*wait_queue_func_t)(struct wait_queue_entry *, unsigned int, int, void *);

struct wait_queue_entry {
    unsigned int flags;
    void *private;
    wait_queue_func_t func;
    struct list_head entry;
};

struct poll_iocb {
    struct file *file;
    struct wait_queue_head *head;
    __poll_t events;
    bool cancelled;
    bool work_scheduled;
    bool work_need_resched;
    struct wait_queue_entry wait;
    struct work_struct work;
};

typedef int kiocb_cancel_fn(struct kiocb *);

struct io_event {
    __u64 data;
    __u64 obj;
    __s64 res;
    __s64 res2;
};

struct kioctx;

struct aio_kiocb {
    union {
        struct file *ki_filp;
        struct kiocb rw;
        struct fsync_iocb fsync;
        struct poll_iocb poll;
    };
    struct kioctx *ki_ctx;
    kiocb_cancel_fn *ki_cancel;
    struct io_event ki_res;
    struct list_head ki_list;
    refcount_t ki_refcnt;
    struct eventfd_ctx *ki_eventfd;
};

struct poll_table_struct;

typedef void (*poll_queue_proc)(struct file *, wait_queue_head_t *, struct poll_table_struct *);

struct poll_table_struct {
    poll_queue_proc _qproc;
    __poll_t _key;
};

struct aio_poll_table {
    struct poll_table_struct pt;
    struct aio_kiocb *iocb;
    bool queued;
    int error;
};

struct aio_ring {
    unsigned int id;
    unsigned int nr;
    unsigned int head;
    unsigned int tail;
    unsigned int magic;
    unsigned int compat_features;
    unsigned int incompat_features;
    unsigned int header_length;
    struct io_event io_events[0];
};

struct aio_waiter {
    struct wait_queue_entry w;
    size_t min_nr;
};

struct akcipher_request;

struct crypto_akcipher;

struct akcipher_alg {
    int (*encrypt)(struct akcipher_request *);
    int (*decrypt)(struct akcipher_request *);
    int (*set_pub_key)(struct crypto_akcipher *, const void *, unsigned int);
    int (*set_priv_key)(struct crypto_akcipher *, const void *, unsigned int);
    unsigned int (*max_size)(struct crypto_akcipher *);
    int (*init)(struct crypto_akcipher *);
    void (*exit)(struct crypto_akcipher *);
    struct crypto_alg base;
};

struct akcipher_instance {
    void (*free)(struct akcipher_instance *);
    union {
        struct {
            char head[56];
            struct crypto_instance base;
        } s;
        struct akcipher_alg alg;
    };
};

struct akcipher_request {
    struct crypto_async_request base;
    struct scatterlist *src;
    struct scatterlist *dst;
    unsigned int src_len;
    unsigned int dst_len;
    void *__ctx[0];
};

struct alarm {
    struct timerqueue_node node;
    struct hrtimer timer;
    void (*function)(struct alarm *, ktime_t);
    enum alarmtimer_type type;
    int state;
    void *data;
};

struct timerqueue_head {
    struct rb_root_cached rb_root;
};

struct timespec64;

struct alarm_base {
    spinlock_t lock;
    struct timerqueue_head timerqueue;
    ktime_t (*get_ktime)(void);
    void (*get_timespec)(struct timespec64 *);
    clockid_t base_clockid;
};

struct alias_prop {
    struct list_head link;
    const char *alias;
    struct device_node *np;
    int id;
    char stem[0];
};

struct source_location {
    const char *file_name;
    union {
        long unsigned int reported;
        struct {
            u32 line;
            u32 column;
        };
    };
};

struct type_descriptor;

struct alignment_assumption_data {
    struct source_location location;
    struct source_location assumption_location;
    struct type_descriptor *type;
};

struct zonelist;

struct zoneref;

struct alloc_context {
    struct zonelist *zonelist;
    nodemask_t *nodemask;
    struct zoneref *preferred_zoneref;
    int migratetype;
    enum zone_type highest_zoneidx;
    bool spread_dirty_pages;
};

struct codetag {
    unsigned int flags;
    unsigned int lineno;
    const char *modname;
    const char *function;
    const char *filename;
};

struct alloc_tag_counters;

struct alloc_tag {
    struct codetag ct;
    struct alloc_tag_counters *counters;
};

struct alloc_tag_counters {
    u64 bytes;
    u64 calls;
};

struct alt_instr {
    s32 orig_offset;
    s32 alt_offset;
    u16 cpucap;
    u8 orig_len;
    u8 alt_len;
};

struct alt_region {
    struct alt_instr *begin;
    struct alt_instr *end;
};

struct amba_cs_uci_id {
    unsigned int devarch;
    unsigned int devarch_mask;
    unsigned int devtype;
    void *data;
};

struct resource {
    resource_size_t start;
    resource_size_t end;
    const char *name;
    long unsigned int flags;
    long unsigned int desc;
    struct resource *parent;
    struct resource *sibling;
    struct resource *child;
};

struct device_dma_parameters {
    unsigned int max_segment_size;
    unsigned int min_align_mask;
    long unsigned int segment_boundary_mask;
};

struct clk;

struct amba_device {
    struct device dev;
    struct resource res;
    struct clk *pclk;
    struct device_dma_parameters dma_parms;
    unsigned int periphid;
    struct mutex periphid_lock;
    unsigned int cid;
    struct amba_cs_uci_id uci;
    unsigned int irq[9];
    const char *driver_override;
};

struct of_device_id;

struct dev_pm_ops;

struct driver_private;

struct device_driver {
    const char *name;
    const struct bus_type *bus;
    struct module *owner;
    const char *mod_name;
    bool suppress_bind_attrs;
    enum probe_type probe_type;
    const struct of_device_id *of_match_table;
    const struct acpi_device_id *acpi_match_table;
    int (*probe)(struct device *);
    void (*sync_state)(struct device *);
    int (*remove)(struct device *);
    void (*shutdown)(struct device *);
    int (*suspend)(struct device *, pm_message_t);
    int (*resume)(struct device *);
    const struct attribute_group **groups;
    const struct attribute_group **dev_groups;
    const struct dev_pm_ops *pm;
    void (*coredump)(struct device *);
    struct driver_private *p;
};

struct amba_id;

struct amba_driver {
    struct device_driver drv;
    int (*probe)(struct amba_device *, const struct amba_id *);
    void (*remove)(struct amba_device *);
    void (*shutdown)(struct amba_device *);
    const struct amba_id *id_table;
    bool driver_managed_dma;
};

struct amba_id {
    unsigned int id;
    unsigned int mask;
    void *data;
};

struct dma_chan;

struct amba_pl011_data {
    bool (*dma_filter)(struct dma_chan *, void *);
    void *dma_rx_param;
    void *dma_tx_param;
    bool dma_rx_poll_enable;
    unsigned int dma_rx_poll_rate;
    unsigned int dma_rx_poll_timeout;
    void (*init)(void);
    void (*exit)(void);
};

struct amd_chipset_type {
    enum amd_chipset_gen gen;
    u8 rev;
};

struct amd_chipset_info {
    struct pci_dev *nb_dev;
    struct pci_dev *smbus_dev;
    int nb_type;
    struct amd_chipset_type sb_type;
    int isoc_reqs;
    int probe_count;
    bool need_pll_quirk;
};

struct analog_param_field {
    unsigned int even;
    unsigned int odd;
};

struct analog_param_range {
    unsigned int min;
    unsigned int typ;
    unsigned int max;
};

struct analog_parameters {
    unsigned int num_lines;
    unsigned int line_duration_ns;
    struct analog_param_range hact_ns;
    struct analog_param_range hfp_ns;
    struct analog_param_range hslen_ns;
    struct analog_param_range hbp_ns;
    struct analog_param_range hblk_ns;
    unsigned int bt601_hfp;
    struct analog_param_field vfp_lines;
    struct analog_param_field vslen_lines;
    struct analog_param_field vbp_lines;
};

struct kobj_uevent_env;

struct kobj_ns_type_operations;

struct class {
    const char *name;
    const struct attribute_group **class_groups;
    const struct attribute_group **dev_groups;
    int (*dev_uevent)(const struct device *, struct kobj_uevent_env *);
    char * (*devnode)(const struct device *, umode_t *);
    void (*class_release)(const struct class *);
    void (*dev_release)(struct device *);
    int (*shutdown_pre)(struct device *);
    const struct kobj_ns_type_operations *ns_type;
    const void * (*namespace)(const struct device *);
    void (*get_ownership)(const struct device *, kuid_t *, kgid_t *);
    const struct dev_pm_ops *pm;
};

struct transport_container;

struct transport_class {
    struct class class;
    int (*setup)(struct transport_container *, struct device *, struct device *);
    int (*configure)(struct transport_container *, struct device *, struct device *);
    int (*remove)(struct transport_container *, struct device *, struct device *);
};

struct klist_node;

struct klist {
    spinlock_t k_lock;
    struct list_head k_list;
    void (*get)(struct klist_node *);
    void (*put)(struct klist_node *);
};

struct device_attribute;

struct attribute_container {
    struct list_head node;
    struct klist containers;
    struct class *class;
    const struct attribute_group *grp;
    struct device_attribute **attrs;
    int (*match)(struct attribute_container *, struct device *);
    long unsigned int flags;
};

struct anon_transport_class {
    struct transport_class tclass;
    struct attribute_container container;
};

struct anon_vma {
    struct anon_vma *root;
    struct rw_semaphore rwsem;
    atomic_t refcount;
    long unsigned int num_children;
    long unsigned int num_active_vmas;
    struct anon_vma *parent;
    struct rb_root_cached rb_root;
};

struct vm_area_struct;

struct anon_vma_chain {
    struct vm_area_struct *vma;
    struct anon_vma *anon_vma;
    struct list_head same_vma;
    struct rb_node rb;
    long unsigned int rb_subtree_last;
};

struct anon_vma_name {
    struct kref kref;
    char name[0];
};

struct aperture_range {
    struct device *dev;
    resource_size_t base;
    resource_size_t size;
    struct list_head lh;
    void (*detach)(struct device *);
};

struct api_context {
    struct completion done;
    int status;
};

struct apparmor_notif_common {
    __u16 len;
    __u16 version;
};

struct apparmor_notif {
    struct apparmor_notif_common base;
    __u16 ntype;
    __u8 signalled;
    __u8 flags;
    __u64 id;
    __s32 error;
} __attribute__((packed));

struct apparmor_notif_filter {
    struct apparmor_notif_common base;
    __u32 modeset;
    __u32 ns;
    __u32 filter;
    __u8 data[0];
};

struct apparmor_notif_op {
    struct apparmor_notif base;
    __u32 allow;
    __u32 deny;
    pid_t pid;
    __u32 label;
    __u16 class;
    __u16 op;
};

struct apparmor_notif_file {
    struct apparmor_notif_op base;
    uid_t subj_uid;
    uid_t obj_uid;
    __u32 name;
    __u8 data[0];
};

struct apparmor_notif_resp_perm {
    struct apparmor_notif base;
    __s32 error;
    __u32 allow;
    __u32 deny;
};

struct apparmor_notif_resp_name {
    union {
        struct apparmor_notif base;
        struct apparmor_notif_resp_perm perm;
    };
    __u32 name;
    __u8 data[0];
};

union apparmor_notif_resp {
    struct apparmor_notif base;
    struct apparmor_notif_resp_perm perm;
    struct apparmor_notif_resp_name name;
};

union apparmor_notif_all {
    struct apparmor_notif_common common;
    struct apparmor_notif_filter filter;
    struct apparmor_notif base;
    struct apparmor_notif_op op;
    struct apparmor_notif_file file;
    union apparmor_notif_resp respnse;
};

struct workqueue_attrs;

struct pool_workqueue;

struct apply_wqattrs_ctx {
    struct workqueue_struct *wq;
    struct workqueue_attrs *attrs;
    struct list_head list;
    struct pool_workqueue *dfl_pwq;
    struct pool_workqueue *pwq_tbl[0];
};

struct arch_elf_state {
    int flags;
};

struct arch_hw_breakpoint_ctrl {
    u32 __reserved: 19;
    u32 len: 8;
    u32 type: 2;
    u32 privilege: 2;
    u32 enabled: 1;
};

struct arch_hw_breakpoint {
    u64 address;
    u64 trigger;
    struct arch_hw_breakpoint_ctrl ctrl;
};

struct arch_io_reserve_memtype_wc_devres {
    resource_size_t start;
    resource_size_t size;
};

struct arch_msi_msg_addr_hi {
    u32 address_hi;
};

typedef struct arch_msi_msg_addr_hi arch_msi_msg_addr_hi_t;

struct arch_msi_msg_addr_lo {
    u32 address_lo;
};

typedef struct arch_msi_msg_addr_lo arch_msi_msg_addr_lo_t;

struct arch_msi_msg_data {
    u32 data;
};

typedef struct arch_msi_msg_data arch_msi_msg_data_t;

struct pt_regs;

typedef void probes_handler_t(u32, long int, struct pt_regs *);

struct arch_probe_insn {
    probes_handler_t *handler;
};

struct arch_specific_insn {
    struct arch_probe_insn api;
    kprobe_opcode_t *xol_insn;
    long unsigned int xol_restore;
};

struct clock_event_device {
    void (*event_handler)(struct clock_event_device *);
    int (*set_next_event)(long unsigned int, struct clock_event_device *);
    int (*set_next_ktime)(ktime_t, struct clock_event_device *);
    ktime_t next_event;
    u64 max_delta_ns;
    u64 min_delta_ns;
    u32 mult;
    u32 shift;
    enum clock_event_state state_use_accessors;
    unsigned int features;
    long unsigned int retries;
    int (*set_state_periodic)(struct clock_event_device *);
    int (*set_state_oneshot)(struct clock_event_device *);
    int (*set_state_oneshot_stopped)(struct clock_event_device *);
    int (*set_state_shutdown)(struct clock_event_device *);
    int (*tick_resume)(struct clock_event_device *);
    void (*broadcast)(const struct cpumask *);
    void (*suspend)(struct clock_event_device *);
    void (*resume)(struct clock_event_device *);
    long unsigned int min_delta_ticks;
    long unsigned int max_delta_ticks;
    const char *name;
    int rating;
    int irq;
    int bound_on;
    const struct cpumask *cpumask;
    struct list_head list;
    struct module *owner;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
};

struct arch_timer {
    void *base;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    struct clock_event_device evt;
};

struct arch_timer_offset {
    u64 *vm_offset;
    u64 *vcpu_offset;
};

struct kvm_vcpu;

struct arch_timer_context {
    struct kvm_vcpu *vcpu;
    struct hrtimer hrtimer;
    u64 ns_frac;
    struct arch_timer_offset offset;
    bool loaded;
    struct {
        bool level;
    } irq;
    u32 host_timer_irq;
};

struct arch_timer_cpu {
    struct arch_timer_context timers[4];
    struct hrtimer bg_timer;
    bool enabled;
};

struct arch_timer_erratum_workaround {
    enum arch_timer_erratum_match_type match_type;
    const void *id;
    const char *desc;
    u64 (*read_cntpct_el0)(void);
    u64 (*read_cntvct_el0)(void);
    int (*set_next_event_phys)(long unsigned int, struct clock_event_device *);
    int (*set_next_event_virt)(long unsigned int, struct clock_event_device *);
    bool disable_compat_vdso;
};

struct cyclecounter;

struct timecounter {
    const struct cyclecounter *cc;
    u64 cycle_last;
    u64 nsec;
    u64 mask;
    u64 frac;
};

struct arch_timer_kvm_info {
    struct timecounter timecounter;
    int virtual_irq;
    int physical_irq;
};

struct arch_timer_mem_frame {
    bool valid;
    phys_addr_t cntbase;
    size_t size;
    int phys_irq;
    int virt_irq;
};

struct arch_timer_mem {
    phys_addr_t cntctlbase;
    size_t size;
    struct arch_timer_mem_frame frame[8];
};

struct arch_timer_vm_data {
    u64 voffset;
    u64 poffset;
    u8 ppi[4];
};

struct arch_tlbflush_unmap_batch {};

struct arch_uprobe {
    union {
        __le32 insn;
        __le32 ixol;
    };
    struct arch_probe_insn api;
    bool simulate;
};

struct arch_uprobe_task {};

struct arch_vdso_time_data {};

struct arg_dev_net_ip {
    struct net *net;
    struct in6_addr *addr;
};

struct arg_netdev_event {
    const struct net_device *dev;
    union {
        unsigned char nh_flags;
        long unsigned int event;
    };
};

struct midr_range {
    u32 model;
    u32 rv_min;
    u32 rv_max;
};

struct arm64_midr_revidr;

struct arm64_cpu_capabilities {
    const char *desc;
    u16 capability;
    u16 type;
    bool (*matches)(const struct arm64_cpu_capabilities *, int);
    void (*cpu_enable)(const struct arm64_cpu_capabilities *);
    union {
        struct {
            struct midr_range midr_range;
            const struct arm64_midr_revidr * const fixed_revs;
        };
        const struct midr_range *midr_range_list;
        struct {
            u32 sys_reg;
            u8 field_pos;
            u8 field_width;
            u8 min_field_value;
            u8 max_field_value;
            u8 hwcap_type;
            bool sign;
            long unsigned int hwcap;
        };
    };
    const struct arm64_cpu_capabilities *match_list;
    const struct cpumask *cpus;
};

struct arm64_ftr_bits {
    bool sign;
    bool visible;
    bool strict;
    enum ftr_type type;
    u8 shift;
    u8 width;
    s64 safe_val;
};

struct arm64_ftr_override {
    u64 val;
    u64 mask;
};

struct arm64_ftr_reg {
    const char *name;
    u64 strict_mask;
    u64 user_mask;
    u64 sys_val;
    u64 user_val;
    struct arm64_ftr_override *override;
    const struct arm64_ftr_bits *ftr_bits;
};

struct arm64_image_header {
    __le32 code0;
    __le32 code1;
    __le64 text_offset;
    __le64 image_size;
    __le64 flags;
    __le64 res2;
    __le64 res3;
    __le64 res4;
    __le32 magic;
    __le32 res5;
};

struct bpf_prog;

struct jit_ctx {
    const struct bpf_prog *prog;
    int idx;
    int epilogue_offset;
    int *offset;
    int exentry_idx;
    int nr_used_callee_reg;
    u8 used_callee_reg[8];
    __le32 *image;
    __le32 *ro_image;
    u32 stack_size;
    u64 user_vm_start;
    u64 arena_vm_start;
    bool fp_used;
    bool write;
};

struct bpf_binary_header;

struct arm64_jit_data {
    struct bpf_binary_header *header;
    u8 *ro_image;
    struct bpf_binary_header *ro_header;
    struct jit_ctx ctx;
};

struct arm64_mem_crypt_ops {
    int (*encrypt)(long unsigned int, int);
    int (*decrypt)(long unsigned int, int);
};

struct arm64_midr_revidr {
    u32 midr_rv;
    u32 revidr_mask;
};

struct arm_cpuidle_irq_context {
    long unsigned int pmr;
    long unsigned int daif_bits;
};

struct iommu_flush_ops;

struct io_pgtable_cfg {
    long unsigned int quirks;
    long unsigned int pgsize_bitmap;
    unsigned int ias;
    unsigned int oas;
    bool coherent_walk;
    const struct iommu_flush_ops *tlb;
    struct device *iommu_dev;
    void * (*alloc)(void *, size_t, gfp_t);
    void (*free)(void *, void *, size_t);
    union {
        struct {
            u64 ttbr;
            struct {
                u32 ips: 3;
                u32 tg: 2;
                u32 sh: 2;
                u32 orgn: 2;
                u32 irgn: 2;
                u32 tsz: 6;
            } tcr;
            u64 mair;
        } arm_lpae_s1_cfg;
        struct {
            u64 vttbr;
            struct {
                u32 ps: 3;
                u32 tg: 2;
                u32 sh: 2;
                u32 orgn: 2;
                u32 irgn: 2;
                u32 sl: 2;
                u32 tsz: 6;
            } vtcr;
        } arm_lpae_s2_cfg;
        struct {
            u32 ttbr;
            u32 tcr;
            u32 nmrr;
            u32 prrr;
        } arm_v7s_cfg;
        struct {
            u64 transtab;
            u64 memattr;
        } arm_mali_lpae_cfg;
        struct {
            u64 ttbr[4];
            u32 n_ttbrs;
        } apple_dart_cfg;
        struct {
            int nid;
        } amd;
    };
};

struct iommu_iotlb_gather;

struct iommu_dirty_bitmap;

struct io_pgtable_ops {
    int (*map_pages)(struct io_pgtable_ops *, long unsigned int, phys_addr_t, size_t, size_t, int, gfp_t, size_t *);
    size_t (*unmap_pages)(struct io_pgtable_ops *, long unsigned int, size_t, size_t, struct iommu_iotlb_gather *);
    phys_addr_t (*iova_to_phys)(struct io_pgtable_ops *, long unsigned int);
    int (*pgtable_walk)(struct io_pgtable_ops *, long unsigned int, void *);
    int (*read_and_clear_dirty)(struct io_pgtable_ops *, long unsigned int, size_t, long unsigned int, struct iommu_dirty_bitmap *);
};

struct io_pgtable {
    enum io_pgtable_fmt fmt;
    void *cookie;
    struct io_pgtable_cfg cfg;
    struct io_pgtable_ops ops;
};

struct arm_lpae_io_pgtable {
    struct io_pgtable iop;
    int pgd_bits;
    int start_level;
    int bits_per_level;
    void *pgd;
};

struct arm_lpae_io_pgtable_walk_data {
    u64 ptes[4];
};

struct perf_cpu_pmu_context;

struct perf_event;

struct mm_struct;

struct perf_event_pmu_context;

struct kmem_cache;

struct perf_output_handle;

struct pmu {
    struct list_head entry;
    struct module *module;
    struct device *dev;
    struct device *parent;
    const struct attribute_group **attr_groups;
    const struct attribute_group **attr_update;
    const char *name;
    int type;
    int capabilities;
    unsigned int scope;
    int *pmu_disable_count;
    struct perf_cpu_pmu_context *cpu_pmu_context;
    atomic_t exclusive_cnt;
    int task_ctx_nr;
    int hrtimer_interval_ms;
    unsigned int nr_addr_filters;
    void (*pmu_enable)(struct pmu *);
    void (*pmu_disable)(struct pmu *);
    int (*event_init)(struct perf_event *);
    void (*event_mapped)(struct perf_event *, struct mm_struct *);
    void (*event_unmapped)(struct perf_event *, struct mm_struct *);
    int (*add)(struct perf_event *, int);
    void (*del)(struct perf_event *, int);
    void (*start)(struct perf_event *, int);
    void (*stop)(struct perf_event *, int);
    void (*read)(struct perf_event *);
    void (*start_txn)(struct pmu *, unsigned int);
    int (*commit_txn)(struct pmu *);
    void (*cancel_txn)(struct pmu *);
    int (*event_idx)(struct perf_event *);
    void (*sched_task)(struct perf_event_pmu_context *, struct task_struct *, bool);
    struct kmem_cache *task_ctx_cache;
    void (*swap_task_ctx)(struct perf_event_pmu_context *, struct perf_event_pmu_context *);
    void * (*setup_aux)(struct perf_event *, void **, int, bool);
    void (*free_aux)(void *);
    long int (*snapshot_aux)(struct perf_event *, struct perf_output_handle *, long unsigned int);
    int (*addr_filters_validate)(struct list_head *);
    void (*addr_filters_sync)(struct perf_event *);
    int (*aux_output_match)(struct perf_event *);
    bool (*filter)(struct pmu *, int);
    int (*check_period)(struct perf_event *, u64);
};

struct cpumask {
    long unsigned int bits[4];
};

typedef struct cpumask cpumask_t;

struct notifier_block;

typedef int (*notifier_fn_t)(struct notifier_block *, long unsigned int, void *);

struct notifier_block {
    notifier_fn_t notifier_call;
    struct notifier_block *next;
    int priority;
};

struct pmu_hw_events;

struct hw_perf_event;

struct perf_event_attr;

struct platform_device;

struct arm_pmu {
    struct pmu pmu;
    cpumask_t supported_cpus;
    char *name;
    int pmuver;
    irqreturn_t (*handle_irq)(struct arm_pmu *);
    void (*enable)(struct perf_event *);
    void (*disable)(struct perf_event *);
    int (*get_event_idx)(struct pmu_hw_events *, struct perf_event *);
    void (*clear_event_idx)(struct pmu_hw_events *, struct perf_event *);
    int (*set_event_filter)(struct hw_perf_event *, struct perf_event_attr *);
    u64 (*read_counter)(struct perf_event *);
    void (*write_counter)(struct perf_event *, u64);
    void (*start)(struct arm_pmu *);
    void (*stop)(struct arm_pmu *);
    void (*reset)(void *);
    int (*map_event)(struct perf_event *);
    long unsigned int cntr_mask[1];
    bool secure_access;
    long unsigned int pmceid_bitmap[1];
    long unsigned int pmceid_ext_bitmap[1];
    struct platform_device *plat_device;
    struct pmu_hw_events *hw_events;
    struct hlist_node node;
    struct notifier_block cpu_pm_nb;
    const struct attribute_group *attr_groups[5];
    u64 reg_pmmir;
    long unsigned int acpi_cpuid;
};

struct arm_pmu_entry {
    struct list_head entry;
    struct arm_pmu *arm_pmu;
};

struct arm_smccc_quirk {
    int id;
    union {
        long unsigned int a6;
    } state;
};

struct arm_smccc_res {
    long unsigned int a0;
    long unsigned int a1;
    long unsigned int a2;
    long unsigned int a3;
};

struct armctrl_ic {
    void *base;
    void *pending[3];
    void *enable[3];
    void *disable[3];
    struct irq_domain *domain;
    void *local_base;
};

struct armv8pmu_probe_info {
    struct arm_pmu *pmu;
    bool present;
};

struct arphdr {
    __be16 ar_hrd;
    __be16 ar_pro;
    unsigned char ar_hln;
    unsigned char ar_pln;
    __be16 ar_op;
};

struct sockaddr {
    sa_family_t sa_family;
    union {
        char sa_data_min[14];
        struct {
            struct {} __empty_sa_data;
            char sa_data[0];
        };
    };
};

struct arpreq {
    struct sockaddr arp_pa;
    struct sockaddr arp_ha;
    int arp_flags;
    struct sockaddr arp_netmask;
    char arp_dev[16];
};

struct trace_array;

struct trace_array_cpu;

struct array_buffer {
    struct trace_array *tr;
    struct trace_buffer *buffer;
    struct trace_array_cpu *data;
    u64 time_start;
    int cpu;
};

typedef int (*asn1_action_t)(void *, size_t, unsigned char, const void *, size_t);

struct asn1_decoder {
    const unsigned char *machine;
    size_t machlen;
    const asn1_action_t *actions;
};

struct assoc_array_ptr;

struct assoc_array {
    struct assoc_array_ptr *root;
    long unsigned int nr_leaves_on_tree;
};

struct assoc_array_node;

struct assoc_array_delete_collapse_context {
    struct assoc_array_node *node;
    const void *skip_leaf;
    int slot;
};

struct assoc_array_ops;

struct assoc_array_edit {
    struct callback_head rcu;
    struct assoc_array *array;
    const struct assoc_array_ops *ops;
    const struct assoc_array_ops *ops_for_excised_subtree;
    struct assoc_array_ptr *leaf;
    struct assoc_array_ptr **leaf_p;
    struct assoc_array_ptr *dead_leaf;
    struct assoc_array_ptr *new_meta[3];
    struct assoc_array_ptr *excised_meta[1];
    struct assoc_array_ptr *excised_subtree;
    struct assoc_array_ptr **set_backpointers[16];
    struct assoc_array_ptr *set_backpointers_to;
    struct assoc_array_node *adjust_count_on;
    long int adjust_count_by;
    struct {
        struct assoc_array_ptr **ptr;
        struct assoc_array_ptr *to;
    } set[2];
    struct {
        u8 *p;
        u8 to;
    } set_parent_slot[1];
    u8 segment_cache[17];
};

struct assoc_array_node {
    struct assoc_array_ptr *back_pointer;
    u8 parent_slot;
    struct assoc_array_ptr *slots[16];
    long unsigned int nr_leaves_on_branch;
};

struct assoc_array_ops {
    long unsigned int (*get_key_chunk)(const void *, int);
    long unsigned int (*get_object_key_chunk)(const void *, int);
    bool (*compare_object)(const void *, const void *);
    int (*diff_objects)(const void *, const void *);
    void (*free_object)(void *);
};

struct assoc_array_shortcut {
    struct assoc_array_ptr *back_pointer;
    int parent_slot;
    int skip_to_level;
    struct assoc_array_ptr *next_node;
    long unsigned int index_key[0];
};

struct assoc_array_walk_result {
    struct {
        struct assoc_array_node *node;
        int level;
        int slot;
    } terminal_node;
    struct {
        struct assoc_array_shortcut *shortcut;
        int level;
        int sc_level;
        long unsigned int sc_segments;
        long unsigned int dissimilarity;
    } wrong_shortcut;
};

struct asym_cap_data {
    struct list_head link;
    struct callback_head rcu;
    long unsigned int capacity;
    long unsigned int cpus[0];
};

struct asymmetric_key_id {
    short unsigned int len;
    unsigned char data[0];
};

struct asymmetric_key_ids {
    void *id[3];
};

struct key_preparsed_payload;

struct asymmetric_key_parser {
    struct list_head link;
    struct module *owner;
    const char *name;
    int (*parse)(struct key_preparsed_payload *);
};

struct key;

struct seq_file;

struct kernel_pkey_params;

struct kernel_pkey_query;

struct public_key_signature;

struct asymmetric_key_subtype {
    struct module *owner;
    const char *name;
    short unsigned int name_len;
    void (*describe)(const struct key *, struct seq_file *);
    void (*destroy)(void *, void *);
    int (*query)(const struct kernel_pkey_params *, struct kernel_pkey_query *);
    int (*eds_op)(struct kernel_pkey_params *, const void *, void *);
    int (*verify_signature)(const struct key *, const struct public_key_signature *);
};

struct usb_dev_state;

struct pid;

struct urb;

struct usb_memory;

struct async {
    struct list_head asynclist;
    struct usb_dev_state *ps;
    struct pid *pid;
    const struct cred *cred;
    unsigned int signr;
    unsigned int ifnum;
    void *userbuffer;
    void *userurb;
    sigval_t userurb_sigval;
    struct urb *urb;
    struct usb_memory *usbm;
    unsigned int mem_usage;
    int status;
    u8 bulk_addr;
    u8 bulk_status;
};

struct async_domain {
    struct list_head pending;
    unsigned int registered: 1;
};

typedef void (*async_func_t)(void *, async_cookie_t);

struct async_entry {
    struct list_head domain_list;
    struct list_head global_list;
    struct work_struct work;
    async_cookie_t cookie;
    async_func_t func;
    void *data;
    struct async_domain *domain;
};

struct io_poll {
    struct file *file;
    struct wait_queue_head *head;
    __poll_t events;
    int retries;
    struct wait_queue_entry wait;
};

struct async_poll {
    struct io_poll poll;
    struct io_poll *double_poll;
};

struct async_scan_data {
    struct list_head list;
    struct Scsi_Host *shost;
    struct completion prev_finished;
};

struct ate_acpi_oem_info {
    char oem_id[7];
    char oem_table_id[9];
    u32 oem_revision;
};

struct atomic_notifier_head {
    spinlock_t lock;
    struct notifier_block *head;
};

struct attribute {
    const char *name;
    umode_t mode;
};

struct bin_attribute;

struct attribute_group {
    const char *name;
    umode_t (*is_visible)(struct kobject *, struct attribute *, int);
    umode_t (*is_bin_visible)(struct kobject *, const struct bin_attribute *, int);
    size_t (*bin_size)(struct kobject *, const struct bin_attribute *, int);
    struct attribute **attrs;
    union {
        struct bin_attribute **bin_attrs;
        const struct bin_attribute * const *bin_attrs_new;
    };
};

struct audit_aux_data {
    struct audit_aux_data *next;
    int type;
};

struct audit_cap_data {
    kernel_cap_t permitted;
    kernel_cap_t inheritable;
    union {
        unsigned int fE;
        kernel_cap_t effective;
    };
    kernel_cap_t ambient;
    kuid_t rootid;
};

struct audit_aux_data_bprm_fcaps {
    struct audit_aux_data d;
    struct audit_cap_data fcap;
    unsigned int fcap_ver;
    struct audit_cap_data old_pcap;
    struct audit_cap_data new_pcap;
};

struct lsm_prop_selinux {
    u32 secid;
};

struct smack_known;

struct lsm_prop_smack {
    struct smack_known *skp;
};

struct lsm_prop_apparmor {
    struct aa_label *label;
};

struct lsm_prop_bpf {};

struct lsm_prop {
    struct lsm_prop_selinux selinux;
    struct lsm_prop_smack smack;
    struct lsm_prop_apparmor apparmor;
    struct lsm_prop_bpf bpf;
};

struct audit_aux_data_pids {
    struct audit_aux_data d;
    pid_t target_pid[16];
    kuid_t target_auid[16];
    kuid_t target_uid[16];
    unsigned int target_sessionid[16];
    struct lsm_prop target_ref[16];
    char target_comm[256];
    int pid_count;
};

struct timespec64 {
    time64_t tv_sec;
    long int tv_nsec;
};

struct audit_stamp {
    struct timespec64 ctime;
    unsigned int serial;
};

struct audit_context;

struct audit_buffer {
    struct sk_buff *skb;
    struct sk_buff_head skb_list;
    struct audit_context *ctx;
    struct audit_stamp stamp;
    gfp_t gfp_mask;
};

struct audit_cache {
    const struct cred *ad_subj_cred;
    u64 ktime_ns_expiration[41];
};

struct audit_tree;

struct audit_node {
    struct list_head list;
    struct audit_tree *owner;
    unsigned int index;
};

struct fsnotify_mark;

struct audit_chunk {
    struct list_head hash;
    long unsigned int key;
    struct fsnotify_mark *mark;
    struct list_head trees;
    int count;
    atomic_long_t refs;
    struct callback_head head;
    struct audit_node owners[0];
};

struct filename;

struct audit_names {
    struct list_head list;
    struct filename *name;
    int name_len;
    bool hidden;
    long unsigned int ino;
    dev_t dev;
    umode_t mode;
    kuid_t uid;
    kgid_t gid;
    dev_t rdev;
    struct lsm_prop oprop;
    struct audit_cap_data fcap;
    unsigned int fcap_ver;
    unsigned char type;
    bool should_free;
};

struct mq_attr {
    __kernel_long_t mq_flags;
    __kernel_long_t mq_maxmsg;
    __kernel_long_t mq_msgsize;
    __kernel_long_t mq_curmsgs;
    __kernel_long_t __reserved[4];
};

struct open_how {
    __u64 flags;
    __u64 mode;
    __u64 resolve;
};

struct audit_ntp_val {
    long long int oldval;
    long long int newval;
};

struct audit_ntp_data {
    struct audit_ntp_val vals[6];
};

struct audit_proctitle {
    int len;
    char *value;
};

struct audit_tree_refs;

struct audit_context {
    int dummy;
    enum {
        AUDIT_CTX_UNUSED = 0,
        AUDIT_CTX_SYSCALL = 1,
        AUDIT_CTX_URING = 2,
    } context;
    enum audit_state state;
    enum audit_state current_state;
    struct audit_stamp stamp;
    int major;
    int uring_op;
    long unsigned int argv[4];
    long int return_code;
    u64 prio;
    int return_valid;
    struct audit_names preallocated_names[5];
    int name_count;
    struct list_head names_list;
    char *filterkey;
    struct path pwd;
    struct audit_aux_data *aux;
    struct audit_aux_data *aux_pids;
    struct __kernel_sockaddr_storage *sockaddr;
    size_t sockaddr_len;
    pid_t ppid;
    kuid_t uid;
    kuid_t euid;
    kuid_t suid;
    kuid_t fsuid;
    kgid_t gid;
    kgid_t egid;
    kgid_t sgid;
    kgid_t fsgid;
    long unsigned int personality;
    int arch;
    pid_t target_pid;
    kuid_t target_auid;
    kuid_t target_uid;
    unsigned int target_sessionid;
    struct lsm_prop target_ref;
    char target_comm[16];
    struct audit_tree_refs *trees;
    struct audit_tree_refs *first_trees;
    struct list_head killed_trees;
    int tree_count;
    int type;
    union {
        struct {
            int nargs;
            long int args[6];
        } socketcall;
        struct {
            kuid_t uid;
            kgid_t gid;
            umode_t mode;
            struct lsm_prop oprop;
            int has_perm;
            uid_t perm_uid;
            gid_t perm_gid;
            umode_t perm_mode;
            long unsigned int qbytes;
        } ipc;
        struct {
            mqd_t mqdes;
            struct mq_attr mqstat;
        } mq_getsetattr;
        struct {
            mqd_t mqdes;
            int sigev_signo;
        } mq_notify;
        struct {
            mqd_t mqdes;
            size_t msg_len;
            unsigned int msg_prio;
            struct timespec64 abs_timeout;
        } mq_sendrecv;
        struct {
            int oflag;
            umode_t mode;
            struct mq_attr attr;
        } mq_open;
        struct {
            pid_t pid;
            struct audit_cap_data cap;
        } capset;
        struct {
            int fd;
            int flags;
        } mmap;
        struct open_how openat2;
        struct {
            int argc;
        } execve;
        struct {
            char *name;
        } module;
        struct {
            struct audit_ntp_data ntp_data;
            struct timespec64 tk_injoffset;
        } time;
    };
    int fds[2];
    struct audit_proctitle proctitle;
};

struct audit_ctl_mutex {
    struct mutex lock;
    void *owner;
};

struct audit_field;

struct audit_watch;

struct audit_fsnotify_mark;

struct audit_krule {
    u32 pflags;
    u32 flags;
    u32 listnr;
    u32 action;
    u32 mask[64];
    u32 buflen;
    u32 field_count;
    char *filterkey;
    struct audit_field *fields;
    struct audit_field *arch_f;
    struct audit_field *inode_f;
    struct audit_watch *watch;
    struct audit_tree *tree;
    struct audit_fsnotify_mark *exe;
    struct list_head rlist;
    struct list_head list;
    u64 prio;
};

struct audit_entry {
    struct list_head list;
    struct callback_head rcu;
    struct audit_krule rule;
};

struct audit_features {
    __u32 vers;
    __u32 mask;
    __u32 features;
    __u32 lock;
};

struct audit_field {
    u32 type;
    union {
        u32 val;
        kuid_t uid;
        kgid_t gid;
        struct {
            char *lsm_str;
            void *lsm_rule;
        };
    };
    u32 op;
};

struct fsnotify_group;

struct fsnotify_mark_connector;

struct fsnotify_mark {
    __u32 mask;
    refcount_t refcnt;
    struct fsnotify_group *group;
    struct list_head g_list;
    spinlock_t lock;
    struct hlist_node obj_list;
    struct fsnotify_mark_connector *connector;
    __u32 ignore_mask;
    unsigned int flags;
};

struct audit_fsnotify_mark {
    dev_t dev;
    long unsigned int ino;
    char *path;
    struct fsnotify_mark mark;
    struct audit_krule *rule;
};

struct audit_net {
    struct sock *sk;
};

struct audit_netlink_list {
    __u32 portid;
    struct net *net;
    struct sk_buff_head q;
};

struct audit_nfcfgop_tab {
    enum audit_nfcfgop op;
    const char *s;
};

struct audit_parent {
    struct list_head watches;
    struct fsnotify_mark mark;
};

struct audit_reply {
    __u32 portid;
    struct net *net;
    struct sk_buff *skb;
};

struct audit_rule_data {
    __u32 flags;
    __u32 action;
    __u32 field_count;
    __u32 mask[64];
    __u32 fields[64];
    __u32 values[64];
    __u32 fieldflags[64];
    __u32 buflen;
    char buf[0];
};

struct audit_sig_info {
    uid_t uid;
    pid_t pid;
    char ctx[0];
};

struct audit_status {
    __u32 mask;
    __u32 enabled;
    __u32 failure;
    __u32 pid;
    __u32 rate_limit;
    __u32 backlog_limit;
    __u32 lost;
    __u32 backlog;
    union {
        __u32 version;
        __u32 feature_bitmap;
    };
    __u32 backlog_wait_time;
    __u32 backlog_wait_time_actual;
};

struct audit_tree {
    refcount_t count;
    int goner;
    struct audit_chunk *root;
    struct list_head chunks;
    struct list_head rules;
    struct list_head list;
    struct list_head same_root;
    struct callback_head head;
    char pathname[0];
};

struct audit_tree_mark {
    struct fsnotify_mark mark;
    struct audit_chunk *chunk;
};

struct audit_tree_refs {
    struct audit_tree_refs *next;
    struct audit_chunk *c[31];
};

struct audit_tty_status {
    __u32 enabled;
    __u32 log_passwd;
};

struct audit_watch {
    refcount_t count;
    dev_t dev;
    char *path;
    long unsigned int ino;
    struct audit_parent *parent;
    struct list_head wlist;
    struct list_head rules;
};

struct auditd_connection {
    struct pid *pid;
    u32 portid;
    struct net *net;
    struct callback_head rcu;
};

struct auth_cred {
    const struct cred *cred;
    const char *principal;
};

struct auth_ops;

struct auth_domain {
    struct kref ref;
    struct hlist_node hash;
    char *name;
    struct auth_ops *flavour;
    struct callback_head callback_head;
};

struct svc_rqst;

struct auth_ops {
    char *name;
    struct module *owner;
    int flavour;
    enum svc_auth_status (*accept)(struct svc_rqst *);
    int (*release)(struct svc_rqst *);
    void (*domain_release)(struct auth_domain *);
    enum svc_auth_status (*set_client)(struct svc_rqst *);
    rpc_authflavor_t (*pseudoflavor)(struct svc_rqst *);
};

struct auto_mode_param {
    int qp_type;
};

struct task_group;

struct autogroup {
    struct kref kref;
    struct task_group *tg;
    struct rw_semaphore lock;
    long unsigned int id;
    int nice;
};

struct auxiliary_device {
    struct device dev;
    const char *name;
    u32 id;
    struct {
        struct xarray irqs;
        struct mutex lock;
        bool irq_dir_exists;
    } sysfs;
};

struct auxiliary_device_id {
    char name[32];
    kernel_ulong_t driver_data;
};

struct auxiliary_driver {
    int (*probe)(struct auxiliary_device *, const struct auxiliary_device_id *);
    void (*remove)(struct auxiliary_device *);
    void (*shutdown)(struct auxiliary_device *);
    int (*suspend)(struct auxiliary_device *, pm_message_t);
    int (*resume)(struct auxiliary_device *);
    const char *name;
    struct device_driver driver;
    const struct auxiliary_device_id *id_table;
};

struct device_attribute {
    struct attribute attr;
    ssize_t (*show)(struct device *, struct device_attribute *, char *);
    ssize_t (*store)(struct device *, struct device_attribute *, const char *, size_t);
};

struct auxiliary_irq_info {
    struct device_attribute sysfs_attr;
    char name[11];
};

struct av_decision {
    u32 allowed;
    u32 auditallow;
    u32 auditdeny;
    u32 seqno;
    u32 flags;
};

struct hlist_head {
    struct hlist_node *first;
};

struct avc_cache {
    struct hlist_head slots[512];
    spinlock_t slots_lock[512];
    atomic_t lru_hint;
    atomic_t active_nodes;
    u32 latest_notif;
};

struct avc_cache_stats {
    unsigned int lookups;
    unsigned int misses;
    unsigned int allocations;
    unsigned int reclaims;
    unsigned int frees;
};

struct avc_callback_node {
    int (*callback)(u32);
    u32 events;
    struct avc_callback_node *next;
};

struct avc_xperms_node;

struct avc_entry {
    u32 ssid;
    u32 tsid;
    u16 tclass;
    struct av_decision avd;
    struct avc_xperms_node *xp_node;
};

struct avc_node {
    struct avc_entry ae;
    struct hlist_node list;
    struct callback_head rhead;
};

struct extended_perms_data;

struct extended_perms_decision {
    u8 used;
    u8 driver;
    u8 base_perm;
    struct extended_perms_data *allowed;
    struct extended_perms_data *auditallow;
    struct extended_perms_data *dontaudit;
};

struct avc_xperms_decision_node {
    struct extended_perms_decision xpd;
    struct list_head xpd_list;
};

struct extended_perms_data {
    u32 p[8];
};

struct extended_perms {
    u16 len;
    u8 base_perms;
    struct extended_perms_data drivers;
};

struct avc_xperms_node {
    struct extended_perms xp;
    struct list_head xpd_head;
};

struct avtab_node;

struct avtab {
    struct avtab_node **htable;
    u32 nel;
    u32 nslot;
    u32 mask;
};

struct avtab_extended_perms;

struct avtab_datum {
    union {
        u32 data;
        struct avtab_extended_perms *xperms;
    } u;
};

struct avtab_extended_perms {
    u8 specified;
    u8 driver;
    struct extended_perms_data perms;
};

struct avtab_key {
    u16 source_type;
    u16 target_type;
    u16 target_class;
    u16 specified;
};

struct avtab_node {
    struct avtab_key key;
    struct avtab_datum datum;
    struct avtab_node *next;
};

struct ctl_table_header;

struct ax25_dev {
    struct list_head list;
    struct net_device *dev;
    netdevice_tracker dev_tracker;
    struct net_device *forward;
    struct ctl_table_header *sysheader;
    int values[14];
    ax25_dama_info dama;
    refcount_t refcount;
    bool device_up;
    struct callback_head rcu;
};

struct dma_device;

struct dma_chan_dev;

struct dma_chan_percpu;

struct dma_router;

struct dma_chan {
    struct dma_device *device;
    struct device *slave;
    dma_cookie_t cookie;
    dma_cookie_t completed_cookie;
    int chan_id;
    struct dma_chan_dev *dev;
    const char *name;
    char *dbg_client_name;
    struct list_head device_node;
    struct dma_chan_percpu *local;
    int client_count;
    int table_count;
    struct dma_router *router;
    void *route_data;
    void *private;
};

struct tasklet_struct {
    struct tasklet_struct *next;
    long unsigned int state;
    atomic_t count;
    bool use_callback;
    union {
        void (*func)(long unsigned int);
        void (*callback)(struct tasklet_struct *);
    };
    long unsigned int data;
};

struct virt_dma_desc;

struct virt_dma_chan {
    struct dma_chan chan;
    struct tasklet_struct task;
    void (*desc_free)(struct virt_dma_desc *);
    spinlock_t lock;
    struct list_head desc_allocated;
    struct list_head desc_submitted;
    struct list_head desc_issued;
    struct list_head desc_completed;
    struct list_head desc_terminated;
    struct virt_dma_desc *cyclic;
};

struct dma_slave_config {
    enum dma_transfer_direction direction;
    phys_addr_t src_addr;
    phys_addr_t dst_addr;
    enum dma_slave_buswidth src_addr_width;
    enum dma_slave_buswidth dst_addr_width;
    u32 src_maxburst;
    u32 dst_maxburst;
    u32 src_port_window_size;
    u32 dst_port_window_size;
    bool device_fc;
    void *peripheral_config;
    size_t peripheral_size;
};

struct axi_dma_chip;

struct dma_pool;

struct axi_dma_desc;

struct axi_dma_chan {
    struct axi_dma_chip *chip;
    void *chan_regs;
    u8 id;
    u8 hw_handshake_num;
    atomic_t descs_allocated;
    struct dma_pool *desc_pool;
    struct virt_dma_chan vc;
    struct axi_dma_desc *desc;
    struct dma_slave_config config;
    enum dma_transfer_direction direction;
    bool cyclic;
    bool is_paused;
};

struct axi_dma_chan_config {
    u8 dst_multblk_type;
    u8 src_multblk_type;
    u8 dst_per;
    u8 src_per;
    u8 tt_fc;
    u8 prior;
    u8 hs_sel_dst;
    u8 hs_sel_src;
};

struct dw_axi_dma;

struct axi_dma_chip {
    struct device *dev;
    int irq[32];
    void *regs;
    void *apb_regs;
    struct clk *core_clk;
    struct clk *cfgr_clk;
    struct dw_axi_dma *dw;
};

typedef void (*dma_async_tx_callback)(void *);

struct dmaengine_result;

typedef void (*dma_async_tx_callback_result)(void *, const struct dmaengine_result *);

struct dmaengine_unmap_data;

struct dma_descriptor_metadata_ops;

struct dma_async_tx_descriptor {
    dma_cookie_t cookie;
    enum dma_ctrl_flags flags;
    dma_addr_t phys;
    struct dma_chan *chan;
    dma_cookie_t (*tx_submit)(struct dma_async_tx_descriptor *);
    int (*desc_free)(struct dma_async_tx_descriptor *);
    dma_async_tx_callback callback;
    dma_async_tx_callback_result callback_result;
    void *callback_param;
    struct dmaengine_unmap_data *unmap;
    enum dma_desc_metadata_mode desc_metadata_mode;
    struct dma_descriptor_metadata_ops *metadata_ops;
    struct dma_async_tx_descriptor *next;
    struct dma_async_tx_descriptor *parent;
    spinlock_t lock;
};

struct dmaengine_result {
    enum dmaengine_tx_result result;
    u32 residue;
};

struct virt_dma_desc {
    struct dma_async_tx_descriptor tx;
    struct dmaengine_result tx_result;
    struct list_head node;
};

struct axi_dma_hw_desc;

struct axi_dma_desc {
    struct axi_dma_hw_desc *hw_desc;
    struct virt_dma_desc vd;
    struct axi_dma_chan *chan;
    u32 completed_blocks;
    u32 length;
    u32 period_len;
    u32 nr_hw_descs;
};

struct axi_dma_lli;

struct axi_dma_hw_desc {
    struct axi_dma_lli *lli;
    dma_addr_t llp;
    u32 len;
};

struct axi_dma_lli {
    __le64 sar;
    __le64 dar;
    __le32 block_ts_lo;
    __le32 block_ts_hi;
    __le64 llp;
    __le32 ctl_lo;
    __le32 ctl_hi;
    __le32 sstat;
    __le32 dstat;
    __le32 status_lo;
    __le32 status_hi;
    __le32 reserved_lo;
    __le32 reserved_hi;
};

struct backing_aio {
    struct kiocb iocb;
    refcount_t ref;
    struct kiocb *orig_iocb;
    void (*end_write)(struct kiocb *, ssize_t);
    struct work_struct work;
    long int res;
};

struct percpu_counter {
    raw_spinlock_t lock;
    s64 count;
    s32 *counters;
};

struct fprop_local_percpu {
    struct percpu_counter events;
    unsigned int period;
    raw_spinlock_t lock;
};

struct delayed_work {
    struct work_struct work;
    struct timer_list timer;
    struct workqueue_struct *wq;
    int cpu;
};

struct percpu_ref_data;

struct percpu_ref {
    long unsigned int percpu_count_ptr;
    struct percpu_ref_data *data;
};

struct backing_dev_info;

struct cgroup_subsys_state;

struct bdi_writeback {
    struct backing_dev_info *bdi;
    long unsigned int state;
    long unsigned int last_old_flush;
    struct list_head b_dirty;
    struct list_head b_io;
    struct list_head b_more_io;
    struct list_head b_dirty_time;
    spinlock_t list_lock;
    atomic_t writeback_inodes;
    struct percpu_counter stat[4];
    long unsigned int bw_time_stamp;
    long unsigned int dirtied_stamp;
    long unsigned int written_stamp;
    long unsigned int write_bandwidth;
    long unsigned int avg_write_bandwidth;
    long unsigned int dirty_ratelimit;
    long unsigned int balanced_dirty_ratelimit;
    struct fprop_local_percpu completions;
    int dirty_exceeded;
    enum wb_reason start_all_reason;
    spinlock_t work_lock;
    struct list_head work_list;
    struct delayed_work dwork;
    struct delayed_work bw_dwork;
    struct list_head bdi_node;
    struct percpu_ref refcnt;
    struct fprop_local_percpu memcg_completions;
    struct cgroup_subsys_state *memcg_css;
    struct cgroup_subsys_state *blkcg_css;
    struct list_head memcg_node;
    struct list_head blkcg_node;
    struct list_head b_attached;
    struct list_head offline_node;
    union {
        struct work_struct release_work;
        struct callback_head rcu;
    };
};

struct backing_dev_info {
    u64 id;
    struct rb_node rb_node;
    struct list_head bdi_list;
    long unsigned int ra_pages;
    long unsigned int io_pages;
    struct kref refcnt;
    unsigned int capabilities;
    unsigned int min_ratio;
    unsigned int max_ratio;
    unsigned int max_prop_frac;
    atomic_long_t tot_write_bandwidth;
    long unsigned int last_bdp_sleep;
    struct bdi_writeback wb;
    struct list_head wb_list;
    struct xarray cgwb_tree;
    struct mutex cgwb_release_mutex;
    struct rw_semaphore wb_switch_rwsem;
    wait_queue_head_t wb_waitq;
    struct device *dev;
    char dev_name[64];
    struct device *owner;
    struct timer_list laptop_mode_wb_timer;
    struct dentry *debug_dir;
};

struct file_ra_state {
    long unsigned int start;
    unsigned int size;
    unsigned int async_size;
    unsigned int ra_pages;
    unsigned int mmap_miss;
    loff_t prev_pos;
};

struct fown_struct;

struct file {
    file_ref_t f_ref;
    spinlock_t f_lock;
    fmode_t f_mode;
    const struct file_operations *f_op;
    struct address_space *f_mapping;
    void *private_data;
    struct inode *f_inode;
    unsigned int f_flags;
    unsigned int f_iocb_flags;
    const struct cred *f_cred;
    struct path f_path;
    union {
        struct mutex f_pos_lock;
        u64 f_pipe;
    };
    loff_t f_pos;
    void *f_security;
    struct fown_struct *f_owner;
    errseq_t f_wb_err;
    errseq_t f_sb_err;
    struct hlist_head *f_ep;
    union {
        struct callback_head f_task_work;
        struct llist_node f_llist;
        struct file_ra_state f_ra;
        freeptr_t f_freeptr;
    };
};

struct backing_file {
    struct file file;
    union {
        struct path user_path;
        freeptr_t bf_freeptr;
    };
};

struct backing_file_ctx {
    const struct cred *cred;
    void (*accessed)(struct file *);
    void (*end_write)(struct kiocb *, ssize_t);
};

struct backlight_properties {
    int brightness;
    int max_brightness;
    int power;
    enum backlight_type type;
    unsigned int state;
    enum backlight_scale scale;
    char display_name[32];
};

struct backlight_ops;

struct backlight_device {
    struct backlight_properties props;
    struct mutex update_lock;
    struct mutex ops_lock;
    const struct backlight_ops *ops;
    struct notifier_block fb_notif;
    struct list_head entry;
    struct device dev;
    bool fb_bl_on[32];
    int use_count;
};

struct backlight_ops {
    unsigned int options;
    int (*update_status)(struct backlight_device *);
    int (*get_brightness)(struct backlight_device *);
    bool (*controls_device)(struct backlight_device *, struct device *);
};

struct bpf_verifier_env;

struct backtrack_state {
    struct bpf_verifier_env *env;
    u32 frame;
    u32 reg_masks[8];
    u64 stack_masks[8];
};

struct badblocks {
    struct device *dev;
    int count;
    int unacked_exist;
    int shift;
    u64 *page;
    int changed;
    seqlock_t lock;
    sector_t sector;
    sector_t size;
};

struct badblocks_context {
    sector_t start;
    sector_t len;
    int ack;
};

struct balance_callback {
    struct balance_callback *next;
    void (*func)(struct rq *);
};

struct balloon_dev_info {
    long unsigned int isolated_pages;
    spinlock_t pages_lock;
    struct list_head pages;
    int (*migratepage)(struct balloon_dev_info *, struct page *, struct page *, enum migrate_mode);
};

struct batadv_unicast_packet {
    __u8 packet_type;
    __u8 version;
    __u8 ttl;
    __u8 ttvn;
    __u8 dest[6];
};

struct batch_u16 {
    u16 entropy[48];
    local_lock_t lock;
    long unsigned int generation;
    unsigned int position;
};

struct batch_u32 {
    u32 entropy[24];
    local_lock_t lock;
    long unsigned int generation;
    unsigned int position;
};

struct batch_u64 {
    u64 entropy[12];
    local_lock_t lock;
    long unsigned int generation;
    unsigned int position;
};

struct batch_u8 {
    u8 entropy[96];
    local_lock_t lock;
    long unsigned int generation;
    unsigned int position;
};

struct bcm2708_dma_cb {
    u32 info;
    u32 src;
    u32 dst;
    u32 length;
    u32 stride;
    u32 next;
    u32 pad[2];
};

struct bcm2711_dma40_scb {
    uint32_t ti;
    uint32_t src;
    uint32_t srci;
    uint32_t dst;
    uint32_t dsti;
    uint32_t len;
    uint32_t next_cb;
    uint32_t rsvd;
};

struct regmap;

struct thermal_zone_device;

struct bcm2711_thermal_priv {
    struct regmap *regmap;
    struct thermal_zone_device *thermal;
};

struct iommu_ops;

struct iommu_device {
    struct list_head list;
    const struct iommu_ops *ops;
    struct fwnode_handle *fwnode;
    struct device *dev;
    struct iommu_group *singleton_group;
    u32 max_pasids;
};

struct bcm2712_iommu_domain;

struct sg_table;

struct bcm2712_iommu_cache;

struct bcm2712_iommu {
    struct device *dev;
    struct iommu_device iommu;
    struct iommu_group *group;
    struct bcm2712_iommu_domain *domain;
    const char *name;
    struct sg_table *sgt;
    u32 *tables;
    struct bcm2712_iommu_cache *cache;
    spinlock_t hw_lock;
    void *reg_base;
    u64 dma_iova_offset;
    u32 bigpage_mask;
    u32 superpage_mask;
    unsigned int nmapped_pages;
    bool dirty;
};

struct bcm2712_iommu_cache {
    struct device *dev;
    spinlock_t hw_lock;
    void *reg_base;
};

struct iommu_domain_geometry {
    dma_addr_t aperture_start;
    dma_addr_t aperture_end;
    bool force_aperture;
};

struct iommu_domain;

typedef int (*iommu_fault_handler_t)(struct iommu_domain *, struct device *, long unsigned int, int, void *);

struct iommu_domain_ops;

struct iommu_dirty_ops;

struct iommu_dma_cookie;

struct iopf_group;

struct iommu_domain {
    unsigned int type;
    const struct iommu_domain_ops *ops;
    const struct iommu_dirty_ops *dirty_ops;
    const struct iommu_ops *owner;
    long unsigned int pgsize_bitmap;
    struct iommu_domain_geometry geometry;
    struct iommu_dma_cookie *iova_cookie;
    int (*iopf_handler)(struct iopf_group *);
    void *fault_data;
    union {
        struct {
            iommu_fault_handler_t handler;
            void *handler_token;
        };
        struct {
            struct mm_struct *mm;
            int users;
            struct list_head next;
        };
    };
};

struct bcm2712_iommu_domain {
    struct iommu_domain base;
    struct bcm2712_iommu *mmu;
};

struct bcm2712_pin_funcs {
    u8 funcs[8];
};

struct pinctrl_pin_desc;

struct pinctrl_ops;

struct pinmux_ops;

struct pinconf_ops;

struct pinconf_generic_params;

struct pin_config_item;

struct pinctrl_desc {
    const char *name;
    const struct pinctrl_pin_desc *pins;
    unsigned int npins;
    const struct pinctrl_ops *pctlops;
    const struct pinmux_ops *pmxops;
    const struct pinconf_ops *confops;
    struct module *owner;
    unsigned int num_custom_params;
    const struct pinconf_generic_params *custom_params;
    const struct pin_config_item *custom_conf_items;
    bool link_consumers;
};

struct gpio_chip;

struct pinctrl_gpio_range {
    struct list_head node;
    const char *name;
    unsigned int id;
    unsigned int base;
    unsigned int pin_base;
    unsigned int npins;
    const unsigned int *pins;
    struct gpio_chip *gc;
};

struct pinctrl_dev;

struct pin_regs;

struct bcm2712_pinctrl {
    struct device *dev;
    void *base;
    struct pinctrl_dev *pctl_dev;
    struct pinctrl_desc pctl_desc;
    const struct pin_regs *pin_regs;
    const struct bcm2712_pin_funcs *pin_funcs;
    const char * const *gpio_groups;
    struct pinctrl_gpio_range gpio_range;
    spinlock_t lock;
};

struct bcm2835_dma_cb;

struct bcm2835_cb_entry {
    struct bcm2835_dma_cb *cb;
    dma_addr_t paddr;
};

struct bcm2835_desc;

struct bcm2835_chan {
    struct virt_dma_chan vc;
    struct dma_slave_config cfg;
    unsigned int dreq;
    int ch;
    struct bcm2835_desc *desc;
    struct dma_pool *cb_pool;
    void *chan_base;
    int irq_number;
    unsigned int irq_flags;
    bool is_lite_channel;
    bool is_40bit_channel;
    bool is_2712;
};

struct clk_hw;

struct bcm2835_cprman;

struct bcm2835_clk_desc {
    struct clk_hw * (*clk_register)(struct bcm2835_cprman *, const void *);
    unsigned int supported;
    const void *data;
};

struct clk_core;

struct clk_init_data;

struct clk_hw {
    struct clk_core *core;
    struct clk *clk;
    const struct clk_init_data *init;
};

struct bcm2835_clock_data;

struct bcm2835_clock {
    struct clk_hw hw;
    struct bcm2835_cprman *cprman;
    const struct bcm2835_clock_data *data;
};

struct bcm2835_clock_data {
    const char *name;
    const char * const *parents;
    int num_mux_parents;
    unsigned int set_rate_parent;
    u32 ctl_reg;
    u32 div_reg;
    u32 int_bits;
    u32 frac_bits;
    u32 flags;
    bool is_vpu_clock;
    bool is_mash_clock;
    bool low_jitter;
    u32 tcnt_mux;
    bool round_up;
};

struct clk_hw_onecell_data {
    unsigned int num;
    struct clk_hw *hws[0];
};

struct rpi_firmware;

struct bcm2835_cprman {
    struct device *dev;
    void *regs;
    struct rpi_firmware *fw;
    spinlock_t regs_lock;
    unsigned int soc;
    const char *real_parent_names[7];
    struct clk_hw_onecell_data onecell;
};

struct bcm2835_desc {
    struct bcm2835_chan *c;
    struct virt_dma_desc vd;
    enum dma_transfer_direction dir;
    unsigned int frames;
    size_t size;
    bool cyclic;
    struct bcm2835_cb_entry cb_list[0];
};

struct bcm2835_dma_cb {
    uint32_t info;
    uint32_t src;
    uint32_t dst;
    uint32_t length;
    uint32_t stride;
    uint32_t next;
    uint32_t pad[2];
};

struct bcm2835_dma_cfg_data {
    u64 dma_mask;
    u32 chan_40bit_mask;
};

typedef bool (*dma_filter_fn)(struct dma_chan *, void *);

struct dma_slave_map;

struct dma_filter {
    dma_filter_fn fn;
    int mapcnt;
    const struct dma_slave_map *map;
};

struct ida {
    struct xarray xa;
};

struct dma_vec;

struct dma_interleaved_template;

struct dma_slave_caps;

struct dma_tx_state;

struct dma_device {
    struct kref ref;
    unsigned int chancnt;
    unsigned int privatecnt;
    struct list_head channels;
    struct list_head global_node;
    struct dma_filter filter;
    dma_cap_mask_t cap_mask;
    enum dma_desc_metadata_mode desc_metadata_modes;
    short unsigned int max_xor;
    short unsigned int max_pq;
    enum dmaengine_alignment copy_align;
    enum dmaengine_alignment xor_align;
    enum dmaengine_alignment pq_align;
    enum dmaengine_alignment fill_align;
    int dev_id;
    struct device *dev;
    struct module *owner;
    struct ida chan_ida;
    u32 src_addr_widths;
    u32 dst_addr_widths;
    u32 directions;
    u32 min_burst;
    u32 max_burst;
    u32 max_sg_burst;
    bool descriptor_reuse;
    enum dma_residue_granularity residue_granularity;
    int (*device_alloc_chan_resources)(struct dma_chan *);
    int (*device_router_config)(struct dma_chan *);
    void (*device_free_chan_resources)(struct dma_chan *);
    struct dma_async_tx_descriptor * (*device_prep_dma_memcpy)(struct dma_chan *, dma_addr_t, dma_addr_t, size_t, long unsigned int);
    struct dma_async_tx_descriptor * (*device_prep_dma_xor)(struct dma_chan *, dma_addr_t, dma_addr_t *, unsigned int, size_t, long unsigned int);
    struct dma_async_tx_descriptor * (*device_prep_dma_xor_val)(struct dma_chan *, dma_addr_t *, unsigned int, size_t, enum sum_check_flags *, long unsigned int);
    struct dma_async_tx_descriptor * (*device_prep_dma_pq)(struct dma_chan *, dma_addr_t *, dma_addr_t *, unsigned int, const unsigned char *, size_t, long unsigned int);
    struct dma_async_tx_descriptor * (*device_prep_dma_pq_val)(struct dma_chan *, dma_addr_t *, dma_addr_t *, unsigned int, const unsigned char *, size_t, enum sum_check_flags *, long unsigned int);
    struct dma_async_tx_descriptor * (*device_prep_dma_memset)(struct dma_chan *, dma_addr_t, int, size_t, long unsigned int);
    struct dma_async_tx_descriptor * (*device_prep_dma_memset_sg)(struct dma_chan *, struct scatterlist *, unsigned int, int, long unsigned int);
    struct dma_async_tx_descriptor * (*device_prep_dma_interrupt)(struct dma_chan *, long unsigned int);
    struct dma_async_tx_descriptor * (*device_prep_peripheral_dma_vec)(struct dma_chan *, const struct dma_vec *, size_t, enum dma_transfer_direction, long unsigned int);
    struct dma_async_tx_descriptor * (*device_prep_slave_sg)(struct dma_chan *, struct scatterlist *, unsigned int, enum dma_transfer_direction, long unsigned int, void *);
    struct dma_async_tx_descriptor * (*device_prep_dma_cyclic)(struct dma_chan *, dma_addr_t, size_t, size_t, enum dma_transfer_direction, long unsigned int);
    struct dma_async_tx_descriptor * (*device_prep_interleaved_dma)(struct dma_chan *, struct dma_interleaved_template *, long unsigned int);
    struct dma_async_tx_descriptor * (*device_prep_dma_imm_data)(struct dma_chan *, dma_addr_t, u64, long unsigned int);
    void (*device_caps)(struct dma_chan *, struct dma_slave_caps *);
    int (*device_config)(struct dma_chan *, struct dma_slave_config *);
    int (*device_pause)(struct dma_chan *);
    int (*device_resume)(struct dma_chan *);
    int (*device_terminate_all)(struct dma_chan *);
    void (*device_synchronize)(struct dma_chan *);
    enum dma_status (*device_tx_status)(struct dma_chan *, dma_cookie_t, struct dma_tx_state *);
    void (*device_issue_pending)(struct dma_chan *);
    void (*device_release)(struct dma_device *);
    void (*dbg_summary_show)(struct seq_file *, struct dma_device *);
    struct dentry *dbg_dev_root;
};

struct bcm2835_dmadev {
    struct dma_device ddev;
    void *base;
    dma_addr_t zero_page;
    const struct bcm2835_dma_cfg_data *cfg_data;
};

struct bcm2835_gate_data {
    const char *name;
    const char *parent;
    u32 ctl_reg;
};

struct sg_page_iter {
    struct scatterlist *sg;
    unsigned int sg_pgoffset;
    unsigned int __nents;
    int __pg_advance;
};

struct sg_mapping_iter {
    struct page *page;
    void *addr;
    size_t length;
    size_t consumed;
    struct sg_page_iter piter;
    unsigned int __offset;
    unsigned int __remaining;
    unsigned int __flags;
};

struct mmc_request;

struct mmc_command;

struct mmc_data;

struct bcm2835_host {
    spinlock_t lock;
    struct mutex mutex;
    void *ioaddr;
    u32 phys_addr;
    struct clk *clk;
    struct platform_device *pdev;
    unsigned int clock;
    unsigned int max_clk;
    struct work_struct dma_work;
    struct delayed_work timeout_work;
    struct sg_mapping_iter sg_miter;
    unsigned int blocks;
    int irq;
    u32 ns_per_fifo_word;
    u32 hcfg;
    u32 cdiv;
    struct mmc_request *mrq;
    struct mmc_command *cmd;
    struct mmc_data *data;
    bool data_complete: 1;
    bool use_busy: 1;
    bool use_sbc: 1;
    bool irq_block;
    bool irq_busy;
    bool irq_data;
    struct dma_chan *dma_chan_rxtx;
    struct dma_chan *dma_chan;
    struct dma_slave_config dma_cfg_rx;
    struct dma_slave_config dma_cfg_tx;
    struct dma_async_tx_descriptor *dma_desc;
    u32 dma_dir;
    u32 drain_words;
    struct page *drain_page;
    u32 drain_offset;
    bool use_dma;
    struct rpi_firmware *fw;
    u32 pio_limit;
    u32 user_overclock_50;
    u32 overclock_50;
    u32 overclock;
    bool reset_clock: 1;
};

struct mbox_chan_ops;

struct mbox_chan;

struct of_phandle_args;

struct mbox_controller {
    struct device *dev;
    const struct mbox_chan_ops *ops;
    struct mbox_chan *chans;
    int num_chans;
    bool txdone_irq;
    bool txdone_poll;
    unsigned int txpoll_period;
    struct mbox_chan * (*of_xlate)(struct mbox_controller *, const struct of_phandle_args *);
    struct hrtimer poll_hrt;
    spinlock_t poll_hrt_lock;
    struct list_head node;
};

struct bcm2835_mbox {
    void *regs;
    spinlock_t lock;
    struct mbox_controller controller;
};

struct irq_fwspec;

struct irq_data;

struct irq_domain_ops {
    int (*match)(struct irq_domain *, struct device_node *, enum irq_domain_bus_token);
    int (*select)(struct irq_domain *, struct irq_fwspec *, enum irq_domain_bus_token);
    int (*map)(struct irq_domain *, unsigned int, irq_hw_number_t);
    void (*unmap)(struct irq_domain *, unsigned int);
    int (*xlate)(struct irq_domain *, struct device_node *, const u32 *, unsigned int, long unsigned int *, unsigned int *);
    int (*alloc)(struct irq_domain *, unsigned int, unsigned int, void *);
    void (*free)(struct irq_domain *, unsigned int, unsigned int);
    int (*activate)(struct irq_domain *, struct irq_data *, bool);
    void (*deactivate)(struct irq_domain *, struct irq_data *);
    int (*translate)(struct irq_domain *, struct irq_fwspec *, long unsigned int *, unsigned int *);
};

struct irq_desc;

typedef void (*irq_flow_handler_t)(struct irq_desc *);

struct irq_chip;

union gpio_irq_fwspec;

struct gpio_irq_chip {
    struct irq_chip *chip;
    struct irq_domain *domain;
    struct fwnode_handle *fwnode;
    struct irq_domain *parent_domain;
    int (*child_to_parent_hwirq)(struct gpio_chip *, unsigned int, unsigned int, unsigned int *, unsigned int *);
    int (*populate_parent_alloc_arg)(struct gpio_chip *, union gpio_irq_fwspec *, unsigned int, unsigned int);
    unsigned int (*child_offset_to_irq)(struct gpio_chip *, unsigned int);
    struct irq_domain_ops child_irq_domain_ops;
    irq_flow_handler_t handler;
    unsigned int default_type;
    struct lock_class_key *lock_key;
    struct lock_class_key *request_key;
    irq_flow_handler_t parent_handler;
    union {
        void *parent_handler_data;
        void **parent_handler_data_array;
    };
    unsigned int num_parents;
    unsigned int *parents;
    unsigned int *map;
    bool threaded;
    bool per_parent_data;
    bool initialized;
    bool domain_is_allocated_externally;
    int (*init_hw)(struct gpio_chip *);
    void (*init_valid_mask)(struct gpio_chip *, long unsigned int *, unsigned int);
    long unsigned int *valid_mask;
    unsigned int first;
    void (*irq_enable)(struct irq_data *);
    void (*irq_disable)(struct irq_data *);
    void (*irq_unmask)(struct irq_data *);
    void (*irq_mask)(struct irq_data *);
};

struct gpio_device;

struct gpio_chip {
    const char *label;
    struct gpio_device *gpiodev;
    struct device *parent;
    struct fwnode_handle *fwnode;
    struct module *owner;
    int (*request)(struct gpio_chip *, unsigned int);
    void (*free)(struct gpio_chip *, unsigned int);
    int (*get_direction)(struct gpio_chip *, unsigned int);
    int (*direction_input)(struct gpio_chip *, unsigned int);
    int (*direction_output)(struct gpio_chip *, unsigned int, int);
    int (*get)(struct gpio_chip *, unsigned int);
    int (*get_multiple)(struct gpio_chip *, long unsigned int *, long unsigned int *);
    void (*set)(struct gpio_chip *, unsigned int, int);
    void (*set_multiple)(struct gpio_chip *, long unsigned int *, long unsigned int *);
    int (*set_config)(struct gpio_chip *, unsigned int, long unsigned int);
    int (*to_irq)(struct gpio_chip *, unsigned int);
    void (*dbg_show)(struct seq_file *, struct gpio_chip *);
    int (*init_valid_mask)(struct gpio_chip *, long unsigned int *, unsigned int);
    int (*add_pin_ranges)(struct gpio_chip *);
    int (*en_hw_timestamp)(struct gpio_chip *, u32, long unsigned int);
    int (*dis_hw_timestamp)(struct gpio_chip *, u32, long unsigned int);
    int base;
    u16 ngpio;
    u16 offset;
    const char * const *names;
    bool can_sleep;
    long unsigned int (*read_reg)(void *);
    void (*write_reg)(void *, long unsigned int);
    bool be_bits;
    void *reg_dat;
    void *reg_set;
    void *reg_clr;
    void *reg_dir_out;
    void *reg_dir_in;
    bool bgpio_dir_unreadable;
    int bgpio_bits;
    raw_spinlock_t bgpio_lock;
    long unsigned int bgpio_data;
    long unsigned int bgpio_dir;
    struct gpio_irq_chip irq;
    long unsigned int *valid_mask;
    unsigned int of_gpio_n_cells;
    int (*of_xlate)(struct gpio_chip *, const struct of_phandle_args *, u32 *);
};

struct bcm2835_pinctrl {
    struct device *dev;
    void *base;
    int *wake_irq;
    long unsigned int enabled_irq_map[2];
    unsigned int irq_type[58];
    struct pinctrl_dev *pctl_dev;
    struct gpio_chip gpio_chip;
    struct pinctrl_desc pctl_desc;
    struct pinctrl_gpio_range gpio_range;
    raw_spinlock_t irq_lock[2];
    spinlock_t fsel_lock;
};

struct bcm2835_pll_data;

struct bcm2835_pll {
    struct clk_hw hw;
    struct bcm2835_cprman *cprman;
    const struct bcm2835_pll_data *data;
};

struct bcm2835_pll_ana_bits {
    u32 mask0;
    u32 set0;
    u32 mask1;
    u32 set1;
    u32 mask3;
    u32 set3;
    u32 fb_prediv_mask;
};

struct bcm2835_pll_data {
    const char *name;
    u32 cm_ctrl_reg;
    u32 a2w_ctrl_reg;
    u32 frac_reg;
    u32 ana_reg_base;
    u32 reference_enable_mask;
    u32 lock_mask;
    u32 flags;
    const struct bcm2835_pll_ana_bits *ana;
    long unsigned int min_rate;
    long unsigned int max_rate;
    long unsigned int max_fb_rate;
};

struct clk_div_table;

struct clk_divider {
    struct clk_hw hw;
    void *reg;
    u8 shift;
    u8 width;
    u16 flags;
    const struct clk_div_table *table;
    spinlock_t *lock;
};

struct bcm2835_pll_divider_data;

struct bcm2835_pll_divider {
    struct clk_divider div;
    struct bcm2835_cprman *cprman;
    const struct bcm2835_pll_divider_data *data;
};

struct bcm2835_pll_divider_data {
    const char *name;
    const char *source_pll;
    u32 cm_reg;
    u32 a2w_reg;
    u32 load_mask;
    u32 hold_mask;
    u32 fixed_divider;
    u32 flags;
};

struct bcm2835_pm {
    struct device *dev;
    void *base;
    void *asb;
    void *rpivid_asb;
};

struct generic_pm_domain;

typedef struct generic_pm_domain * (*genpd_xlate_t)(const struct of_phandle_args *, void *);

struct genpd_onecell_data {
    struct generic_pm_domain **domains;
    unsigned int num_domains;
    genpd_xlate_t xlate;
};

struct dev_pm_ops {
    int (*prepare)(struct device *);
    void (*complete)(struct device *);
    int (*suspend)(struct device *);
    int (*resume)(struct device *);
    int (*freeze)(struct device *);
    int (*thaw)(struct device *);
    int (*poweroff)(struct device *);
    int (*restore)(struct device *);
    int (*suspend_late)(struct device *);
    int (*resume_early)(struct device *);
    int (*freeze_late)(struct device *);
    int (*thaw_early)(struct device *);
    int (*poweroff_late)(struct device *);
    int (*restore_early)(struct device *);
    int (*suspend_noirq)(struct device *);
    int (*resume_noirq)(struct device *);
    int (*freeze_noirq)(struct device *);
    int (*thaw_noirq)(struct device *);
    int (*poweroff_noirq)(struct device *);
    int (*restore_noirq)(struct device *);
    int (*runtime_suspend)(struct device *);
    int (*runtime_resume)(struct device *);
    int (*runtime_idle)(struct device *);
};

struct dev_pm_domain {
    struct dev_pm_ops ops;
    int (*start)(struct device *);
    void (*detach)(struct device *, bool);
    int (*activate)(struct device *);
    void (*sync)(struct device *);
    void (*dismiss)(struct device *);
    int (*set_performance_state)(struct device *, unsigned int);
};

typedef struct cpumask cpumask_var_t[1];

struct raw_notifier_head {
    struct notifier_block *head;
};

struct gpd_dev_ops {
    int (*start)(struct device *);
    int (*stop)(struct device *);
};

struct dev_power_governor;

struct genpd_governor_data;

struct opp_table;

struct genpd_power_state;

struct genpd_lock_ops;

struct generic_pm_domain {
    struct device dev;
    struct dev_pm_domain domain;
    struct list_head gpd_list_node;
    struct list_head parent_links;
    struct list_head child_links;
    struct list_head dev_list;
    struct dev_power_governor *gov;
    struct genpd_governor_data *gd;
    struct work_struct power_off_work;
    struct fwnode_handle *provider;
    bool has_provider;
    const char *name;
    atomic_t sd_count;
    enum gpd_status status;
    unsigned int device_count;
    unsigned int device_id;
    unsigned int suspended_count;
    unsigned int prepared_count;
    unsigned int performance_state;
    cpumask_var_t cpus;
    bool synced_poweroff;
    int (*power_off)(struct generic_pm_domain *);
    int (*power_on)(struct generic_pm_domain *);
    struct raw_notifier_head power_notifiers;
    struct opp_table *opp_table;
    int (*set_performance_state)(struct generic_pm_domain *, unsigned int);
    struct gpd_dev_ops dev_ops;
    int (*set_hwmode_dev)(struct generic_pm_domain *, struct device *, bool);
    bool (*get_hwmode_dev)(struct generic_pm_domain *, struct device *);
    int (*attach_dev)(struct generic_pm_domain *, struct device *);
    void (*detach_dev)(struct generic_pm_domain *, struct device *);
    unsigned int flags;
    struct genpd_power_state *states;
    void (*free_states)(struct genpd_power_state *, unsigned int);
    unsigned int state_count;
    unsigned int state_idx;
    u64 on_time;
    u64 accounting_time;
    const struct genpd_lock_ops *lock_ops;
    union {
        struct mutex mlock;
        struct {
            spinlock_t slock;
            long unsigned int lock_flags;
        };
        struct {
            raw_spinlock_t raw_slock;
            long unsigned int raw_lock_flags;
        };
    };
};

struct bcm2835_power;

struct bcm2835_power_domain {
    struct generic_pm_domain base;
    struct bcm2835_power *power;
    u32 domain;
    struct clk *clk;
};

struct reset_control_ops;

struct reset_controller_dev {
    const struct reset_control_ops *ops;
    struct module *owner;
    struct list_head list;
    struct list_head reset_control_head;
    struct device *dev;
    struct device_node *of_node;
    const struct of_phandle_args *of_args;
    int of_reset_n_cells;
    int (*of_xlate)(struct reset_controller_dev *, const struct of_phandle_args *);
    unsigned int nr_resets;
};

struct bcm2835_power {
    struct device *dev;
    void *base;
    void *asb;
    void *rpivid_asb;
    struct genpd_onecell_data pd_xlate;
    struct bcm2835_power_domain domains[13];
    struct reset_controller_dev reset;
};

struct bcm2835_rng_of_data {
    bool mask_interrupts;
};

struct hwrng {
    const char *name;
    int (*init)(struct hwrng *);
    void (*cleanup)(struct hwrng *);
    int (*data_present)(struct hwrng *, int);
    int (*data_read)(struct hwrng *, u32 *);
    int (*read)(struct hwrng *, void *, size_t, bool);
    long unsigned int priv;
    short unsigned int quality;
    struct list_head list;
    struct kref ref;
    struct completion cleanup_done;
    struct completion dying;
};

struct reset_control;

struct bcm2835_rng_priv {
    struct hwrng rng;
    void *base;
    bool mask_interrupts;
    struct clk *clk;
    struct reset_control *reset;
};

struct bcm2835_thermal_data {
    struct thermal_zone_device *tz;
    void *regs;
    struct clk *clk;
    struct dentry *debugfsdir;
};

struct bcm2835_wdt {
    void *base;
    spinlock_t lock;
};

struct bcm2835aux_data {
    struct clk *clk;
    int line;
    u32 cntl;
};

struct bcm2836_arm_irqchip_intc {
    struct irq_domain *domain;
    void *base;
};

struct bcm54616s_phy_priv {
    bool mode_1000bx_en;
};

struct bcm_ptp_private;

struct bcm54xx_phy_priv {
    u64 *stats;
    struct bcm_ptp_private *ptp;
    int wake_irq;
    bool wake_irq_enabled;
    bool brr_mode;
};

struct bcm7xxx_phy_priv {
    u64 *stats;
};

struct bcm7xxx_regs {
    int reg;
    u16 value;
};

struct bcm_phy_hw_stat {
    const char *string;
    int devad;
    u16 reg;
    u8 shift;
    u8 bits;
};

struct bcm_plat_data {
    const struct gpio_chip *gpio_chip;
    const struct pinctrl_desc *pctl_desc;
    const struct pinctrl_gpio_range *gpio_range;
};

struct bcm_plat_data___2 {
    const struct pinctrl_desc *pctl_desc;
    const struct pinctrl_gpio_range *gpio_range;
    const struct pin_regs *pin_regs;
    const struct bcm2712_pin_funcs *pin_funcs;
};

struct bcm_ptp_capture {
    ktime_t hwtstamp;
    u16 seq_id;
    u8 msgtype;
    bool tx_dir;
};

struct kernel_hwtstamp_config;

struct phy_device;

struct kernel_ethtool_ts_info;

struct mii_timestamper {
    bool (*rxtstamp)(struct mii_timestamper *, struct sk_buff *, int);
    void (*txtstamp)(struct mii_timestamper *, struct sk_buff *, int);
    int (*hwtstamp)(struct mii_timestamper *, struct kernel_hwtstamp_config *, struct netlink_ext_ack *);
    void (*link_state)(struct mii_timestamper *, struct phy_device *);
    int (*ts_info)(struct mii_timestamper *, struct kernel_ethtool_ts_info *);
    struct device *device;
};

struct ptp_pin_desc;

struct ptp_system_timestamp;

struct system_device_crosststamp;

struct ptp_clock_request;

struct ptp_clock_info {
    struct module *owner;
    char name[32];
    s32 max_adj;
    int n_alarm;
    int n_ext_ts;
    int n_per_out;
    int n_pins;
    int pps;
    struct ptp_pin_desc *pin_config;
    int (*adjfine)(struct ptp_clock_info *, long int);
    int (*adjphase)(struct ptp_clock_info *, s32);
    s32 (*getmaxphase)(struct ptp_clock_info *);
    int (*adjtime)(struct ptp_clock_info *, s64);
    int (*gettime64)(struct ptp_clock_info *, struct timespec64 *);
    int (*gettimex64)(struct ptp_clock_info *, struct timespec64 *, struct ptp_system_timestamp *);
    int (*getcrosststamp)(struct ptp_clock_info *, struct system_device_crosststamp *);
    int (*settime64)(struct ptp_clock_info *, const struct timespec64 *);
    int (*getcycles64)(struct ptp_clock_info *, struct timespec64 *);
    int (*getcyclesx64)(struct ptp_clock_info *, struct timespec64 *, struct ptp_system_timestamp *);
    int (*getcrosscycles)(struct ptp_clock_info *, struct system_device_crosststamp *);
    int (*enable)(struct ptp_clock_info *, struct ptp_clock_request *, int);
    int (*verify)(struct ptp_clock_info *, unsigned int, enum ptp_pin_function, unsigned int);
    long int (*do_aux_work)(struct ptp_clock_info *);
};

struct ptp_pin_desc {
    char name[64];
    unsigned int index;
    unsigned int func;
    unsigned int chan;
    unsigned int rsv[5];
};

struct ptp_clock;

struct bcm_ptp_private {
    struct phy_device *phydev;
    struct mii_timestamper mii_ts;
    struct ptp_clock *ptp_clock;
    struct ptp_clock_info ptp_info;
    struct ptp_pin_desc pin;
    struct mutex mutex;
    struct sk_buff_head tx_queue;
    int tx_type;
    bool hwts_rx;
    u16 nse_ctrl;
    bool pin_active;
    struct delayed_work pin_work;
};

struct bcm_ptp_skb_cb {
    long unsigned int timeout;
    u16 seq_id;
    u8 msgtype;
    bool discard;
};

struct bcmgenet_hw_params {
    u8 tx_queues;
    u8 tx_bds_per_q;
    u8 rx_queues;
    u8 rx_bds_per_q;
    u8 bp_in_en_shift;
    u32 bp_in_mask;
    u8 hfb_filter_cnt;
    u8 hfb_filter_size;
    u8 qtag_mask;
    u16 tbuf_offset;
    u32 hfb_offset;
    u32 hfb_reg_offset;
    u32 rdma_offset;
    u32 tdma_offset;
    u32 words_per_bd;
    u32 flags;
};

struct bcmgenet_pkt_counters {
    u32 cnt_64;
    u32 cnt_127;
    u32 cnt_255;
    u32 cnt_511;
    u32 cnt_1023;
    u32 cnt_1518;
    u32 cnt_mgv;
    u32 cnt_2047;
    u32 cnt_4095;
    u32 cnt_9216;
};

struct bcmgenet_rx_counters {
    struct bcmgenet_pkt_counters pkt_cnt;
    u32 pkt;
    u32 bytes;
    u32 mca;
    u32 bca;
    u32 fcs;
    u32 cf;
    u32 pf;
    u32 uo;
    u32 aln;
    u32 flr;
    u32 cde;
    u32 fcr;
    u32 ovr;
    u32 jbr;
    u32 mtue;
    u32 pok;
    u32 uc;
    u32 ppp;
    u32 rcrc;
};

struct bcmgenet_tx_counters {
    struct bcmgenet_pkt_counters pkt_cnt;
    u32 pkts;
    u32 mca;
    u32 bca;
    u32 pf;
    u32 cf;
    u32 fcs;
    u32 ovr;
    u32 drf;
    u32 edf;
    u32 scl;
    u32 mcl;
    u32 lcl;
    u32 ecl;
    u32 frg;
    u32 ncl;
    u32 jbr;
    u32 bytes;
    u32 pok;
    u32 uc;
};

struct bcmgenet_mib_counters {
    struct bcmgenet_rx_counters rx;
    struct bcmgenet_tx_counters tx;
    u32 rx_runt_cnt;
    u32 rx_runt_fcs;
    u32 rx_runt_fcs_align;
    u32 rx_runt_bytes;
    u32 rbuf_ovflow_cnt;
    u32 rbuf_err_cnt;
    u32 mdf_err_cnt;
    u32 alloc_rx_buff_failed;
    u32 rx_dma_failed;
    u32 tx_dma_failed;
    u32 tx_realloc_tsb;
    u32 tx_realloc_tsb_failed;
};

struct dim_stats {
    int ppms;
    int bpms;
    int epms;
    int cpms;
    int cpe_ratio;
};

struct dim_sample {
    ktime_t time;
    u32 pkt_ctr;
    u32 byte_ctr;
    u16 event_ctr;
    u32 comp_ctr;
};

struct dim {
    u8 state;
    struct dim_stats prev_stats;
    struct dim_sample start_sample;
    struct dim_sample measuring_sample;
    struct work_struct work;
    void *priv;
    u8 profile_ix;
    u8 mode;
    u8 tune_state;
    u8 steps_right;
    u8 steps_left;
    u8 tired;
};

struct bcmgenet_net_dim {
    u16 use_dim;
    u16 event_ctr;
    long unsigned int packets;
    long unsigned int bytes;
    struct dim dim;
};

struct bcmgenet_plat_data {
    enum bcmgenet_version version;
    u32 dma_max_burst_length;
    bool ephy_16nm;
};

struct bcmgenet_platform_data {
    bool mdio_enabled;
    phy_interface_t phy_interface;
    int phy_address;
    int phy_speed;
    int phy_duplex;
    u8 mac_address[6];
    int genet_version;
};

struct gro_list {
    struct list_head list;
    int count;
};

struct napi_config;

struct napi_struct {
    struct list_head poll_list;
    long unsigned int state;
    int weight;
    u32 defer_hard_irqs_count;
    long unsigned int gro_bitmask;
    int (*poll)(struct napi_struct *, int);
    int poll_owner;
    int list_owner;
    struct net_device *dev;
    struct gro_list gro_hash[8];
    struct sk_buff *skb;
    struct list_head rx_list;
    int rx_count;
    unsigned int napi_id;
    struct hrtimer timer;
    struct task_struct *thread;
    long unsigned int gro_flush_timeout;
    long unsigned int irq_suspend_timeout;
    u32 defer_hard_irqs;
    struct list_head dev_list;
    struct hlist_node napi_hash_node;
    int irq;
    int index;
    struct napi_config *config;
};

struct enet_cb;

struct bcmgenet_priv;

struct bcmgenet_tx_ring {
    spinlock_t lock;
    struct napi_struct napi;
    long unsigned int packets;
    long unsigned int bytes;
    unsigned int index;
    unsigned int queue;
    struct enet_cb *cbs;
    unsigned int size;
    unsigned int clean_ptr;
    unsigned int c_index;
    unsigned int free_bds;
    unsigned int write_ptr;
    unsigned int prod_index;
    unsigned int cb_ptr;
    unsigned int end_ptr;
    void (*int_enable)(struct bcmgenet_tx_ring *);
    void (*int_disable)(struct bcmgenet_tx_ring *);
    struct bcmgenet_priv *priv;
};

struct ethtool_tcpip4_spec {
    __be32 ip4src;
    __be32 ip4dst;
    __be16 psrc;
    __be16 pdst;
    __u8 tos;
};

struct ethtool_ah_espip4_spec {
    __be32 ip4src;
    __be32 ip4dst;
    __be32 spi;
    __u8 tos;
};

struct ethtool_usrip4_spec {
    __be32 ip4src;
    __be32 ip4dst;
    __be32 l4_4_bytes;
    __u8 tos;
    __u8 ip_ver;
    __u8 proto;
};

struct ethtool_tcpip6_spec {
    __be32 ip6src[4];
    __be32 ip6dst[4];
    __be16 psrc;
    __be16 pdst;
    __u8 tclass;
};

struct ethtool_ah_espip6_spec {
    __be32 ip6src[4];
    __be32 ip6dst[4];
    __be32 spi;
    __u8 tclass;
};

struct ethtool_usrip6_spec {
    __be32 ip6src[4];
    __be32 ip6dst[4];
    __be32 l4_4_bytes;
    __u8 tclass;
    __u8 l4_proto;
};

struct ethhdr {
    unsigned char h_dest[6];
    unsigned char h_source[6];
    __be16 h_proto;
};

union ethtool_flow_union {
    struct ethtool_tcpip4_spec tcp_ip4_spec;
    struct ethtool_tcpip4_spec udp_ip4_spec;
    struct ethtool_tcpip4_spec sctp_ip4_spec;
    struct ethtool_ah_espip4_spec ah_ip4_spec;
    struct ethtool_ah_espip4_spec esp_ip4_spec;
    struct ethtool_usrip4_spec usr_ip4_spec;
    struct ethtool_tcpip6_spec tcp_ip6_spec;
    struct ethtool_tcpip6_spec udp_ip6_spec;
    struct ethtool_tcpip6_spec sctp_ip6_spec;
    struct ethtool_ah_espip6_spec ah_ip6_spec;
    struct ethtool_ah_espip6_spec esp_ip6_spec;
    struct ethtool_usrip6_spec usr_ip6_spec;
    struct ethhdr ether_spec;
    __u8 hdata[52];
};

struct ethtool_flow_ext {
    __u8 padding[2];
    unsigned char h_dest[6];
    __be16 vlan_etype;
    __be16 vlan_tci;
    __be32 data[2];
};

struct ethtool_rx_flow_spec {
    __u32 flow_type;
    union ethtool_flow_union h_u;
    struct ethtool_flow_ext h_ext;
    union ethtool_flow_union m_u;
    struct ethtool_flow_ext m_ext;
    __u64 ring_cookie;
    __u32 location;
};

struct bcmgenet_rxnfc_rule {
    struct list_head list;
    struct ethtool_rx_flow_spec fs;
    enum bcmgenet_rxnfc_state state;
};

struct bcmgenet_rx_ring {
    struct napi_struct napi;
    long unsigned int bytes;
    long unsigned int packets;
    long unsigned int errors;
    long unsigned int dropped;
    unsigned int index;
    struct enet_cb *cbs;
    unsigned int size;
    unsigned int c_index;
    unsigned int read_ptr;
    unsigned int cb_ptr;
    unsigned int end_ptr;
    unsigned int old_discards;
    struct bcmgenet_net_dim dim;
    u32 rx_max_coalesced_frames;
    u32 rx_coalesce_usecs;
    void (*int_enable)(struct bcmgenet_rx_ring *);
    void (*int_disable)(struct bcmgenet_rx_ring *);
    struct bcmgenet_priv *priv;
};

struct ethtool_keee {
    long unsigned int supported[2];
    long unsigned int advertised[2];
    long unsigned int lp_advertised[2];
    u32 tx_lpi_timer;
    bool tx_lpi_enabled;
    bool eee_active;
    bool eee_enabled;
};

struct mii_bus;

struct bcmgenet_priv {
    void *base;
    spinlock_t reg_lock;
    enum bcmgenet_version version;
    struct net_device *dev;
    void *tx_bds;
    struct enet_cb *tx_cbs;
    unsigned int num_tx_bds;
    struct bcmgenet_tx_ring tx_rings[17];
    void *rx_bds;
    struct enet_cb *rx_cbs;
    unsigned int num_rx_bds;
    unsigned int rx_buf_len;
    struct bcmgenet_rxnfc_rule rxnfc_rules[16];
    struct list_head rxnfc_list;
    struct bcmgenet_rx_ring rx_rings[17];
    struct bcmgenet_hw_params *hw_params;
    unsigned int autoneg_pause: 1;
    unsigned int tx_pause: 1;
    unsigned int rx_pause: 1;
    wait_queue_head_t wq;
    bool internal_phy;
    struct device_node *phy_dn;
    struct device_node *mdio_dn;
    struct mii_bus *mii_bus;
    u16 gphy_rev;
    struct clk *clk_eee;
    bool clk_eee_enabled;
    phy_interface_t phy_interface;
    int phy_addr;
    int ext_phy;
    bool ephy_16nm;
    struct work_struct bcmgenet_irq_work;
    int irq0;
    int irq1;
    int wol_irq;
    bool wol_irq_disabled;
    spinlock_t lock;
    unsigned int irq0_stat;
    bool crc_fwd_en;
    u32 dma_max_burst_length;
    u32 msg_enable;
    struct clk *clk;
    struct platform_device *pdev;
    struct platform_device *mii_pdev;
    struct clk *clk_wol;
    u32 wolopts;
    u8 sopass[6];
    bool wol_active;
    struct bcmgenet_mib_counters mib;
    struct ethtool_keee eee;
};

struct bcmgenet_skb_cb {
    struct enet_cb *first_cb;
    struct enet_cb *last_cb;
    unsigned int bytes_sent;
};

struct bcmgenet_stats {
    char stat_string[32];
    int stat_sizeof;
    int stat_offset;
    enum bcmgenet_stat_type type;
    u16 reg_offset;
};

struct bd_holder_disk {
    struct list_head list;
    struct kobject *holder_dir;
    int refcnt;
};

struct gendisk;

struct request_queue;

struct disk_stats;

struct blk_holder_ops;

struct partition_meta_info;

struct block_device {
    sector_t bd_start_sect;
    sector_t bd_nr_sectors;
    struct gendisk *bd_disk;
    struct request_queue *bd_queue;
    struct disk_stats *bd_stats;
    long unsigned int bd_stamp;
    atomic_t __bd_flags;
    dev_t bd_dev;
    struct address_space *bd_mapping;
    atomic_t bd_openers;
    spinlock_t bd_size_lock;
    void *bd_claiming;
    void *bd_holder;
    const struct blk_holder_ops *bd_holder_ops;
    struct mutex bd_holder_lock;
    int bd_holders;
    struct kobject *bd_holder_dir;
    atomic_t bd_fsfreeze_count;
    struct mutex bd_fsfreeze_mutex;
    struct partition_meta_info *bd_meta_info;
    int bd_writers;
    void *bd_security;
    struct device bd_device;
};

struct posix_acl;

struct inode_operations;

struct super_block;

struct file_lock_context;

struct pipe_inode_info;

struct cdev;

struct fscrypt_inode_info;

struct inode {
    umode_t i_mode;
    short unsigned int i_opflags;
    kuid_t i_uid;
    kgid_t i_gid;
    unsigned int i_flags;
    struct posix_acl *i_acl;
    struct posix_acl *i_default_acl;
    const struct inode_operations *i_op;
    struct super_block *i_sb;
    struct address_space *i_mapping;
    void *i_security;
    long unsigned int i_ino;
    union {
        const unsigned int i_nlink;
        unsigned int __i_nlink;
    };
    dev_t i_rdev;
    loff_t i_size;
    time64_t i_atime_sec;
    time64_t i_mtime_sec;
    time64_t i_ctime_sec;
    u32 i_atime_nsec;
    u32 i_mtime_nsec;
    u32 i_ctime_nsec;
    u32 i_generation;
    spinlock_t i_lock;
    short unsigned int i_bytes;
    u8 i_blkbits;
    enum rw_hint i_write_hint;
    blkcnt_t i_blocks;
    u32 i_state;
    struct rw_semaphore i_rwsem;
    long unsigned int dirtied_when;
    long unsigned int dirtied_time_when;
    struct hlist_node i_hash;
    struct list_head i_io_list;
    struct bdi_writeback *i_wb;
    int i_wb_frn_winner;
    u16 i_wb_frn_avg_time;
    u16 i_wb_frn_history;
    struct list_head i_lru;
    struct list_head i_sb_list;
    struct list_head i_wb_list;
    union {
        struct hlist_head i_dentry;
        struct callback_head i_rcu;
    };
    atomic64_t i_version;
    atomic64_t i_sequence;
    atomic_t i_count;
    atomic_t i_dio_count;
    atomic_t i_writecount;
    atomic_t i_readcount;
    union {
        const struct file_operations *i_fop;
        void (*free_inode)(struct inode *);
    };
    struct file_lock_context *i_flctx;
    struct address_space i_data;
    union {
        struct list_head i_devices;
        int i_linklen;
    };
    union {
        struct pipe_inode_info *i_pipe;
        struct cdev *i_cdev;
        char *i_link;
        unsigned int i_dir_seq;
    };
    __u32 i_fsnotify_mask;
    struct fsnotify_mark_connector *i_fsnotify_marks;
    struct fscrypt_inode_info *i_crypt_info;
    void *i_private;
};

struct bdev_inode {
    struct block_device bdev;
    struct inode vfs_inode;
};

struct bgl_lock {
    spinlock_t lock;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
};

struct bh_accounting {
    int nr;
    int ratelimit;
};

struct bh_lru {
    struct buffer_head *bhs[16];
};

struct bictcp {
    u32 cnt;
    u32 last_max_cwnd;
    u32 last_cwnd;
    u32 last_time;
    u32 bic_origin_point;
    u32 bic_K;
    u32 delay_min;
    u32 epoch_start;
    u32 ack_cnt;
    u32 tcp_cwnd;
    u16 unused;
    u8 sample_cnt;
    u8 found;
    u32 round_start;
    u32 end_seq;
    u32 last_ack;
    u32 curr_rtt;
};

struct bin_attribute {
    struct attribute attr;
    size_t size;
    void *private;
    struct address_space * (*f_mapping)(void);
    ssize_t (*read)(struct file *, struct kobject *, struct bin_attribute *, char *, loff_t, size_t);
    ssize_t (*read_new)(struct file *, struct kobject *, const struct bin_attribute *, char *, loff_t, size_t);
    ssize_t (*write)(struct file *, struct kobject *, struct bin_attribute *, char *, loff_t, size_t);
    ssize_t (*write_new)(struct file *, struct kobject *, const struct bin_attribute *, char *, loff_t, size_t);
    loff_t (*llseek)(struct file *, struct kobject *, const struct bin_attribute *, loff_t, int);
    int (*mmap)(struct file *, struct kobject *, const struct bin_attribute *, struct vm_area_struct *);
};

struct binfmt_misc {
    struct list_head entries;
    rwlock_t entries_lock;
    bool enabled;
};

struct bvec_iter {
    sector_t bi_sector;
    unsigned int bi_size;
    unsigned int bi_idx;
    unsigned int bi_bvec_done;
} __attribute__((packed));

struct bio;

typedef void bio_end_io_t(struct bio *);

struct bio_issue {
    u64 value;
};

struct bio_vec {
    struct page *bv_page;
    unsigned int bv_len;
    unsigned int bv_offset;
};

struct blkcg_gq;

struct bio_crypt_ctx;

struct bio_integrity_payload;

struct bio_set;

struct bio {
    struct bio *bi_next;
    struct block_device *bi_bdev;
    blk_opf_t bi_opf;
    short unsigned int bi_flags;
    short unsigned int bi_ioprio;
    enum rw_hint bi_write_hint;
    blk_status_t bi_status;
    atomic_t __bi_remaining;
    struct bvec_iter bi_iter;
    union {
        blk_qc_t bi_cookie;
        unsigned int __bi_nr_segments;
    };
    bio_end_io_t *bi_end_io;
    void *bi_private;
    struct blkcg_gq *bi_blkg;
    struct bio_issue bi_issue;
    struct bio_crypt_ctx *bi_crypt_context;
    struct bio_integrity_payload *bi_integrity;
    short unsigned int bi_vcnt;
    short unsigned int bi_max_vecs;
    atomic_t __bi_cnt;
    struct bio_vec *bi_io_vec;
    struct bio_set *bi_pool;
    struct bio_vec bi_inline_vecs[0];
};

struct bio_alloc_cache {
    struct bio *free_list;
    struct bio *free_list_irq;
    unsigned int nr;
    unsigned int nr_irq;
};

struct blk_crypto_key;

struct bio_crypt_ctx {
    const struct blk_crypto_key *bc_key;
    u64 bc_dun[4];
};

struct bio_fallback_crypt_ctx {
    struct bio_crypt_ctx crypt_ctx;
    struct bvec_iter crypt_iter;
    union {
        struct {
            struct work_struct work;
            struct bio *bio;
        };
        struct {
            void *bi_private_orig;
            bio_end_io_t *bi_end_io_orig;
        };
    };
};

struct bio_integrity_payload {
    struct bio *bip_bio;
    struct bvec_iter bip_iter;
    short unsigned int bip_vcnt;
    short unsigned int bip_max_vcnt;
    short unsigned int bip_flags;
    u16 app_tag;
    struct bvec_iter bio_iter;
    struct work_struct bip_work;
    struct bio_vec *bip_vec;
    struct bio_vec bip_inline_vecs[0];
};

struct bio_list {
    struct bio *head;
    struct bio *tail;
};

struct iovec {
    void *iov_base;
    __kernel_size_t iov_len;
};

struct kvec;

struct folio_queue;

struct iov_iter {
    u8 iter_type;
    bool nofault;
    bool data_source;
    size_t iov_offset;
    union {
        struct iovec __ubuf_iovec;
        struct {
            union {
                const struct iovec *__iov;
                const struct kvec *kvec;
                const struct bio_vec *bvec;
                const struct folio_queue *folioq;
                struct xarray *xarray;
                void *ubuf;
            };
            size_t count;
        };
    };
    union {
        long unsigned int nr_segs;
        u8 folioq_slot;
        loff_t xarray_start;
    };
};

struct bio_map_data {
    bool is_our_pages: 1;
    bool is_null_mapped: 1;
    struct iov_iter iter;
    struct iovec iov[0];
};

struct bio_post_read_ctx {
    struct bio *bio;
    struct work_struct work;
    unsigned int cur_step;
    unsigned int enabled_steps;
};

typedef void *mempool_alloc_t(gfp_t, void *);

typedef void mempool_free_t(void *, void *);

struct mempool_s {
    spinlock_t lock;
    int min_nr;
    int curr_nr;
    void **elements;
    void *pool_data;
    mempool_alloc_t *alloc;
    mempool_free_t *free;
    wait_queue_head_t wait;
};

typedef struct mempool_s mempool_t;

struct bio_set {
    struct kmem_cache *bio_slab;
    unsigned int front_pad;
    struct bio_alloc_cache *cache;
    mempool_t bio_pool;
    mempool_t bvec_pool;
    mempool_t bio_integrity_pool;
    mempool_t bvec_integrity_pool;
    unsigned int back_pad;
    spinlock_t rescue_lock;
    struct bio_list rescue_list;
    struct work_struct rescue_work;
    struct workqueue_struct *rescue_workqueue;
    struct hlist_node cpuhp_dead;
};

struct bio_slab {
    struct kmem_cache *slab;
    unsigned int slab_ref;
    unsigned int slab_size;
    char name[12];
};

struct biovec_slab {
    int nr_vecs;
    char *name;
    struct kmem_cache *slab;
};

struct led_classdev;

struct bl_trig_notifier {
    struct led_classdev *led;
    int brightness;
    int old_status;
    struct notifier_block notifier;
    unsigned int invert;
};

struct blacklist_entry {
    struct list_head next;
    char *buf;
};

struct blake2s_state {
    u32 h[8];
    u32 t[2];
    u32 f[2];
    u8 buf[64];
    unsigned int buflen;
    unsigned int outlen;
};

struct blk_crypto_profile;

struct blk_crypto_attr {
    struct attribute attr;
    ssize_t (*show)(struct blk_crypto_profile *, struct blk_crypto_attr *, char *);
};

struct blk_crypto_config {
    enum blk_crypto_mode_num crypto_mode;
    unsigned int data_unit_size;
    unsigned int dun_bytes;
};

struct crypto_skcipher;

struct blk_crypto_fallback_keyslot {
    enum blk_crypto_mode_num crypto_mode;
    struct crypto_skcipher *tfms[5];
};

union blk_crypto_iv {
    __le64 dun[4];
    u8 bytes[32];
};

struct blk_crypto_key {
    struct blk_crypto_config crypto_cfg;
    unsigned int data_unit_size_bits;
    unsigned int size;
    u8 raw[64];
};

struct blk_crypto_keyslot {
    atomic_t slot_refs;
    struct list_head idle_slot_node;
    struct hlist_node hash_node;
    const struct blk_crypto_key *key;
    struct blk_crypto_profile *profile;
};

struct blk_crypto_kobj {
    struct kobject kobj;
    struct blk_crypto_profile *profile;
};

struct blk_crypto_ll_ops {
    int (*keyslot_program)(struct blk_crypto_profile *, const struct blk_crypto_key *, unsigned int);
    int (*keyslot_evict)(struct blk_crypto_profile *, const struct blk_crypto_key *, unsigned int);
};

struct blk_crypto_mode {
    const char *name;
    const char *cipher_str;
    unsigned int keysize;
    unsigned int ivsize;
};

struct blk_crypto_profile {
    struct blk_crypto_ll_ops ll_ops;
    unsigned int max_dun_bytes_supported;
    unsigned int modes_supported[5];
    struct device *dev;
    unsigned int num_slots;
    struct rw_semaphore lock;
    struct lock_class_key lockdep_key;
    wait_queue_head_t idle_slots_wait_queue;
    struct list_head idle_slots;
    spinlock_t idle_slots_lock;
    struct hlist_head *slot_hashtable;
    unsigned int log_slot_ht_size;
    struct blk_crypto_keyslot *slots;
};

struct blk_expired_data {
    bool has_timedout_rq;
    long unsigned int next;
    long unsigned int timeout_start;
};

struct request;

struct blk_flush_queue {
    spinlock_t mq_flush_lock;
    unsigned int flush_pending_idx: 1;
    unsigned int flush_running_idx: 1;
    blk_status_t rq_status;
    long unsigned int flush_pending_since;
    struct list_head flush_queue[2];
    long unsigned int flush_data_in_flight;
    struct request *flush_rq;
};

struct blk_holder_ops {
    void (*mark_dead)(struct block_device *, bool);
    void (*sync)(struct block_device *);
    int (*freeze)(struct block_device *);
    int (*thaw)(struct block_device *);
};

struct blk_independent_access_range;

struct blk_ia_range_sysfs_entry {
    struct attribute attr;
    ssize_t (*show)(struct blk_independent_access_range *, char *);
};

struct blk_independent_access_range {
    struct kobject kobj;
    sector_t sector;
    sector_t nr_sectors;
};

struct blk_independent_access_ranges {
    struct kobject kobj;
    bool sysfs_registered;
    unsigned int nr_ia_ranges;
    struct blk_independent_access_range ia_range[0];
};

struct blk_integrity {
    unsigned char flags;
    enum blk_integrity_checksum csum_type;
    unsigned char tuple_size;
    unsigned char pi_offset;
    unsigned char interval_exp;
    unsigned char tag_size;
};

struct blk_integrity_iter {
    void *prot_buf;
    void *data_buf;
    sector_t seed;
    unsigned int data_size;
    short unsigned int interval;
    const char *disk_name;
};

struct blk_io_trace {
    __u32 magic;
    __u32 sequence;
    __u64 time;
    __u64 sector;
    __u32 bytes;
    __u32 action;
    __u32 pid;
    __u32 device;
    __u32 cpu;
    __u16 error;
    __u16 pdu_len;
};

struct blk_io_trace_remap {
    __be32 device_from;
    __be32 device_to;
    __be64 sector_from;
};

struct blk_iou_cmd {
    int res;
    bool nowait;
};

struct blk_major_name {
    struct blk_major_name *next;
    int major;
    char name[16];
    void (*probe)(dev_t);
};

struct rq_list;

struct blk_mq_ctx;

struct blk_mq_hw_ctx;

struct blk_mq_alloc_data {
    struct request_queue *q;
    blk_mq_req_flags_t flags;
    unsigned int shallow_depth;
    blk_opf_t cmd_flags;
    req_flags_t rq_flags;
    unsigned int nr_tags;
    struct rq_list *cached_rqs;
    struct blk_mq_ctx *ctx;
    struct blk_mq_hw_ctx *hctx;
};

struct blk_mq_ctxs;

struct blk_mq_ctx {
    struct {
        spinlock_t lock;
        struct list_head rq_lists[3];
        long: 64;
    };
    unsigned int cpu;
    short unsigned int index_hw[3];
    struct blk_mq_hw_ctx *hctxs[3];
    struct request_queue *queue;
    struct blk_mq_ctxs *ctxs;
    struct kobject kobj;
    long: 64;
};

struct blk_mq_ctxs {
    struct kobject kobj;
    struct blk_mq_ctx *queue_ctx;
};

struct seq_operations;

struct blk_mq_debugfs_attr {
    const char *name;
    umode_t mode;
    int (*show)(void *, struct seq_file *);
    ssize_t (*write)(void *, const char *, size_t, loff_t *);
    const struct seq_operations *seq_ops;
};

struct sbitmap_word;

struct sbitmap {
    unsigned int depth;
    unsigned int shift;
    unsigned int map_nr;
    bool round_robin;
    struct sbitmap_word *map;
    unsigned int *alloc_hint;
};

typedef struct wait_queue_entry wait_queue_entry_t;

struct blk_mq_hw_ctx {
    struct {
        spinlock_t lock;
        struct list_head dispatch;
        long unsigned int state;
        long: 64;
        long: 64;
        long: 64;
        long: 64;
    };
    struct delayed_work run_work;
    cpumask_var_t cpumask;
    int next_cpu;
    int next_cpu_batch;
    long unsigned int flags;
    void *sched_data;
    struct request_queue *queue;
    struct blk_flush_queue *fq;
    void *driver_data;
    struct sbitmap ctx_map;
    struct blk_mq_ctx *dispatch_from;
    unsigned int dispatch_busy;
    short unsigned int type;
    short unsigned int nr_ctx;
    struct blk_mq_ctx **ctxs;
    spinlock_t dispatch_wait_lock;
    wait_queue_entry_t dispatch_wait;
    atomic_t wait_index;
    struct blk_mq_tags *tags;
    struct blk_mq_tags *sched_tags;
    unsigned int numa_node;
    unsigned int queue_num;
    atomic_t nr_active;
    struct hlist_node cpuhp_online;
    struct hlist_node cpuhp_dead;
    struct kobject kobj;
    struct dentry *debugfs_dir;
    struct dentry *sched_debugfs_dir;
    struct list_head hctx_list;
    long: 64;
};

struct blk_mq_hw_ctx_sysfs_entry {
    struct attribute attr;
    ssize_t (*show)(struct blk_mq_hw_ctx *, char *);
};

struct blk_mq_queue_data;

struct io_comp_batch;

struct blk_mq_ops {
    blk_status_t (*queue_rq)(struct blk_mq_hw_ctx *, const struct blk_mq_queue_data *);
    void (*commit_rqs)(struct blk_mq_hw_ctx *);
    void (*queue_rqs)(struct rq_list *);
    int (*get_budget)(struct request_queue *);
    void (*put_budget)(struct request_queue *, int);
    void (*set_rq_budget_token)(struct request *, int);
    int (*get_rq_budget_token)(struct request *);
    enum blk_eh_timer_return (*timeout)(struct request *);
    int (*poll)(struct blk_mq_hw_ctx *, struct io_comp_batch *);
    void (*complete)(struct request *);
    int (*init_hctx)(struct blk_mq_hw_ctx *, void *, unsigned int);
    void (*exit_hctx)(struct blk_mq_hw_ctx *, unsigned int);
    int (*init_request)(struct blk_mq_tag_set *, struct request *, unsigned int, unsigned int);
    void (*exit_request)(struct blk_mq_tag_set *, struct request *, unsigned int);
    void (*cleanup_rq)(struct request *);
    bool (*busy)(struct request_queue *);
    void (*map_queues)(struct blk_mq_tag_set *);
    void (*show_rq)(struct seq_file *, struct request *);
};

struct elevator_type;

struct blk_mq_qe_pair {
    struct list_head node;
    struct request_queue *q;
    struct elevator_type *type;
};

struct blk_mq_queue_data {
    struct request *rq;
    bool last;
};

struct sbq_wait_state;

struct sbitmap_queue {
    struct sbitmap sb;
    unsigned int wake_batch;
    atomic_t wake_index;
    struct sbq_wait_state *ws;
    atomic_t ws_active;
    unsigned int min_shallow_depth;
    atomic_t completion_cnt;
    atomic_t wakeup_cnt;
};

struct blk_mq_tags {
    unsigned int nr_tags;
    unsigned int nr_reserved_tags;
    unsigned int active_queues;
    struct sbitmap_queue bitmap_tags;
    struct sbitmap_queue breserved_tags;
    struct request **rqs;
    struct request **static_rqs;
    struct list_head page_list;
    spinlock_t lock;
};

struct rq_list {
    struct request *head;
    struct request *tail;
};

struct blk_plug {
    struct rq_list mq_list;
    struct rq_list cached_rqs;
    u64 cur_ktime;
    short unsigned int nr_ios;
    short unsigned int rq_count;
    bool multiple_queues;
    bool has_elevator;
    struct list_head cb_list;
};

struct blk_plug_cb;

typedef void (*blk_plug_cb_fn)(struct blk_plug_cb *, bool);

struct blk_plug_cb {
    struct list_head list;
    blk_plug_cb_fn callback;
    void *data;
};

struct blk_queue_stats {
    struct list_head callbacks;
    spinlock_t lock;
    int accounting;
};

struct blk_revalidate_zone_args {
    struct gendisk *disk;
    long unsigned int *conv_zones_bitmap;
    unsigned int nr_zones;
    unsigned int zone_capacity;
    unsigned int last_zone_capacity;
    sector_t sector;
};

struct blk_rq_stat {
    u64 mean;
    u64 min;
    u64 max;
    u32 nr_samples;
    u64 batch;
};

struct blk_rq_wait {
    struct completion done;
    blk_status_t ret;
};

struct blk_stat_callback {
    struct list_head list;
    struct timer_list timer;
    struct blk_rq_stat *cpu_stat;
    int (*bucket_fn)(const struct request *);
    unsigned int buckets;
    struct blk_rq_stat *stat;
    void (*timer_fn)(struct blk_stat_callback *);
    void *data;
    struct callback_head rcu;
};

struct rchan;

struct blk_trace {
    int trace_state;
    struct rchan *rchan;
    long unsigned int *sequence;
    unsigned char *msg_data;
    u16 act_mask;
    u64 start_lba;
    u64 end_lba;
    u32 pid;
    u32 dev;
    struct dentry *dir;
    struct list_head running_list;
    atomic_t dropped;
};

struct blk_user_trace_setup {
    char name[32];
    __u16 act_mask;
    __u32 buf_size;
    __u32 buf_nr;
    __u64 start_lba;
    __u64 end_lba;
    __u32 pid;
};

struct blk_zone {
    __u64 start;
    __u64 len;
    __u64 wp;
    __u8 type;
    __u8 cond;
    __u8 non_seq;
    __u8 reset;
    __u8 resv[4];
    __u64 capacity;
    __u8 reserved[24];
};

struct blk_zone_range {
    __u64 sector;
    __u64 nr_sectors;
};

struct blk_zone_report {
    __u64 sector;
    __u32 nr_zones;
    __u32 flags;
    struct blk_zone zones[0];
};

struct blk_zone_wplug {
    struct hlist_node node;
    refcount_t ref;
    spinlock_t lock;
    unsigned int flags;
    unsigned int zone_no;
    unsigned int wp_offset;
    struct bio_list bio_list;
    struct work_struct bio_work;
    struct callback_head callback_head;
    struct gendisk *disk;
};

struct rcu_work {
    struct work_struct work;
    struct callback_head rcu;
    struct workqueue_struct *wq;
};

struct cgroup_subsys;

struct cgroup_subsys_state {
    struct cgroup *cgroup;
    struct cgroup_subsys *ss;
    struct percpu_ref refcnt;
    struct list_head sibling;
    struct list_head children;
    struct list_head rstat_css_node;
    int id;
    unsigned int flags;
    u64 serial_nr;
    atomic_t online_cnt;
    struct work_struct destroy_work;
    struct rcu_work destroy_rwork;
    struct cgroup_subsys_state *parent;
    int nr_descendants;
};

struct blkcg_policy_data;

struct llist_head;

struct blkcg {
    struct cgroup_subsys_state css;
    spinlock_t lock;
    refcount_t online_pin;
    atomic_t congestion_count;
    struct xarray blkg_tree;
    struct blkcg_gq *blkg_hint;
    struct hlist_head blkg_list;
    struct blkcg_policy_data *cpd[6];
    struct list_head all_blkcgs_node;
    struct llist_head *lhead;
    char fc_app_id[129];
    struct list_head cgwb_list;
};

struct blkg_iostat {
    u64 bytes[3];
    u64 ios[3];
};

struct blkg_iostat_set {
    struct u64_stats_sync sync;
    struct blkcg_gq *blkg;
    struct llist_node lnode;
    int lqueued;
    struct blkg_iostat cur;
    struct blkg_iostat last;
};

struct blkg_policy_data;

struct blkcg_gq {
    struct request_queue *q;
    struct list_head q_node;
    struct hlist_node blkcg_node;
    struct blkcg *blkcg;
    struct blkcg_gq *parent;
    struct percpu_ref refcnt;
    bool online;
    struct blkg_iostat_set *iostat_cpu;
    struct blkg_iostat_set iostat;
    struct blkg_policy_data *pd[6];
    spinlock_t async_bio_lock;
    struct bio_list async_bios;
    union {
        struct work_struct async_bio_work;
        struct work_struct free_work;
    };
    atomic_t use_delay;
    atomic64_t delay_nsec;
    atomic64_t delay_start;
    u64 last_delay;
    int last_use;
    struct callback_head callback_head;
};

typedef struct blkcg_policy_data *blkcg_pol_alloc_cpd_fn(gfp_t);

typedef void blkcg_pol_free_cpd_fn(struct blkcg_policy_data *);

typedef struct blkg_policy_data *blkcg_pol_alloc_pd_fn(struct gendisk *, struct blkcg *, gfp_t);

typedef void blkcg_pol_init_pd_fn(struct blkg_policy_data *);

typedef void blkcg_pol_online_pd_fn(struct blkg_policy_data *);

typedef void blkcg_pol_offline_pd_fn(struct blkg_policy_data *);

typedef void blkcg_pol_free_pd_fn(struct blkg_policy_data *);

typedef void blkcg_pol_reset_pd_stats_fn(struct blkg_policy_data *);

typedef void blkcg_pol_stat_pd_fn(struct blkg_policy_data *, struct seq_file *);

struct cftype;

struct blkcg_policy {
    int plid;
    struct cftype *dfl_cftypes;
    struct cftype *legacy_cftypes;
    blkcg_pol_alloc_cpd_fn *cpd_alloc_fn;
    blkcg_pol_free_cpd_fn *cpd_free_fn;
    blkcg_pol_alloc_pd_fn *pd_alloc_fn;
    blkcg_pol_init_pd_fn *pd_init_fn;
    blkcg_pol_online_pd_fn *pd_online_fn;
    blkcg_pol_offline_pd_fn *pd_offline_fn;
    blkcg_pol_free_pd_fn *pd_free_fn;
    blkcg_pol_reset_pd_stats_fn *pd_reset_stats_fn;
    blkcg_pol_stat_pd_fn *pd_stat_fn;
};

struct blkcg_policy_data {
    struct blkcg *blkcg;
    int plid;
};

struct blkdev_dio {
    union {
        struct kiocb *iocb;
        struct task_struct *waiter;
    };
    size_t size;
    atomic_t ref;
    unsigned int flags;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    struct bio bio;
};

struct blkg_conf_ctx {
    char *input;
    char *body;
    struct block_device *bdev;
    struct blkcg_gq *blkg;
};

struct blkg_policy_data {
    struct blkcg_gq *blkg;
    int plid;
    bool online;
};

struct blkg_rwstat {
    struct percpu_counter cpu_cnt[5];
    atomic64_t aux_cnt[5];
};

struct blkg_rwstat_sample {
    u64 cnt[5];
};

struct blkpg_ioctl_arg {
    int op;
    int flags;
    int datalen;
    void *data;
};

struct blkpg_partition {
    long long int start;
    long long int length;
    int pno;
    char devname[64];
    char volname[64];
};

typedef int (*report_zones_cb)(struct blk_zone *, unsigned int, void *);

struct hd_geometry;

struct pr_ops;

struct block_device_operations {
    void (*submit_bio)(struct bio *);
    int (*poll_bio)(struct bio *, struct io_comp_batch *, unsigned int);
    int (*open)(struct gendisk *, blk_mode_t);
    void (*release)(struct gendisk *);
    int (*ioctl)(struct block_device *, blk_mode_t, unsigned int, long unsigned int);
    int (*compat_ioctl)(struct block_device *, blk_mode_t, unsigned int, long unsigned int);
    unsigned int (*check_events)(struct gendisk *, unsigned int);
    void (*unlock_native_capacity)(struct gendisk *);
    int (*getgeo)(struct block_device *, struct hd_geometry *);
    int (*set_read_only)(struct block_device *, bool);
    void (*free_disk)(struct gendisk *);
    void (*swap_slot_free_notify)(struct block_device *, long unsigned int);
    int (*report_zones)(struct gendisk *, sector_t, unsigned int, report_zones_cb, void *);
    char * (*devnode)(struct gendisk *, umode_t *);
    int (*get_unique_id)(struct gendisk *, u8 *, enum blk_unique_id);
    struct module *owner;
    const struct pr_ops *pr_ops;
    int (*alternative_gpt_sector)(struct gendisk *, sector_t *);
};

struct blockgroup_lock {
    struct bgl_lock locks[128];
};

struct blocking_notifier_head {
    struct rw_semaphore rwsem;
    struct notifier_block *head;
};

struct software_node;

struct spi_board_info {
    char modalias[32];
    const void *platform_data;
    const struct software_node *swnode;
    void *controller_data;
    int irq;
    u32 max_speed_hz;
    u16 bus_num;
    u16 chip_select;
    u32 mode;
};

struct boardinfo {
    struct list_head list;
    struct spi_board_info board_info;
};

struct boot_triggers {
    const char *event;
    char *trigger;
};

struct iphdr {
    __u8 ihl: 4;
    __u8 version: 4;
    __u8 tos;
    __be16 tot_len;
    __be16 id;
    __be16 frag_off;
    __u8 ttl;
    __u8 protocol;
    __sum16 check;
    union {
        struct {
            __be32 saddr;
            __be32 daddr;
        };
        struct {
            __be32 saddr;
            __be32 daddr;
        } addrs;
    };
};

struct udphdr {
    __be16 source;
    __be16 dest;
    __be16 len;
    __sum16 check;
};

struct bootp_pkt {
    struct iphdr iph;
    struct udphdr udph;
    u8 op;
    u8 htype;
    u8 hlen;
    u8 hops;
    __be32 xid;
    __be16 secs;
    __be16 flags;
    __be32 client_ip;
    __be32 your_ip;
    __be32 server_ip;
    __be32 relay_ip;
    u8 hw_addr[16];
    u8 serv_name[64];
    u8 boot_file[128];
    u8 exten[312];
};

struct bp_slots_histogram {
    atomic_t *count;
};

struct bp_cpuinfo {
    unsigned int cpu_pinned;
    struct bp_slots_histogram tsk_pinned;
};

typedef void (*bp_hardening_cb_t)(void);

struct bp_hardening_data {
    enum arm64_hyp_spectre_vector slot;
    bp_hardening_cb_t fn;
};

struct bpf_map_ops;

struct btf_record;

struct btf;

struct obj_cgroup;

struct btf_type;

struct bpf_map {
    const struct bpf_map_ops *ops;
    struct bpf_map *inner_map_meta;
    void *security;
    enum bpf_map_type map_type;
    u32 key_size;
    u32 value_size;
    u32 max_entries;
    u64 map_extra;
    u32 map_flags;
    u32 id;
    struct btf_record *record;
    int numa_node;
    u32 btf_key_type_id;
    u32 btf_value_type_id;
    u32 btf_vmlinux_value_type_id;
    struct btf *btf;
    struct obj_cgroup *objcg;
    char name[16];
    struct mutex freeze_mutex;
    atomic64_t refcnt;
    atomic64_t usercnt;
    union {
        struct work_struct work;
        struct callback_head rcu;
    };
    atomic64_t writecnt;
    struct {
        const struct btf_type *attach_func_proto;
        spinlock_t lock;
        enum bpf_prog_type type;
        bool jited;
        bool xdp_has_frags;
    } owner;
    bool bypass_spec_v1;
    bool frozen;
    bool free_after_mult_rcu_gp;
    bool free_after_rcu_gp;
    atomic64_t sleepable_refcnt;
    s64 *elem_count;
};

struct range_tree {
    struct rb_root_cached it_root;
    struct rb_root_cached range_size_root;
};

struct vm_struct;

struct bpf_arena {
    struct bpf_map map;
    u64 user_vm_start;
    u64 user_vm_end;
    struct vm_struct *kern_vm;
    struct range_tree rt;
    struct list_head vma_list;
    struct mutex lock;
};

struct bpf_array_aux;

struct bpf_array {
    struct bpf_map map;
    u32 elem_size;
    u32 index_mask;
    struct bpf_array_aux *aux;
    union {
        struct {
            struct {} __empty_value;
            char value[0];
        };
        struct {
            struct {} __empty_ptrs;
            void *ptrs[0];
        };
        struct {
            struct {} __empty_pptrs;
            void *pptrs[0];
        };
    };
};

struct bpf_array_aux {
    struct list_head poke_progs;
    struct bpf_map *map;
    struct mutex poke_mutex;
    struct work_struct work;
};

struct bpf_async_cb {
    struct bpf_map *map;
    struct bpf_prog *prog;
    void *callback_fn;
    void *value;
    union {
        struct callback_head rcu;
        struct work_struct delete_work;
    };
    u64 flags;
};

struct bpf_spin_lock {
    __u32 val;
};

struct bpf_hrtimer;

struct bpf_work;

struct bpf_async_kern {
    union {
        struct bpf_async_cb *cb;
        struct bpf_hrtimer *timer;
        struct bpf_work *work;
    };
    struct bpf_spin_lock lock;
};

struct btf_func_model {
    u8 ret_size;
    u8 ret_flags;
    u8 nr_args;
    u8 arg_size[12];
    u8 arg_flags[12];
};

struct bpf_attach_target_info {
    struct btf_func_model fmodel;
    long int tgt_addr;
    struct module *tgt_mod;
    const char *tgt_name;
    const struct btf_type *tgt_type;
};

union bpf_attr {
    struct {
        __u32 map_type;
        __u32 key_size;
        __u32 value_size;
        __u32 max_entries;
        __u32 map_flags;
        __u32 inner_map_fd;
        __u32 numa_node;
        char map_name[16];
        __u32 map_ifindex;
        __u32 btf_fd;
        __u32 btf_key_type_id;
        __u32 btf_value_type_id;
        __u32 btf_vmlinux_value_type_id;
        __u64 map_extra;
        __s32 value_type_btf_obj_fd;
        __s32 map_token_fd;
    };
    struct {
        __u32 map_fd;
        __u64 key;
        union {
            __u64 value;
            __u64 next_key;
        };
        __u64 flags;
    };
    struct {
        __u64 in_batch;
        __u64 out_batch;
        __u64 keys;
        __u64 values;
        __u32 count;
        __u32 map_fd;
        __u64 elem_flags;
        __u64 flags;
    } batch;
    struct {
        __u32 prog_type;
        __u32 insn_cnt;
        __u64 insns;
        __u64 license;
        __u32 log_level;
        __u32 log_size;
        __u64 log_buf;
        __u32 kern_version;
        __u32 prog_flags;
        char prog_name[16];
        __u32 prog_ifindex;
        __u32 expected_attach_type;
        __u32 prog_btf_fd;
        __u32 func_info_rec_size;
        __u64 func_info;
        __u32 func_info_cnt;
        __u32 line_info_rec_size;
        __u64 line_info;
        __u32 line_info_cnt;
        __u32 attach_btf_id;
        union {
            __u32 attach_prog_fd;
            __u32 attach_btf_obj_fd;
        };
        __u32 core_relo_cnt;
        __u64 fd_array;
        __u64 core_relos;
        __u32 core_relo_rec_size;
        __u32 log_true_size;
        __s32 prog_token_fd;
        __u32 fd_array_cnt;
    };
    struct {
        __u64 pathname;
        __u32 bpf_fd;
        __u32 file_flags;
        __s32 path_fd;
    };
    struct {
        union {
            __u32 target_fd;
            __u32 target_ifindex;
        };
        __u32 attach_bpf_fd;
        __u32 attach_type;
        __u32 attach_flags;
        __u32 replace_bpf_fd;
        union {
            __u32 relative_fd;
            __u32 relative_id;
        };
        __u64 expected_revision;
    };
    struct {
        __u32 prog_fd;
        __u32 retval;
        __u32 data_size_in;
        __u32 data_size_out;
        __u64 data_in;
        __u64 data_out;
        __u32 repeat;
        __u32 duration;
        __u32 ctx_size_in;
        __u32 ctx_size_out;
        __u64 ctx_in;
        __u64 ctx_out;
        __u32 flags;
        __u32 cpu;
        __u32 batch_size;
    } test;
    struct {
        union {
            __u32 start_id;
            __u32 prog_id;
            __u32 map_id;
            __u32 btf_id;
            __u32 link_id;
        };
        __u32 next_id;
        __u32 open_flags;
    };
    struct {
        __u32 bpf_fd;
        __u32 info_len;
        __u64 info;
    } info;
    struct {
        union {
            __u32 target_fd;
            __u32 target_ifindex;
        };
        __u32 attach_type;
        __u32 query_flags;
        __u32 attach_flags;
        __u64 prog_ids;
        union {
            __u32 prog_cnt;
            __u32 count;
        };
        __u64 prog_attach_flags;
        __u64 link_ids;
        __u64 link_attach_flags;
        __u64 revision;
    } query;
    struct {
        __u64 name;
        __u32 prog_fd;
        __u64 cookie;
    } raw_tracepoint;
    struct {
        __u64 btf;
        __u64 btf_log_buf;
        __u32 btf_size;
        __u32 btf_log_size;
        __u32 btf_log_level;
        __u32 btf_log_true_size;
        __u32 btf_flags;
        __s32 btf_token_fd;
    };
    struct {
        __u32 pid;
        __u32 fd;
        __u32 flags;
        __u32 buf_len;
        __u64 buf;
        __u32 prog_id;
        __u32 fd_type;
        __u64 probe_offset;
        __u64 probe_addr;
    } task_fd_query;
    struct {
        union {
            __u32 prog_fd;
            __u32 map_fd;
        };
        union {
            __u32 target_fd;
            __u32 target_ifindex;
        };
        __u32 attach_type;
        __u32 flags;
        union {
            __u32 target_btf_id;
            struct {
                __u64 iter_info;
                __u32 iter_info_len;
            };
            struct {
                __u64 bpf_cookie;
            } perf_event;
            struct {
                __u32 flags;
                __u32 cnt;
                __u64 syms;
                __u64 addrs;
                __u64 cookies;
            } kprobe_multi;
            struct {
                __u32 target_btf_id;
                __u64 cookie;
            } tracing;
            struct {
                __u32 pf;
                __u32 hooknum;
                __s32 priority;
                __u32 flags;
            } netfilter;
            struct {
                union {
                    __u32 relative_fd;
                    __u32 relative_id;
                };
                __u64 expected_revision;
            } tcx;
            struct {
                __u64 path;
                __u64 offsets;
                __u64 ref_ctr_offsets;
                __u64 cookies;
                __u32 cnt;
                __u32 flags;
                __u32 pid;
            } uprobe_multi;
            struct {
                union {
                    __u32 relative_fd;
                    __u32 relative_id;
                };
                __u64 expected_revision;
            } netkit;
        };
    } link_create;
    struct {
        __u32 link_fd;
        union {
            __u32 new_prog_fd;
            __u32 new_map_fd;
        };
        __u32 flags;
        union {
            __u32 old_prog_fd;
            __u32 old_map_fd;
        };
    } link_update;
    struct {
        __u32 link_fd;
    } link_detach;
    struct {
        __u32 type;
    } enable_stats;
    struct {
        __u32 link_fd;
        __u32 flags;
    } iter_create;
    struct {
        __u32 prog_fd;
        __u32 map_fd;
        __u32 flags;
    } prog_bind_map;
    struct {
        __u32 flags;
        __u32 bpffs_fd;
    } token_create;
};

struct bpf_binary_header {
    u32 size;
    long: 0;
    u8 image[0];
};

struct bpf_bloom_filter {
    struct bpf_map map;
    u32 bitset_mask;
    u32 hash_seed;
    u32 nr_hash_funcs;
    long unsigned int bitset[0];
};

struct bpf_bprintf_buffers {
    char bin_args[512];
    char buf[1024];
};

struct bpf_bprintf_data {
    u32 *bin_args;
    char *buf;
    bool get_bin_args;
    bool get_buf;
};

struct bpf_btf_info {
    __u64 btf;
    __u32 btf_size;
    __u32 id;
    __u64 name;
    __u32 name_len;
    __u32 kernel_btf;
};

struct btf_field;

struct bpf_call_arg_meta {
    struct bpf_map *map_ptr;
    bool raw_mode;
    bool pkt_access;
    u8 release_regno;
    int regno;
    int access_size;
    int mem_size;
    u64 msize_max_value;
    int ref_obj_id;
    int dynptr_id;
    int map_uid;
    int func_id;
    struct btf *btf;
    u32 btf_id;
    struct btf *ret_btf;
    u32 ret_btf_id;
    u32 subprogno;
    struct btf_field *kptr_field;
    s64 const_map_key;
};

struct bpf_cand_cache {
    const char *name;
    u32 name_len;
    u16 kind;
    u16 cnt;
    struct {
        const struct btf *btf;
        u32 id;
    } cands[0];
};

struct bpf_run_ctx {};

struct bpf_prog_array_item;

struct bpf_cg_run_ctx {
    struct bpf_run_ctx run_ctx;
    const struct bpf_prog_array_item *prog_item;
    int retval;
};

struct bpf_cgroup_dev_ctx {
    __u32 access_type;
    __u32 major;
    __u32 minor;
};

struct bpf_link_ops;

struct bpf_link {
    atomic64_t refcnt;
    u32 id;
    enum bpf_link_type type;
    const struct bpf_link_ops *ops;
    struct bpf_prog *prog;
    bool sleepable;
    union {
        struct callback_head rcu;
        struct work_struct work;
    };
};

struct bpf_cgroup_link {
    struct bpf_link link;
    struct cgroup *cgroup;
    enum bpf_attach_type type;
};

struct bpf_cgroup_storage_key {
    __u64 cgroup_inode_id;
    __u32 attach_type;
};

struct bpf_storage_buffer;

struct bpf_cgroup_storage_map;

struct bpf_cgroup_storage {
    union {
        struct bpf_storage_buffer *buf;
        void *percpu_buf;
    };
    struct bpf_cgroup_storage_map *map;
    struct bpf_cgroup_storage_key key;
    struct list_head list_map;
    struct list_head list_cg;
    struct rb_node node;
    struct callback_head rcu;
};

struct bpf_cgroup_storage_map {
    struct bpf_map map;
    spinlock_t lock;
    struct rb_root root;
    struct list_head list;
};

struct bpf_lru_list {
    struct list_head lists[3];
    unsigned int counts[2];
    struct list_head *next_inactive_rotation;
    raw_spinlock_t lock;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
};

struct bpf_lru_locallist;

struct bpf_common_lru {
    struct bpf_lru_list lru_list;
    struct bpf_lru_locallist *local_list;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
};

struct bpf_core_accessor {
    __u32 type_id;
    __u32 idx;
    const char *name;
};

struct bpf_core_cand {
    const struct btf *btf;
    __u32 id;
};

struct bpf_core_cand_list {
    struct bpf_core_cand *cands;
    int len;
};

struct bpf_verifier_log;

struct bpf_core_ctx {
    struct bpf_verifier_log *log;
    const struct btf *btf;
};

struct bpf_core_relo {
    __u32 insn_off;
    __u32 type_id;
    __u32 access_str_off;
    enum bpf_core_relo_kind kind;
};

struct bpf_core_relo_res {
    __u64 orig_val;
    __u64 new_val;
    bool poison;
    bool validate;
    bool fail_memsz_adjust;
    __u32 orig_sz;
    __u32 orig_type_id;
    __u32 new_sz;
    __u32 new_type_id;
};

struct bpf_core_spec {
    const struct btf *btf;
    struct bpf_core_accessor spec[64];
    __u32 root_type_id;
    enum bpf_core_relo_kind relo_kind;
    int len;
    int raw_spec[64];
    int raw_len;
    __u32 bit_offset;
};

struct bpf_cpu_map_entry;

struct bpf_cpu_map {
    struct bpf_map map;
    struct bpf_cpu_map_entry **cpu_map;
};

struct bpf_cpumap_val {
    __u32 qsize;
    union {
        int fd;
        __u32 id;
    } bpf_prog;
};

struct xdp_bulk_queue;

struct ptr_ring;

struct bpf_cpu_map_entry {
    u32 cpu;
    int map_id;
    struct xdp_bulk_queue *bulkq;
    struct ptr_ring *queue;
    struct task_struct *kthread;
    struct bpf_cpumap_val value;
    struct bpf_prog *prog;
    struct completion kthread_running;
    struct rcu_work free_work;
};

struct bpf_cpumask {
    cpumask_t cpumask;
    refcount_t usage;
};

struct bpf_crypto_type;

struct bpf_crypto_ctx {
    const struct bpf_crypto_type *type;
    void *tfm;
    u32 siv_len;
    struct callback_head rcu;
    refcount_t usage;
};

struct bpf_crypto_params {
    char type[14];
    u8 reserved[2];
    char algo[128];
    u8 key[256];
    u32 key_len;
    u32 authsize;
};

struct bpf_crypto_type {
    void * (*alloc_tfm)(const char *);
    void (*free_tfm)(void *);
    int (*has_algo)(const char *);
    int (*setkey)(void *, const u8 *, unsigned int);
    int (*setauthsize)(void *, unsigned int);
    int (*encrypt)(void *, const u8 *, u8 *, unsigned int, u8 *);
    int (*decrypt)(void *, const u8 *, u8 *, unsigned int, u8 *);
    unsigned int (*ivsize)(void *);
    unsigned int (*statesize)(void *);
    u32 (*get_flags)(void *);
    struct module *owner;
    char name[14];
};

struct bpf_crypto_type_list {
    const struct bpf_crypto_type *type;
    struct list_head list;
};

struct bpf_ctx_arg_aux {
    u32 offset;
    enum bpf_reg_type reg_type;
    struct btf *btf;
    u32 btf_id;
};

struct skb_ext;

struct sk_buff {
    union {
        struct {
            struct sk_buff *next;
            struct sk_buff *prev;
            union {
                struct net_device *dev;
                long unsigned int dev_scratch;
            };
        };
        struct rb_node rbnode;
        struct list_head list;
        struct llist_node ll_node;
    };
    struct sock *sk;
    union {
        ktime_t tstamp;
        u64 skb_mstamp_ns;
    };
    char cb[48];
    union {
        struct {
            long unsigned int _skb_refdst;
            void (*destructor)(struct sk_buff *);
        };
        struct list_head tcp_tsorted_anchor;
        long unsigned int _sk_redir;
    };
    long unsigned int _nfct;
    unsigned int len;
    unsigned int data_len;
    __u16 mac_len;
    __u16 hdr_len;
    __u16 queue_mapping;
    __u8 __cloned_offset[0];
    __u8 cloned: 1;
    __u8 nohdr: 1;
    __u8 fclone: 2;
    __u8 peeked: 1;
    __u8 head_frag: 1;
    __u8 pfmemalloc: 1;
    __u8 pp_recycle: 1;
    __u8 active_extensions;
    union {
        struct {
            __u8 __pkt_type_offset[0];
            __u8 pkt_type: 3;
            __u8 ignore_df: 1;
            __u8 dst_pending_confirm: 1;
            __u8 ip_summed: 2;
            __u8 ooo_okay: 1;
            __u8 __mono_tc_offset[0];
            __u8 tstamp_type: 2;
            __u8 tc_at_ingress: 1;
            __u8 tc_skip_classify: 1;
            __u8 remcsum_offload: 1;
            __u8 csum_complete_sw: 1;
            __u8 csum_level: 2;
            __u8 inner_protocol_type: 1;
            __u8 l4_hash: 1;
            __u8 sw_hash: 1;
            __u8 wifi_acked_valid: 1;
            __u8 wifi_acked: 1;
            __u8 no_fcs: 1;
            __u8 encapsulation: 1;
            __u8 encap_hdr_csum: 1;
            __u8 csum_valid: 1;
            __u8 ndisc_nodetype: 2;
            __u8 ipvs_property: 1;
            __u8 nf_trace: 1;
            __u8 offload_fwd_mark: 1;
            __u8 offload_l3_fwd_mark: 1;
            __u8 redirected: 1;
            __u8 from_ingress: 1;
            __u8 nf_skip_egress: 1;
            __u8 decrypted: 1;
            __u8 slow_gro: 1;
            __u8 csum_not_inet: 1;
            __u8 unreadable: 1;
            __u16 tc_index;
            u16 alloc_cpu;
            union {
                __wsum csum;
                struct {
                    __u16 csum_start;
                    __u16 csum_offset;
                };
            };
            __u32 priority;
            int skb_iif;
            __u32 hash;
            union {
                u32 vlan_all;
                struct {
                    __be16 vlan_proto;
                    __u16 vlan_tci;
                };
            };
            union {
                unsigned int napi_id;
                unsigned int sender_cpu;
            };
            __u32 secmark;
            union {
                __u32 mark;
                __u32 reserved_tailroom;
            };
            union {
                __be16 inner_protocol;
                __u8 inner_ipproto;
            };
            __u16 inner_transport_header;
            __u16 inner_network_header;
            __u16 inner_mac_header;
            __be16 protocol;
            __u16 transport_header;
            __u16 network_header;
            __u16 mac_header;
        };
        struct {
            __u8 __pkt_type_offset[0];
            __u8 pkt_type: 3;
            __u8 ignore_df: 1;
            __u8 dst_pending_confirm: 1;
            __u8 ip_summed: 2;
            __u8 ooo_okay: 1;
            __u8 __mono_tc_offset[0];
            __u8 tstamp_type: 2;
            __u8 tc_at_ingress: 1;
            __u8 tc_skip_classify: 1;
            __u8 remcsum_offload: 1;
            __u8 csum_complete_sw: 1;
            __u8 csum_level: 2;
            __u8 inner_protocol_type: 1;
            __u8 l4_hash: 1;
            __u8 sw_hash: 1;
            __u8 wifi_acked_valid: 1;
            __u8 wifi_acked: 1;
            __u8 no_fcs: 1;
            __u8 encapsulation: 1;
            __u8 encap_hdr_csum: 1;
            __u8 csum_valid: 1;
            __u8 ndisc_nodetype: 2;
            __u8 ipvs_property: 1;
            __u8 nf_trace: 1;
            __u8 offload_fwd_mark: 1;
            __u8 offload_l3_fwd_mark: 1;
            __u8 redirected: 1;
            __u8 from_ingress: 1;
            __u8 nf_skip_egress: 1;
            __u8 decrypted: 1;
            __u8 slow_gro: 1;
            __u8 csum_not_inet: 1;
            __u8 unreadable: 1;
            __u16 tc_index;
            u16 alloc_cpu;
            union {
                __wsum csum;
                struct {
                    __u16 csum_start;
                    __u16 csum_offset;
                };
            };
            __u32 priority;
            int skb_iif;
            __u32 hash;
            union {
                u32 vlan_all;
                struct {
                    __be16 vlan_proto;
                    __u16 vlan_tci;
                };
            };
            union {
                unsigned int napi_id;
                unsigned int sender_cpu;
            };
            __u32 secmark;
            union {
                __u32 mark;
                __u32 reserved_tailroom;
            };
            union {
                __be16 inner_protocol;
                __u8 inner_ipproto;
            };
            __u16 inner_transport_header;
            __u16 inner_network_header;
            __u16 inner_mac_header;
            __be16 protocol;
            __u16 transport_header;
            __u16 network_header;
            __u16 mac_header;
        } headers;
    };
    sk_buff_data_t tail;
    sk_buff_data_t end;
    unsigned char *head;
    unsigned char *data;
    unsigned int truesize;
    refcount_t users;
    struct skb_ext *extensions;
};

struct xdp_md {
    __u32 data;
    __u32 data_end;
    __u32 data_meta;
    __u32 ingress_ifindex;
    __u32 rx_queue_index;
    __u32 egress_ifindex;
};

struct xdp_rxq_info;

struct xdp_txq_info;

struct xdp_buff {
    void *data;
    void *data_end;
    void *data_meta;
    void *data_hard_start;
    struct xdp_rxq_info *rxq;
    struct xdp_txq_info *txq;
    u32 frame_sz;
    u32 flags;
};

struct bpf_sock {
    __u32 bound_dev_if;
    __u32 family;
    __u32 type;
    __u32 protocol;
    __u32 mark;
    __u32 priority;
    __u32 src_ip4;
    __u32 src_ip6[4];
    __u32 src_port;
    __be16 dst_port;
    __u32 dst_ip4;
    __u32 dst_ip6[4];
    __u32 state;
    __s32 rx_queue_mapping;
};

struct hlist_nulls_node {
    struct hlist_nulls_node *next;
    struct hlist_nulls_node **pprev;
};

struct proto;

struct inet_timewait_death_row;

struct sock_common {
    union {
        __addrpair skc_addrpair;
        struct {
            __be32 skc_daddr;
            __be32 skc_rcv_saddr;
        };
    };
    union {
        unsigned int skc_hash;
        __u16 skc_u16hashes[2];
    };
    union {
        __portpair skc_portpair;
        struct {
            __be16 skc_dport;
            __u16 skc_num;
        };
    };
    short unsigned int skc_family;
    volatile unsigned char skc_state;
    unsigned char skc_reuse: 4;
    unsigned char skc_reuseport: 1;
    unsigned char skc_ipv6only: 1;
    unsigned char skc_net_refcnt: 1;
    int skc_bound_dev_if;
    union {
        struct hlist_node skc_bind_node;
        struct hlist_node skc_portaddr_node;
    };
    struct proto *skc_prot;
    possible_net_t skc_net;
    struct in6_addr skc_v6_daddr;
    struct in6_addr skc_v6_rcv_saddr;
    atomic64_t skc_cookie;
    union {
        long unsigned int skc_flags;
        struct sock *skc_listener;
        struct inet_timewait_death_row *skc_tw_dr;
    };
    int skc_dontcopy_begin[0];
    union {
        struct hlist_node skc_node;
        struct hlist_nulls_node skc_nulls_node;
    };
    short unsigned int skc_tx_queue_mapping;
    short unsigned int skc_rx_queue_mapping;
    union {
        int skc_incoming_cpu;
        u32 skc_rcv_wnd;
        u32 skc_tw_rcv_nxt;
    };
    refcount_t skc_refcnt;
    int skc_dontcopy_end[0];
    union {
        u32 skc_rxhash;
        u32 skc_window_clamp;
        u32 skc_tw_snd_nxt;
    };
};

struct page_frag {
    struct page *page;
    __u32 offset;
    __u32 size;
};

struct sock_cgroup_data {
    struct cgroup *cgroup;
    u32 classid;
    u16 prioidx;
};

struct dst_entry;

struct sk_filter;

struct socket_wq;

struct socket;

struct mem_cgroup;

struct xfrm_policy;

struct sock_reuseport;

struct bpf_local_storage;

struct sock {
    struct sock_common __sk_common;
    __u8 __cacheline_group_begin__sock_write_rx[0];
    atomic_t sk_drops;
    __s32 sk_peek_off;
    struct sk_buff_head sk_error_queue;
    struct sk_buff_head sk_receive_queue;
    struct {
        atomic_t rmem_alloc;
        int len;
        struct sk_buff *head;
        struct sk_buff *tail;
    } sk_backlog;
    __u8 __cacheline_group_end__sock_write_rx[0];
    __u8 __cacheline_group_begin__sock_read_rx[0];
    struct dst_entry *sk_rx_dst;
    int sk_rx_dst_ifindex;
    u32 sk_rx_dst_cookie;
    unsigned int sk_ll_usec;
    unsigned int sk_napi_id;
    u16 sk_busy_poll_budget;
    u8 sk_prefer_busy_poll;
    u8 sk_userlocks;
    int sk_rcvbuf;
    struct sk_filter *sk_filter;
    union {
        struct socket_wq *sk_wq;
        struct socket_wq *sk_wq_raw;
    };
    void (*sk_data_ready)(struct sock *);
    long int sk_rcvtimeo;
    int sk_rcvlowat;
    __u8 __cacheline_group_end__sock_read_rx[0];
    __u8 __cacheline_group_begin__sock_read_rxtx[0];
    int sk_err;
    struct socket *sk_socket;
    struct mem_cgroup *sk_memcg;
    struct xfrm_policy *sk_policy[2];
    __u8 __cacheline_group_end__sock_read_rxtx[0];
    __u8 __cacheline_group_begin__sock_write_rxtx[0];
    socket_lock_t sk_lock;
    u32 sk_reserved_mem;
    int sk_forward_alloc;
    u32 sk_tsflags;
    __u8 __cacheline_group_end__sock_write_rxtx[0];
    __u8 __cacheline_group_begin__sock_write_tx[0];
    int sk_write_pending;
    atomic_t sk_omem_alloc;
    int sk_sndbuf;
    int sk_wmem_queued;
    refcount_t sk_wmem_alloc;
    long unsigned int sk_tsq_flags;
    union {
        struct sk_buff *sk_send_head;
        struct rb_root tcp_rtx_queue;
    };
    struct sk_buff_head sk_write_queue;
    u32 sk_dst_pending_confirm;
    u32 sk_pacing_status;
    struct page_frag sk_frag;
    struct timer_list sk_timer;
    long unsigned int sk_pacing_rate;
    atomic_t sk_zckey;
    atomic_t sk_tskey;
    __u8 __cacheline_group_end__sock_write_tx[0];
    __u8 __cacheline_group_begin__sock_read_tx[0];
    long unsigned int sk_max_pacing_rate;
    long int sk_sndtimeo;
    u32 sk_priority;
    u32 sk_mark;
    struct dst_entry *sk_dst_cache;
    netdev_features_t sk_route_caps;
    struct sk_buff * (*sk_validate_xmit_skb)(struct sock *, struct net_device *, struct sk_buff *);
    u16 sk_gso_type;
    u16 sk_gso_max_segs;
    unsigned int sk_gso_max_size;
    gfp_t sk_allocation;
    u32 sk_txhash;
    u8 sk_pacing_shift;
    bool sk_use_task_frag;
    __u8 __cacheline_group_end__sock_read_tx[0];
    u8 sk_gso_disabled: 1;
    u8 sk_kern_sock: 1;
    u8 sk_no_check_tx: 1;
    u8 sk_no_check_rx: 1;
    u8 sk_shutdown;
    u16 sk_type;
    u16 sk_protocol;
    long unsigned int sk_lingertime;
    struct proto *sk_prot_creator;
    rwlock_t sk_callback_lock;
    int sk_err_soft;
    u32 sk_ack_backlog;
    u32 sk_max_ack_backlog;
    kuid_t sk_uid;
    spinlock_t sk_peer_lock;
    int sk_bind_phc;
    struct pid *sk_peer_pid;
    const struct cred *sk_peer_cred;
    ktime_t sk_stamp;
    int sk_disconnects;
    u8 sk_txrehash;
    u8 sk_clockid;
    u8 sk_txtime_deadline_mode: 1;
    u8 sk_txtime_report_errors: 1;
    u8 sk_txtime_unused: 6;
    void *sk_user_data;
    void *sk_security;
    struct sock_cgroup_data sk_cgrp_data;
    void (*sk_state_change)(struct sock *);
    void (*sk_write_space)(struct sock *);
    void (*sk_error_report)(struct sock *);
    int (*sk_backlog_rcv)(struct sock *, struct sk_buff *);
    void (*sk_destruct)(struct sock *);
    struct sock_reuseport *sk_reuseport_cb;
    struct bpf_local_storage *sk_bpf_storage;
    struct callback_head sk_rcu;
    netns_tracker ns_tracker;
    struct xarray sk_user_frags;
};

struct bpf_sock_addr {
    __u32 user_family;
    __u32 user_ip4;
    __u32 user_ip6[4];
    __u32 user_port;
    __u32 family;
    __u32 type;
    __u32 protocol;
    __u32 msg_src_ip4;
    __u32 msg_src_ip6[4];
    union {
        struct bpf_sock *sk;
    };
};

struct bpf_sock_addr_kern {
    struct sock *sk;
    struct sockaddr *uaddr;
    u64 tmp_reg;
    void *t_ctx;
    u32 uaddrlen;
};

struct bpf_sock_ops {
    __u32 op;
    union {
        __u32 args[4];
        __u32 reply;
        __u32 replylong[4];
    };
    __u32 family;
    __u32 remote_ip4;
    __u32 local_ip4;
    __u32 remote_ip6[4];
    __u32 local_ip6[4];
    __u32 remote_port;
    __u32 local_port;
    __u32 is_fullsock;
    __u32 snd_cwnd;
    __u32 srtt_us;
    __u32 bpf_sock_ops_cb_flags;
    __u32 state;
    __u32 rtt_min;
    __u32 snd_ssthresh;
    __u32 rcv_nxt;
    __u32 snd_nxt;
    __u32 snd_una;
    __u32 mss_cache;
    __u32 ecn_flags;
    __u32 rate_delivered;
    __u32 rate_interval_us;
    __u32 packets_out;
    __u32 retrans_out;
    __u32 total_retrans;
    __u32 segs_in;
    __u32 data_segs_in;
    __u32 segs_out;
    __u32 data_segs_out;
    __u32 lost_out;
    __u32 sacked_out;
    __u32 sk_txhash;
    __u64 bytes_received;
    __u64 bytes_acked;
    union {
        struct bpf_sock *sk;
    };
    union {
        void *skb_data;
    };
    union {
        void *skb_data_end;
    };
    __u32 skb_len;
    __u32 skb_tcp_flags;
    __u64 skb_hwtstamp;
};

struct bpf_sock_ops_kern {
    struct sock *sk;
    union {
        u32 args[4];
        u32 reply;
        u32 replylong[4];
    };
    struct sk_buff *syn_skb;
    struct sk_buff *skb;
    void *skb_data_end;
    u8 op;
    u8 is_fullsock;
    u8 remaining_opt_len;
    u64 temp;
};

struct sk_msg_md {
    union {
        void *data;
    };
    union {
        void *data_end;
    };
    __u32 family;
    __u32 remote_ip4;
    __u32 local_ip4;
    __u32 remote_ip6[4];
    __u32 local_ip6[4];
    __u32 remote_port;
    __u32 local_port;
    __u32 size;
    union {
        struct bpf_sock *sk;
    };
};

struct scatterlist {
    long unsigned int page_link;
    unsigned int offset;
    unsigned int length;
    dma_addr_t dma_address;
    unsigned int dma_length;
    unsigned int dma_flags;
};

struct sk_msg_sg {
    u32 start;
    u32 curr;
    u32 end;
    u32 size;
    u32 copybreak;
    long unsigned int copy[1];
    struct scatterlist data[19];
};

struct sk_msg {
    struct sk_msg_sg sg;
    void *data;
    void *data_end;
    u32 apply_bytes;
    u32 cork_bytes;
    u32 flags;
    struct sk_buff *skb;
    struct sock *sk_redir;
    struct sock *sk;
    struct list_head list;
};

struct bpf_flow_dissector {
    struct bpf_flow_keys *flow_keys;
    const struct sk_buff *skb;
    const void *data;
    const void *data_end;
};

struct user_pt_regs {
    __u64 regs[31];
    __u64 sp;
    __u64 pc;
    __u64 pstate;
};

typedef struct user_pt_regs bpf_user_pt_regs_t;

struct frame_record {
    u64 fp;
    u64 lr;
};

struct frame_record_meta {
    struct frame_record record;
    u64 type;
};

struct pt_regs {
    union {
        struct user_pt_regs user_regs;
        struct {
            u64 regs[31];
            u64 sp;
            u64 pc;
            u64 pstate;
        };
    };
    u64 orig_x0;
    s32 syscallno;
    u32 pmr;
    u64 sdei_ttbr1;
    struct frame_record_meta stackframe;
    u64 lockdep_hardirqs;
    u64 exit_rcu;
};

struct bpf_perf_event_data {
    bpf_user_pt_regs_t regs;
    __u64 sample_period;
    __u64 addr;
};

struct perf_sample_data;

struct bpf_perf_event_data_kern {
    bpf_user_pt_regs_t *regs;
    struct perf_sample_data *data;
    struct perf_event *event;
};

struct bpf_raw_tracepoint_args {
    __u64 args[0];
};

struct bpf_sysctl {
    __u32 write;
    __u32 file_pos;
};

struct ctl_table;

struct bpf_sysctl_kern {
    struct ctl_table_header *head;
    const struct ctl_table *table;
    void *cur_val;
    size_t cur_len;
    void *new_val;
    size_t new_len;
    int new_updated;
    int write;
    loff_t *ppos;
    u64 tmp_reg;
};

struct bpf_sockopt {
    union {
        struct bpf_sock *sk;
    };
    union {
        void *optval;
    };
    union {
        void *optval_end;
    };
    __s32 level;
    __s32 optname;
    __s32 optlen;
    __s32 retval;
};

struct bpf_sockopt_kern {
    struct sock *sk;
    u8 *optval;
    u8 *optval_end;
    s32 level;
    s32 optname;
    s32 optlen;
    struct task_struct *current_task;
    u64 tmp_reg;
};

struct sk_reuseport_md {
    union {
        void *data;
    };
    union {
        void *data_end;
    };
    __u32 len;
    __u32 eth_protocol;
    __u32 ip_protocol;
    __u32 bind_inany;
    __u32 hash;
    union {
        struct bpf_sock *sk;
    };
    union {
        struct bpf_sock *migrating_sk;
    };
};

struct sk_reuseport_kern {
    struct sk_buff *skb;
    struct sock *sk;
    struct sock *selected_sk;
    struct sock *migrating_sk;
    void *data_end;
    u32 hash;
    u32 reuseport_id;
    bool bind_inany;
};

struct bpf_sk_lookup {
    union {
        union {
            struct bpf_sock *sk;
        };
        __u64 cookie;
    };
    __u32 family;
    __u32 protocol;
    __u32 remote_ip4;
    __u32 remote_ip6[4];
    __be16 remote_port;
    __u32 local_ip4;
    __u32 local_ip6[4];
    __u32 local_port;
    __u32 ingress_ifindex;
};

struct bpf_sk_lookup_kern {
    u16 family;
    u16 protocol;
    __be16 sport;
    u16 dport;
    struct {
        __be32 saddr;
        __be32 daddr;
    } v4;
    struct {
        const struct in6_addr *saddr;
        const struct in6_addr *daddr;
    } v6;
    struct sock *selected_sk;
    u32 ingress_ifindex;
    bool no_reuseport;
};

struct nf_hook_state;

struct bpf_nf_ctx {
    const struct nf_hook_state *state;
    struct sk_buff *skb;
};

struct bpf_ctx_convert {
    struct __sk_buff BPF_PROG_TYPE_SOCKET_FILTER_prog;
    struct sk_buff BPF_PROG_TYPE_SOCKET_FILTER_kern;
    struct __sk_buff BPF_PROG_TYPE_SCHED_CLS_prog;
    struct sk_buff BPF_PROG_TYPE_SCHED_CLS_kern;
    struct __sk_buff BPF_PROG_TYPE_SCHED_ACT_prog;
    struct sk_buff BPF_PROG_TYPE_SCHED_ACT_kern;
    struct xdp_md BPF_PROG_TYPE_XDP_prog;
    struct xdp_buff BPF_PROG_TYPE_XDP_kern;
    struct __sk_buff BPF_PROG_TYPE_CGROUP_SKB_prog;
    struct sk_buff BPF_PROG_TYPE_CGROUP_SKB_kern;
    struct bpf_sock BPF_PROG_TYPE_CGROUP_SOCK_prog;
    struct sock BPF_PROG_TYPE_CGROUP_SOCK_kern;
    struct bpf_sock_addr BPF_PROG_TYPE_CGROUP_SOCK_ADDR_prog;
    struct bpf_sock_addr_kern BPF_PROG_TYPE_CGROUP_SOCK_ADDR_kern;
    struct __sk_buff BPF_PROG_TYPE_LWT_IN_prog;
    struct sk_buff BPF_PROG_TYPE_LWT_IN_kern;
    struct __sk_buff BPF_PROG_TYPE_LWT_OUT_prog;
    struct sk_buff BPF_PROG_TYPE_LWT_OUT_kern;
    struct __sk_buff BPF_PROG_TYPE_LWT_XMIT_prog;
    struct sk_buff BPF_PROG_TYPE_LWT_XMIT_kern;
    struct __sk_buff BPF_PROG_TYPE_LWT_SEG6LOCAL_prog;
    struct sk_buff BPF_PROG_TYPE_LWT_SEG6LOCAL_kern;
    struct bpf_sock_ops BPF_PROG_TYPE_SOCK_OPS_prog;
    struct bpf_sock_ops_kern BPF_PROG_TYPE_SOCK_OPS_kern;
    struct __sk_buff BPF_PROG_TYPE_SK_SKB_prog;
    struct sk_buff BPF_PROG_TYPE_SK_SKB_kern;
    struct sk_msg_md BPF_PROG_TYPE_SK_MSG_prog;
    struct sk_msg BPF_PROG_TYPE_SK_MSG_kern;
    struct __sk_buff BPF_PROG_TYPE_FLOW_DISSECTOR_prog;
    struct bpf_flow_dissector BPF_PROG_TYPE_FLOW_DISSECTOR_kern;
    bpf_user_pt_regs_t BPF_PROG_TYPE_KPROBE_prog;
    struct pt_regs BPF_PROG_TYPE_KPROBE_kern;
    __u64 BPF_PROG_TYPE_TRACEPOINT_prog;
    u64 BPF_PROG_TYPE_TRACEPOINT_kern;
    struct bpf_perf_event_data BPF_PROG_TYPE_PERF_EVENT_prog;
    struct bpf_perf_event_data_kern BPF_PROG_TYPE_PERF_EVENT_kern;
    struct bpf_raw_tracepoint_args BPF_PROG_TYPE_RAW_TRACEPOINT_prog;
    u64 BPF_PROG_TYPE_RAW_TRACEPOINT_kern;
    struct bpf_raw_tracepoint_args BPF_PROG_TYPE_RAW_TRACEPOINT_WRITABLE_prog;
    u64 BPF_PROG_TYPE_RAW_TRACEPOINT_WRITABLE_kern;
    void *BPF_PROG_TYPE_TRACING_prog;
    void *BPF_PROG_TYPE_TRACING_kern;
    struct bpf_cgroup_dev_ctx BPF_PROG_TYPE_CGROUP_DEVICE_prog;
    struct bpf_cgroup_dev_ctx BPF_PROG_TYPE_CGROUP_DEVICE_kern;
    struct bpf_sysctl BPF_PROG_TYPE_CGROUP_SYSCTL_prog;
    struct bpf_sysctl_kern BPF_PROG_TYPE_CGROUP_SYSCTL_kern;
    struct bpf_sockopt BPF_PROG_TYPE_CGROUP_SOCKOPT_prog;
    struct bpf_sockopt_kern BPF_PROG_TYPE_CGROUP_SOCKOPT_kern;
    struct sk_reuseport_md BPF_PROG_TYPE_SK_REUSEPORT_prog;
    struct sk_reuseport_kern BPF_PROG_TYPE_SK_REUSEPORT_kern;
    struct bpf_sk_lookup BPF_PROG_TYPE_SK_LOOKUP_prog;
    struct bpf_sk_lookup_kern BPF_PROG_TYPE_SK_LOOKUP_kern;
    void *BPF_PROG_TYPE_STRUCT_OPS_prog;
    void *BPF_PROG_TYPE_STRUCT_OPS_kern;
    void *BPF_PROG_TYPE_EXT_prog;
    void *BPF_PROG_TYPE_EXT_kern;
    void *BPF_PROG_TYPE_SYSCALL_prog;
    void *BPF_PROG_TYPE_SYSCALL_kern;
    struct bpf_nf_ctx BPF_PROG_TYPE_NETFILTER_prog;
    struct bpf_nf_ctx BPF_PROG_TYPE_NETFILTER_kern;
};

struct bpf_devmap_val {
    __u32 ifindex;
    union {
        int fd;
        __u32 id;
    } bpf_prog;
};

struct bpf_dispatcher_prog {
    struct bpf_prog *prog;
    refcount_t users;
};

struct latch_tree_node {
    struct rb_node node[2];
};

struct bpf_ksym {
    long unsigned int start;
    long unsigned int end;
    char name[512];
    struct list_head lnode;
    struct latch_tree_node tnode;
    bool prog;
};

struct bpf_dispatcher {
    struct mutex mutex;
    void *func;
    struct bpf_dispatcher_prog progs[48];
    int num_progs;
    void *image;
    void *rw_image;
    u32 image_off;
    struct bpf_ksym ksym;
};

struct bpf_dtab_netdev;

struct bpf_dtab {
    struct bpf_map map;
    struct bpf_dtab_netdev **netdev_map;
    struct list_head list;
    struct hlist_head *dev_index_head;
    spinlock_t index_lock;
    unsigned int items;
    u32 n_buckets;
};

struct bpf_dtab_netdev {
    struct net_device *dev;
    struct hlist_node index_hlist;
    struct bpf_prog *xdp_prog;
    struct callback_head rcu;
    unsigned int idx;
    struct bpf_devmap_val val;
};

struct bpf_dummy_ops_state;

struct bpf_dummy_ops {
    int (*test_1)(struct bpf_dummy_ops_state *);
    int (*test_2)(struct bpf_dummy_ops_state *, int, short unsigned int, char, long unsigned int);
    int (*test_sleepable)(struct bpf_dummy_ops_state *);
};

struct bpf_dummy_ops_state {
    int val;
};

struct bpf_dummy_ops_test_args {
    u64 args[12];
    struct bpf_dummy_ops_state state;
};

struct bpf_dynptr {
    __u64 __opaque[2];
};

struct bpf_dynptr_kern {
    void *data;
    u32 size;
    u32 offset;
};

struct bpf_prog_array_item {
    struct bpf_prog *prog;
    union {
        struct bpf_cgroup_storage *cgroup_storage[2];
        u64 bpf_cookie;
    };
};

struct bpf_prog_array {
    struct callback_head rcu;
    struct bpf_prog_array_item items[0];
};

struct bpf_empty_prog_array {
    struct bpf_prog_array hdr;
    struct bpf_prog *null_prog;
};

struct bpf_event_entry {
    struct perf_event *event;
    struct file *perf_file;
    struct file *map_file;
    struct callback_head rcu;
};

struct bpf_fentry_test_t {
    struct bpf_fentry_test_t *a;
};

struct bpf_fib_lookup {
    __u8 family;
    __u8 l4_protocol;
    __be16 sport;
    __be16 dport;
    union {
        __u16 tot_len;
        __u16 mtu_result;
    };
    __u32 ifindex;
    union {
        __u8 tos;
        __be32 flowinfo;
        __u32 rt_metric;
    };
    union {
        __be32 ipv4_src;
        __u32 ipv6_src[4];
    };
    union {
        __be32 ipv4_dst;
        __u32 ipv6_dst[4];
    };
    union {
        struct {
            __be16 h_vlan_proto;
            __be16 h_vlan_TCI;
        };
        __u32 tbid;
    };
    union {
        struct {
            __u32 mark;
        };
        struct {
            __u8 smac[6];
            __u8 dmac[6];
        };
    };
};

struct bpf_flow_keys {
    __u16 nhoff;
    __u16 thoff;
    __u16 addr_proto;
    __u8 is_frag;
    __u8 is_first_frag;
    __u8 is_encap;
    __u8 ip_proto;
    __be16 n_proto;
    __be16 sport;
    __be16 dport;
    union {
        struct {
            __be32 ipv4_src;
            __be32 ipv4_dst;
        };
        struct {
            __u32 ipv6_src[4];
            __u32 ipv6_dst[4];
        };
    };
    __u32 flags;
    __be32 flow_label;
};

struct bpf_func_info {
    __u32 insn_off;
    __u32 type_id;
};

struct bpf_func_info_aux {
    u16 linkage;
    bool unreliable;
    bool called: 1;
    bool verified: 1;
};

struct bpf_func_proto {
    u64 (*func)(u64, u64, u64, u64, u64);
    bool gpl_only;
    bool pkt_access;
    bool might_sleep;
    bool allow_fastcall;
    enum bpf_return_type ret_type;
    union {
        struct {
            enum bpf_arg_type arg1_type;
            enum bpf_arg_type arg2_type;
            enum bpf_arg_type arg3_type;
            enum bpf_arg_type arg4_type;
            enum bpf_arg_type arg5_type;
        };
        enum bpf_arg_type arg_type[5];
    };
    union {
        struct {
            u32 *arg1_btf_id;
            u32 *arg2_btf_id;
            u32 *arg3_btf_id;
            u32 *arg4_btf_id;
            u32 *arg5_btf_id;
        };
        u32 *arg_btf_id[5];
        struct {
            size_t arg1_size;
            size_t arg2_size;
            size_t arg3_size;
            size_t arg4_size;
            size_t arg5_size;
        };
        size_t arg_size[5];
    };
    int *ret_btf_id;
    bool (*allowed)(const struct bpf_prog *);
};

struct tnum {
    u64 value;
    u64 mask;
};

struct bpf_reg_state {
    enum bpf_reg_type type;
    s32 off;
    union {
        int range;
        struct {
            struct bpf_map *map_ptr;
            u32 map_uid;
        };
        struct {
            struct btf *btf;
            u32 btf_id;
        };
        struct {
            u32 mem_size;
            u32 dynptr_id;
        };
        struct {
            enum bpf_dynptr_type type;
            bool first_slot;
        } dynptr;
        struct {
            struct btf *btf;
            u32 btf_id;
            enum bpf_iter_state state: 2;
            int depth: 30;
        } iter;
        struct {
            long unsigned int raw1;
            long unsigned int raw2;
        } raw;
        u32 subprogno;
    };
    struct tnum var_off;
    s64 smin_value;
    s64 smax_value;
    u64 umin_value;
    u64 umax_value;
    s32 s32_min_value;
    s32 s32_max_value;
    u32 u32_min_value;
    u32 u32_max_value;
    u32 id;
    u32 ref_obj_id;
    struct bpf_reg_state *parent;
    u32 frameno;
    s32 subreg_def;
    enum bpf_reg_liveness live;
    bool precise;
};

struct bpf_retval_range {
    s32 minval;
    s32 maxval;
};

struct bpf_stack_state;

struct bpf_func_state {
    struct bpf_reg_state regs[11];
    int callsite;
    u32 frameno;
    u32 subprogno;
    u32 async_entry_cnt;
    struct bpf_retval_range callback_ret_range;
    bool in_callback_fn;
    bool in_async_callback_fn;
    bool in_exception_callback_fn;
    u32 callback_depth;
    struct bpf_stack_state *stack;
    int allocated_stack;
};

struct bpf_hrtimer {
    struct bpf_async_cb cb;
    struct hrtimer timer;
    atomic_t cancelling;
};

struct bpf_mem_caches;

struct bpf_mem_cache;

struct bpf_mem_alloc {
    struct bpf_mem_caches *caches;
    struct bpf_mem_cache *cache;
    struct obj_cgroup *objcg;
    bool percpu;
    struct work_struct work;
};

struct pcpu_freelist_node;

struct pcpu_freelist_head {
    struct pcpu_freelist_node *first;
    raw_spinlock_t lock;
};

struct pcpu_freelist {
    struct pcpu_freelist_head *freelist;
    struct pcpu_freelist_head extralist;
};

struct bpf_lru_node;

typedef bool (*del_from_htab_func)(void *, struct bpf_lru_node *);

struct bpf_lru {
    union {
        struct bpf_common_lru common_lru;
        struct bpf_lru_list *percpu_lru;
    };
    del_from_htab_func del_from_htab;
    void *del_arg;
    unsigned int hash_offset;
    unsigned int nr_scans;
    bool percpu;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
};

struct bucket;

struct htab_elem;

struct bpf_htab {
    struct bpf_map map;
    struct bpf_mem_alloc ma;
    struct bpf_mem_alloc pcpu_ma;
    struct bucket *buckets;
    void *elems;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    union {
        struct pcpu_freelist freelist;
        struct bpf_lru lru;
    };
    struct htab_elem **extra_elems;
    struct percpu_counter pcount;
    atomic_t count;
    bool use_percpu_counter;
    u32 n_buckets;
    u32 elem_size;
    u32 hashrnd;
    struct lock_class_key lockdep_key;
    int *map_locked[8];
    long: 64;
};

struct bpf_id_pair {
    u32 old;
    u32 cur;
};

struct bpf_idmap {
    u32 tmp_id_gen;
    struct bpf_id_pair map[600];
};

struct bpf_idset {
    u32 count;
    u32 ids[600];
};

struct bpf_insn {
    __u8 code;
    __u8 dst_reg: 4;
    __u8 src_reg: 4;
    __s16 off;
    __s32 imm;
};

struct bpf_insn_access_aux {
    enum bpf_reg_type reg_type;
    bool is_ldsx;
    union {
        int ctx_field_size;
        struct {
            struct btf *btf;
            u32 btf_id;
        };
    };
    struct bpf_verifier_log *log;
    bool is_retval;
};

struct bpf_map_ptr_state {
    struct bpf_map *map_ptr;
    bool poison;
    bool unpriv;
};

struct bpf_loop_inline_state {
    unsigned int initialized: 1;
    unsigned int fit_for_inline: 1;
    u32 callback_subprogno;
};

struct btf_struct_meta;

struct bpf_insn_aux_data {
    union {
        enum bpf_reg_type ptr_type;
        struct bpf_map_ptr_state map_ptr_state;
        s32 call_imm;
        u32 alu_limit;
        struct {
            u32 map_index;
            u32 map_off;
        };
        struct {
            enum bpf_reg_type reg_type;
            union {
                struct {
                    struct btf *btf;
                    u32 btf_id;
                };
                u32 mem_size;
            };
        } btf_var;
        struct bpf_loop_inline_state loop_inline_state;
    };
    union {
        u64 obj_new_size;
        u64 insert_off;
    };
    struct btf_struct_meta *kptr_struct_meta;
    u64 map_key_state;
    int ctx_field_size;
    u32 seen;
    bool sanitize_stack_spill;
    bool zext_dst;
    bool needs_zext;
    bool storage_get_func_atomic;
    bool is_iter_next;
    bool call_with_percpu_alloc_ptr;
    u8 alu_state;
    u8 fastcall_pattern: 1;
    u8 fastcall_spills_num: 3;
    unsigned int orig_idx;
    bool jmp_point;
    bool prune_point;
    bool force_checkpoint;
    bool calls_callback;
};

typedef void (*bpf_insn_print_t)(void *, const char *, ...);

typedef const char * (*bpf_insn_revmap_call_t)(void *, const struct bpf_insn *);

typedef const char * (*bpf_insn_print_imm_t)(void *, const struct bpf_insn *, __u64);

struct bpf_insn_cbs {
    bpf_insn_print_t cb_print;
    bpf_insn_revmap_call_t cb_call;
    bpf_insn_print_imm_t cb_imm;
    void *private_data;
};

struct bpf_insn_hist_entry {
    u32 idx;
    u32 prev_idx: 22;
    u32 flags: 10;
    u64 linked_regs;
};

struct bpf_iter_meta;

struct bpf_iter__bpf_link {
    union {
        struct bpf_iter_meta *meta;
    };
    union {
        struct bpf_link *link;
    };
};

struct bpf_iter__bpf_map {
    union {
        struct bpf_iter_meta *meta;
    };
    union {
        struct bpf_map *map;
    };
};

struct bpf_iter__bpf_map_elem {
    union {
        struct bpf_iter_meta *meta;
    };
    union {
        struct bpf_map *map;
    };
    union {
        void *key;
    };
    union {
        void *value;
    };
};

struct bpf_iter__bpf_prog {
    union {
        struct bpf_iter_meta *meta;
    };
    union {
        struct bpf_prog *prog;
    };
};

struct bpf_iter__bpf_sk_storage_map {
    union {
        struct bpf_iter_meta *meta;
    };
    union {
        struct bpf_map *map;
    };
    union {
        struct sock *sk;
    };
    union {
        void *value;
    };
};

struct bpf_iter__cgroup {
    union {
        struct bpf_iter_meta *meta;
    };
    union {
        struct cgroup *cgroup;
    };
};

struct fib6_info;

struct bpf_iter__ipv6_route {
    union {
        struct bpf_iter_meta *meta;
    };
    union {
        struct fib6_info *rt;
    };
};

struct bpf_iter__kmem_cache {
    union {
        struct bpf_iter_meta *meta;
    };
    union {
        struct kmem_cache *s;
    };
};

struct kallsym_iter;

struct bpf_iter__ksym {
    union {
        struct bpf_iter_meta *meta;
    };
    union {
        struct kallsym_iter *ksym;
    };
};

struct netlink_sock;

struct bpf_iter__netlink {
    union {
        struct bpf_iter_meta *meta;
    };
    union {
        struct netlink_sock *sk;
    };
};

struct bpf_iter__sockmap {
    union {
        struct bpf_iter_meta *meta;
    };
    union {
        struct bpf_map *map;
    };
    union {
        void *key;
    };
    union {
        struct sock *sk;
    };
};

struct bpf_iter__task {
    union {
        struct bpf_iter_meta *meta;
    };
    union {
        struct task_struct *task;
    };
};

struct bpf_iter__task__safe_trusted {
    struct bpf_iter_meta *meta;
    struct task_struct *task;
};

struct bpf_iter__task_file {
    union {
        struct bpf_iter_meta *meta;
    };
    union {
        struct task_struct *task;
    };
    u32 fd;
    union {
        struct file *file;
    };
};

struct bpf_iter__task_vma {
    union {
        struct bpf_iter_meta *meta;
    };
    union {
        struct task_struct *task;
    };
    union {
        struct vm_area_struct *vma;
    };
};

struct bpf_iter__tcp {
    union {
        struct bpf_iter_meta *meta;
    };
    union {
        struct sock_common *sk_common;
    };
    uid_t uid;
};

struct udp_sock;

struct bpf_iter__udp {
    union {
        struct bpf_iter_meta *meta;
    };
    union {
        struct udp_sock *udp_sk;
    };
    uid_t uid;
    long: 0;
    int bucket;
};

struct unix_sock;

struct bpf_iter__unix {
    union {
        struct bpf_iter_meta *meta;
    };
    union {
        struct unix_sock *unix_sk;
    };
    uid_t uid;
};

struct bpf_iter_aux_info {
    struct bpf_map *map;
    struct {
        struct cgroup *start;
        enum bpf_cgroup_iter_order order;
    } cgroup;
    struct {
        enum bpf_iter_task_type type;
        u32 pid;
    } task;
};

struct bpf_iter_bits {
    __u64 __opaque[2];
};

struct bpf_iter_bits_kern {
    union {
        __u64 *bits;
        __u64 bits_copy;
    };
    int nr_bits;
    int bit;
};

struct bpf_iter_css {
    __u64 __opaque[3];
};

struct bpf_iter_css_kern {
    struct cgroup_subsys_state *start;
    struct cgroup_subsys_state *pos;
    unsigned int flags;
};

struct bpf_iter_css_task {
    __u64 __opaque[1];
};

struct css_task_iter;

struct bpf_iter_css_task_kern {
    struct css_task_iter *css_it;
};

struct bpf_iter_kmem_cache {
    __u64 __opaque[1];
};

struct bpf_iter_kmem_cache_kern {
    struct kmem_cache *pos;
};

struct bpf_iter_target_info;

struct bpf_iter_link {
    struct bpf_link link;
    struct bpf_iter_aux_info aux;
    struct bpf_iter_target_info *tinfo;
};

union bpf_iter_link_info {
    struct {
        __u32 map_fd;
    } map;
    struct {
        enum bpf_cgroup_iter_order order;
        __u32 cgroup_fd;
        __u64 cgroup_id;
    } cgroup;
    struct {
        __u32 tid;
        __u32 pid;
        __u32 pid_fd;
    } task;
};

struct bpf_iter_meta {
    union {
        struct seq_file *seq;
    };
    u64 session_id;
    u64 seq_num;
};

struct bpf_iter_meta__safe_trusted {
    struct seq_file *seq;
};

struct bpf_iter_num {
    __u64 __opaque[1];
};

struct bpf_iter_num_kern {
    int cur;
    int end;
};

struct bpf_iter_seq_info;

struct bpf_iter_priv_data {
    struct bpf_iter_target_info *tinfo;
    const struct bpf_iter_seq_info *seq_info;
    struct bpf_prog *prog;
    u64 session_id;
    u64 seq_num;
    bool done_stop;
    long: 0;
    u8 target_private[0];
};

typedef int (*bpf_iter_attach_target_t)(struct bpf_prog *, union bpf_iter_link_info *, struct bpf_iter_aux_info *);

typedef void (*bpf_iter_detach_target_t)(struct bpf_iter_aux_info *);

typedef void (*bpf_iter_show_fdinfo_t)(const struct bpf_iter_aux_info *, struct seq_file *);

struct bpf_link_info;

typedef int (*bpf_iter_fill_link_info_t)(const struct bpf_iter_aux_info *, struct bpf_link_info *);

typedef const struct bpf_func_proto * (*bpf_iter_get_func_proto_t)(enum bpf_func_id, const struct bpf_prog *);

struct bpf_iter_reg {
    const char *target;
    bpf_iter_attach_target_t attach_target;
    bpf_iter_detach_target_t detach_target;
    bpf_iter_show_fdinfo_t show_fdinfo;
    bpf_iter_fill_link_info_t fill_link_info;
    bpf_iter_get_func_proto_t get_func_proto;
    u32 ctx_arg_info_size;
    u32 feature;
    struct bpf_ctx_arg_aux ctx_arg_info[2];
    const struct bpf_iter_seq_info *seq_info;
};

struct bpf_iter_scx_dsq {
    u64 __opaque[6];
};

struct scx_dsq_list_node {
    struct list_head node;
    u32 flags;
    u32 priv;
};

struct scx_dispatch_q;

struct bpf_iter_scx_dsq_kern {
    struct scx_dsq_list_node cursor;
    struct scx_dispatch_q *dsq;
    u64 slice;
    u64 vtime;
};

struct bpf_iter_seq_array_map_info {
    struct bpf_map *map;
    void *percpu_value_buf;
    u32 index;
};

struct bpf_iter_seq_hash_map_info {
    struct bpf_map *map;
    struct bpf_htab *htab;
    void *percpu_value_buf;
    u32 bucket_id;
    u32 skip_elems;
};

typedef int (*bpf_iter_init_seq_priv_t)(void *, struct bpf_iter_aux_info *);

typedef void (*bpf_iter_fini_seq_priv_t)(void *);

struct bpf_iter_seq_info {
    const struct seq_operations *seq_ops;
    bpf_iter_init_seq_priv_t init_seq_private;
    bpf_iter_fini_seq_priv_t fini_seq_private;
    u32 seq_priv_size;
};

struct bpf_iter_seq_link_info {
    u32 link_id;
};

struct bpf_iter_seq_map_info {
    u32 map_id;
};

struct bpf_iter_seq_prog_info {
    u32 prog_id;
};

struct bpf_iter_seq_sk_storage_map_info {
    struct bpf_map *map;
    unsigned int bucket_id;
    unsigned int skip_elems;
};

struct pid_namespace;

struct bpf_iter_seq_task_common {
    struct pid_namespace *ns;
    enum bpf_iter_task_type type;
    u32 pid;
    u32 pid_visiting;
};

struct bpf_iter_seq_task_file_info {
    struct bpf_iter_seq_task_common common;
    struct task_struct *task;
    u32 tid;
    u32 fd;
};

struct bpf_iter_seq_task_info {
    struct bpf_iter_seq_task_common common;
    u32 tid;
};

struct bpf_iter_seq_task_vma_info {
    struct bpf_iter_seq_task_common common;
    struct task_struct *task;
    struct mm_struct *mm;
    struct vm_area_struct *vma;
    u32 tid;
    long unsigned int prev_vm_start;
    long unsigned int prev_vm_end;
};

struct bpf_iter_target_info {
    struct list_head list;
    const struct bpf_iter_reg *reg_info;
    u32 btf_id;
};

struct bpf_iter_task {
    __u64 __opaque[3];
};

struct bpf_iter_task_kern {
    struct task_struct *task;
    struct task_struct *pos;
    unsigned int flags;
};

struct bpf_iter_task_vma {
    __u64 __opaque[1];
};

struct bpf_iter_task_vma_kern_data;

struct bpf_iter_task_vma_kern {
    struct bpf_iter_task_vma_kern_data *data;
};

struct maple_enode;

struct maple_tree;

struct maple_alloc;

struct ma_state {
    struct maple_tree *tree;
    long unsigned int index;
    long unsigned int last;
    struct maple_enode *node;
    long unsigned int min;
    long unsigned int max;
    struct maple_alloc *alloc;
    enum maple_status status;
    unsigned char depth;
    unsigned char offset;
    unsigned char mas_flags;
    unsigned char end;
    enum store_type store_type;
};

struct vma_iterator {
    struct ma_state mas;
};

struct mmap_unlock_irq_work;

struct bpf_iter_task_vma_kern_data {
    struct task_struct *task;
    struct mm_struct *mm;
    struct mmap_unlock_irq_work *work;
    struct vma_iterator vmi;
};

struct bpf_jit_poke_descriptor {
    void *tailcall_target;
    void *tailcall_bypass;
    void *bypass_addr;
    void *aux;
    union {
        struct {
            struct bpf_map *map;
            u32 key;
        } tail_call;
    };
    bool tailcall_target_stable;
    u8 adj_off;
    u16 reason;
    u32 insn_idx;
};

struct bpf_key {
    struct key *key;
    bool has_ref;
};

struct bpf_kfunc_btf {
    struct btf *btf;
    struct module *module;
    u16 offset;
};

struct bpf_kfunc_btf_tab {
    struct bpf_kfunc_btf descs[256];
    u32 nr_descs;
};

struct bpf_kfunc_call_arg_meta {
    struct btf *btf;
    u32 func_id;
    u32 kfunc_flags;
    const struct btf_type *func_proto;
    const char *func_name;
    u32 ref_obj_id;
    u8 release_regno;
    bool r0_rdonly;
    u32 ret_btf_id;
    u64 r0_size;
    u32 subprogno;
    struct {
        u64 value;
        bool found;
    } arg_constant;
    struct btf *arg_btf;
    u32 arg_btf_id;
    bool arg_owning_ref;
    struct {
        struct btf_field *field;
    } arg_list_head;
    struct {
        struct btf_field *field;
    } arg_rbtree_root;
    struct {
        enum bpf_dynptr_type type;
        u32 id;
        u32 ref_obj_id;
    } initialized_dynptr;
    struct {
        u8 spi;
        u8 frameno;
    } iter;
    struct {
        struct bpf_map *ptr;
        int uid;
    } map;
    u64 mem_size;
};

struct bpf_kfunc_desc {
    struct btf_func_model func_model;
    u32 func_id;
    s32 imm;
    u16 offset;
    long unsigned int addr;
};

struct bpf_kfunc_desc_tab {
    struct bpf_kfunc_desc descs[256];
    u32 nr_descs;
};

struct fprobe;

struct ftrace_regs;

typedef int (*fprobe_entry_cb)(struct fprobe *, long unsigned int, long unsigned int, struct ftrace_regs *, void *);

typedef void (*fprobe_exit_cb)(struct fprobe *, long unsigned int, long unsigned int, struct ftrace_regs *, void *);

struct fprobe_hlist;

struct fprobe {
    long unsigned int nmissed;
    unsigned int flags;
    size_t entry_data_size;
    fprobe_entry_cb entry_handler;
    fprobe_exit_cb exit_handler;
    struct fprobe_hlist *hlist_array;
};

struct bpf_kprobe_multi_link {
    struct bpf_link link;
    struct fprobe fp;
    long unsigned int *addrs;
    u64 *cookies;
    u32 cnt;
    u32 mods_cnt;
    struct module **mods;
    u32 flags;
};

struct bpf_session_run_ctx {
    struct bpf_run_ctx run_ctx;
    bool is_return;
    void *data;
};

struct bpf_kprobe_multi_run_ctx {
    struct bpf_session_run_ctx session_ctx;
    struct bpf_kprobe_multi_link *link;
    long unsigned int entry_ip;
};

struct bpf_line_info {
    __u32 insn_off;
    __u32 file_name_off;
    __u32 line_off;
    __u32 line_col;
};

struct bpf_link_info {
    __u32 type;
    __u32 id;
    __u32 prog_id;
    union {
        struct {
            __u64 tp_name;
            __u32 tp_name_len;
        } raw_tracepoint;
        struct {
            __u32 attach_type;
            __u32 target_obj_id;
            __u32 target_btf_id;
        } tracing;
        struct {
            __u64 cgroup_id;
            __u32 attach_type;
        } cgroup;
        struct {
            __u64 target_name;
            __u32 target_name_len;
            union {
                struct {
                    __u32 map_id;
                } map;
            };
            union {
                struct {
                    __u64 cgroup_id;
                    __u32 order;
                } cgroup;
                struct {
                    __u32 tid;
                    __u32 pid;
                } task;
            };
        } iter;
        struct {
            __u32 netns_ino;
            __u32 attach_type;
        } netns;
        struct {
            __u32 ifindex;
        } xdp;
        struct {
            __u32 map_id;
        } struct_ops;
        struct {
            __u32 pf;
            __u32 hooknum;
            __s32 priority;
            __u32 flags;
        } netfilter;
        struct {
            __u64 addrs;
            __u32 count;
            __u32 flags;
            __u64 missed;
            __u64 cookies;
        } kprobe_multi;
        struct {
            __u64 path;
            __u64 offsets;
            __u64 ref_ctr_offsets;
            __u64 cookies;
            __u32 path_size;
            __u32 count;
            __u32 flags;
            __u32 pid;
        } uprobe_multi;
        struct {
            __u32 type;
            union {
                struct {
                    __u64 file_name;
                    __u32 name_len;
                    __u32 offset;
                    __u64 cookie;
                } uprobe;
                struct {
                    __u64 func_name;
                    __u32 name_len;
                    __u32 offset;
                    __u64 addr;
                    __u64 missed;
                    __u64 cookie;
                } kprobe;
                struct {
                    __u64 tp_name;
                    __u32 name_len;
                    __u64 cookie;
                } tracepoint;
                struct {
                    __u64 config;
                    __u32 type;
                    __u64 cookie;
                } event;
            };
        } perf_event;
        struct {
            __u32 ifindex;
            __u32 attach_type;
        } tcx;
        struct {
            __u32 ifindex;
            __u32 attach_type;
        } netkit;
        struct {
            __u32 map_id;
            __u32 attach_type;
        } sockmap;
    };
};

struct bpf_link_ops {
    void (*release)(struct bpf_link *);
    void (*dealloc)(struct bpf_link *);
    void (*dealloc_deferred)(struct bpf_link *);
    int (*detach)(struct bpf_link *);
    int (*update_prog)(struct bpf_link *, struct bpf_prog *, struct bpf_prog *);
    void (*show_fdinfo)(const struct bpf_link *, struct seq_file *);
    int (*fill_link_info)(const struct bpf_link *, struct bpf_link_info *);
    int (*update_map)(struct bpf_link *, struct bpf_map *, struct bpf_map *);
    __poll_t (*poll)(struct file *, struct poll_table_struct *);
};

struct bpf_link_primer {
    struct bpf_link *link;
    struct file *file;
    int fd;
    u32 id;
};

struct bpf_list_head {
    __u64 __opaque[2];
};

struct bpf_list_node {
    __u64 __opaque[3];
};

struct bpf_list_node_kern {
    struct list_head list_head;
    void *owner;
};

struct bpf_local_storage_data;

struct bpf_local_storage_map;

struct bpf_local_storage {
    struct bpf_local_storage_data *cache[16];
    struct bpf_local_storage_map *smap;
    struct hlist_head list;
    void *owner;
    struct callback_head rcu;
    raw_spinlock_t lock;
};

struct bpf_local_storage_cache {
    spinlock_t idx_lock;
    u64 idx_usage_counts[16];
};

struct bpf_local_storage_data {
    struct bpf_local_storage_map *smap;
    u8 data[0];
};

struct bpf_local_storage_elem {
    struct hlist_node map_node;
    struct hlist_node snode;
    struct bpf_local_storage *local_storage;
    union {
        struct callback_head rcu;
        struct hlist_node free_node;
    };
    long: 64;
    struct bpf_local_storage_data sdata;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
};

struct bpf_local_storage_map_bucket;

struct bpf_local_storage_map {
    struct bpf_map map;
    struct bpf_local_storage_map_bucket *buckets;
    u32 bucket_log;
    u16 elem_size;
    u16 cache_idx;
    struct bpf_mem_alloc selem_ma;
    struct bpf_mem_alloc storage_ma;
    bool bpf_ma;
};

struct bpf_local_storage_map_bucket {
    struct hlist_head list;
    raw_spinlock_t lock;
};

struct bpf_lpm_trie_key_hdr {
    __u32 prefixlen;
};

struct bpf_lpm_trie_key_u8 {
    union {
        struct bpf_lpm_trie_key_hdr hdr;
        __u32 prefixlen;
    };
    __u8 data[0];
};

struct bpf_lru_locallist {
    struct list_head lists[2];
    u16 next_steal;
    raw_spinlock_t lock;
};

struct bpf_lru_node {
    struct list_head list;
    u16 cpu;
    u8 type;
    u8 ref;
};

struct bpf_lwt_prog {
    struct bpf_prog *prog;
    char *name;
};

struct bpf_lwt {
    struct bpf_lwt_prog in;
    struct bpf_lwt_prog out;
    struct bpf_lwt_prog xmit;
    int family;
};

struct bpf_offloaded_map;

struct bpf_map_dev_ops {
    int (*map_get_next_key)(struct bpf_offloaded_map *, void *, void *);
    int (*map_lookup_elem)(struct bpf_offloaded_map *, void *, void *);
    int (*map_update_elem)(struct bpf_offloaded_map *, void *, void *, u64);
    int (*map_delete_elem)(struct bpf_offloaded_map *, void *);
};

struct bpf_map_info {
    __u32 type;
    __u32 id;
    __u32 key_size;
    __u32 value_size;
    __u32 max_entries;
    __u32 map_flags;
    char name[16];
    __u32 ifindex;
    __u32 btf_vmlinux_value_type_id;
    __u64 netns_dev;
    __u64 netns_ino;
    __u32 btf_id;
    __u32 btf_key_type_id;
    __u32 btf_value_type_id;
    __u32 btf_vmlinux_id;
    __u64 map_extra;
};

typedef u64 (*bpf_callback_t)(u64, u64, u64, u64, u64);

struct bpf_prog_aux;

struct bpf_map_ops {
    int (*map_alloc_check)(union bpf_attr *);
    struct bpf_map * (*map_alloc)(union bpf_attr *);
    void (*map_release)(struct bpf_map *, struct file *);
    void (*map_free)(struct bpf_map *);
    int (*map_get_next_key)(struct bpf_map *, void *, void *);
    void (*map_release_uref)(struct bpf_map *);
    void * (*map_lookup_elem_sys_only)(struct bpf_map *, void *);
    int (*map_lookup_batch)(struct bpf_map *, const union bpf_attr *, union bpf_attr *);
    int (*map_lookup_and_delete_elem)(struct bpf_map *, void *, void *, u64);
    int (*map_lookup_and_delete_batch)(struct bpf_map *, const union bpf_attr *, union bpf_attr *);
    int (*map_update_batch)(struct bpf_map *, struct file *, const union bpf_attr *, union bpf_attr *);
    int (*map_delete_batch)(struct bpf_map *, const union bpf_attr *, union bpf_attr *);
    void * (*map_lookup_elem)(struct bpf_map *, void *);
    long int (*map_update_elem)(struct bpf_map *, void *, void *, u64);
    long int (*map_delete_elem)(struct bpf_map *, void *);
    long int (*map_push_elem)(struct bpf_map *, void *, u64);
    long int (*map_pop_elem)(struct bpf_map *, void *);
    long int (*map_peek_elem)(struct bpf_map *, void *);
    void * (*map_lookup_percpu_elem)(struct bpf_map *, void *, u32);
    void * (*map_fd_get_ptr)(struct bpf_map *, struct file *, int);
    void (*map_fd_put_ptr)(struct bpf_map *, void *, bool);
    int (*map_gen_lookup)(struct bpf_map *, struct bpf_insn *);
    u32 (*map_fd_sys_lookup_elem)(void *);
    void (*map_seq_show_elem)(struct bpf_map *, void *, struct seq_file *);
    int (*map_check_btf)(const struct bpf_map *, const struct btf *, const struct btf_type *, const struct btf_type *);
    int (*map_poke_track)(struct bpf_map *, struct bpf_prog_aux *);
    void (*map_poke_untrack)(struct bpf_map *, struct bpf_prog_aux *);
    void (*map_poke_run)(struct bpf_map *, u32, struct bpf_prog *, struct bpf_prog *);
    int (*map_direct_value_addr)(const struct bpf_map *, u64 *, u32);
    int (*map_direct_value_meta)(const struct bpf_map *, u64, u32 *);
    int (*map_mmap)(struct bpf_map *, struct vm_area_struct *);
    __poll_t (*map_poll)(struct bpf_map *, struct file *, struct poll_table_struct *);
    long unsigned int (*map_get_unmapped_area)(struct file *, long unsigned int, long unsigned int, long unsigned int, long unsigned int);
    int (*map_local_storage_charge)(struct bpf_local_storage_map *, void *, u32);
    void (*map_local_storage_uncharge)(struct bpf_local_storage_map *, void *, u32);
    struct bpf_local_storage ** (*map_owner_storage_ptr)(void *);
    long int (*map_redirect)(struct bpf_map *, u64, u64);
    bool (*map_meta_equal)(const struct bpf_map *, const struct bpf_map *);
    int (*map_set_for_each_callback_args)(struct bpf_verifier_env *, struct bpf_func_state *, struct bpf_func_state *);
    long int (*map_for_each_callback)(struct bpf_map *, bpf_callback_t, void *, u64);
    u64 (*map_mem_usage)(const struct bpf_map *);
    int *map_btf_id;
    const struct bpf_iter_seq_info *iter_seq_info;
};

struct llist_head {
    struct llist_node *first;
};

struct rcuwait {
    struct task_struct *task;
};

struct irq_work {
    struct __call_single_node node;
    void (*func)(struct irq_work *);
    struct rcuwait irqwait;
};

struct bpf_mem_cache {
    struct llist_head free_llist;
    local_t active;
    struct llist_head free_llist_extra;
    struct irq_work refill_work;
    struct obj_cgroup *objcg;
    int unit_size;
    int free_cnt;
    int low_watermark;
    int high_watermark;
    int batch;
    int percpu_size;
    bool draining;
    struct bpf_mem_cache *tgt;
    struct llist_head free_by_rcu;
    struct llist_node *free_by_rcu_tail;
    struct llist_head waiting_for_gp;
    struct llist_node *waiting_for_gp_tail;
    struct callback_head rcu;
    atomic_t call_rcu_in_progress;
    struct llist_head free_llist_extra_rcu;
    struct llist_head free_by_rcu_ttrace;
    struct llist_head waiting_for_gp_ttrace;
    struct callback_head rcu_ttrace;
    atomic_t call_rcu_ttrace_in_progress;
};

struct bpf_mem_caches {
    struct bpf_mem_cache cache[11];
};

struct bpf_mount_opts {
    kuid_t uid;
    kgid_t gid;
    umode_t mode;
    u64 delegate_cmds;
    u64 delegate_maps;
    u64 delegate_progs;
    u64 delegate_attachs;
};

struct bpf_mprog_fp {
    struct bpf_prog *prog;
};

struct bpf_mprog_bundle;

struct bpf_mprog_entry {
    struct bpf_mprog_fp fp_items[64];
    struct bpf_mprog_bundle *parent;
};

struct bpf_mprog_cp {
    struct bpf_link *link;
};

struct bpf_mprog_bundle {
    struct bpf_mprog_entry a;
    struct bpf_mprog_entry b;
    struct bpf_mprog_cp cp_items[64];
    struct bpf_prog *ref;
    atomic64_t revision;
    u32 count;
};

struct bpf_nested_pt_regs {
    struct pt_regs regs[3];
};

struct bpf_nh_params {
    u32 nh_family;
    union {
        u32 ipv4_nh;
        struct in6_addr ipv6_nh;
    };
};

struct bpf_redirect_info {
    u64 tgt_index;
    void *tgt_value;
    struct bpf_map *map;
    u32 flags;
    u32 map_id;
    enum bpf_map_type map_type;
    struct bpf_nh_params nh;
    u32 kern_flags;
};

struct bpf_net_context {
    struct bpf_redirect_info ri;
    struct list_head cpu_map_flush_list;
    struct list_head dev_map_flush_list;
    struct list_head xskmap_map_flush_list;
};

struct bpf_netns_link {
    struct bpf_link link;
    enum bpf_attach_type type;
    enum netns_bpf_attach_type netns_type;
    struct net *net;
    struct list_head node;
};

typedef unsigned int nf_hookfn(void *, struct sk_buff *, const struct nf_hook_state *);

struct nf_hook_ops {
    nf_hookfn *hook;
    struct net_device *dev;
    void *priv;
    u8 pf;
    enum nf_hook_ops_type hook_ops_type: 8;
    unsigned int hooknum;
    int priority;
};

struct nf_defrag_hook;

struct bpf_nf_link {
    struct bpf_link link;
    struct nf_hook_ops hook_ops;
    netns_tracker ns_tracker;
    struct net *net;
    u32 dead;
    const struct nf_defrag_hook *defrag_hook;
};

struct bpf_prog_offload_ops;

struct bpf_offload_dev {
    const struct bpf_prog_offload_ops *ops;
    struct list_head netdevs;
    void *priv;
};

struct bpf_offload_netdev {
    struct rhash_head l;
    struct net_device *netdev;
    struct bpf_offload_dev *offdev;
    struct list_head progs;
    struct list_head maps;
    struct list_head offdev_netdevs;
};

struct bpf_offloaded_map {
    struct bpf_map map;
    struct net_device *netdev;
    const struct bpf_map_dev_ops *dev_ops;
    void *dev_priv;
    struct list_head offloads;
};

struct bpf_perf_event_value {
    __u64 counter;
    __u64 enabled;
    __u64 running;
};

struct bpf_perf_link {
    struct bpf_link link;
    struct file *perf_file;
};

struct bpf_pidns_info {
    __u32 pid;
    __u32 tgid;
};

struct bpf_plt {
    u32 insn_ldr;
    u32 insn_br;
    u64 target;
};

struct bpf_preload_info {
    char link_name[16];
    struct bpf_link *link;
};

struct bpf_preload_ops {
    int (*preload)(struct bpf_preload_info *);
    struct module *owner;
};

struct sock_filter {
    __u16 code;
    __u8 jt;
    __u8 jf;
    __u32 k;
};

struct bpf_prog_stats;

struct sock_fprog_kern;

struct bpf_prog {
    u16 pages;
    u16 jited: 1;
    u16 jit_requested: 1;
    u16 gpl_compatible: 1;
    u16 cb_access: 1;
    u16 dst_needed: 1;
    u16 blinding_requested: 1;
    u16 blinded: 1;
    u16 is_func: 1;
    u16 kprobe_override: 1;
    u16 has_callchain_buf: 1;
    u16 enforce_expected_attach_type: 1;
    u16 call_get_stack: 1;
    u16 call_get_func_ip: 1;
    u16 tstamp_type_access: 1;
    u16 sleepable: 1;
    enum bpf_prog_type type;
    enum bpf_attach_type expected_attach_type;
    u32 len;
    u32 jited_len;
    u8 tag[8];
    struct bpf_prog_stats *stats;
    int *active;
    unsigned int (*bpf_func)(const void *, const struct bpf_insn *);
    struct bpf_prog_aux *aux;
    struct sock_fprog_kern *orig_prog;
    union {
        struct {
            struct {} __empty_insns;
            struct sock_filter insns[0];
        };
        struct {
            struct {} __empty_insnsi;
            struct bpf_insn insnsi[0];
        };
    };
};

struct bpf_trampoline;

struct bpf_prog_ops;

struct btf_mod_pair;

struct user_struct;

struct bpf_token;

struct bpf_prog_offload;

struct exception_table_entry;

struct bpf_prog_aux {
    atomic64_t refcnt;
    u32 used_map_cnt;
    u32 used_btf_cnt;
    u32 max_ctx_offset;
    u32 max_pkt_offset;
    u32 max_tp_access;
    u32 stack_depth;
    u32 id;
    u32 func_cnt;
    u32 real_func_cnt;
    u32 func_idx;
    u32 attach_btf_id;
    u32 ctx_arg_info_size;
    u32 max_rdonly_access;
    u32 max_rdwr_access;
    struct btf *attach_btf;
    const struct bpf_ctx_arg_aux *ctx_arg_info;
    void *priv_stack_ptr;
    struct mutex dst_mutex;
    struct bpf_prog *dst_prog;
    struct bpf_trampoline *dst_trampoline;
    enum bpf_prog_type saved_dst_prog_type;
    enum bpf_attach_type saved_dst_attach_type;
    bool verifier_zext;
    bool dev_bound;
    bool offload_requested;
    bool attach_btf_trace;
    bool attach_tracing_prog;
    bool func_proto_unreliable;
    bool tail_call_reachable;
    bool xdp_has_frags;
    bool exception_cb;
    bool exception_boundary;
    bool is_extended;
    bool jits_use_priv_stack;
    bool priv_stack_requested;
    bool changes_pkt_data;
    u64 prog_array_member_cnt;
    struct mutex ext_mutex;
    struct bpf_arena *arena;
    void (*recursion_detected)(struct bpf_prog *);
    const struct btf_type *attach_func_proto;
    const char *attach_func_name;
    struct bpf_prog **func;
    void *jit_data;
    struct bpf_jit_poke_descriptor *poke_tab;
    struct bpf_kfunc_desc_tab *kfunc_tab;
    struct bpf_kfunc_btf_tab *kfunc_btf_tab;
    u32 size_poke_tab;
    struct bpf_ksym ksym;
    const struct bpf_prog_ops *ops;
    struct bpf_map **used_maps;
    struct mutex used_maps_mutex;
    struct btf_mod_pair *used_btfs;
    struct bpf_prog *prog;
    struct user_struct *user;
    u64 load_time;
    u32 verified_insns;
    int cgroup_atype;
    struct bpf_map *cgroup_storage[2];
    char name[16];
    u64 (*bpf_exception_cb)(u64, u64, u64, u64, u64);
    void *security;
    struct bpf_token *token;
    struct bpf_prog_offload *offload;
    struct btf *btf;
    struct bpf_func_info *func_info;
    struct bpf_func_info_aux *func_info_aux;
    struct bpf_line_info *linfo;
    void **jited_linfo;
    u32 func_info_cnt;
    u32 nr_linfo;
    u32 linfo_idx;
    struct module *mod;
    u32 num_exentries;
    struct exception_table_entry *extable;
    union {
        struct work_struct work;
        struct callback_head rcu;
    };
};

struct bpf_prog_dummy {
    struct bpf_prog prog;
};

struct bpf_prog_info {
    __u32 type;
    __u32 id;
    __u8 tag[8];
    __u32 jited_prog_len;
    __u32 xlated_prog_len;
    __u64 jited_prog_insns;
    __u64 xlated_prog_insns;
    __u64 load_time;
    __u32 created_by_uid;
    __u32 nr_map_ids;
    __u64 map_ids;
    char name[16];
    __u32 ifindex;
    __u32 gpl_compatible: 1;
    __u64 netns_dev;
    __u64 netns_ino;
    __u32 nr_jited_ksyms;
    __u32 nr_jited_func_lens;
    __u64 jited_ksyms;
    __u64 jited_func_lens;
    __u32 btf_id;
    __u32 func_info_rec_size;
    __u64 func_info;
    __u32 nr_func_info;
    __u32 nr_line_info;
    __u64 line_info;
    __u64 jited_line_info;
    __u32 nr_jited_line_info;
    __u32 line_info_rec_size;
    __u32 jited_line_info_rec_size;
    __u32 nr_prog_tags;
    __u64 prog_tags;
    __u64 run_time_ns;
    __u64 run_cnt;
    __u64 recursion_misses;
    __u32 verified_insns;
    __u32 attach_btf_obj_id;
    __u32 attach_btf_id;
};

struct bpf_prog_kstats {
    u64 nsecs;
    u64 cnt;
    u64 misses;
};

struct bpf_prog_list {
    struct hlist_node node;
    struct bpf_prog *prog;
    struct bpf_cgroup_link *link;
    struct bpf_cgroup_storage *storage[2];
};

struct bpf_prog_offload {
    struct bpf_prog *prog;
    struct net_device *netdev;
    struct bpf_offload_dev *offdev;
    void *dev_priv;
    struct list_head offloads;
    bool dev_state;
    bool opt_failed;
    void *jited_image;
    u32 jited_len;
};

struct bpf_prog_offload_ops {
    int (*insn_hook)(struct bpf_verifier_env *, int, int);
    int (*finalize)(struct bpf_verifier_env *);
    int (*replace_insn)(struct bpf_verifier_env *, u32, struct bpf_insn *);
    int (*remove_insns)(struct bpf_verifier_env *, u32, u32);
    int (*prepare)(struct bpf_prog *);
    int (*translate)(struct bpf_prog *);
    void (*destroy)(struct bpf_prog *);
};

struct bpf_prog_ops {
    int (*test_run)(struct bpf_prog *, const union bpf_attr *, union bpf_attr *);
};

struct bpf_prog_pack {
    struct list_head list;
    void *ptr;
    long unsigned int bitmap[0];
};

struct bpf_prog_stats {
    u64_stats_t cnt;
    u64_stats_t nsecs;
    u64_stats_t misses;
    struct u64_stats_sync syncp;
    long: 64;
};

struct bpf_queue_stack {
    struct bpf_map map;
    raw_spinlock_t lock;
    u32 head;
    u32 tail;
    u32 size;
    char elements[0];
};

struct bpf_raw_event_map {
    struct tracepoint *tp;
    void *bpf_func;
    u32 num_args;
    u32 writable_size;
    long: 64;
};

struct bpf_raw_tp_link {
    struct bpf_link link;
    struct bpf_raw_event_map *btp;
    u64 cookie;
};

struct bpf_raw_tp_null_args {
    const char *func;
    u64 mask;
};

struct bpf_raw_tp_regs {
    struct pt_regs regs[3];
};

struct bpf_raw_tp_test_run_info {
    struct bpf_prog *prog;
    void *ctx;
    u32 retval;
};

struct bpf_rb_node {
    __u64 __opaque[4];
};

struct bpf_rb_node_kern {
    struct rb_node rb_node;
    void *owner;
};

struct bpf_rb_root {
    __u64 __opaque[2];
};

struct bpf_redir_neigh {
    __u32 nh_family;
    union {
        __be32 ipv4_nh;
        __u32 ipv6_nh[4];
    };
};

struct bpf_refcount {
    __u32 __opaque[1];
};

struct bpf_reference_state {
    enum ref_state_type type;
    int id;
    int insn_idx;
    void *ptr;
};

struct bpf_reg_types {
    const enum bpf_reg_type types[10];
    u32 *btf_id;
};

struct bpf_ringbuf {
    wait_queue_head_t waitq;
    struct irq_work work;
    u64 mask;
    struct page **pages;
    int nr_pages;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    raw_spinlock_t spinlock;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    atomic_t busy;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long unsigned int consumer_pos;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long unsigned int producer_pos;
    long unsigned int pending_pos;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    char data[0];
};

struct bpf_ringbuf_hdr {
    u32 len;
    u32 pg_off;
};

struct bpf_ringbuf_map {
    struct bpf_map map;
    struct bpf_ringbuf *rb;
};

struct bpf_sanitize_info {
    struct bpf_insn_aux_data aux;
    bool mask_to_left;
};

struct bpf_security_struct {
    u32 sid;
};

struct sk_psock_progs {
    struct bpf_prog *msg_parser;
    struct bpf_prog *stream_parser;
    struct bpf_prog *stream_verdict;
    struct bpf_prog *skb_verdict;
    struct bpf_link *msg_parser_link;
    struct bpf_link *stream_parser_link;
    struct bpf_link *stream_verdict_link;
    struct bpf_link *skb_verdict_link;
};

struct bpf_shtab_bucket;

struct bpf_shtab {
    struct bpf_map map;
    struct bpf_shtab_bucket *buckets;
    u32 buckets_num;
    u32 elem_size;
    struct sk_psock_progs progs;
    atomic_t count;
};

struct bpf_shtab_bucket {
    struct hlist_head head;
    spinlock_t lock;
};

struct bpf_shtab_elem {
    struct callback_head rcu;
    u32 hash;
    struct sock *sk;
    struct hlist_node node;
    u8 key[0];
};

struct bpf_sk_storage_diag {
    u32 nr_maps;
    struct bpf_map *maps[0];
};

struct qdisc_skb_cb {
    struct {
        unsigned int pkt_len;
        u16 slave_dev_queue_mapping;
        u16 tc_classid;
    };
    unsigned char data[20];
};

struct bpf_skb_data_end {
    struct qdisc_skb_cb qdisc_cb;
    void *data_meta;
    void *data_end;
};

struct bpf_sock_tuple {
    union {
        struct {
            __be32 saddr;
            __be32 daddr;
            __be16 sport;
            __be16 dport;
        } ipv4;
        struct {
            __be32 saddr[4];
            __be32 daddr[4];
            __be16 sport;
            __be16 dport;
        } ipv6;
    };
};

struct bpf_sockopt_buf {
    u8 data[32];
};

struct bpf_stab {
    struct bpf_map map;
    struct sock **sks;
    struct sk_psock_progs progs;
    spinlock_t lock;
};

struct bpf_stack_build_id {
    __s32 status;
    unsigned char build_id[20];
    union {
        __u64 offset;
        __u64 ip;
    };
};

struct stack_map_bucket;

struct bpf_stack_map {
    struct bpf_map map;
    void *elems;
    struct pcpu_freelist freelist;
    u32 n_buckets;
    struct stack_map_bucket *buckets[0];
};

struct bpf_stack_state {
    struct bpf_reg_state spilled_ptr;
    u8 slot_type[8];
};

struct bpf_storage_buffer {
    struct callback_head rcu;
    char data[0];
};

struct bpf_verifier_ops;

struct btf_member;

struct bpf_struct_ops {
    const struct bpf_verifier_ops *verifier_ops;
    int (*init)(struct btf *);
    int (*check_member)(const struct btf_type *, const struct btf_member *, const struct bpf_prog *);
    int (*init_member)(const struct btf_type *, const struct btf_member *, void *, const void *);
    int (*reg)(void *, struct bpf_link *);
    void (*unreg)(void *, struct bpf_link *);
    int (*update)(void *, void *, struct bpf_link *);
    int (*validate)(void *);
    void *cfi_stubs;
    struct module *owner;
    const char *name;
    struct btf_func_model func_models[64];
};

struct bpf_struct_ops_arg_info {
    struct bpf_ctx_arg_aux *info;
    u32 cnt;
};

struct bpf_struct_ops_common_value {
    refcount_t refcnt;
    enum bpf_struct_ops_state state;
};

struct bpf_struct_ops_bpf_dummy_ops {
    struct bpf_struct_ops_common_value common;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    struct bpf_dummy_ops data;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
};

struct bpf_struct_ops_desc {
    struct bpf_struct_ops *st_ops;
    const struct btf_type *type;
    const struct btf_type *value_type;
    u32 type_id;
    u32 value_id;
    struct bpf_struct_ops_arg_info *arg_info;
};

struct bpf_struct_ops_link {
    struct bpf_link link;
    struct bpf_map *map;
    wait_queue_head_t wait_hup;
};

struct bpf_struct_ops_value {
    struct bpf_struct_ops_common_value common;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    char data[0];
};

struct bpf_struct_ops_map {
    struct bpf_map map;
    const struct bpf_struct_ops_desc *st_ops_desc;
    struct mutex lock;
    struct bpf_link **links;
    struct bpf_ksym **ksyms;
    u32 funcs_cnt;
    u32 image_pages_cnt;
    void *image_pages[8];
    struct btf *btf;
    struct bpf_struct_ops_value *uvalue;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    struct bpf_struct_ops_value kvalue;
};

struct scx_cpu_acquire_args;

struct scx_cpu_release_args;

struct scx_init_task_args;

struct scx_exit_task_args;

struct scx_dump_ctx;

struct scx_cgroup_init_args;

struct scx_exit_info;

struct sched_ext_ops {
    s32 (*select_cpu)(struct task_struct *, s32, u64);
    void (*enqueue)(struct task_struct *, u64);
    void (*dequeue)(struct task_struct *, u64);
    void (*dispatch)(s32, struct task_struct *);
    void (*tick)(struct task_struct *);
    void (*runnable)(struct task_struct *, u64);
    void (*running)(struct task_struct *);
    void (*stopping)(struct task_struct *, bool);
    void (*quiescent)(struct task_struct *, u64);
    bool (*yield)(struct task_struct *, struct task_struct *);
    bool (*core_sched_before)(struct task_struct *, struct task_struct *);
    void (*set_weight)(struct task_struct *, u32);
    void (*set_cpumask)(struct task_struct *, const struct cpumask *);
    void (*update_idle)(s32, bool);
    void (*cpu_acquire)(s32, struct scx_cpu_acquire_args *);
    void (*cpu_release)(s32, struct scx_cpu_release_args *);
    s32 (*init_task)(struct task_struct *, struct scx_init_task_args *);
    void (*exit_task)(struct task_struct *, struct scx_exit_task_args *);
    void (*enable)(struct task_struct *);
    void (*disable)(struct task_struct *);
    void (*dump)(struct scx_dump_ctx *);
    void (*dump_cpu)(struct scx_dump_ctx *, s32, bool);
    void (*dump_task)(struct scx_dump_ctx *, struct task_struct *);
    s32 (*cgroup_init)(struct cgroup *, struct scx_cgroup_init_args *);
    void (*cgroup_exit)(struct cgroup *);
    s32 (*cgroup_prep_move)(struct task_struct *, struct cgroup *, struct cgroup *);
    void (*cgroup_move)(struct task_struct *, struct cgroup *, struct cgroup *);
    void (*cgroup_cancel_move)(struct task_struct *, struct cgroup *, struct cgroup *);
    void (*cgroup_set_weight)(struct cgroup *, u32);
    void (*cpu_online)(s32);
    void (*cpu_offline)(s32);
    s32 (*init)(void);
    void (*exit)(struct scx_exit_info *);
    u32 dispatch_max_batch;
    u64 flags;
    u32 timeout_ms;
    u32 exit_dump_len;
    u64 hotplug_seq;
    char name[128];
};

struct bpf_struct_ops_sched_ext_ops {
    struct bpf_struct_ops_common_value common;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    struct sched_ext_ops data;
    long: 64;
    long: 64;
    long: 64;
};

struct rate_sample;

union tcp_cc_info;

struct tcp_congestion_ops {
    u32 (*ssthresh)(struct sock *);
    void (*cong_avoid)(struct sock *, u32, u32);
    void (*set_state)(struct sock *, u8);
    void (*cwnd_event)(struct sock *, enum tcp_ca_event);
    void (*in_ack_event)(struct sock *, u32);
    void (*pkts_acked)(struct sock *, const struct ack_sample *);
    u32 (*min_tso_segs)(struct sock *);
    void (*cong_control)(struct sock *, u32, int, const struct rate_sample *);
    u32 (*undo_cwnd)(struct sock *);
    u32 (*sndbuf_expand)(struct sock *);
    size_t (*get_info)(struct sock *, u32, int *, union tcp_cc_info *);
    char name[16];
    struct module *owner;
    struct list_head list;
    u32 key;
    u32 flags;
    void (*init)(struct sock *);
    void (*release)(struct sock *);
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
};

struct bpf_struct_ops_tcp_congestion_ops {
    struct bpf_struct_ops_common_value common;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    struct tcp_congestion_ops data;
};

struct bpf_subprog_arg_info {
    enum bpf_arg_type arg_type;
    union {
        u32 mem_size;
        u32 btf_id;
    };
};

struct bpf_subprog_info {
    u32 start;
    u32 linfo_idx;
    u16 stack_depth;
    u16 stack_extra;
    s16 fastcall_stack_off;
    bool has_tail_call: 1;
    bool tail_call_reachable: 1;
    bool has_ld_abs: 1;
    bool is_cb: 1;
    bool is_async_cb: 1;
    bool is_exception_cb: 1;
    bool args_cached: 1;
    bool keep_fastcall_stack: 1;
    bool changes_pkt_data: 1;
    enum priv_stack_mode priv_stack_mode;
    u8 arg_cnt;
    struct bpf_subprog_arg_info args[5];
};

struct tcp_iter_state {
    struct seq_net_private p;
    enum tcp_seq_states state;
    struct sock *syn_wait_sk;
    int bucket;
    int offset;
    int sbucket;
    int num;
    loff_t last_pos;
};

struct bpf_tcp_iter_state {
    struct tcp_iter_state state;
    unsigned int cur_sk;
    unsigned int end_sk;
    unsigned int max_sk;
    struct sock **batch;
    bool st_bucket_done;
};

struct bpf_tcp_req_attrs {
    u32 rcv_tsval;
    u32 rcv_tsecr;
    u16 mss;
    u8 rcv_wscale;
    u8 snd_wscale;
    u8 ecn_ok;
    u8 wscale_ok;
    u8 sack_ok;
    u8 tstamp_ok;
    u8 usec_ts_ok;
    u8 reserved[3];
};

struct bpf_tcp_sock {
    __u32 snd_cwnd;
    __u32 srtt_us;
    __u32 rtt_min;
    __u32 snd_ssthresh;
    __u32 rcv_nxt;
    __u32 snd_nxt;
    __u32 snd_una;
    __u32 mss_cache;
    __u32 ecn_flags;
    __u32 rate_delivered;
    __u32 rate_interval_us;
    __u32 packets_out;
    __u32 retrans_out;
    __u32 total_retrans;
    __u32 segs_in;
    __u32 data_segs_in;
    __u32 segs_out;
    __u32 data_segs_out;
    __u32 lost_out;
    __u32 sacked_out;
    __u64 bytes_received;
    __u64 bytes_acked;
    __u32 dsack_dups;
    __u32 delivered;
    __u32 delivered_ce;
    __u32 icsk_retransmits;
};

struct bpf_test_timer {
    enum {
        NO_PREEMPT = 0,
        NO_MIGRATE = 1,
    } mode;
    u32 i;
    u64 time_start;
    u64 time_spent;
};

struct bpf_throw_ctx {
    struct bpf_prog_aux *aux;
    u64 sp;
    u64 bp;
    int cnt;
};

struct bpf_timer {
    __u64 __opaque[2];
};

struct user_namespace;

struct bpf_token {
    struct work_struct work;
    atomic64_t refcnt;
    struct user_namespace *userns;
    u64 allowed_cmds;
    u64 allowed_maps;
    u64 allowed_progs;
    u64 allowed_attachs;
    void *security;
};

struct bpf_trace_module {
    struct module *module;
    struct list_head list;
};

struct bpf_trace_run_ctx {
    struct bpf_run_ctx run_ctx;
    u64 bpf_cookie;
    bool is_uprobe;
};

union perf_sample_weight {
    __u64 full;
    struct {
        __u32 var1_dw;
        __u16 var2_w;
        __u16 var3_w;
    };
};

union perf_mem_data_src {
    __u64 val;
    struct {
        __u64 mem_op: 5;
        __u64 mem_lvl: 14;
        __u64 mem_snoop: 5;
        __u64 mem_lock: 2;
        __u64 mem_dtlb: 7;
        __u64 mem_lvl_num: 4;
        __u64 mem_remote: 1;
        __u64 mem_snoopx: 2;
        __u64 mem_blk: 3;
        __u64 mem_hops: 3;
        __u64 mem_rsvd: 18;
    };
};

struct perf_regs {
    __u64 abi;
    struct pt_regs *regs;
};

struct perf_callchain_entry;

struct perf_raw_record;

struct perf_branch_stack;

struct perf_sample_data {
    u64 sample_flags;
    u64 period;
    u64 dyn_size;
    u64 type;
    struct {
        u32 pid;
        u32 tid;
    } tid_entry;
    u64 time;
    u64 id;
    struct {
        u32 cpu;
        u32 reserved;
    } cpu_entry;
    u64 ip;
    struct perf_callchain_entry *callchain;
    struct perf_raw_record *raw;
    struct perf_branch_stack *br_stack;
    u64 *br_stack_cntr;
    union perf_sample_weight weight;
    union perf_mem_data_src data_src;
    u64 txn;
    struct perf_regs regs_user;
    struct perf_regs regs_intr;
    u64 stack_user_size;
    u64 stream_id;
    u64 cgroup;
    u64 addr;
    u64 phys_addr;
    u64 data_page_size;
    u64 code_page_size;
    u64 aux_size;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
};

struct bpf_trace_sample_data {
    struct perf_sample_data sds[3];
};

struct bpf_tramp_link {
    struct bpf_link link;
    struct hlist_node tramp_hlist;
    u64 cookie;
};

struct bpf_tracing_link {
    struct bpf_tramp_link link;
    enum bpf_attach_type attach_type;
    struct bpf_trampoline *trampoline;
    struct bpf_prog *tgt_prog;
};

struct bpf_tramp_image {
    void *image;
    int size;
    struct bpf_ksym ksym;
    struct percpu_ref pcref;
    void *ip_after_call;
    void *ip_epilogue;
    union {
        struct callback_head rcu;
        struct work_struct work;
    };
};

struct bpf_tramp_links {
    struct bpf_tramp_link *links[38];
    int nr_links;
};

struct bpf_tramp_run_ctx {
    struct bpf_run_ctx run_ctx;
    u64 bpf_cookie;
    struct bpf_run_ctx *saved_run_ctx;
};

struct ftrace_ops;

struct bpf_trampoline {
    struct hlist_node hlist;
    struct ftrace_ops *fops;
    struct mutex mutex;
    refcount_t refcnt;
    u32 flags;
    u64 key;
    struct {
        struct btf_func_model model;
        void *addr;
        bool ftrace_managed;
    } func;
    struct bpf_prog *extension_prog;
    struct hlist_head progs_hlist[3];
    int progs_cnt[3];
    struct bpf_tramp_image *cur_image;
};

struct bpf_tunnel_key {
    __u32 tunnel_id;
    union {
        __u32 remote_ipv4;
        __u32 remote_ipv6[4];
    };
    __u8 tunnel_tos;
    __u8 tunnel_ttl;
    union {
        __u16 tunnel_ext;
        __be16 tunnel_flags;
    };
    __u32 tunnel_label;
    union {
        __u32 local_ipv4;
        __u32 local_ipv6[4];
    };
};

struct bpf_tuple {
    struct bpf_prog *prog;
    struct bpf_link *link;
};

struct udp_iter_state {
    struct seq_net_private p;
    int bucket;
};

struct bpf_udp_iter_state {
    struct udp_iter_state state;
    unsigned int cur_sk;
    unsigned int end_sk;
    unsigned int max_sk;
    int offset;
    struct sock **batch;
    bool st_bucket_done;
};

struct bpf_unix_iter_state {
    struct seq_net_private p;
    unsigned int cur_sk;
    unsigned int end_sk;
    unsigned int max_sk;
    struct sock **batch;
    bool st_bucket_done;
};

struct bpf_unwind_consume_entry_data {
    bool (*consume_entry)(void *, u64, u64, u64);
    void *cookie;
};

struct uprobe_consumer {
    int (*handler)(struct uprobe_consumer *, struct pt_regs *, __u64 *);
    int (*ret_handler)(struct uprobe_consumer *, long unsigned int, struct pt_regs *, __u64 *);
    bool (*filter)(struct uprobe_consumer *, struct mm_struct *);
    struct list_head cons_node;
    __u64 id;
};

struct bpf_uprobe_multi_link;

struct uprobe;

struct bpf_uprobe {
    struct bpf_uprobe_multi_link *link;
    loff_t offset;
    long unsigned int ref_ctr_offset;
    u64 cookie;
    struct uprobe *uprobe;
    struct uprobe_consumer consumer;
    bool session;
};

struct bpf_uprobe_multi_link {
    struct path path;
    struct bpf_link link;
    u32 cnt;
    u32 flags;
    struct bpf_uprobe *uprobes;
    struct task_struct *task;
};

struct bpf_uprobe_multi_run_ctx {
    struct bpf_session_run_ctx session_ctx;
    long unsigned int entry_ip;
    struct bpf_uprobe *uprobe;
};

struct btf_mod_pair {
    struct btf *btf;
    struct module *module;
};

struct bpf_verifier_log {
    u64 start_pos;
    u64 end_pos;
    char *ubuf;
    u32 level;
    u32 len_total;
    u32 len_max;
    char kbuf[1024];
};

struct bpf_verifier_stack_elem;

struct bpf_verifier_state;

struct bpf_verifier_state_list;

struct bpf_verifier_env {
    u32 insn_idx;
    u32 prev_insn_idx;
    struct bpf_prog *prog;
    const struct bpf_verifier_ops *ops;
    struct module *attach_btf_mod;
    struct bpf_verifier_stack_elem *head;
    int stack_size;
    bool strict_alignment;
    bool test_state_freq;
    bool test_reg_invariants;
    struct bpf_verifier_state *cur_state;
    struct bpf_verifier_state_list **explored_states;
    struct bpf_verifier_state_list *free_list;
    struct bpf_map *used_maps[64];
    struct btf_mod_pair used_btfs[64];
    u32 used_map_cnt;
    u32 used_btf_cnt;
    u32 id_gen;
    u32 hidden_subprog_cnt;
    int exception_callback_subprog;
    bool explore_alu_limits;
    bool allow_ptr_leaks;
    bool allow_uninit_stack;
    bool bpf_capable;
    bool bypass_spec_v1;
    bool bypass_spec_v4;
    bool seen_direct_write;
    bool seen_exception;
    struct bpf_insn_aux_data *insn_aux_data;
    const struct bpf_line_info *prev_linfo;
    struct bpf_verifier_log log;
    struct bpf_subprog_info subprog_info[258];
    union {
        struct bpf_idmap idmap_scratch;
        struct bpf_idset idset_scratch;
    };
    struct {
        int *insn_state;
        int *insn_stack;
        int cur_stack;
    } cfg;
    struct backtrack_state bt;
    struct bpf_insn_hist_entry *insn_hist;
    struct bpf_insn_hist_entry *cur_hist_ent;
    u32 insn_hist_cap;
    u32 pass_cnt;
    u32 subprog_cnt;
    u32 prev_insn_processed;
    u32 insn_processed;
    u32 prev_jmps_processed;
    u32 jmps_processed;
    u64 verification_time;
    u32 max_states_per_insn;
    u32 total_states;
    u32 peak_states;
    u32 longest_mark_read_walk;
    bpfptr_t fd_array;
    u32 scratched_regs;
    u64 scratched_stack_slots;
    u64 prev_log_pos;
    u64 prev_insn_print_pos;
    struct bpf_reg_state fake_reg[2];
    char tmp_str_buf[320];
    struct bpf_insn insn_buf[32];
    struct bpf_insn epilogue_buf[32];
};

struct bpf_verifier_ops {
    const struct bpf_func_proto * (*get_func_proto)(enum bpf_func_id, const struct bpf_prog *);
    bool (*is_valid_access)(int, int, enum bpf_access_type, const struct bpf_prog *, struct bpf_insn_access_aux *);
    int (*gen_prologue)(struct bpf_insn *, bool, const struct bpf_prog *);
    int (*gen_epilogue)(struct bpf_insn *, const struct bpf_prog *, s16);
    int (*gen_ld_abs)(const struct bpf_insn *, struct bpf_insn *);
    u32 (*convert_ctx_access)(enum bpf_access_type, const struct bpf_insn *, struct bpf_insn *, struct bpf_prog *, u32 *);
    int (*btf_struct_access)(struct bpf_verifier_log *, const struct bpf_reg_state *, int, int);
};

struct bpf_verifier_state {
    struct bpf_func_state *frame[8];
    struct bpf_verifier_state *parent;
    struct bpf_reference_state *refs;
    u32 branches;
    u32 insn_idx;
    u32 curframe;
    u32 acquired_refs;
    u32 active_locks;
    u32 active_preempt_locks;
    u32 active_irq_id;
    bool active_rcu_lock;
    bool speculative;
    bool used_as_loop_entry;
    bool in_sleepable;
    u32 first_insn_idx;
    u32 last_insn_idx;
    struct bpf_verifier_state *loop_entry;
    u32 insn_hist_start;
    u32 insn_hist_end;
    u32 dfs_depth;
    u32 callback_unroll_depth;
    u32 may_goto_depth;
};

struct bpf_verifier_stack_elem {
    struct bpf_verifier_state st;
    int insn_idx;
    int prev_insn_idx;
    struct bpf_verifier_stack_elem *next;
    u32 log_pos;
};

struct bpf_verifier_state_list {
    struct bpf_verifier_state state;
    struct bpf_verifier_state_list *next;
    int miss_cnt;
    int hit_cnt;
};

struct bpf_work {
    struct bpf_async_cb cb;
    struct work_struct work;
    struct work_struct delete_work;
};

struct bpf_wq {
    __u64 __opaque[2];
};

struct bpf_xdp_link;

struct bpf_xdp_entity {
    struct bpf_prog *prog;
    struct bpf_xdp_link *link;
};

struct bpf_xdp_link {
    struct bpf_link link;
    struct net_device *dev;
    int flags;
};

struct bpf_xdp_sock {
    __u32 queue_id;
};

struct bpf_xfrm_state {
    __u32 reqid;
    __u32 spi;
    __u16 family;
    __u16 ext;
    union {
        __u32 remote_ipv4;
        __u32 remote_ipv6[4];
    };
};

struct bpf_xfrm_state_opts {
    s32 error;
    s32 netns_id;
    u32 mark;
    xfrm_address_t daddr;
    __be32 spi;
    u8 proto;
    u16 family;
};

struct bpffs_btf_enums {
    const struct btf *btf;
    const struct btf_type *cmd_t;
    const struct btf_type *map_t;
    const struct btf_type *prog_t;
    const struct btf_type *attach_t;
};

struct trace_entry {
    short unsigned int type;
    unsigned char flags;
    unsigned char preempt_count;
    int pid;
};

struct bprint_entry {
    struct trace_entry ent;
    long unsigned int ip;
    const char *fmt;
    u32 buf[0];
};

struct bputs_entry {
    struct trace_entry ent;
    long unsigned int ip;
    const char *str;
};

struct br_input_skb_cb {
    struct net_device *brdev;
    u16 frag_max_size;
    u8 igmp;
    u8 mrouters_only: 1;
    u8 proxyarp_replied: 1;
    u8 src_port_isolated: 1;
    u8 promisc: 1;
    u8 vlan_filtered: 1;
    u8 br_netfilter_broute: 1;
    u8 tx_fwd_offload: 1;
    int src_hwdom;
    long unsigned int fwd_hwdoms;
    u32 backup_nhid;
};

struct br_ip {
    union {
        __be32 ip4;
        struct in6_addr ip6;
    } src;
    union {
        __be32 ip4;
        struct in6_addr ip6;
        unsigned char mac_addr[6];
    } dst;
    __be16 proto;
    __u16 vid;
};

struct br_mcast_stats {
    __u64 igmp_v1queries[2];
    __u64 igmp_v2queries[2];
    __u64 igmp_v3queries[2];
    __u64 igmp_leaves[2];
    __u64 igmp_v1reports[2];
    __u64 igmp_v2reports[2];
    __u64 igmp_v3reports[2];
    __u64 igmp_parse_errors;
    __u64 mld_v1queries[2];
    __u64 mld_v2queries[2];
    __u64 mld_leaves[2];
    __u64 mld_v1reports[2];
    __u64 mld_v2reports[2];
    __u64 mld_parse_errors;
    __u64 mcast_bytes[2];
    __u64 mcast_packets[2];
};

struct br_mdb_entry {
    __u32 ifindex;
    __u8 state;
    __u8 flags;
    __u16 vid;
    struct {
        union {
            __be32 ip4;
            struct in6_addr ip6;
            unsigned char mac_addr[6];
        } u;
        __be16 proto;
    } addr;
};

struct br_port_msg {
    __u8 family;
    __u32 ifindex;
};

struct metadata_dst;

struct br_tunnel_info {
    __be64 tunnel_id;
    struct metadata_dst *tunnel_dst;
};

struct brcm_msi {
    struct device *dev;
    void *base;
    struct device_node *np;
    struct irq_domain *msi_domain;
    struct irq_domain *inner_domain;
    struct mutex lock;
    u64 target_addr;
    int irq;
    long unsigned int used[1];
    bool legacy;
    int legacy_shift;
    int nr;
    void *intr_base;
};

struct subdev_regulators;

struct pcie_cfg_data;

struct brcm_pcie {
    struct device *dev;
    void *base;
    struct clk *clk;
    struct device_node *np;
    bool ssc;
    int gen;
    u64 msi_target_addr;
    struct brcm_msi *msi;
    struct reset_control *rescal;
    struct reset_control *perst_reset;
    struct reset_control *bridge_reset;
    struct reset_control *swinit_reset;
    int num_memc;
    u64 memc_size[3];
    u32 hw_rev;
    struct subdev_regulators *sr;
    bool ep_wakeup_capable;
    const struct pcie_cfg_data *cfg;
};

struct brcmstb_intc_init_params {
    irq_flow_handler_t handler;
    int cpu_status;
    int cpu_clear;
    int cpu_mask_status;
    int cpu_mask_set;
    int cpu_mask_clear;
};

struct irq_chip_generic;

struct brcmstb_l2_intc_data {
    struct irq_domain *domain;
    struct irq_chip_generic *gc;
    int status_offset;
    int mask_offset;
    bool can_wake;
    u32 saved_mask;
};

struct brcmvirt_gpio {
    struct gpio_chip gc;
    u32 *ts_base;
    u32 enables_disables[2];
    dma_addr_t bus_addr;
};

struct break_hook {
    struct list_head node;
    int (*fn)(struct pt_regs *, long unsigned int);
    u16 imm;
    u16 mask;
};

struct bridge_id {
    unsigned char prio[2];
    unsigned char addr[6];
};

typedef struct bridge_id bridge_id;

struct bridge_mcast_other_query {
    struct timer_list timer;
    struct timer_list delay_timer;
};

struct bridge_mcast_own_query {
    struct timer_list timer;
    u32 startup_sent;
};

struct bridge_mcast_querier {
    struct br_ip addr;
    int port_ifidx;
    seqcount_spinlock_t seq;
};

struct bridge_mcast_stats {
    struct br_mcast_stats mstats;
    struct u64_stats_sync syncp;
};

struct bridge_stp_xstats {
    __u64 transition_blk;
    __u64 transition_fwd;
    __u64 rx_bpdu;
    __u64 tx_bpdu;
    __u64 rx_tcn;
    __u64 tx_tcn;
};

struct broadcast_sk {
    struct sock *sk;
    struct work_struct work;
};

struct broken_edid {
    u8 manufacturer[4];
    u32 model;
    u32 fix;
};

struct fs_pin {
    wait_queue_head_t wait;
    int done;
    struct hlist_node s_list;
    struct hlist_node m_list;
    void (*kill)(struct fs_pin *);
};

struct bsd_acct_struct {
    struct fs_pin pin;
    atomic_long_t count;
    struct callback_head rcu;
    struct mutex lock;
    bool active;
    bool check_space;
    long unsigned int needcheck;
    struct file *file;
    struct pid_namespace *ns;
    struct work_struct work;
    struct completion done;
    acct_t ac;
};

struct bsd_partition {
    __le32 p_size;
    __le32 p_offset;
    __le32 p_fsize;
    __u8 p_fstype;
    __u8 p_frag;
    __le16 p_cpg;
};

struct bsd_disklabel {
    __le32 d_magic;
    __s16 d_type;
    __s16 d_subtype;
    char d_typename[16];
    char d_packname[16];
    __u32 d_secsize;
    __u32 d_nsectors;
    __u32 d_ntracks;
    __u32 d_ncylinders;
    __u32 d_secpercyl;
    __u32 d_secperunit;
    __u16 d_sparespertrack;
    __u16 d_sparespercyl;
    __u32 d_acylinders;
    __u16 d_rpm;
    __u16 d_interleave;
    __u16 d_trackskew;
    __u16 d_cylskew;
    __u32 d_headswitch;
    __u32 d_trkseek;
    __u32 d_flags;
    __u32 d_drivedata[5];
    __u32 d_spare[5];
    __le32 d_magic2;
    __le16 d_checksum;
    __le16 d_npartitions;
    __le32 d_bbsize;
    __le32 d_sbsize;
    struct bsd_partition d_partitions[16];
};

struct bsg_buffer {
    unsigned int payload_len;
    int sg_cnt;
    struct scatterlist *sg_list;
};

struct cdev {
    struct kobject kobj;
    struct module *owner;
    const struct file_operations *ops;
    struct list_head list;
    dev_t dev;
    unsigned int count;
};

struct sg_io_v4;

typedef int bsg_sg_io_fn(struct request_queue *, struct sg_io_v4 *, bool, unsigned int);

struct bsg_device {
    struct request_queue *queue;
    struct device device;
    struct cdev cdev;
    int max_queue;
    unsigned int timeout;
    unsigned int reserved_size;
    bsg_sg_io_fn *sg_io_fn;
};

struct bsg_job {
    struct device *dev;
    struct kref kref;
    unsigned int timeout;
    void *request;
    void *reply;
    unsigned int request_len;
    unsigned int reply_len;
    struct bsg_buffer request_payload;
    struct bsg_buffer reply_payload;
    int result;
    unsigned int reply_payload_rcv_len;
    struct request *bidi_rq;
    struct bio *bidi_bio;
    void *dd_data;
};

typedef int bsg_job_fn(struct bsg_job *);

typedef enum blk_eh_timer_return bsg_timeout_fn(struct request *);

struct bsg_set {
    struct blk_mq_tag_set tag_set;
    struct bsg_device *bd;
    bsg_job_fn *job_fn;
    bsg_timeout_fn *timeout_fn;
};

typedef bool busy_tag_iter_fn(struct request *, void *);

struct bt_iter_data {
    struct blk_mq_hw_ctx *hctx;
    struct request_queue *q;
    busy_tag_iter_fn *fn;
    void *data;
    bool reserved;
};

struct bt_tags_iter_data {
    struct blk_mq_tags *tags;
    busy_tag_iter_fn *fn;
    void *data;
    unsigned int flags;
};

struct btf_header {
    __u16 magic;
    __u8 version;
    __u8 flags;
    __u32 hdr_len;
    __u32 type_off;
    __u32 type_len;
    __u32 str_off;
    __u32 str_len;
};

struct btf_kfunc_set_tab;

struct btf_id_dtor_kfunc_tab;

struct btf_struct_metas;

struct btf_struct_ops_tab;

struct btf {
    void *data;
    struct btf_type **types;
    u32 *resolved_ids;
    u32 *resolved_sizes;
    const char *strings;
    void *nohdr_data;
    struct btf_header hdr;
    u32 nr_types;
    u32 types_size;
    u32 data_size;
    refcount_t refcnt;
    u32 id;
    struct callback_head rcu;
    struct btf_kfunc_set_tab *kfunc_set_tab;
    struct btf_id_dtor_kfunc_tab *dtor_kfunc_tab;
    struct btf_struct_metas *struct_meta_tab;
    struct btf_struct_ops_tab *struct_ops_tab;
    struct btf *base_btf;
    u32 start_id;
    u32 start_str_off;
    char name[56];
    bool kernel_btf;
    __u32 *base_id_map;
};

struct btf_anon_stack {
    u32 tid;
    u32 offset;
};

struct btf_array {
    __u32 type;
    __u32 index_type;
    __u32 nelems;
};

struct btf_decl_tag {
    __s32 component_idx;
};

struct btf_enum {
    __u32 name_off;
    __s32 val;
};

struct btf_enum64 {
    __u32 name_off;
    __u32 val_lo32;
    __u32 val_hi32;
};

typedef void (*btf_dtor_kfunc_t)(void *);

struct btf_field_kptr {
    struct btf *btf;
    struct module *module;
    btf_dtor_kfunc_t dtor;
    u32 btf_id;
};

struct btf_field_graph_root {
    struct btf *btf;
    u32 value_btf_id;
    u32 node_offset;
    struct btf_record *value_rec;
};

struct btf_field {
    u32 offset;
    u32 size;
    enum btf_field_type type;
    union {
        struct btf_field_kptr kptr;
        struct btf_field_graph_root graph_root;
    };
};

struct btf_field_desc {
    int t_off_cnt;
    int t_offs[2];
    int m_sz;
    int m_off_cnt;
    int m_offs[1];
};

struct btf_field_info {
    enum btf_field_type type;
    u32 off;
    union {
        struct {
            u32 type_id;
        } kptr;
        struct {
            const char *node_name;
            u32 value_btf_id;
        } graph_root;
    };
};

struct btf_field_iter {
    struct btf_field_desc desc;
    void *p;
    int m_idx;
    int off_idx;
    int vlen;
};

struct btf_id_dtor_kfunc {
    u32 btf_id;
    u32 kfunc_btf_id;
};

struct btf_id_dtor_kfunc_tab {
    u32 cnt;
    struct btf_id_dtor_kfunc dtors[0];
};

struct btf_id_set {
    u32 cnt;
    u32 ids[0];
};

struct btf_id_set8 {
    u32 cnt;
    u32 flags;
    struct {
        u32 id;
        u32 flags;
    } pairs[0];
};

typedef int (*btf_kfunc_filter_t)(const struct bpf_prog *, u32);

struct btf_kfunc_hook_filter {
    btf_kfunc_filter_t filters[16];
    u32 nr_filters;
};

struct btf_kfunc_id_set {
    struct module *owner;
    struct btf_id_set8 *set;
    btf_kfunc_filter_t filter;
};

struct btf_kfunc_set_tab {
    struct btf_id_set8 *sets[14];
    struct btf_kfunc_hook_filter hook_filters[14];
};

struct btf_verifier_env;

struct resolve_vertex;

struct btf_show;

struct btf_kind_operations {
    s32 (*check_meta)(struct btf_verifier_env *, const struct btf_type *, u32);
    int (*resolve)(struct btf_verifier_env *, const struct resolve_vertex *);
    int (*check_member)(struct btf_verifier_env *, const struct btf_type *, const struct btf_member *, const struct btf_type *);
    int (*check_kflag_member)(struct btf_verifier_env *, const struct btf_type *, const struct btf_member *, const struct btf_type *);
    void (*log_details)(struct btf_verifier_env *, const struct btf_type *);
    void (*show)(const struct btf *, const struct btf_type *, u32, void *, u8, struct btf_show *);
};

struct btf_member {
    __u32 name_off;
    __u32 type;
    __u32 offset;
};

struct btf_module {
    struct list_head list;
    struct module *module;
    struct btf *btf;
    struct bin_attribute *sysfs_attr;
    int flags;
};

struct btf_name_info {
    const char *name;
    bool needs_size: 1;
    unsigned int size: 31;
    __u32 id;
};

struct btf_param {
    __u32 name_off;
    __u32 type;
};

struct btf_ptr {
    void *ptr;
    __u32 type_id;
    __u32 flags;
};

struct btf_record {
    u32 cnt;
    u32 field_mask;
    int spin_lock_off;
    int timer_off;
    int wq_off;
    int refcount_off;
    struct btf_field fields[0];
};

struct btf_relocate {
    struct btf *btf;
    const struct btf *base_btf;
    const struct btf *dist_base_btf;
    unsigned int nr_base_types;
    unsigned int nr_split_types;
    unsigned int nr_dist_base_types;
    int dist_str_len;
    int base_str_len;
    __u32 *id_map;
    __u32 *str_map;
};

struct btf_sec_info {
    u32 off;
    u32 len;
};

struct btf_show {
    u64 flags;
    void *target;
    void (*showfn)(struct btf_show *, const char *, va_list);
    const struct btf *btf;
    struct {
        u8 depth;
        u8 depth_to_show;
        u8 depth_check;
        u8 array_member: 1;
        u8 array_terminated: 1;
        u16 array_encoding;
        u32 type_id;
        int status;
        const struct btf_type *type;
        const struct btf_member *member;
        char name[80];
    } state;
    struct {
        u32 size;
        void *head;
        void *data;
        u8 safe[32];
    } obj;
};

struct btf_show_snprintf {
    struct btf_show show;
    int len_left;
    int len;
};

struct btf_struct_meta {
    u32 btf_id;
    struct btf_record *record;
};

struct btf_struct_metas {
    u32 cnt;
    struct btf_struct_meta types[0];
};

struct btf_struct_ops_tab {
    u32 cnt;
    u32 capacity;
    struct bpf_struct_ops_desc ops[0];
};

struct btf_type {
    __u32 name_off;
    __u32 info;
    union {
        __u32 size;
        __u32 type;
    };
};

struct btf_var {
    __u32 linkage;
};

struct btf_var_secinfo {
    __u32 type;
    __u32 offset;
    __u32 size;
};

struct resolve_vertex {
    const struct btf_type *t;
    u32 type_id;
    u16 next_member;
};

struct btf_verifier_env {
    struct btf *btf;
    u8 *visit_states;
    struct resolve_vertex stack[32];
    struct bpf_verifier_log log;
    u32 log_type_id;
    u32 top_stack;
    enum verifier_phase phase;
    enum resolve_mode resolve_mode;
};

struct btree_geo {
    int keylen;
    int no_pairs;
    int no_longs;
};

struct btree_head {
    long unsigned int *node;
    mempool_t *mempool;
    int height;
};

struct hlist_nulls_head {
    struct hlist_nulls_node *first;
};

struct bucket {
    struct hlist_nulls_head head;
    raw_spinlock_t raw_lock;
};

struct lockdep_map {};

struct rhash_lock_head;

struct bucket_table {
    unsigned int size;
    unsigned int nest;
    u32 hash_rnd;
    struct list_head walkers;
    struct callback_head rcu;
    struct bucket_table *future_tbl;
    struct lockdep_map dep_map;
    long: 64;
    struct rhash_lock_head *buckets[0];
};

struct buf_sel_arg {
    struct iovec *iovs;
    size_t out_len;
    size_t max_len;
    short unsigned int nr_iovs;
    short unsigned int mode;
};

struct buffer_data_page {
    u64 time_stamp;
    local_t commit;
    unsigned char data[0];
};

struct buffer_data_read_page {
    unsigned int order;
    struct buffer_data_page *data;
};

typedef void bh_end_io_t(struct buffer_head *, int);

struct buffer_head {
    long unsigned int b_state;
    struct buffer_head *b_this_page;
    union {
        struct page *b_page;
        struct folio *b_folio;
    };
    sector_t b_blocknr;
    size_t b_size;
    char *b_data;
    struct block_device *b_bdev;
    bh_end_io_t *b_end_io;
    void *b_private;
    struct list_head b_assoc_buffers;
    struct address_space *b_assoc_map;
    atomic_t b_count;
    spinlock_t b_uptodate_lock;
};

struct buffer_page {
    struct list_head list;
    local_t write;
    unsigned int read;
    local_t entries;
    long unsigned int real_end;
    unsigned int order;
    u32 id: 30;
    u32 range: 1;
    struct buffer_data_page *page;
};

struct buffer_ref {
    struct trace_buffer *buffer;
    void *page;
    int cpu;
    refcount_t refcount;
};

struct bug_entry {
    int bug_addr_disp;
    int file_disp;
    short unsigned int line;
    short unsigned int flags;
};

struct builtin_fw {
    char *name;
    void *data;
    long unsigned int size;
};

struct vchiq_bulk;

struct bulk_waiter {
    struct vchiq_bulk *bulk;
    struct completion event;
    int actual;
};

struct bulk_waiter_node {
    struct bulk_waiter bulk_waiter;
    int pid;
    struct list_head list;
};

struct group_data {
    int limit[21];
    int base[20];
    int permute[258];
    int minLen;
    int maxLen;
};

struct bunzip_data {
    int writeCopies;
    int writePos;
    int writeRunCountdown;
    int writeCount;
    int writeCurrent;
    long int (*fill)(void *, long unsigned int);
    long int inbufCount;
    long int inbufPos;
    unsigned char *inbuf;
    unsigned int inbufBitCount;
    unsigned int inbufBits;
    unsigned int crc32Table[256];
    unsigned int headerCRC;
    unsigned int totalCRC;
    unsigned int writeCRC;
    unsigned int *dbuf;
    unsigned int dbufSize;
    unsigned char selectors[32768];
    struct group_data groups[6];
    int io_error;
    int byteCount[256];
    unsigned char symToByte[256];
    unsigned char mtfSymbol[256];
};

struct bus_attribute {
    struct attribute attr;
    ssize_t (*show)(const struct bus_type *, char *);
    ssize_t (*store)(const struct bus_type *, const char *, size_t);
};

struct bus_dma_region {
    phys_addr_t cpu_start;
    dma_addr_t dma_start;
    u64 size;
};

struct bus_type {
    const char *name;
    const char *dev_name;
    const struct attribute_group **bus_groups;
    const struct attribute_group **dev_groups;
    const struct attribute_group **drv_groups;
    int (*match)(struct device *, const struct device_driver *);
    int (*uevent)(const struct device *, struct kobj_uevent_env *);
    int (*probe)(struct device *);
    void (*sync_state)(struct device *);
    void (*remove)(struct device *);
    void (*shutdown)(struct device *);
    const struct cpumask * (*irq_get_affinity)(struct device *, unsigned int);
    int (*online)(struct device *);
    int (*offline)(struct device *);
    int (*suspend)(struct device *, pm_message_t);
    int (*resume)(struct device *);
    int (*num_vf)(struct device *);
    int (*dma_configure)(struct device *);
    void (*dma_cleanup)(struct device *);
    const struct dev_pm_ops *pm;
    bool need_parent_lock;
};

struct bvec_iter_all {
    struct bio_vec bv;
    int idx;
    unsigned int done;
};

struct cache_head;

struct cache_deferred_req {
    struct hlist_node hash;
    struct list_head recent;
    struct cache_head *item;
    void *owner;
    void (*revisit)(struct cache_deferred_req *, int);
};

struct cache_head {
    struct hlist_node cache_list;
    time64_t expiry_time;
    time64_t last_refresh;
    struct kref ref;
    long unsigned int flags;
};

struct cache_req {
    struct cache_deferred_req * (*defer)(struct cache_req *);
    long unsigned int thread_wait;
};

struct cache_type_info {
    const char *size_prop;
    const char *line_size_props[2];
    const char *nr_sets_prop;
};

struct cacheinfo {
    unsigned int id;
    enum cache_type type;
    unsigned int level;
    unsigned int coherency_line_size;
    unsigned int number_of_sets;
    unsigned int ways_of_associativity;
    unsigned int physical_line_partition;
    unsigned int size;
    cpumask_t shared_cpu_map;
    unsigned int attributes;
    void *fw_token;
    bool disable_sysfs;
    void *priv;
};

struct cacheline_padding {
    char x[0];
};

struct cachestat {
    __u64 nr_cache;
    __u64 nr_dirty;
    __u64 nr_writeback;
    __u64 nr_evicted;
    __u64 nr_recently_evicted;
};

struct cachestat_range {
    __u64 off;
    __u64 len;
};

struct calipso_doi {
    u32 doi;
    u32 type;
    refcount_t refcount;
    struct list_head list;
    struct callback_head rcu;
};

struct calipso_map_cache_bkt {
    spinlock_t lock;
    u32 size;
    struct list_head list;
};

struct netlbl_lsm_cache;

struct calipso_map_cache_entry {
    u32 hash;
    unsigned char *key;
    size_t key_len;
    struct netlbl_lsm_cache *lsm_data;
    u32 activity;
    struct list_head list;
};

struct call_function_data {
    call_single_data_t *csd;
    cpumask_var_t cpumask;
    cpumask_var_t cpumask_ipi;
};

struct callchain_cpus_entries {
    struct callback_head callback_head;
    struct perf_callchain_entry *cpu_entries[0];
};

struct compact_control;

struct capture_control {
    struct compact_control *cc;
    struct page *page;
};

struct cat_datum {
    u32 value;
    unsigned char isalias;
};

struct cdrom_msf0 {
    __u8 minute;
    __u8 second;
    __u8 frame;
};

union cdrom_addr {
    struct cdrom_msf0 msf;
    int lba;
};

struct cdrom_device_ops;

struct cdrom_device_info {
    const struct cdrom_device_ops *ops;
    struct list_head list;
    struct gendisk *disk;
    void *handle;
    int mask;
    int speed;
    int capacity;
    unsigned int options: 30;
    unsigned int mc_flags: 2;
    unsigned int vfs_events;
    unsigned int ioctl_events;
    int use_count;
    char name[20];
    __u8 sanyo_slot: 2;
    __u8 keeplocked: 1;
    __u8 reserved: 5;
    int cdda_method;
    __u8 last_sense;
    __u8 media_written;
    short unsigned int mmc3_profile;
    int (*exit)(struct cdrom_device_info *);
    int mrw_mode_page;
    bool opened_for_data;
    __s64 last_media_change_ms;
};

struct cdrom_multisession;

struct cdrom_mcn;

struct packet_command;

struct cdrom_device_ops {
    int (*open)(struct cdrom_device_info *, int);
    void (*release)(struct cdrom_device_info *);
    int (*drive_status)(struct cdrom_device_info *, int);
    unsigned int (*check_events)(struct cdrom_device_info *, unsigned int, int);
    int (*tray_move)(struct cdrom_device_info *, int);
    int (*lock_door)(struct cdrom_device_info *, int);
    int (*select_speed)(struct cdrom_device_info *, long unsigned int);
    int (*get_last_session)(struct cdrom_device_info *, struct cdrom_multisession *);
    int (*get_mcn)(struct cdrom_device_info *, struct cdrom_mcn *);
    int (*reset)(struct cdrom_device_info *);
    int (*audio_ioctl)(struct cdrom_device_info *, unsigned int, void *);
    int (*generic_packet)(struct cdrom_device_info *, struct packet_command *);
    int (*read_cdda_bpc)(struct cdrom_device_info *, void *, u32, u32, u8 *);
    const int capability;
};

struct request_sense;

struct cdrom_generic_command {
    unsigned char cmd[12];
    unsigned char *buffer;
    unsigned int buflen;
    int stat;
    struct request_sense *sense;
    unsigned char data_direction;
    int quiet;
    int timeout;
    union {
        void *reserved[1];
        void *unused;
    };
};

struct cdrom_mcn {
    __u8 medium_catalog_number[14];
};

struct cdrom_multisession {
    union cdrom_addr addr;
    __u8 xa_flag;
    __u8 addr_format;
};

struct ce_unbind {
    struct clock_event_device *ce;
    int res;
};

struct cea_db {
    u8 tag_length;
    u8 data[0];
};

struct drm_edid;

struct drm_edid_iter {
    const struct drm_edid *drm_edid;
    int index;
};

struct displayid_iter {
    const struct drm_edid *drm_edid;
    const u8 *section;
    int length;
    int idx;
    int ext_index;
    u8 version;
    u8 primary_use;
};

struct cea_db_iter {
    struct drm_edid_iter edid_iter;
    struct displayid_iter displayid_iter;
    const u8 *collection;
    int index;
    int end;
};

struct cea_sad {
    u8 format;
    u8 channels;
    u8 freq;
    u8 byte2;
};

struct cee_pfc {
    __u8 willing;
    __u8 error;
    __u8 pfc_en;
    __u8 tcs_supported;
};

struct cee_pg {
    __u8 willing;
    __u8 error;
    __u8 pg_en;
    __u8 tcs_supported;
    __u8 pg_bw[8];
    __u8 prio_pg[8];
};

struct cfg80211_bss_select_adjust {
    enum nl80211_band band;
    s8 delta;
};

struct cfg80211_bss_selection {
    enum nl80211_bss_select_attr behaviour;
    union {
        enum nl80211_band band_pref;
        struct cfg80211_bss_select_adjust adjust;
    } param;
};

struct ieee80211_edmg {
    u8 channels;
    enum ieee80211_edmg_bw_config bw_config;
};

struct ieee80211_channel;

struct cfg80211_chan_def {
    struct ieee80211_channel *chan;
    enum nl80211_chan_width width;
    u32 center_freq1;
    u32 center_freq2;
    struct ieee80211_edmg edmg;
    u16 freq1_offset;
    u16 punctured;
};

struct cfg80211_crypto_settings {
    u32 wpa_versions;
    u32 cipher_group;
    int n_ciphers_pairwise;
    u32 ciphers_pairwise[5];
    int n_akm_suites;
    u32 akm_suites[10];
    bool control_port;
    __be16 control_port_ethertype;
    bool control_port_no_encrypt;
    bool control_port_over_nl80211;
    bool control_port_no_preauth;
    const u8 *psk;
    const u8 *sae_pwd;
    u8 sae_pwd_len;
    enum nl80211_sae_pwe_mechanism sae_pwe;
};

struct ieee80211_mcs_info {
    u8 rx_mask[10];
    __le16 rx_highest;
    u8 tx_params;
    u8 reserved[3];
};

struct ieee80211_ht_cap {
    __le16 cap_info;
    u8 ampdu_params_info;
    struct ieee80211_mcs_info mcs;
    __le16 extended_ht_cap_info;
    __le32 tx_BF_cap_info;
    u8 antenna_selection_info;
} __attribute__((packed));

struct ieee80211_vht_mcs_info {
    __le16 rx_mcs_map;
    __le16 rx_highest;
    __le16 tx_mcs_map;
    __le16 tx_highest;
};

struct ieee80211_vht_cap {
    __le32 vht_cap_info;
    struct ieee80211_vht_mcs_info supp_mcs;
};

struct cfg80211_connect_params {
    struct ieee80211_channel *channel;
    struct ieee80211_channel *channel_hint;
    const u8 *bssid;
    const u8 *bssid_hint;
    const u8 *ssid;
    size_t ssid_len;
    enum nl80211_auth_type auth_type;
    const u8 *ie;
    size_t ie_len;
    bool privacy;
    enum nl80211_mfp mfp;
    struct cfg80211_crypto_settings crypto;
    const u8 *key;
    u8 key_len;
    u8 key_idx;
    u32 flags;
    int bg_scan_period;
    struct ieee80211_ht_cap ht_capa;
    struct ieee80211_ht_cap ht_capa_mask;
    struct ieee80211_vht_cap vht_capa;
    struct ieee80211_vht_cap vht_capa_mask;
    bool pbss;
    struct cfg80211_bss_selection bss_select;
    const u8 *prev_bssid;
    const u8 *fils_erp_username;
    size_t fils_erp_username_len;
    const u8 *fils_erp_realm;
    size_t fils_erp_realm_len;
    u16 fils_erp_next_seq_num;
    const u8 *fils_erp_rrk;
    size_t fils_erp_rrk_len;
    bool want_1x;
    struct ieee80211_edmg edmg;
};

struct key_params;

struct cfg80211_ibss_params {
    const u8 *ssid;
    const u8 *bssid;
    struct cfg80211_chan_def chandef;
    const u8 *ie;
    u8 ssid_len;
    u8 ie_len;
    u16 beacon_interval;
    u32 basic_rates;
    bool channel_fixed;
    bool privacy;
    bool control_port;
    bool control_port_over_nl80211;
    bool userspace_handles_dfs;
    int mcast_rate[6];
    struct ieee80211_ht_cap ht_capa;
    struct ieee80211_ht_cap ht_capa_mask;
    struct key_params *wep_keys;
    int wep_tx_key;
};

struct cfg80211_ssid {
    u8 ssid[32];
    u8 ssid_len;
};

struct cfg80211_match_set {
    struct cfg80211_ssid ssid;
    u8 bssid[6];
    s32 rssi_thold;
};

struct cfg80211_pkt_pattern {
    const u8 *mask;
    const u8 *pattern;
    int pattern_len;
    int pkt_offset;
};

struct cfg80211_pmsr_capabilities {
    unsigned int max_peers;
    u8 report_ap_tsf: 1;
    u8 randomize_mac_addr: 1;
    struct {
        u32 preambles;
        u32 bandwidths;
        s8 max_bursts_exponent;
        u8 max_ftms_per_burst;
        u8 supported: 1;
        u8 asap: 1;
        u8 non_asap: 1;
        u8 request_lci: 1;
        u8 request_civicloc: 1;
        u8 trigger_based: 1;
        u8 non_trigger_based: 1;
    } ftm;
};

struct cfg80211_sar_freq_ranges;

struct cfg80211_sar_capa {
    enum nl80211_sar_type type;
    u32 num_freq_ranges;
    const struct cfg80211_sar_freq_ranges *freq_ranges;
};

struct cfg80211_sar_freq_ranges {
    u32 start_freq;
    u32 end_freq;
};

struct cfg80211_sched_scan_plan {
    u32 interval;
    u32 iterations;
};

struct wiphy;

struct cfg80211_sched_scan_request {
    u64 reqid;
    struct cfg80211_ssid *ssids;
    int n_ssids;
    u32 n_channels;
    const u8 *ie;
    size_t ie_len;
    u32 flags;
    struct cfg80211_match_set *match_sets;
    int n_match_sets;
    s32 min_rssi_thold;
    u32 delay;
    struct cfg80211_sched_scan_plan *scan_plans;
    int n_scan_plans;
    u8 mac_addr[6];
    u8 mac_addr_mask[6];
    bool relative_rssi_set;
    s8 relative_rssi;
    struct cfg80211_bss_select_adjust rssi_adjust;
    struct wiphy *wiphy;
    struct net_device *dev;
    long unsigned int scan_start;
    bool report_results;
    struct callback_head callback_head;
    u32 owner_nlportid;
    bool nl_owner_dead;
    struct list_head list;
    struct ieee80211_channel *channels[0];
};

struct cfg80211_wowlan_tcp;

struct cfg80211_wowlan {
    bool any;
    bool disconnect;
    bool magic_pkt;
    bool gtk_rekey_failure;
    bool eap_identity_req;
    bool four_way_handshake;
    bool rfkill_release;
    struct cfg80211_pkt_pattern *patterns;
    struct cfg80211_wowlan_tcp *tcp;
    int n_patterns;
    struct cfg80211_sched_scan_request *nd_config;
};

struct nl80211_wowlan_tcp_data_seq {
    __u32 start;
    __u32 offset;
    __u32 len;
};

struct nl80211_wowlan_tcp_data_token {
    __u32 offset;
    __u32 len;
    __u8 token_stream[0];
};

struct cfg80211_wowlan_tcp {
    struct socket *sock;
    __be32 src;
    __be32 dst;
    u16 src_port;
    u16 dst_port;
    u8 dst_mac[6];
    int payload_len;
    const u8 *payload;
    struct nl80211_wowlan_tcp_data_seq payload_seq;
    u32 data_interval;
    u32 wake_len;
    const u8 *wake_data;
    const u8 *wake_mask;
    u32 tokens_size;
    struct nl80211_wowlan_tcp_data_token payload_tok;
};

struct cfs_bandwidth {
    raw_spinlock_t lock;
    ktime_t period;
    u64 quota;
    u64 runtime;
    u64 burst;
    u64 runtime_snap;
    s64 hierarchical_quota;
    u8 idle;
    u8 period_active;
    u8 slack_started;
    struct hrtimer period_timer;
    struct hrtimer slack_timer;
    struct list_head throttled_cfs_rq;
    int nr_periods;
    int nr_throttled;
    int nr_burst;
    u64 throttled_time;
    u64 burst_time;
};

struct config_group;

struct config_item_type;

struct config_item {
    char *ci_name;
    char ci_namebuf[20];
    struct kref ci_kref;
    struct list_head ci_entry;
    struct config_item *ci_parent;
    struct config_group *ci_group;
    const struct config_item_type *ci_type;
    struct dentry *ci_dentry;
};

struct firmware;

struct cfs_overlay_item {
    struct config_item item;
    char path[4096];
    const struct firmware *fw;
    struct device_node *overlay;
    int ov_id;
    void *dtbo;
    int dtbo_size;
};

struct load_weight {
    long unsigned int weight;
    u32 inv_weight;
};

struct sched_avg {
    u64 last_update_time;
    u64 load_sum;
    u64 runnable_sum;
    u32 util_sum;
    u32 period_contrib;
    long unsigned int load_avg;
    long unsigned int runnable_avg;
    long unsigned int util_avg;
    unsigned int util_est;
};

struct sched_entity;

struct cfs_rq {
    struct load_weight load;
    unsigned int nr_queued;
    unsigned int h_nr_queued;
    unsigned int h_nr_runnable;
    unsigned int h_nr_idle;
    s64 avg_vruntime;
    u64 avg_load;
    u64 min_vruntime;
    struct rb_root_cached tasks_timeline;
    struct sched_entity *curr;
    struct sched_entity *next;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    struct sched_avg avg;
    struct {
        raw_spinlock_t lock;
        int nr;
        long unsigned int load_avg;
        long unsigned int util_avg;
        long unsigned int runnable_avg;
        long: 64;
        long: 64;
        long: 64;
        long: 64;
    } removed;
    u64 last_update_tg_load_avg;
    long unsigned int tg_load_avg_contrib;
    long int propagate;
    long int prop_runnable_sum;
    long unsigned int h_load;
    u64 last_h_load_update;
    struct sched_entity *h_load_next;
    struct rq *rq;
    int on_list;
    struct list_head leaf_cfs_rq_list;
    struct task_group *tg;
    int idle;
    int runtime_enabled;
    s64 runtime_remaining;
    u64 throttled_pelt_idle;
    u64 throttled_clock;
    u64 throttled_clock_pelt;
    u64 throttled_clock_pelt_time;
    u64 throttled_clock_self;
    u64 throttled_clock_self_time;
    int throttled;
    int throttle_count;
    struct list_head throttled_list;
    struct list_head throttled_csd_list;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
};

struct cfs_schedulable_data {
    struct task_group *tg;
    u64 period;
    u64 quota;
};

struct kernfs_ops;

struct kernfs_open_file;

struct cftype {
    char name[64];
    long unsigned int private;
    size_t max_write_len;
    unsigned int flags;
    unsigned int file_offset;
    struct cgroup_subsys *ss;
    struct list_head node;
    struct kernfs_ops *kf_ops;
    int (*open)(struct kernfs_open_file *);
    void (*release)(struct kernfs_open_file *);
    u64 (*read_u64)(struct cgroup_subsys_state *, struct cftype *);
    s64 (*read_s64)(struct cgroup_subsys_state *, struct cftype *);
    int (*seq_show)(struct seq_file *, void *);
    void * (*seq_start)(struct seq_file *, loff_t *);
    void * (*seq_next)(struct seq_file *, void *, loff_t *);
    void (*seq_stop)(struct seq_file *, void *);
    int (*write_u64)(struct cgroup_subsys_state *, struct cftype *, u64);
    int (*write_s64)(struct cgroup_subsys_state *, struct cftype *, s64);
    ssize_t (*write)(struct kernfs_open_file *, char *, size_t, loff_t);
    __poll_t (*poll)(struct kernfs_open_file *, struct poll_table_struct *);
    struct lock_class_key lockdep_key;
};

struct cgroup_file {
    struct kernfs_node *kn;
    long unsigned int notified_at;
    struct timer_list notify_timer;
};

struct task_cputime {
    u64 stime;
    u64 utime;
    long long unsigned int sum_exec_runtime;
};

struct cgroup_base_stat {
    struct task_cputime cputime;
    u64 ntime;
};

struct prev_cputime {
    u64 utime;
    u64 stime;
    raw_spinlock_t lock;
};

struct cgroup_bpf {
    struct bpf_prog_array *effective[28];
    struct hlist_head progs[28];
    u8 flags[28];
    struct list_head storages;
    struct bpf_prog_array *inactive;
    struct percpu_ref refcnt;
    struct work_struct release_work;
};

struct cgroup_freezer_state {
    bool freeze;
    bool e_freeze;
    int nr_frozen_descendants;
    int nr_frozen_tasks;
};

struct cgroup_root;

struct cgroup_rstat_cpu;

struct psi_group;

struct cgroup {
    struct cgroup_subsys_state self;
    long unsigned int flags;
    int level;
    int max_depth;
    int nr_descendants;
    int nr_dying_descendants;
    int max_descendants;
    int nr_populated_csets;
    int nr_populated_domain_children;
    int nr_populated_threaded_children;
    int nr_threaded_children;
    unsigned int kill_seq;
    struct kernfs_node *kn;
    struct cgroup_file procs_file;
    struct cgroup_file events_file;
    struct cgroup_file psi_files[3];
    u16 subtree_control;
    u16 subtree_ss_mask;
    u16 old_subtree_control;
    u16 old_subtree_ss_mask;
    struct cgroup_subsys_state *subsys[15];
    int nr_dying_subsys[15];
    struct cgroup_root *root;
    struct list_head cset_links;
    struct list_head e_csets[15];
    struct cgroup *dom_cgrp;
    struct cgroup *old_dom_cgrp;
    struct cgroup_rstat_cpu *rstat_cpu;
    struct list_head rstat_css_list;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    struct cacheline_padding _pad_;
    struct cgroup *rstat_flush_next;
    struct cgroup_base_stat last_bstat;
    struct cgroup_base_stat bstat;
    struct prev_cputime prev_cputime;
    struct list_head pidlists;
    struct mutex pidlist_mutex;
    wait_queue_head_t offline_waitq;
    struct work_struct release_agent_work;
    struct psi_group *psi;
    struct cgroup_bpf bpf;
    struct cgroup_freezer_state freezer;
    struct bpf_local_storage *bpf_cgrp_storage;
    struct cgroup *ancestors[0];
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
};

struct cgroup__safe_rcu {
    struct kernfs_node *kn;
};

struct cgroup_cls_state {
    struct cgroup_subsys_state css;
    u32 classid;
};

struct css_set;

struct css_task_iter {
    struct cgroup_subsys *ss;
    unsigned int flags;
    struct list_head *cset_pos;
    struct list_head *cset_head;
    struct list_head *tcset_pos;
    struct list_head *tcset_head;
    struct list_head *task_pos;
    struct list_head *cur_tasks_head;
    struct css_set *cur_cset;
    struct css_set *cur_dcset;
    struct task_struct *cur_task;
    struct list_head iters_node;
};

struct cgroup_of_peak {
    long unsigned int value;
    struct list_head list;
};

struct cgroup_namespace;

struct cgroup_pidlist;

struct cgroup_file_ctx {
    struct cgroup_namespace *ns;
    struct {
        void *trigger;
    } psi;
    struct {
        bool started;
        struct css_task_iter iter;
    } procs;
    struct {
        struct cgroup_pidlist *pidlist;
    } procs1;
    struct cgroup_of_peak peak;
};

struct kernfs_root;

struct kernfs_fs_context {
    struct kernfs_root *root;
    void *ns_tag;
    long unsigned int magic;
    bool new_sb_created;
};

struct cgroup_fs_context {
    struct kernfs_fs_context kfc;
    struct cgroup_root *root;
    struct cgroup_namespace *ns;
    unsigned int flags;
    bool cpuset_clone_children;
    bool none;
    bool all_ss;
    u16 subsys_mask;
    char *name;
    char *release_agent;
};

struct cgroup_iter_priv {
    struct cgroup_subsys_state *start_css;
    bool visited_all;
    bool terminate;
    int order;
};

struct cgroup_taskset {
    struct list_head src_csets;
    struct list_head dst_csets;
    int nr_tasks;
    int ssid;
    struct list_head *csets;
    struct css_set *cur_cset;
    struct task_struct *cur_task;
};

struct cgroup_mgctx {
    struct list_head preloaded_src_csets;
    struct list_head preloaded_dst_csets;
    struct cgroup_taskset tset;
    u16 ss_mask;
};

struct proc_ns_operations;

struct ns_common {
    struct dentry *stashed;
    const struct proc_ns_operations *ops;
    unsigned int inum;
    refcount_t count;
};

struct ucounts;

struct cgroup_namespace {
    struct ns_common ns;
    struct user_namespace *user_ns;
    struct ucounts *ucounts;
    struct css_set *root_cset;
};

struct cgroup_pidlist {
    struct {
        enum cgroup_filetype type;
        struct pid_namespace *ns;
    } key;
    pid_t *list;
    int length;
    struct list_head links;
    struct cgroup *owner;
    struct delayed_work destroy_dwork;
};

struct cgroup_root {
    struct kernfs_root *kf_root;
    unsigned int subsys_mask;
    int hierarchy_id;
    struct list_head root_list;
    struct callback_head rcu;
    long: 64;
    long: 64;
    struct cgroup cgrp;
    struct cgroup *cgrp_ancestor_storage;
    atomic_t nr_cgrps;
    unsigned int flags;
    char release_agent_path[4096];
    char name[64];
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
};

struct cgroup_rstat_cpu {
    struct u64_stats_sync bsync;
    struct cgroup_base_stat bstat;
    struct cgroup_base_stat last_bstat;
    struct cgroup_base_stat subtree_bstat;
    struct cgroup_base_stat last_subtree_bstat;
    struct cgroup *updated_children;
    struct cgroup *updated_next;
};

struct idr {
    struct xarray idr_rt;
    unsigned int idr_base;
    unsigned int idr_next;
};

struct cgroup_subsys {
    struct cgroup_subsys_state * (*css_alloc)(struct cgroup_subsys_state *);
    int (*css_online)(struct cgroup_subsys_state *);
    void (*css_offline)(struct cgroup_subsys_state *);
    void (*css_released)(struct cgroup_subsys_state *);
    void (*css_free)(struct cgroup_subsys_state *);
    void (*css_reset)(struct cgroup_subsys_state *);
    void (*css_killed)(struct cgroup_subsys_state *);
    void (*css_rstat_flush)(struct cgroup_subsys_state *, int);
    int (*css_extra_stat_show)(struct seq_file *, struct cgroup_subsys_state *);
    int (*css_local_stat_show)(struct seq_file *, struct cgroup_subsys_state *);
    int (*can_attach)(struct cgroup_taskset *);
    void (*cancel_attach)(struct cgroup_taskset *);
    void (*attach)(struct cgroup_taskset *);
    void (*post_attach)(void);
    int (*can_fork)(struct task_struct *, struct css_set *);
    void (*cancel_fork)(struct task_struct *, struct css_set *);
    void (*fork)(struct task_struct *);
    void (*exit)(struct task_struct *);
    void (*release)(struct task_struct *);
    void (*bind)(struct cgroup_subsys_state *);
    bool early_init: 1;
    bool implicit_on_dfl: 1;
    bool threaded: 1;
    int id;
    const char *name;
    const char *legacy_name;
    struct cgroup_root *root;
    struct idr css_idr;
    struct list_head cfts;
    struct cftype *dfl_cftypes;
    struct cftype *legacy_cftypes;
    unsigned int depends_on;
};

struct cgroupstats {
    __u64 nr_sleeping;
    __u64 nr_running;
    __u64 nr_stopped;
    __u64 nr_uninterruptible;
    __u64 nr_io_wait;
};

struct cgrp_cset_link {
    struct cgroup *cgrp;
    struct css_set *cset;
    struct list_head cset_link;
    struct list_head cgrp_link;
};

struct ethnl_reply_data {
    struct net_device *dev;
};

struct ethtool_channels {
    __u32 cmd;
    __u32 max_rx;
    __u32 max_tx;
    __u32 max_other;
    __u32 max_combined;
    __u32 rx_count;
    __u32 tx_count;
    __u32 other_count;
    __u32 combined_count;
};

struct channels_reply_data {
    struct ethnl_reply_data base;
    struct ethtool_channels channels;
};

struct char_device_struct {
    struct char_device_struct *next;
    unsigned int major;
    unsigned int baseminor;
    int minorct;
    char name[64];
    struct cdev *cdev;
};

struct qdisc_walker {
    int stop;
    int skip;
    int count;
    int (*fn)(struct Qdisc *, long unsigned int, struct qdisc_walker *);
};

struct check_loop_arg {
    struct qdisc_walker w;
    struct Qdisc *p;
    int depth;
};

struct check_mount {
    struct vfsmount *mnt;
    unsigned int mounted;
};

struct check_walk_data {
    enum pkvm_page_state desired;
    enum pkvm_page_state (*get_page_state)(kvm_pte_t, u64);
};

struct chksum_ctx {
    u32 key;
};

struct chksum_desc_ctx {
    __u16 crc;
};

struct chksum_desc_ctx___2 {
    u32 crc;
};

struct cipher_context {
    char iv[20];
    char rec_seq[8];
};

struct cipso_v4_std_map_tbl;

struct cipso_v4_doi {
    u32 doi;
    u32 type;
    union {
        struct cipso_v4_std_map_tbl *std;
    } map;
    u8 tags[5];
    refcount_t refcount;
    struct list_head list;
    struct callback_head rcu;
};

struct cipso_v4_map_cache_bkt {
    spinlock_t lock;
    u32 size;
    struct list_head list;
};

struct cipso_v4_map_cache_entry {
    u32 hash;
    unsigned char *key;
    size_t key_len;
    struct netlbl_lsm_cache *lsm_data;
    u32 activity;
    struct list_head list;
};

struct cipso_v4_std_map_tbl {
    struct {
        u32 *cipso;
        u32 *local;
        u32 cipso_size;
        u32 local_size;
    } lvl;
    struct {
        u32 *cipso;
        u32 *local;
        u32 cipso_size;
        u32 local_size;
    } cat;
};

struct mmc_card;

struct sdio_func;

typedef int tpl_parse_t(struct mmc_card *, struct sdio_func *, const unsigned char *, unsigned int);

struct cis_tpl {
    unsigned char code;
    unsigned char min_size;
    tpl_parse_t *parse;
};

struct class_attribute {
    struct attribute attr;
    ssize_t (*show)(const struct class *, const struct class_attribute *, char *);
    ssize_t (*store)(const struct class *, const struct class_attribute *, const char *, size_t);
};

struct class_attribute_string {
    struct class_attribute attr;
    char *str;
};

struct class_compat {
    struct kobject *kobj;
};

struct hashtab_node;

struct hashtab {
    struct hashtab_node **htable;
    u32 size;
    u32 nel;
};

struct symtab {
    struct hashtab table;
    u32 nprim;
};

struct common_datum;

struct constraint_node;

struct class_datum {
    u32 value;
    char *comkey;
    struct common_datum *comdatum;
    struct symtab permissions;
    struct constraint_node *constraints;
    struct constraint_node *validatetrans;
    char default_user;
    char default_role;
    char default_type;
    char default_range;
};

struct klist_iter {
    struct klist *i_klist;
    struct klist_node *i_cur;
};

struct subsys_private;

struct class_dev_iter {
    struct klist_iter ki;
    const struct device_type *type;
    struct subsys_private *sp;
};

struct class_dir {
    struct kobject kobj;
    const struct class *class;
};

struct class_info {
    int class;
    char *class_name;
};

struct class_interface {
    struct list_head node;
    const struct class *class;
    int (*add_dev)(struct device *);
    void (*remove_dev)(struct device *);
};

struct mmu_notifier_range {
    struct mm_struct *mm;
    long unsigned int start;
    long unsigned int end;
    unsigned int flags;
    enum mmu_notifier_event event;
    void *owner;
};

struct wp_walk {
    struct mmu_notifier_range range;
    long unsigned int tlbflush_start;
    long unsigned int tlbflush_end;
    long unsigned int total;
};

struct clean_walk {
    struct wp_walk base;
    long unsigned int bitmap_pgoff;
    long unsigned int *bitmap;
    long unsigned int start;
    long unsigned int end;
};

struct clear_refs_private {
    enum clear_refs_types type;
};

struct clk {
    struct clk_core *core;
    struct device *dev;
    const char *dev_id;
    const char *con_id;
    long unsigned int min_rate;
    long unsigned int max_rate;
    unsigned int exclusive_count;
    struct hlist_node clks_node;
};

struct clk_bulk_data {
    const char *id;
    struct clk *clk;
};

struct clk_bulk_devres {
    struct clk_bulk_data *clks;
    int num_clks;
};

struct clk_rate_request;

struct clk_duty;

struct clk_ops {
    int (*prepare)(struct clk_hw *);
    void (*unprepare)(struct clk_hw *);
    int (*is_prepared)(struct clk_hw *);
    void (*unprepare_unused)(struct clk_hw *);
    int (*enable)(struct clk_hw *);
    void (*disable)(struct clk_hw *);
    int (*is_enabled)(struct clk_hw *);
    void (*disable_unused)(struct clk_hw *);
    int (*save_context)(struct clk_hw *);
    void (*restore_context)(struct clk_hw *);
    long unsigned int (*recalc_rate)(struct clk_hw *, long unsigned int);
    long int (*round_rate)(struct clk_hw *, long unsigned int, long unsigned int *);
    int (*determine_rate)(struct clk_hw *, struct clk_rate_request *);
    int (*set_parent)(struct clk_hw *, u8);
    u8 (*get_parent)(struct clk_hw *);
    int (*set_rate)(struct clk_hw *, long unsigned int, long unsigned int);
    int (*set_rate_and_parent)(struct clk_hw *, long unsigned int, long unsigned int, u8);
    long unsigned int (*recalc_accuracy)(struct clk_hw *, long unsigned int);
    int (*get_phase)(struct clk_hw *);
    int (*set_phase)(struct clk_hw *, int);
    int (*get_duty_cycle)(struct clk_hw *, struct clk_duty *);
    int (*set_duty_cycle)(struct clk_hw *, struct clk_duty *);
    int (*init)(struct clk_hw *);
    void (*terminate)(struct clk_hw *);
    void (*debug_init)(struct clk_hw *, struct dentry *);
};

struct clk_composite {
    struct clk_hw hw;
    struct clk_ops ops;
    struct clk_hw *mux_hw;
    struct clk_hw *rate_hw;
    struct clk_hw *gate_hw;
    const struct clk_ops *mux_ops;
    const struct clk_ops *rate_ops;
    const struct clk_ops *gate_ops;
};

struct clk_duty {
    unsigned int num;
    unsigned int den;
};

struct clk_parent_map;

struct clk_core {
    const char *name;
    const struct clk_ops *ops;
    struct clk_hw *hw;
    struct module *owner;
    struct device *dev;
    struct hlist_node rpm_node;
    struct device_node *of_node;
    struct clk_core *parent;
    struct clk_parent_map *parents;
    u8 num_parents;
    u8 new_parent_index;
    long unsigned int rate;
    long unsigned int req_rate;
    long unsigned int new_rate;
    struct clk_core *new_parent;
    struct clk_core *new_child;
    long unsigned int flags;
    bool orphan;
    bool rpm_enabled;
    unsigned int enable_count;
    unsigned int prepare_count;
    unsigned int protect_count;
    long unsigned int min_rate;
    long unsigned int max_rate;
    long unsigned int accuracy;
    int phase;
    struct clk_duty duty;
    struct hlist_head children;
    struct hlist_node child_node;
    struct hlist_head clks;
    unsigned int notifier_count;
    struct dentry *dentry;
    struct hlist_node debug_node;
    struct kref ref;
};

struct clk_div_table {
    unsigned int val;
    unsigned int div;
};

struct reset_simple_data {
    spinlock_t lock;
    void *membase;
    struct reset_controller_dev rcdev;
    bool active_low;
    bool status_active_low;
    unsigned int reset_us;
};

struct clk_dvp {
    struct clk_hw_onecell_data *data;
    struct reset_simple_data reset;
};

struct clk_fixed_factor {
    struct clk_hw hw;
    unsigned int mult;
    unsigned int div;
    long unsigned int acc;
    unsigned int flags;
};

struct clk_fixed_rate {
    struct clk_hw hw;
    long unsigned int fixed_rate;
    long unsigned int fixed_accuracy;
    long unsigned int flags;
};

struct clk_fractional_divider {
    struct clk_hw hw;
    void *reg;
    u8 mshift;
    u8 mwidth;
    u8 nshift;
    u8 nwidth;
    u8 flags;
    void (*approximation)(struct clk_hw *, long unsigned int, long unsigned int *, long unsigned int *, long unsigned int *);
    spinlock_t *lock;
};

struct clk_gate {
    struct clk_hw hw;
    void *reg;
    u8 bit_idx;
    u8 flags;
    spinlock_t *lock;
};

struct gpio_desc;

struct clk_gpio {
    struct clk_hw hw;
    struct gpio_desc *gpiod;
};

struct regulator;

struct clk_gated_fixed {
    struct clk_gpio clk_gpio;
    struct regulator *supply;
    long unsigned int rate;
};

struct clk_parent_data;

struct clk_init_data {
    const char *name;
    const struct clk_ops *ops;
    const char * const *parent_names;
    const struct clk_parent_data *parent_data;
    const struct clk_hw **parent_hws;
    u8 num_parents;
    long unsigned int flags;
};

struct clk_lookup {
    struct list_head node;
    const char *dev_id;
    const char *con_id;
    struct clk *clk;
    struct clk_hw *clk_hw;
};

struct clk_lookup_alloc {
    struct clk_lookup cl;
    char dev_id[24];
    char con_id[16];
};

struct clk_multiplier {
    struct clk_hw hw;
    void *reg;
    u8 shift;
    u8 width;
    u8 flags;
    spinlock_t *lock;
};

struct clk_mux {
    struct clk_hw hw;
    void *reg;
    const u32 *table;
    u32 mask;
    u8 shift;
    u8 flags;
    spinlock_t *lock;
};

struct srcu_node;

struct srcu_usage {
    struct srcu_node *node;
    struct srcu_node *level[3];
    int srcu_size_state;
    struct mutex srcu_cb_mutex;
    spinlock_t lock;
    struct mutex srcu_gp_mutex;
    long unsigned int srcu_gp_seq;
    long unsigned int srcu_gp_seq_needed;
    long unsigned int srcu_gp_seq_needed_exp;
    long unsigned int srcu_gp_start;
    long unsigned int srcu_last_gp_end;
    long unsigned int srcu_size_jiffies;
    long unsigned int srcu_n_lock_retries;
    long unsigned int srcu_n_exp_nodelay;
    bool sda_is_static;
    long unsigned int srcu_barrier_seq;
    struct mutex srcu_barrier_mutex;
    struct completion srcu_barrier_completion;
    atomic_t srcu_barrier_cpu_cnt;
    long unsigned int reschedule_jiffies;
    long unsigned int reschedule_count;
    struct delayed_work work;
    struct srcu_struct *srcu_ssp;
};

struct srcu_data;

struct srcu_struct {
    unsigned int srcu_idx;
    struct srcu_data *sda;
    struct lockdep_map dep_map;
    struct srcu_usage *srcu_sup;
};

struct srcu_notifier_head {
    struct mutex mutex;
    struct srcu_usage srcuu;
    struct srcu_struct srcu;
    struct notifier_block *head;
};

struct clk_notifier {
    struct clk *clk;
    struct srcu_notifier_head notifier_head;
    struct list_head node;
};

struct clk_notifier_data {
    struct clk *clk;
    long unsigned int old_rate;
    long unsigned int new_rate;
};

struct clk_notifier_devres {
    struct clk *clk;
    struct notifier_block *nb;
};

struct clk_onecell_data {
    struct clk **clks;
    unsigned int clk_num;
};

struct clk_parent_data {
    const struct clk_hw *hw;
    const char *fw_name;
    const char *name;
    int index;
};

struct clk_parent_map {
    const struct clk_hw *hw;
    struct clk_core *core;
    const char *fw_name;
    const char *name;
    int index;
};

struct clk_rate_request {
    struct clk_core *core;
    long unsigned int rate;
    long unsigned int min_rate;
    long unsigned int max_rate;
    long unsigned int best_parent_rate;
    struct clk_hw *best_parent_hw;
};

struct clock_read_data {
    u64 epoch_ns;
    u64 epoch_cyc;
    u64 sched_clock_mask;
    u64 (*read_sched_clock)(void);
    u32 mult;
    u32 shift;
};

struct clock_data {
    seqcount_latch_t seq;
    struct clock_read_data read_data[2];
    ktime_t wrap_kt;
    long unsigned int rate;
    u64 (*actual_read_sched_clock)(void);
};

struct clock_identity {
    u8 id[8];
};

struct clock_provider {
    void (*clk_init_cb)(struct device_node *);
    struct device_node *np;
    struct list_head node;
};

struct clocksource_base;

struct clocksource {
    u64 (*read)(struct clocksource *);
    u64 mask;
    u32 mult;
    u32 shift;
    u64 max_idle_ns;
    u32 maxadj;
    u32 uncertainty_margin;
    u64 max_cycles;
    u64 max_raw_delta;
    const char *name;
    struct list_head list;
    u32 freq_khz;
    int rating;
    enum clocksource_ids id;
    enum vdso_clock_mode vdso_clock_mode;
    long unsigned int flags;
    struct clocksource_base *base;
    int (*enable)(struct clocksource *);
    void (*disable)(struct clocksource *);
    void (*suspend)(struct clocksource *);
    void (*resume)(struct clocksource *);
    void (*mark_unstable)(struct clocksource *);
    void (*tick_stable)(struct clocksource *);
    struct module *owner;
};

struct clocksource_base {
    enum clocksource_ids id;
    u32 freq_khz;
    u64 offset;
    u32 numerator;
    u32 denominator;
};

struct clocksource_mmio {
    void *reg;
    struct clocksource clksrc;
};

struct clone_args {
    __u64 flags;
    __u64 pidfd;
    __u64 child_tid;
    __u64 parent_tid;
    __u64 exit_signal;
    __u64 stack;
    __u64 stack_size;
    __u64 tls;
    __u64 set_tid;
    __u64 set_tid_size;
    __u64 cgroup;
};

typedef void closure_fn(struct work_struct *);

struct closure_syncer;

struct closure {
    union {
        struct {
            struct workqueue_struct *wq;
            struct closure_syncer *s;
            struct llist_node list;
            closure_fn *fn;
        };
        struct work_struct work;
    };
    struct closure *parent;
    atomic_t remaining;
    bool closure_get_happened;
};

struct closure_syncer {
    struct task_struct *task;
    int done;
};

struct closure_waitlist {
    struct llist_head list;
};

struct cma_kobject;

struct cma {
    long unsigned int base_pfn;
    long unsigned int count;
    long unsigned int *bitmap;
    unsigned int order_per_bit;
    spinlock_t lock;
    char name[64];
    atomic64_t nr_pages_succeeded;
    atomic64_t nr_pages_failed;
    atomic64_t nr_pages_released;
    struct cma_kobject *cma_kobj;
    bool reserve_pages_on_error;
};

struct cma_check_range_data {
    u64 start;
    u64 end;
};

struct dma_heap;

struct cma_heap {
    struct dma_heap *heap;
    struct cma *cma;
};

struct cma_heap_buffer {
    struct cma_heap *heap;
    struct list_head attachments;
    struct mutex lock;
    long unsigned int len;
    struct page *cma_pages;
    struct page **pages;
    long unsigned int pagecount;
    int vmap_cnt;
    void *vaddr;
};

struct cma_kobject {
    struct kobject kobj;
    struct cma *cma;
};

struct cmis_cdb_advert_rpl {
    u8 inst_supported;
    u8 read_write_len_ext;
    u8 resv1;
    u8 resv2;
};

struct cmis_cdb_fw_mng_features_rpl {
    u8 resv1;
    u8 resv2;
    u8 start_cmd_payload_size;
    u8 resv3;
    u8 read_write_len_ext;
    u8 write_mechanism;
    u8 resv4;
    u8 resv5;
    __be16 max_duration_start;
    __be16 resv6;
    __be16 max_duration_write;
    __be16 max_duration_complete;
    __be16 resv7;
};

struct cmis_cdb_module_features_rpl {
    u8 resv1[34];
    __be16 max_completion_time;
};

struct cmis_cdb_query_status_pl {
    u16 response_delay;
};

struct cmis_cdb_query_status_rpl {
    u8 length;
    u8 status;
};

struct cmis_cdb_run_fw_image_pl {
    u8 resv1;
    u8 image_to_run;
    u16 delay_to_reset;
};

struct cmis_cdb_start_fw_download_pl_h {
    __be32 image_size;
    __be32 resv1;
};

struct cmis_cdb_start_fw_download_pl {
    union {
        struct {
            __be32 image_size;
            __be32 resv1;
        };
        struct cmis_cdb_start_fw_download_pl_h head;
    };
    u8 vendor_data[112];
};

struct cmis_cdb_write_fw_block_epl_pl {
    u8 fw_block[2048];
};

struct cmis_cdb_write_fw_block_lpl_pl {
    __be32 block_address;
    u8 fw_block[116];
};

struct cmis_fw_update_fw_mng_features {
    u8 start_cmd_payload_size;
    u8 write_mechanism;
    u16 max_duration_start;
    u16 max_duration_write;
    u16 max_duration_complete;
};

struct cmis_password_entry_pl {
    __be32 password;
};

struct cmis_rev_rpl {
    u8 rev;
};

struct cmis_wait_for_cond_rpl {
    u8 state;
};

struct cmsghdr {
    __kernel_size_t cmsg_len;
    int cmsg_level;
    int cmsg_type;
};

struct ethtool_coalesce {
    __u32 cmd;
    __u32 rx_coalesce_usecs;
    __u32 rx_max_coalesced_frames;
    __u32 rx_coalesce_usecs_irq;
    __u32 rx_max_coalesced_frames_irq;
    __u32 tx_coalesce_usecs;
    __u32 tx_max_coalesced_frames;
    __u32 tx_coalesce_usecs_irq;
    __u32 tx_max_coalesced_frames_irq;
    __u32 stats_block_coalesce_usecs;
    __u32 use_adaptive_rx_coalesce;
    __u32 use_adaptive_tx_coalesce;
    __u32 pkt_rate_low;
    __u32 rx_coalesce_usecs_low;
    __u32 rx_max_coalesced_frames_low;
    __u32 tx_coalesce_usecs_low;
    __u32 tx_max_coalesced_frames_low;
    __u32 pkt_rate_high;
    __u32 rx_coalesce_usecs_high;
    __u32 rx_max_coalesced_frames_high;
    __u32 tx_coalesce_usecs_high;
    __u32 tx_max_coalesced_frames_high;
    __u32 rate_sample_interval;
};

struct kernel_ethtool_coalesce {
    u8 use_cqe_mode_tx;
    u8 use_cqe_mode_rx;
    u32 tx_aggr_max_bytes;
    u32 tx_aggr_max_frames;
    u32 tx_aggr_time_usecs;
};

struct coalesce_reply_data {
    struct ethnl_reply_data base;
    struct ethtool_coalesce coalesce;
    struct kernel_ethtool_coalesce kernel_coalesce;
    u32 supported_params;
};

struct collapse_control {
    bool is_khugepaged;
    u32 node_load[1];
    nodemask_t alloc_nmask;
};

struct commit_header {
    __be32 h_magic;
    __be32 h_blocktype;
    __be32 h_sequence;
    unsigned char h_chksum_type;
    unsigned char h_chksum_size;
    unsigned char h_padding[2];
    __be32 h_chksum[8];
    __be64 h_commit_sec;
    __be32 h_commit_nsec;
};

struct common_datum {
    u32 value;
    struct symtab permissions;
};

struct comp_opts {
    int dict_size;
};

struct zone;

struct compact_control {
    struct list_head freepages[11];
    struct list_head migratepages;
    unsigned int nr_freepages;
    unsigned int nr_migratepages;
    long unsigned int free_pfn;
    long unsigned int migrate_pfn;
    long unsigned int fast_start_pfn;
    struct zone *zone;
    long unsigned int total_migrate_scanned;
    long unsigned int total_free_scanned;
    short unsigned int fast_search_fail;
    short int search_order;
    const gfp_t gfp_mask;
    int order;
    int migratetype;
    const unsigned int alloc_flags;
    const int highest_zoneidx;
    enum migrate_mode mode;
    bool ignore_skip_hint;
    bool no_set_skip_hint;
    bool ignore_block_suitable;
    bool direct_compaction;
    bool proactive_compaction;
    bool whole_zone;
    bool contended;
    bool finish_pageblock;
    bool alloc_contig;
};

struct compat_user_vfp {
    compat_u64 fpregs[32];
    compat_ulong_t fpscr;
};

struct compat_user_vfp_exc {
    compat_ulong_t fpexc;
    compat_ulong_t fpinst;
    compat_ulong_t fpinst2;
};

struct compat_vfp_sigframe {
    compat_ulong_t magic;
    compat_ulong_t size;
    struct compat_user_vfp ufp;
    struct compat_user_vfp_exc ufp_exc;
};

struct compat_aux_sigframe {
    struct compat_vfp_sigframe vfp;
    long unsigned int end_magic;
};

struct compat_blkpg_ioctl_arg {
    compat_int_t op;
    compat_int_t flags;
    compat_int_t datalen;
    compat_caddr_t data;
};

struct compat_cdrom_generic_command {
    unsigned char cmd[12];
    compat_caddr_t buffer;
    compat_uint_t buflen;
    compat_int_t stat;
    compat_caddr_t sense;
    unsigned char data_direction;
    unsigned char pad[3];
    compat_int_t quiet;
    compat_int_t timeout;
    compat_caddr_t unused;
};

struct compat_cmsghdr {
    compat_size_t cmsg_len;
    compat_int_t cmsg_level;
    compat_int_t cmsg_type;
};

struct compat_console_font_op {
    compat_uint_t op;
    compat_uint_t flags;
    compat_uint_t width;
    compat_uint_t height;
    compat_uint_t charcount;
    compat_caddr_t data;
};

struct compat_dirent {
    u32 d_ino;
    compat_off_t d_off;
    u16 d_reclen;
    char d_name[256];
};

struct compat_elf_prpsinfo {
    char pr_state;
    char pr_sname;
    char pr_zomb;
    char pr_nice;
    compat_ulong_t pr_flag;
    __compat_uid_t pr_uid;
    __compat_gid_t pr_gid;
    compat_pid_t pr_pid;
    compat_pid_t pr_ppid;
    compat_pid_t pr_pgrp;
    compat_pid_t pr_sid;
    char pr_fname[16];
    char pr_psargs[80];
};

struct compat_elf_siginfo {
    compat_int_t si_signo;
    compat_int_t si_code;
    compat_int_t si_errno;
};

struct old_timeval32 {
    old_time32_t tv_sec;
    s32 tv_usec;
};

struct compat_elf_prstatus_common {
    struct compat_elf_siginfo pr_info;
    short int pr_cursig;
    compat_ulong_t pr_sigpend;
    compat_ulong_t pr_sighold;
    compat_pid_t pr_pid;
    compat_pid_t pr_ppid;
    compat_pid_t pr_pgrp;
    compat_pid_t pr_sid;
    struct old_timeval32 pr_utime;
    struct old_timeval32 pr_stime;
    struct old_timeval32 pr_cutime;
    struct old_timeval32 pr_cstime;
};

struct compat_elf_prstatus {
    struct compat_elf_prstatus_common common;
    compat_elf_gregset_t pr_reg;
    compat_int_t pr_fpvalid;
};

struct compat_ext4_new_group_input {
    u32 group;
    compat_u64 block_bitmap;
    compat_u64 inode_bitmap;
    compat_u64 inode_table;
    u32 blocks_count;
    u16 reserved_blocks;
    u16 unused;
};

struct compat_flock {
    short int l_type;
    short int l_whence;
    compat_off_t l_start;
    compat_off_t l_len;
    compat_pid_t l_pid;
};

struct compat_flock64 {
    short int l_type;
    short int l_whence;
    compat_loff_t l_start;
    compat_loff_t l_len;
    compat_pid_t l_pid;
};

struct compat_frame_tail {
    compat_uptr_t fp;
    u32 sp;
    u32 lr;
};

struct dir_context;

typedef bool (*filldir_t)(struct dir_context *, const char *, int, loff_t, u64, unsigned int);

struct dir_context {
    filldir_t actor;
    loff_t pos;
};

struct compat_linux_dirent;

struct compat_getdents_callback {
    struct dir_context ctx;
    struct compat_linux_dirent *current_dir;
    int prev_reclen;
    int count;
    int error;
};

struct compat_group_filter {
    union {
        struct {
            __u32 gf_interface_aux;
            struct __kernel_sockaddr_storage gf_group_aux;
            __u32 gf_fmode_aux;
            __u32 gf_numsrc_aux;
            struct __kernel_sockaddr_storage gf_slist[1];
        } __attribute__((packed));
        struct {
            __u32 gf_interface;
            struct __kernel_sockaddr_storage gf_group;
            __u32 gf_fmode;
            __u32 gf_numsrc;
            struct __kernel_sockaddr_storage gf_slist_flex[0];
        } __attribute__((packed));
    };
};

struct compat_group_req {
    __u32 gr_interface;
    struct __kernel_sockaddr_storage gr_group;
} __attribute__((packed));

struct compat_group_source_req {
    __u32 gsr_interface;
    struct __kernel_sockaddr_storage gsr_group;
    struct __kernel_sockaddr_storage gsr_source;
} __attribute__((packed));

struct compat_hd_geometry {
    unsigned char heads;
    unsigned char sectors;
    short unsigned int cylinders;
    u32 start;
};

struct compat_if_dqblk {
    compat_u64 dqb_bhardlimit;
    compat_u64 dqb_bsoftlimit;
    compat_u64 dqb_curspace;
    compat_u64 dqb_ihardlimit;
    compat_u64 dqb_isoftlimit;
    compat_u64 dqb_curinodes;
    compat_u64 dqb_btime;
    compat_u64 dqb_itime;
    compat_uint_t dqb_valid;
};

struct compat_if_settings {
    unsigned int type;
    unsigned int size;
    compat_uptr_t ifs_ifsu;
};

struct compat_ifconf {
    compat_int_t ifc_len;
    compat_caddr_t ifcbuf;
};

struct compat_ifmap {
    compat_ulong_t mem_start;
    compat_ulong_t mem_end;
    short unsigned int base_addr;
    unsigned char irq;
    unsigned char dma;
    unsigned char port;
};

struct compat_ifreq {
    union {
        char ifrn_name[16];
    } ifr_ifrn;
    union {
        struct sockaddr ifru_addr;
        struct sockaddr ifru_dstaddr;
        struct sockaddr ifru_broadaddr;
        struct sockaddr ifru_netmask;
        struct sockaddr ifru_hwaddr;
        short int ifru_flags;
        compat_int_t ifru_ivalue;
        compat_int_t ifru_mtu;
        struct compat_ifmap ifru_map;
        char ifru_slave[16];
        char ifru_newname[16];
        compat_caddr_t ifru_data;
        struct compat_if_settings ifru_settings;
    } ifr_ifru;
};

struct compat_in6_rtmsg {
    struct in6_addr rtmsg_dst;
    struct in6_addr rtmsg_src;
    struct in6_addr rtmsg_gateway;
    u32 rtmsg_type;
    u16 rtmsg_dst_len;
    u16 rtmsg_src_len;
    u32 rtmsg_metric;
    u32 rtmsg_info;
    u32 rtmsg_flags;
    s32 rtmsg_ifindex;
};

struct compat_iovec {
    compat_uptr_t iov_base;
    compat_size_t iov_len;
};

struct compat_ipc64_perm {
    compat_key_t key;
    __compat_uid32_t uid;
    __compat_gid32_t gid;
    __compat_uid32_t cuid;
    __compat_gid32_t cgid;
    compat_mode_t mode;
    unsigned char __pad1[2];
    compat_ushort_t seq;
    compat_ushort_t __pad2;
    compat_ulong_t unused1;
    compat_ulong_t unused2;
};

struct compat_ipc_perm {
    key_t key;
    __compat_uid_t uid;
    __compat_gid_t gid;
    __compat_uid_t cuid;
    __compat_gid_t cgid;
    compat_mode_t mode;
    short unsigned int seq;
};

struct compat_iw_point {
    compat_caddr_t pointer;
    __u16 length;
    __u16 flags;
};

struct compat_keyctl_kdf_params {
    compat_uptr_t hashname;
    compat_uptr_t otherinfo;
    __u32 otherinfolen;
    __u32 __spare[8];
};

struct compat_linux_dirent {
    compat_ulong_t d_ino;
    compat_ulong_t d_off;
    short unsigned int d_reclen;
    char d_name[0];
};

struct compat_loop_info {
    compat_int_t lo_number;
    compat_dev_t lo_device;
    compat_ulong_t lo_inode;
    compat_dev_t lo_rdevice;
    compat_int_t lo_offset;
    compat_int_t lo_encrypt_type;
    compat_int_t lo_encrypt_key_size;
    compat_int_t lo_flags;
    char lo_name[64];
    unsigned char lo_encrypt_key[32];
    compat_ulong_t lo_init[2];
    char reserved[4];
};

struct compat_msghdr {
    compat_uptr_t msg_name;
    compat_int_t msg_namelen;
    compat_uptr_t msg_iov;
    compat_size_t msg_iovlen;
    compat_uptr_t msg_control;
    compat_size_t msg_controllen;
    compat_uint_t msg_flags;
};

struct compat_mmsghdr {
    struct compat_msghdr msg_hdr;
    compat_uint_t msg_len;
};

struct compat_mq_attr {
    compat_long_t mq_flags;
    compat_long_t mq_maxmsg;
    compat_long_t mq_msgsize;
    compat_long_t mq_curmsgs;
    compat_long_t __reserved[4];
};

struct compat_msgbuf {
    compat_long_t mtype;
    char mtext[0];
};

struct compat_msqid64_ds {
    struct compat_ipc64_perm msg_perm;
    compat_ulong_t msg_stime;
    compat_ulong_t msg_stime_high;
    compat_ulong_t msg_rtime;
    compat_ulong_t msg_rtime_high;
    compat_ulong_t msg_ctime;
    compat_ulong_t msg_ctime_high;
    compat_ulong_t msg_cbytes;
    compat_ulong_t msg_qnum;
    compat_ulong_t msg_qbytes;
    compat_pid_t msg_lspid;
    compat_pid_t msg_lrpid;
    compat_ulong_t __unused4;
    compat_ulong_t __unused5;
};

struct compat_msqid_ds {
    struct compat_ipc_perm msg_perm;
    compat_uptr_t msg_first;
    compat_uptr_t msg_last;
    old_time32_t msg_stime;
    old_time32_t msg_rtime;
    old_time32_t msg_ctime;
    compat_ulong_t msg_lcbytes;
    compat_ulong_t msg_lqbytes;
    short unsigned int msg_cbytes;
    short unsigned int msg_qnum;
    short unsigned int msg_qbytes;
    compat_ipc_pid_t msg_lspid;
    compat_ipc_pid_t msg_lrpid;
};

struct compat_old_linux_dirent {
    compat_ulong_t d_ino;
    compat_ulong_t d_offset;
    short unsigned int d_namlen;
    char d_name[0];
};

struct compat_old_sigaction {
    compat_uptr_t sa_handler;
    compat_old_sigset_t sa_mask;
    compat_ulong_t sa_flags;
    compat_uptr_t sa_restorer;
};

struct compat_readdir_callback {
    struct dir_context ctx;
    struct compat_old_linux_dirent *dirent;
    int result;
};

struct compat_rlimit {
    compat_ulong_t rlim_cur;
    compat_ulong_t rlim_max;
};

struct compat_robust_list {
    compat_uptr_t next;
};

struct compat_robust_list_head {
    struct compat_robust_list list;
    compat_long_t futex_offset;
    compat_uptr_t list_op_pending;
};

union compat_sigval {
    compat_int_t sival_int;
    compat_uptr_t sival_ptr;
};

typedef union compat_sigval compat_sigval_t;

struct compat_siginfo {
    int si_signo;
    int si_errno;
    int si_code;
    union {
        int _pad[29];
        struct {
            compat_pid_t _pid;
            __compat_uid32_t _uid;
        } _kill;
        struct {
            compat_timer_t _tid;
            int _overrun;
            compat_sigval_t _sigval;
        } _timer;
        struct {
            compat_pid_t _pid;
            __compat_uid32_t _uid;
            compat_sigval_t _sigval;
        } _rt;
        struct {
            compat_pid_t _pid;
            __compat_uid32_t _uid;
            int _status;
            compat_clock_t _utime;
            compat_clock_t _stime;
        } _sigchld;
        struct {
            compat_uptr_t _addr;
            union {
                int _trapno;
                short int _addr_lsb;
                struct {
                    char _dummy_bnd[4];
                    compat_uptr_t _lower;
                    compat_uptr_t _upper;
                } _addr_bnd;
                struct {
                    char _dummy_pkey[4];
                    u32 _pkey;
                } _addr_pkey;
                struct {
                    compat_ulong_t _data;
                    u32 _type;
                    u32 _flags;
                } _perf;
            };
        } _sigfault;
        struct {
            compat_long_t _band;
            int _fd;
        } _sigpoll;
        struct {
            compat_uptr_t _call_addr;
            int _syscall;
            unsigned int _arch;
        } _sigsys;
    } _sifields;
};

struct compat_sigaltstack {
    compat_uptr_t ss_sp;
    int ss_flags;
    compat_size_t ss_size;
};

typedef struct compat_sigaltstack compat_stack_t;

struct compat_sigcontext {
    compat_ulong_t trap_no;
    compat_ulong_t error_code;
    compat_ulong_t oldmask;
    compat_ulong_t arm_r0;
    compat_ulong_t arm_r1;
    compat_ulong_t arm_r2;
    compat_ulong_t arm_r3;
    compat_ulong_t arm_r4;
    compat_ulong_t arm_r5;
    compat_ulong_t arm_r6;
    compat_ulong_t arm_r7;
    compat_ulong_t arm_r8;
    compat_ulong_t arm_r9;
    compat_ulong_t arm_r10;
    compat_ulong_t arm_fp;
    compat_ulong_t arm_ip;
    compat_ulong_t arm_sp;
    compat_ulong_t arm_lr;
    compat_ulong_t arm_pc;
    compat_ulong_t arm_cpsr;
    compat_ulong_t fault_address;
};

struct compat_ucontext {
    compat_ulong_t uc_flags;
    compat_uptr_t uc_link;
    compat_stack_t uc_stack;
    struct compat_sigcontext uc_mcontext;
    compat_sigset_t uc_sigmask;
    int __unused[30];
    compat_ulong_t uc_regspace[128];
};

struct compat_sigframe {
    struct compat_ucontext uc;
    compat_ulong_t retcode[2];
};

struct compat_rt_sigframe {
    struct compat_siginfo info;
    struct compat_sigframe sig;
};

struct compat_rtentry {
    u32 rt_pad1;
    struct sockaddr rt_dst;
    struct sockaddr rt_gateway;
    struct sockaddr rt_genmask;
    short unsigned int rt_flags;
    short int rt_pad2;
    u32 rt_pad3;
    unsigned char rt_tos;
    unsigned char rt_class;
    short int rt_pad4;
    short int rt_metric;
    compat_uptr_t rt_dev;
    u32 rt_mtu;
    u32 rt_window;
    short unsigned int rt_irtt;
};

struct compat_rusage {
    struct old_timeval32 ru_utime;
    struct old_timeval32 ru_stime;
    compat_long_t ru_maxrss;
    compat_long_t ru_ixrss;
    compat_long_t ru_idrss;
    compat_long_t ru_isrss;
    compat_long_t ru_minflt;
    compat_long_t ru_majflt;
    compat_long_t ru_nswap;
    compat_long_t ru_inblock;
    compat_long_t ru_oublock;
    compat_long_t ru_msgsnd;
    compat_long_t ru_msgrcv;
    compat_long_t ru_nsignals;
    compat_long_t ru_nvcsw;
    compat_long_t ru_nivcsw;
};

struct compat_sel_arg_struct {
    compat_ulong_t n;
    compat_uptr_t inp;
    compat_uptr_t outp;
    compat_uptr_t exp;
    compat_uptr_t tvp;
};

struct compat_semid64_ds {
    struct compat_ipc64_perm sem_perm;
    compat_ulong_t sem_otime;
    compat_ulong_t sem_otime_high;
    compat_ulong_t sem_ctime;
    compat_ulong_t sem_ctime_high;
    compat_ulong_t sem_nsems;
    compat_ulong_t __unused3;
    compat_ulong_t __unused4;
};

struct compat_semid_ds {
    struct compat_ipc_perm sem_perm;
    old_time32_t sem_otime;
    old_time32_t sem_ctime;
    compat_uptr_t sem_base;
    compat_uptr_t sem_pending;
    compat_uptr_t sem_pending_last;
    compat_uptr_t undo;
    short unsigned int sem_nsems;
};

struct compat_sg_io_hdr {
    compat_int_t interface_id;
    compat_int_t dxfer_direction;
    unsigned char cmd_len;
    unsigned char mx_sb_len;
    short unsigned int iovec_count;
    compat_uint_t dxfer_len;
    compat_uint_t dxferp;
    compat_uptr_t cmdp;
    compat_uptr_t sbp;
    compat_uint_t timeout;
    compat_uint_t flags;
    compat_int_t pack_id;
    compat_uptr_t usr_ptr;
    unsigned char status;
    unsigned char masked_status;
    unsigned char msg_status;
    unsigned char sb_len_wr;
    short unsigned int host_status;
    short unsigned int driver_status;
    compat_int_t resid;
    compat_uint_t duration;
    compat_uint_t info;
};

struct compat_sg_req_info {
    char req_state;
    char orphan;
    char sg_io_owned;
    char problem;
    int pack_id;
    compat_uptr_t usr_ptr;
    unsigned int duration;
    int unused;
};

struct compat_shm_info {
    compat_int_t used_ids;
    compat_ulong_t shm_tot;
    compat_ulong_t shm_rss;
    compat_ulong_t shm_swp;
    compat_ulong_t swap_attempts;
    compat_ulong_t swap_successes;
};

struct compat_shmid64_ds {
    struct compat_ipc64_perm shm_perm;
    compat_size_t shm_segsz;
    compat_ulong_t shm_atime;
    compat_ulong_t shm_atime_high;
    compat_ulong_t shm_dtime;
    compat_ulong_t shm_dtime_high;
    compat_ulong_t shm_ctime;
    compat_ulong_t shm_ctime_high;
    compat_pid_t shm_cpid;
    compat_pid_t shm_lpid;
    compat_ulong_t shm_nattch;
    compat_ulong_t __unused4;
    compat_ulong_t __unused5;
};

struct compat_shmid_ds {
    struct compat_ipc_perm shm_perm;
    int shm_segsz;
    old_time32_t shm_atime;
    old_time32_t shm_dtime;
    old_time32_t shm_ctime;
    compat_ipc_pid_t shm_cpid;
    compat_ipc_pid_t shm_lpid;
    short unsigned int shm_nattch;
    short unsigned int shm_unused;
    compat_uptr_t shm_unused2;
    compat_uptr_t shm_unused3;
};

struct compat_shminfo64 {
    compat_ulong_t shmmax;
    compat_ulong_t shmmin;
    compat_ulong_t shmmni;
    compat_ulong_t shmseg;
    compat_ulong_t shmall;
    compat_ulong_t __unused1;
    compat_ulong_t __unused2;
    compat_ulong_t __unused3;
    compat_ulong_t __unused4;
};

struct compat_sigaction {
    compat_uptr_t sa_handler;
    compat_ulong_t sa_flags;
    compat_uptr_t sa_restorer;
    compat_sigset_t sa_mask;
};

struct compat_sigevent {
    compat_sigval_t sigev_value;
    compat_int_t sigev_signo;
    compat_int_t sigev_notify;
    union {
        compat_int_t _pad[13];
        compat_int_t _tid;
        struct {
            compat_uptr_t _function;
            compat_uptr_t _attribute;
        } _sigev_thread;
    } _sigev_un;
};

typedef struct compat_siginfo compat_siginfo_t;

struct compat_sigset_argpack {
    compat_uptr_t p;
    compat_size_t size;
};

struct compat_sioc_mif_req6 {
    mifi_t mifi;
    compat_ulong_t icount;
    compat_ulong_t ocount;
    compat_ulong_t ibytes;
    compat_ulong_t obytes;
};

struct in_addr {
    __be32 s_addr;
};

struct compat_sioc_sg_req {
    struct in_addr src;
    struct in_addr grp;
    compat_ulong_t pktcnt;
    compat_ulong_t bytecnt;
    compat_ulong_t wrong_if;
};

struct sockaddr_in6 {
    short unsigned int sin6_family;
    __be16 sin6_port;
    __be32 sin6_flowinfo;
    struct in6_addr sin6_addr;
    __u32 sin6_scope_id;
};

struct compat_sioc_sg_req6 {
    struct sockaddr_in6 src;
    struct sockaddr_in6 grp;
    compat_ulong_t pktcnt;
    compat_ulong_t bytecnt;
    compat_ulong_t wrong_if;
};

struct compat_sioc_vif_req {
    vifi_t vifi;
    compat_ulong_t icount;
    compat_ulong_t ocount;
    compat_ulong_t ibytes;
    compat_ulong_t obytes;
};

struct compat_sock_fprog {
    u16 len;
    compat_uptr_t filter;
};

struct compat_stat {
    compat_dev_t st_dev;
    compat_ino_t st_ino;
    compat_mode_t st_mode;
    compat_ushort_t st_nlink;
    __compat_uid16_t st_uid;
    __compat_gid16_t st_gid;
    compat_dev_t st_rdev;
    compat_off_t st_size;
    compat_off_t st_blksize;
    compat_off_t st_blocks;
    old_time32_t st_atime;
    compat_ulong_t st_atime_nsec;
    old_time32_t st_mtime;
    compat_ulong_t st_mtime_nsec;
    old_time32_t st_ctime;
    compat_ulong_t st_ctime_nsec;
    compat_ulong_t __unused4[2];
};

struct compat_statfs {
    int f_type;
    int f_bsize;
    int f_blocks;
    int f_bfree;
    int f_bavail;
    int f_files;
    int f_ffree;
    compat_fsid_t f_fsid;
    int f_namelen;
    int f_frsize;
    int f_flags;
    int f_spare[4];
};

struct compat_statfs64 {
    __u32 f_type;
    __u32 f_bsize;
    __u64 f_blocks;
    __u64 f_bfree;
    __u64 f_bavail;
    __u64 f_files;
    __u64 f_ffree;
    __kernel_fsid_t f_fsid;
    __u32 f_namelen;
    __u32 f_frsize;
    __u32 f_flags;
    __u32 f_spare[4];
} __attribute__((packed));

struct compat_sysinfo {
    s32 uptime;
    u32 loads[3];
    u32 totalram;
    u32 freeram;
    u32 sharedram;
    u32 bufferram;
    u32 totalswap;
    u32 freeswap;
    u16 procs;
    u16 pad;
    u32 totalhigh;
    u32 freehigh;
    u32 mem_unit;
    char _f[8];
};

struct compat_tms {
    compat_clock_t tms_utime;
    compat_clock_t tms_stime;
    compat_clock_t tms_cutime;
    compat_clock_t tms_cstime;
};

struct compat_unimapdesc {
    short unsigned int entry_ct;
    compat_caddr_t entries;
};

struct compat_ustat {
    compat_daddr_t f_tfree;
    compat_ino_t f_tinode;
    char f_fname[6];
    char f_fpack[6];
};

struct component_ops;

struct component {
    struct list_head node;
    struct aggregate_device *adev;
    bool bound;
    const struct component_ops *ops;
    int subcomponent;
    struct device *dev;
};

struct component_master_ops {
    int (*bind)(struct device *);
    void (*unbind)(struct device *);
};

struct component_match_array;

struct component_match {
    size_t alloc;
    size_t num;
    struct component_match_array *compare;
};

struct component_match_array {
    void *data;
    int (*compare)(struct device *, void *);
    int (*compare_typed)(struct device *, int, void *);
    void (*release)(struct device *, void *);
    struct component *component;
    bool duplicate;
};

struct component_ops {
    int (*bind)(struct device *, struct device *, void *);
    void (*unbind)(struct device *, struct device *, void *);
};

typedef int (*decompress_fn)(unsigned char *, long int, long int (*)(void *, long unsigned int), long int (*)(void *, long unsigned int), unsigned char *, long int *, void (*)(char *));

struct compress_format {
    unsigned char magic[2];
    const char *name;
    decompress_fn decompressor;
};

struct consw;

struct con_driver {
    const struct consw *con;
    const char *desc;
    struct device *dev;
    int node;
    int first;
    int last;
    int flag;
};

struct cond_av_list {
    struct avtab_node **nodes;
    u32 len;
};

struct cond_bool_datum {
    u32 value;
    int state;
};

struct cond_expr_node;

struct cond_expr {
    struct cond_expr_node *nodes;
    u32 len;
};

struct cond_expr_node {
    u32 expr_type;
    u32 boolean;
};

struct policydb;

struct cond_insertf_data {
    struct policydb *p;
    struct avtab_node **dst;
    struct cond_av_list *other;
};

struct cond_node {
    int cur_state;
    struct cond_expr expr;
    struct cond_av_list true_list;
    struct cond_av_list false_list;
};

typedef bool (*cond_update_fn_t)(struct trace_array *, void *);

struct cond_snapshot {
    void *cond_data;
    cond_update_fn_t update;
};

struct configfs_subsystem;

struct config_group {
    struct config_item cg_item;
    struct list_head cg_children;
    struct configfs_subsystem *cg_subsys;
    struct list_head default_groups;
    struct list_head group_entry;
};

struct configfs_item_operations;

struct configfs_group_operations;

struct configfs_attribute;

struct configfs_bin_attribute;

struct config_item_type {
    struct module *ct_owner;
    struct configfs_item_operations *ct_item_ops;
    struct configfs_group_operations *ct_group_ops;
    struct configfs_attribute **ct_attrs;
    struct configfs_bin_attribute **ct_bin_attrs;
};

struct deflate_state;

typedef struct deflate_state deflate_state;

typedef block_state (*compress_func)(deflate_state *, int);

struct config_s {
    ush good_length;
    ush max_lazy;
    ush nice_length;
    ush max_chain;
    compress_func func;
};

typedef struct config_s config;

struct configfs_attribute {
    const char *ca_name;
    struct module *ca_owner;
    umode_t ca_mode;
    ssize_t (*show)(struct config_item *, char *);
    ssize_t (*store)(struct config_item *, const char *, size_t);
};

struct configfs_bin_attribute {
    struct configfs_attribute cb_attr;
    void *cb_private;
    size_t cb_max_size;
    ssize_t (*read)(struct config_item *, void *, size_t);
    ssize_t (*write)(struct config_item *, const void *, size_t);
};

struct configfs_buffer {
    size_t count;
    loff_t pos;
    char *page;
    struct configfs_item_operations *ops;
    struct mutex mutex;
    int needs_read_fill;
    bool read_in_progress;
    bool write_in_progress;
    char *bin_buffer;
    int bin_buffer_size;
    int cb_max_size;
    struct config_item *item;
    struct module *owner;
    union {
        struct configfs_attribute *attr;
        struct configfs_bin_attribute *bin_attr;
    };
};

struct iattr;

struct configfs_fragment;

struct configfs_dirent {
    atomic_t s_count;
    int s_dependent_count;
    struct list_head s_sibling;
    struct list_head s_children;
    int s_links;
    void *s_element;
    int s_type;
    umode_t s_mode;
    struct dentry *s_dentry;
    struct iattr *s_iattr;
    struct configfs_fragment *s_frag;
};

struct configfs_fragment {
    atomic_t frag_count;
    struct rw_semaphore frag_sem;
    bool frag_dead;
};

struct configfs_group_operations {
    struct config_item * (*make_item)(struct config_group *, const char *);
    struct config_group * (*make_group)(struct config_group *, const char *);
    void (*disconnect_notify)(struct config_group *, struct config_item *);
    void (*drop_item)(struct config_group *, struct config_item *);
    bool (*is_visible)(struct config_item *, struct configfs_attribute *, int);
    bool (*is_bin_visible)(struct config_item *, struct configfs_bin_attribute *, int);
};

struct configfs_item_operations {
    void (*release)(struct config_item *);
    int (*allow_link)(struct config_item *, struct config_item *);
    void (*drop_link)(struct config_item *, struct config_item *);
};

struct configfs_subsystem {
    struct config_group su_group;
    struct mutex su_mutex;
};

struct console;

struct printk_buffers;

struct nbcon_context {
    struct console *console;
    unsigned int spinwait_max_us;
    enum nbcon_prio prio;
    unsigned int allow_unsafe_takeover: 1;
    unsigned int backlog: 1;
    struct printk_buffers *pbufs;
    u64 seq;
};

struct tty_driver;

struct nbcon_write_context;

struct console {
    char name[16];
    void (*write)(struct console *, const char *, unsigned int);
    int (*read)(struct console *, char *, unsigned int);
    struct tty_driver * (*device)(struct console *, int *);
    void (*unblank)(void);
    int (*setup)(struct console *, char *);
    int (*exit)(struct console *);
    int (*match)(struct console *, char *, int, char *);
    short int flags;
    short int index;
    int cflag;
    uint ispeed;
    uint ospeed;
    u64 seq;
    long unsigned int dropped;
    void *data;
    struct hlist_node node;
    void (*write_atomic)(struct console *, struct nbcon_write_context *);
    void (*write_thread)(struct console *, struct nbcon_write_context *);
    void (*device_lock)(struct console *, long unsigned int *);
    void (*device_unlock)(struct console *, long unsigned int);
    atomic_t nbcon_state;
    atomic_long_t nbcon_seq;
    struct nbcon_context nbcon_device_ctxt;
    atomic_long_t nbcon_prev_seq;
    struct printk_buffers *pbufs;
    struct task_struct *kthread;
    struct rcuwait rcuwait;
    struct irq_work irq_work;
};

struct console_cmdline {
    char name[16];
    int index;
    char devname[32];
    bool user_specified;
    char *options;
};

struct console_flush_type {
    bool nbcon_atomic;
    bool nbcon_offload;
    bool legacy_direct;
    bool legacy_offload;
};

struct console_font {
    unsigned int width;
    unsigned int height;
    unsigned int charcount;
    unsigned char *data;
};

struct console_font_op {
    unsigned int op;
    unsigned int flags;
    unsigned int width;
    unsigned int height;
    unsigned int charcount;
    unsigned char *data;
};

struct constant_table {
    const char *name;
    int value;
};

struct ebitmap_node;

struct ebitmap {
    struct ebitmap_node *node;
    u32 highbit;
};

struct type_set;

struct constraint_expr {
    u32 expr_type;
    u32 attr;
    u32 op;
    struct ebitmap names;
    struct type_set *type_names;
    struct constraint_expr *next;
};

struct constraint_node {
    u32 permissions;
    struct constraint_expr *expr;
    struct constraint_node *next;
};

struct vc_data;

struct consw {
    struct module *owner;
    const char * (*con_startup)(void);
    void (*con_init)(struct vc_data *, bool);
    void (*con_deinit)(struct vc_data *);
    void (*con_clear)(struct vc_data *, unsigned int, unsigned int, unsigned int);
    void (*con_putc)(struct vc_data *, u16, unsigned int, unsigned int);
    void (*con_putcs)(struct vc_data *, const u16 *, unsigned int, unsigned int, unsigned int);
    void (*con_cursor)(struct vc_data *, bool);
    bool (*con_scroll)(struct vc_data *, unsigned int, unsigned int, enum con_scroll, unsigned int);
    bool (*con_switch)(struct vc_data *);
    bool (*con_blank)(struct vc_data *, enum vesa_blank_mode, bool);
    int (*con_font_set)(struct vc_data *, const struct console_font *, unsigned int, unsigned int);
    int (*con_font_get)(struct vc_data *, struct console_font *, unsigned int);
    int (*con_font_default)(struct vc_data *, struct console_font *, const char *);
    int (*con_resize)(struct vc_data *, unsigned int, unsigned int, bool);
    void (*con_set_palette)(struct vc_data *, const unsigned char *);
    void (*con_scrolldelta)(struct vc_data *, int);
    bool (*con_set_origin)(struct vc_data *);
    void (*con_save_screen)(struct vc_data *);
    u8 (*con_build_attr)(struct vc_data *, u8, enum vc_intensity, bool, bool, bool, bool);
    void (*con_invert_region)(struct vc_data *, u16 *, int);
    void (*con_debug_enter)(struct vc_data *);
    void (*con_debug_leave)(struct vc_data *);
};

struct container_dev {
    struct device dev;
    int (*offline)(struct container_dev *);
};

struct mls_level {
    u32 sens;
    struct ebitmap cat;
};

struct mls_range {
    struct mls_level level[2];
};

struct context {
    u32 user;
    u32 role;
    u32 type;
    u32 len;
    struct mls_range range;
    char *str;
};

struct context_tracking {
    bool active;
    int recursion;
    atomic_t state;
    long int nesting;
    long int nmi_nesting;
};

struct contig_page_info {
    long unsigned int free_pages;
    long unsigned int free_blocks_total;
    long unsigned int free_blocks_suitable;
};

struct convert_context_args {
    struct policydb *oldp;
    struct policydb *newp;
};

struct cooling_dev_stats {
    spinlock_t lock;
    unsigned int total_trans;
    long unsigned int state;
    ktime_t last_time;
    ktime_t *time_in_state;
    unsigned int *trans_table;
};

struct cooling_spec {
    long unsigned int upper;
    long unsigned int lower;
    unsigned int weight;
};

struct copy_subpage_arg {
    struct folio *dst;
    struct folio *src;
    struct vm_area_struct *vma;
};

struct core_name {
    char *corename;
    int used;
    int size;
};

struct core_thread {
    struct task_struct *task;
    struct core_thread *next;
};

struct core_state {
    atomic_t nr_threads;
    struct core_thread dumper;
    struct completion startup;
};

struct core_vma_metadata {
    long unsigned int start;
    long unsigned int end;
    long unsigned int flags;
    long unsigned int dump_size;
    long unsigned int pgoff;
    struct file *file;
};

struct kernel_siginfo;

typedef struct kernel_siginfo kernel_siginfo_t;

struct coredump_params {
    const kernel_siginfo_t *siginfo;
    struct file *file;
    long unsigned int limit;
    long unsigned int mm_flags;
    int cpu;
    loff_t written;
    loff_t pos;
    loff_t to_skip;
    int vma_count;
    size_t vma_data_size;
    struct core_vma_metadata *vma_meta;
};

struct counted_str {
    struct kref count;
    char name[0];
};

struct regulator_dev;

struct regulator_coupler;

struct coupling_desc {
    struct regulator_dev **coupled_rdevs;
    struct regulator_coupler *coupler;
    int n_resolved;
    int n_coupled;
};

struct cper_sec_proc_arm {
    u32 validation_bits;
    u16 err_info_num;
    u16 context_info_num;
    u32 section_length;
    u8 affinity_level;
    u8 reserved[3];
    u64 mpidr;
    u64 midr;
    u32 running_state;
    u32 psci_state;
};

struct cpio_data {
    void *data;
    size_t size;
    char name[18];
};

struct cprman_plat_data {
    unsigned int soc;
};

struct cpu {
    int node_id;
    int hotpluggable;
    struct device dev;
};

struct cpu_attr {
    struct device_attribute attr;
    const struct cpumask * const map;
};

struct cpu_cacheinfo {
    struct cacheinfo *info_list;
    unsigned int per_cpu_data_slice_size;
    unsigned int num_levels;
    unsigned int num_leaves;
    bool cpu_map_populated;
    bool early_ci_levels;
};

struct cpu_context {
    long unsigned int x19;
    long unsigned int x20;
    long unsigned int x21;
    long unsigned int x22;
    long unsigned int x23;
    long unsigned int x24;
    long unsigned int x25;
    long unsigned int x26;
    long unsigned int x27;
    long unsigned int x28;
    long unsigned int fp;
    long unsigned int sp;
    long unsigned int pc;
};

struct update_util_data {
    void (*func)(struct update_util_data *, u64, unsigned int);
};

struct policy_dbs_info;

struct cpu_dbs_info {
    u64 prev_cpu_idle;
    u64 prev_update_time;
    u64 prev_cpu_nice;
    unsigned int prev_load;
    struct update_util_data update_util;
    struct policy_dbs_info *policy_dbs;
};

struct folio_batch {
    unsigned char nr;
    unsigned char i;
    bool percpu_pvec_drained;
    struct folio *folios[31];
};

struct cpu_fbatches {
    local_lock_t lock;
    struct folio_batch lru_add;
    struct folio_batch lru_deactivate_file;
    struct folio_batch lru_deactivate;
    struct folio_batch lru_lazyfree;
    struct folio_batch lru_activate;
    local_lock_t lock_irq;
    struct folio_batch lru_move_tail;
};

struct user_fpsimd_state;

struct cpu_fp_state {
    struct user_fpsimd_state *st;
    void *sve_state;
    void *sme_state;
    u64 *svcr;
    u64 *fpmr;
    unsigned int sve_vl;
    unsigned int sme_vl;
    enum fp_type *fp_type;
    enum fp_type to_save;
};

struct cpu_itimer {
    u64 expires;
    u64 incr;
};

struct cpu_lpi_count {
    atomic_t managed;
    atomic_t unmanaged;
};

struct cpu_operations {
    const char *name;
    int (*cpu_init)(unsigned int);
    int (*cpu_prepare)(unsigned int);
    int (*cpu_boot)(unsigned int);
    void (*cpu_postboot)(void);
};

struct cpu_rmap {
    struct kref refcount;
    u16 size;
    void **obj;
    struct {
        u16 index;
        u16 dist;
    } near[0];
};

struct cpu_stop_done {
    atomic_t nr_todo;
    int ret;
    struct completion completion;
};

typedef int (*cpu_stop_fn_t)(void *);

struct cpu_stop_work {
    struct list_head list;
    cpu_stop_fn_t fn;
    long unsigned int caller;
    void *arg;
    struct cpu_stop_done *done;
};

struct cpu_stopper {
    struct task_struct *thread;
    raw_spinlock_t lock;
    bool enabled;
    struct list_head works;
    struct cpu_stop_work stop_work;
    long unsigned int caller;
    cpu_stop_fn_t fn;
};

struct cpu_suspend_ctx {
    u64 ctx_regs[13];
    u64 sp;
};

struct cpu_sve_state {
    __u64 zcr_el1;
    __u32 fpsr;
    __u32 fpcr;
    __u8 sve_regs[0];
};

struct cpu_timer {
    struct timerqueue_node node;
    struct timerqueue_head *head;
    struct pid *pid;
    struct list_head elist;
    bool firing;
    bool nanosleep;
    struct task_struct *handling;
};

struct cpu_topology {
    int thread_id;
    int core_id;
    int cluster_id;
    int package_id;
    cpumask_t thread_sibling;
    cpumask_t core_sibling;
    cpumask_t cluster_sibling;
    cpumask_t llc_sibling;
};

struct cpu_vfs_cap_data {
    __u32 magic_etc;
    kuid_t rootid;
    kernel_cap_t permitted;
    kernel_cap_t inheritable;
};

struct kernel_cpustat;

struct cpuacct {
    struct cgroup_subsys_state css;
    u64 *cpuusage;
    struct kernel_cpustat *cpustat;
};

struct cpudl_item;

struct cpudl {
    raw_spinlock_t lock;
    int size;
    cpumask_var_t free_cpus;
    struct cpudl_item *elements;
};

struct cpudl_item {
    u64 dl;
    int cpu;
    int idx;
};

struct thermal_cooling_device;

struct thermal_cooling_device_ops {
    int (*get_max_state)(struct thermal_cooling_device *, long unsigned int *);
    int (*get_cur_state)(struct thermal_cooling_device *, long unsigned int *);
    int (*set_cur_state)(struct thermal_cooling_device *, long unsigned int);
    int (*get_requested_power)(struct thermal_cooling_device *, u32 *);
    int (*state2power)(struct thermal_cooling_device *, long unsigned int, u32 *);
    int (*power2state)(struct thermal_cooling_device *, u32, long unsigned int *);
};

struct plist_node {
    int prio;
    struct list_head prio_list;
    struct list_head node_list;
};

struct freq_constraints;

struct freq_qos_request {
    enum freq_qos_req_type type;
    struct plist_node pnode;
    struct freq_constraints *qos;
};

struct em_perf_domain;

struct cpufreq_policy;

struct cpufreq_cooling_device {
    u32 last_load;
    unsigned int cpufreq_state;
    unsigned int max_level;
    struct em_perf_domain *em;
    struct cpufreq_policy *policy;
    struct thermal_cooling_device_ops cooling_ops;
    struct freq_qos_request qos_req;
};

struct cpufreq_cpuinfo {
    unsigned int max_freq;
    unsigned int min_freq;
    unsigned int transition_latency;
};

struct cpufreq_policy_data;

struct freq_attr;

struct cpufreq_driver {
    char name[16];
    u16 flags;
    void *driver_data;
    int (*init)(struct cpufreq_policy *);
    int (*verify)(struct cpufreq_policy_data *);
    int (*setpolicy)(struct cpufreq_policy *);
    int (*target)(struct cpufreq_policy *, unsigned int, unsigned int);
    int (*target_index)(struct cpufreq_policy *, unsigned int);
    unsigned int (*fast_switch)(struct cpufreq_policy *, unsigned int);
    void (*adjust_perf)(unsigned int, long unsigned int, long unsigned int, long unsigned int);
    unsigned int (*get_intermediate)(struct cpufreq_policy *, unsigned int);
    int (*target_intermediate)(struct cpufreq_policy *, unsigned int);
    unsigned int (*get)(unsigned int);
    void (*update_limits)(unsigned int);
    int (*bios_limit)(int, unsigned int *);
    int (*online)(struct cpufreq_policy *);
    int (*offline)(struct cpufreq_policy *);
    void (*exit)(struct cpufreq_policy *);
    int (*suspend)(struct cpufreq_policy *);
    int (*resume)(struct cpufreq_policy *);
    void (*ready)(struct cpufreq_policy *);
    struct freq_attr **attr;
    bool boost_enabled;
    int (*set_boost)(struct cpufreq_policy *, int);
    void (*register_em)(struct cpufreq_policy *);
};

struct cpufreq_dt_platform_data {
    bool have_governor_per_policy;
    unsigned int (*get_intermediate)(struct cpufreq_policy *, unsigned int);
    int (*target_intermediate)(struct cpufreq_policy *, unsigned int);
    int (*suspend)(struct cpufreq_policy *);
    int (*resume)(struct cpufreq_policy *);
};

struct cpufreq_freqs {
    struct cpufreq_policy *policy;
    unsigned int old;
    unsigned int new;
    u8 flags;
};

struct cpufreq_frequency_table {
    unsigned int flags;
    unsigned int driver_data;
    unsigned int frequency;
};

struct cpufreq_governor {
    char name[16];
    int (*init)(struct cpufreq_policy *);
    void (*exit)(struct cpufreq_policy *);
    int (*start)(struct cpufreq_policy *);
    void (*stop)(struct cpufreq_policy *);
    void (*limits)(struct cpufreq_policy *);
    ssize_t (*show_setspeed)(struct cpufreq_policy *, char *);
    int (*store_setspeed)(struct cpufreq_policy *, unsigned int);
    struct list_head governor_list;
    struct module *owner;
    u8 flags;
};

struct plist_head {
    struct list_head node_list;
};

struct pm_qos_constraints {
    struct plist_head list;
    s32 target_value;
    s32 default_value;
    s32 no_constraint_value;
    enum pm_qos_type type;
    struct blocking_notifier_head *notifiers;
};

struct freq_constraints {
    struct pm_qos_constraints min_freq;
    struct blocking_notifier_head min_freq_notifiers;
    struct pm_qos_constraints max_freq;
    struct blocking_notifier_head max_freq_notifiers;
};

struct cpufreq_stats;

struct cpufreq_policy {
    cpumask_var_t cpus;
    cpumask_var_t related_cpus;
    cpumask_var_t real_cpus;
    unsigned int shared_type;
    unsigned int cpu;
    struct clk *clk;
    struct cpufreq_cpuinfo cpuinfo;
    unsigned int min;
    unsigned int max;
    unsigned int cur;
    unsigned int suspend_freq;
    unsigned int policy;
    unsigned int last_policy;
    struct cpufreq_governor *governor;
    void *governor_data;
    char last_governor[16];
    struct work_struct update;
    struct freq_constraints constraints;
    struct freq_qos_request *min_freq_req;
    struct freq_qos_request *max_freq_req;
    struct cpufreq_frequency_table *freq_table;
    enum cpufreq_table_sorting freq_table_sorted;
    struct list_head policy_list;
    struct kobject kobj;
    struct completion kobj_unregister;
    struct rw_semaphore rwsem;
    bool fast_switch_possible;
    bool fast_switch_enabled;
    bool strict_target;
    bool efficiencies_available;
    unsigned int transition_delay_us;
    bool dvfs_possible_from_any_cpu;
    bool boost_enabled;
    bool boost_supported;
    unsigned int cached_target_freq;
    unsigned int cached_resolved_idx;
    bool transition_ongoing;
    spinlock_t transition_lock;
    wait_queue_head_t transition_wait;
    struct task_struct *transition_task;
    struct cpufreq_stats *stats;
    void *driver_data;
    struct thermal_cooling_device *cdev;
    struct notifier_block nb_min;
    struct notifier_block nb_max;
};

struct cpufreq_policy_data {
    struct cpufreq_cpuinfo cpuinfo;
    struct cpufreq_frequency_table *freq_table;
    unsigned int cpu;
    unsigned int min;
    unsigned int max;
};

struct cpufreq_stats {
    unsigned int total_trans;
    long long unsigned int last_time;
    unsigned int max_state;
    unsigned int state_num;
    unsigned int last_index;
    u64 *time_in_state;
    unsigned int *freq_table;
    unsigned int *trans_table;
    unsigned int reset_pending;
    long long unsigned int reset_time;
};

struct cpuhp_cpu_state {
    enum cpuhp_state state;
    enum cpuhp_state target;
    enum cpuhp_state fail;
    struct task_struct *thread;
    bool should_run;
    bool rollback;
    bool single;
    bool bringup;
    struct hlist_node *node;
    struct hlist_node *last;
    enum cpuhp_state cb_state;
    int result;
    atomic_t ap_sync_state;
    struct completion done_up;
    struct completion done_down;
};

struct cpuhp_step {
    const char *name;
    union {
        int (*single)(unsigned int);
        int (*multi)(unsigned int, struct hlist_node *);
    } startup;
    union {
        int (*single)(unsigned int);
        int (*multi)(unsigned int, struct hlist_node *);
    } teardown;
    struct hlist_head list;
    bool cant_stop;
    bool multi_instance;
};

struct cpuidle_device;

struct cpuidle_attr {
    struct attribute attr;
    ssize_t (*show)(struct cpuidle_device *, char *);
    ssize_t (*store)(struct cpuidle_device *, const char *, size_t);
};

struct cpuidle_state_usage {
    long long unsigned int disable;
    long long unsigned int usage;
    u64 time_ns;
    long long unsigned int above;
    long long unsigned int below;
    long long unsigned int rejected;
};

struct cpuidle_driver_kobj;

struct cpuidle_state_kobj;

struct cpuidle_device_kobj;

struct cpuidle_device {
    unsigned int registered: 1;
    unsigned int enabled: 1;
    unsigned int poll_time_limit: 1;
    unsigned int cpu;
    ktime_t next_hrtimer;
    int last_state_idx;
    u64 last_residency_ns;
    u64 poll_limit_ns;
    u64 forced_idle_latency_limit_ns;
    struct cpuidle_state_usage states_usage[10];
    struct cpuidle_state_kobj *kobjs[10];
    struct cpuidle_driver_kobj *kobj_driver;
    struct cpuidle_device_kobj *kobj_dev;
    struct list_head device_list;
};

struct cpuidle_device_kobj {
    struct cpuidle_device *dev;
    struct completion kobj_unregister;
    struct kobject kobj;
};

struct cpuidle_driver;

struct cpuidle_state {
    char name[16];
    char desc[32];
    s64 exit_latency_ns;
    s64 target_residency_ns;
    unsigned int flags;
    unsigned int exit_latency;
    int power_usage;
    unsigned int target_residency;
    int (*enter)(struct cpuidle_device *, struct cpuidle_driver *, int);
    void (*enter_dead)(struct cpuidle_device *, int);
    int (*enter_s2idle)(struct cpuidle_device *, struct cpuidle_driver *, int);
};

struct cpuidle_driver {
    const char *name;
    struct module *owner;
    unsigned int bctimer: 1;
    struct cpuidle_state states[10];
    int state_count;
    int safe_state_index;
    struct cpumask *cpumask;
    const char *governor;
};

struct cpuidle_governor {
    char name[16];
    struct list_head governor_list;
    unsigned int rating;
    int (*enable)(struct cpuidle_driver *, struct cpuidle_device *);
    void (*disable)(struct cpuidle_driver *, struct cpuidle_device *);
    int (*select)(struct cpuidle_driver *, struct cpuidle_device *, bool *);
    void (*reflect)(struct cpuidle_device *, int);
};

struct cpuidle_state_attr {
    struct attribute attr;
    ssize_t (*show)(struct cpuidle_state *, struct cpuidle_state_usage *, char *);
    ssize_t (*store)(struct cpuidle_state *, struct cpuidle_state_usage *, const char *, size_t);
};

struct cpuidle_state_kobj {
    struct cpuidle_state *state;
    struct cpuidle_state_usage *state_usage;
    struct completion kobj_unregister;
    struct kobject kobj;
    struct cpuidle_device *device;
};

struct cpuinfo_32bit {
    u32 reg_id_dfr0;
    u32 reg_id_dfr1;
    u32 reg_id_isar0;
    u32 reg_id_isar1;
    u32 reg_id_isar2;
    u32 reg_id_isar3;
    u32 reg_id_isar4;
    u32 reg_id_isar5;
    u32 reg_id_isar6;
    u32 reg_id_mmfr0;
    u32 reg_id_mmfr1;
    u32 reg_id_mmfr2;
    u32 reg_id_mmfr3;
    u32 reg_id_mmfr4;
    u32 reg_id_mmfr5;
    u32 reg_id_pfr0;
    u32 reg_id_pfr1;
    u32 reg_id_pfr2;
    u32 reg_mvfr0;
    u32 reg_mvfr1;
    u32 reg_mvfr2;
};

struct cpuinfo_arm64 {
    struct kobject kobj;
    u64 reg_ctr;
    u64 reg_cntfrq;
    u64 reg_dczid;
    u64 reg_midr;
    u64 reg_revidr;
    u64 reg_gmid;
    u64 reg_smidr;
    u64 reg_mpamidr;
    u64 reg_id_aa64dfr0;
    u64 reg_id_aa64dfr1;
    u64 reg_id_aa64isar0;
    u64 reg_id_aa64isar1;
    u64 reg_id_aa64isar2;
    u64 reg_id_aa64isar3;
    u64 reg_id_aa64mmfr0;
    u64 reg_id_aa64mmfr1;
    u64 reg_id_aa64mmfr2;
    u64 reg_id_aa64mmfr3;
    u64 reg_id_aa64mmfr4;
    u64 reg_id_aa64pfr0;
    u64 reg_id_aa64pfr1;
    u64 reg_id_aa64pfr2;
    u64 reg_id_aa64zfr0;
    u64 reg_id_aa64smfr0;
    u64 reg_id_aa64fpfr0;
    struct cpuinfo_32bit aarch32;
};

union cpumask_rcuhead {
    cpumask_t cpumask;
    struct callback_head rcu;
};

struct cpupri_vec {
    atomic_t count;
    cpumask_var_t mask;
};

struct cpupri {
    struct cpupri_vec pri_to_cpu[101];
    int *cpu_to_pri;
};

struct fmeter {
    int cnt;
    int val;
    time64_t time;
    spinlock_t lock;
};

struct uf_node {
    struct uf_node *parent;
    unsigned int rank;
};

struct cpuset {
    struct cgroup_subsys_state css;
    long unsigned int flags;
    cpumask_var_t cpus_allowed;
    nodemask_t mems_allowed;
    cpumask_var_t effective_cpus;
    nodemask_t effective_mems;
    cpumask_var_t effective_xcpus;
    cpumask_var_t exclusive_cpus;
    nodemask_t old_mems_allowed;
    struct fmeter fmeter;
    int attach_in_progress;
    int relax_domain_level;
    int nr_subparts;
    int partition_root_state;
    int nr_deadline_tasks;
    int nr_migrate_dl_tasks;
    u64 sum_migrate_dl_bw;
    enum prs_errcode prs_err;
    struct cgroup_file partition_file;
    struct list_head remote_sibling;
    struct uf_node node;
};

struct cpuset_migrate_mm_work {
    struct work_struct work;
    struct mm_struct *mm;
    nodemask_t from;
    nodemask_t to;
};

struct range {
    u64 start;
    u64 end;
};

struct crash_mem {
    unsigned int max_nr_ranges;
    unsigned int nr_ranges;
    struct range ranges[0];
};

struct crc64_pi_tuple {
    __be64 guard_tag;
    __be16 app_tag;
    __u8 ref_tag[6];
};

struct group_info;

struct cred {
    atomic_long_t usage;
    kuid_t uid;
    kgid_t gid;
    kuid_t suid;
    kgid_t sgid;
    kuid_t euid;
    kgid_t egid;
    kuid_t fsuid;
    kgid_t fsgid;
    unsigned int securebits;
    kernel_cap_t cap_inheritable;
    kernel_cap_t cap_permitted;
    kernel_cap_t cap_effective;
    kernel_cap_t cap_bset;
    kernel_cap_t cap_ambient;
    unsigned char jit_keyring;
    struct key *session_keyring;
    struct key *process_keyring;
    struct key *thread_keyring;
    struct key *request_key_auth;
    void *security;
    struct user_struct *user;
    struct user_namespace *user_ns;
    struct ucounts *ucounts;
    struct group_info *group_info;
    union {
        int non_rcu;
        struct callback_head rcu;
    };
};

struct cred_label {
    const struct cred *cred;
    struct aa_label *label;
};

struct crng {
    u8 key[32];
    long unsigned int generation;
    local_lock_t lock;
};

struct crypto_tfm {
    refcount_t refcnt;
    u32 crt_flags;
    int node;
    void (*exit)(struct crypto_tfm *);
    struct crypto_alg *__crt_alg;
    void *__crt_ctx[0];
};

struct crypto_acomp {
    int (*compress)(struct acomp_req *);
    int (*decompress)(struct acomp_req *);
    void (*dst_free)(struct scatterlist *);
    unsigned int reqsize;
    struct crypto_tfm base;
};

struct crypto_wait {
    struct completion completion;
    int err;
};

struct crypto_acomp_ctx {
    struct crypto_acomp *acomp;
    struct acomp_req *req;
    struct crypto_wait wait;
    u8 *buffer;
    struct mutex mutex;
    bool is_sleepable;
};

struct crypto_aead {
    unsigned int authsize;
    unsigned int reqsize;
    struct crypto_tfm base;
};

struct crypto_spawn {
    struct list_head list;
    struct crypto_alg *alg;
    union {
        struct crypto_instance *inst;
        struct crypto_spawn *next;
    };
    const struct crypto_type *frontend;
    u32 mask;
    bool dead;
    bool registered;
};

struct crypto_aead_spawn {
    struct crypto_spawn base;
};

struct crypto_aes_ctx {
    u32 key_enc[60];
    u32 key_dec[60];
    u32 key_length;
};

struct crypto_ahash {
    bool using_shash;
    unsigned int statesize;
    unsigned int reqsize;
    struct crypto_tfm base;
};

struct crypto_ahash_spawn {
    struct crypto_spawn base;
};

struct crypto_akcipher {
    unsigned int reqsize;
    struct crypto_tfm base;
};

struct crypto_akcipher_spawn {
    struct crypto_spawn base;
};

struct crypto_akcipher_sync_data {
    struct crypto_akcipher *tfm;
    const void *src;
    void *dst;
    unsigned int slen;
    unsigned int dlen;
    struct akcipher_request *req;
    struct crypto_wait cwait;
    struct scatterlist sg;
    u8 *buf;
};

struct crypto_attr_alg {
    char name[128];
};

struct crypto_attr_type {
    u32 type;
    u32 mask;
};

struct crypto_cipher {
    struct crypto_tfm base;
};

struct crypto_cipher_spawn {
    struct crypto_spawn base;
};

struct crypto_comp {
    struct crypto_tfm base;
};

struct crypto_hash_walk {
    char *data;
    unsigned int offset;
    unsigned int flags;
    struct page *pg;
    unsigned int entrylen;
    unsigned int total;
    struct scatterlist *sg;
};

struct crypto_kpp {
    unsigned int reqsize;
    struct crypto_tfm base;
};

struct crypto_kpp_spawn {
    struct crypto_spawn base;
};

struct crypto_larval {
    struct crypto_alg alg;
    struct crypto_alg *adult;
    struct completion completion;
    u32 mask;
    bool test_started;
};

struct crypto_lskcipher {
    struct crypto_tfm base;
};

struct crypto_lskcipher_spawn {
    struct crypto_spawn base;
};

struct crypto_queue {
    struct list_head list;
    struct list_head *backlog;
    unsigned int qlen;
    unsigned int max_qlen;
};

struct crypto_report_acomp {
    char type[64];
};

struct crypto_report_aead {
    char type[64];
    char geniv[64];
    unsigned int blocksize;
    unsigned int maxauthsize;
    unsigned int ivsize;
};

struct crypto_report_akcipher {
    char type[64];
};

struct crypto_report_blkcipher {
    char type[64];
    char geniv[64];
    unsigned int blocksize;
    unsigned int min_keysize;
    unsigned int max_keysize;
    unsigned int ivsize;
};

struct crypto_report_comp {
    char type[64];
};

struct crypto_report_hash {
    char type[64];
    unsigned int blocksize;
    unsigned int digestsize;
};

struct crypto_report_kpp {
    char type[64];
};

struct crypto_report_rng {
    char type[64];
    unsigned int seedsize;
};

struct crypto_report_sig {
    char type[64];
};

struct crypto_rfc3686_ctx {
    struct crypto_skcipher *child;
    u8 nonce[4];
};

struct skcipher_request {
    unsigned int cryptlen;
    u8 *iv;
    struct scatterlist *src;
    struct scatterlist *dst;
    struct crypto_async_request base;
    void *__ctx[0];
};

struct crypto_rfc3686_req_ctx {
    u8 iv[16];
    struct skcipher_request subreq;
};

struct crypto_rng {
    struct crypto_tfm base;
};

struct crypto_scomp {
    struct crypto_tfm base;
};

struct crypto_shash {
    unsigned int descsize;
    struct crypto_tfm base;
};

struct crypto_shash_spawn {
    struct crypto_spawn base;
};

struct crypto_sig {
    struct crypto_tfm base;
};

struct crypto_sig_spawn {
    struct crypto_spawn base;
};

struct crypto_skcipher {
    unsigned int reqsize;
    struct crypto_tfm base;
};

struct crypto_skcipher_spawn {
    struct crypto_spawn base;
};

struct crypto_sync_skcipher {
    struct crypto_skcipher base;
};

struct rtattr;

struct crypto_template {
    struct list_head list;
    struct hlist_head instances;
    struct module *module;
    int (*create)(struct crypto_template *, struct rtattr **);
    char name[128];
};

struct crypto_test_param {
    char driver[128];
    char alg[128];
    u32 type;
};

struct crypto_type {
    unsigned int (*ctxsize)(struct crypto_alg *, u32, u32);
    unsigned int (*extsize)(struct crypto_alg *);
    int (*init_tfm)(struct crypto_tfm *);
    void (*show)(struct seq_file *, struct crypto_alg *);
    int (*report)(struct sk_buff *, struct crypto_alg *);
    void (*free)(struct crypto_instance *);
    unsigned int type;
    unsigned int maskclear;
    unsigned int maskset;
    unsigned int tfmsize;
};

struct rtattr {
    short unsigned int rta_len;
    short unsigned int rta_type;
};

struct cryptomgr_param {
    struct rtattr *tb[34];
    struct {
        struct rtattr attr;
        struct crypto_attr_type data;
    } type;
    struct {
        struct rtattr attr;
        struct crypto_attr_alg data;
    } attrs[32];
    char template[128];
    struct crypto_larval *larval;
    u32 otype;
    u32 omask;
};

struct cs_dbs_tuners {
    unsigned int down_threshold;
    unsigned int freq_step;
};

struct dbs_data;

struct policy_dbs_info {
    struct cpufreq_policy *policy;
    struct mutex update_mutex;
    u64 last_sample_time;
    s64 sample_delay_ns;
    atomic_t work_count;
    struct irq_work irq_work;
    struct work_struct work;
    struct dbs_data *dbs_data;
    struct list_head list;
    unsigned int rate_mult;
    unsigned int idle_periods;
    bool is_shared;
    bool work_in_progress;
};

struct cs_policy_dbs_info {
    struct policy_dbs_info policy_dbs;
    unsigned int down_skip;
    unsigned int requested_freq;
};

struct mem_ctl_info;

struct rank_info;

struct csrow_info {
    struct device dev;
    long unsigned int first_page;
    long unsigned int last_page;
    long unsigned int page_mask;
    int csrow_idx;
    u32 ue_count;
    u32 ce_count;
    struct mem_ctl_info *mci;
    u32 nr_channels;
    struct rank_info **channels;
};

struct css_set {
    struct cgroup_subsys_state *subsys[15];
    refcount_t refcount;
    struct css_set *dom_cset;
    struct cgroup *dfl_cgrp;
    int nr_tasks;
    struct list_head tasks;
    struct list_head mg_tasks;
    struct list_head dying_tasks;
    struct list_head task_iters;
    struct list_head e_cset_node[15];
    struct list_head threaded_csets;
    struct list_head threaded_csets_node;
    struct hlist_node hlist;
    struct list_head cgrp_links;
    struct list_head mg_src_preload_node;
    struct list_head mg_dst_preload_node;
    struct list_head mg_node;
    struct cgroup *mg_src_cgrp;
    struct cgroup *mg_dst_cgrp;
    struct css_set *mg_dst_cset;
    bool dead;
    struct callback_head callback_head;
};

struct css_set__safe_rcu {
    struct cgroup *dfl_cgrp;
};

struct cstate {
    int state;
    uint32_t rep0;
    uint32_t rep1;
    uint32_t rep2;
    uint32_t rep3;
};

struct csum_pseudo_header {
    __be64 data_seq;
    __be32 subflow_seq;
    __be16 data_len;
    __sum16 csum;
};

struct csum_state {
    __wsum csum;
    size_t off;
};

struct ct_data_s {
    union {
        ush freq;
        ush code;
    } fc;
    union {
        ush dad;
        ush len;
    } dl;
};

typedef struct ct_data_s ct_data;

struct ctl_table_root;

struct ctl_table_set;

struct ctl_dir;

struct ctl_node;

struct ctl_table_header {
    union {
        struct {
            const struct ctl_table *ctl_table;
            int ctl_table_size;
            int used;
            int count;
            int nreg;
        };
        struct callback_head rcu;
    };
    struct completion *unregistering;
    const struct ctl_table *ctl_table_arg;
    struct ctl_table_root *root;
    struct ctl_table_set *set;
    struct ctl_dir *parent;
    struct ctl_node *node;
    struct hlist_head inodes;
    enum {
        SYSCTL_TABLE_TYPE_DEFAULT = 0,
        SYSCTL_TABLE_TYPE_PERMANENTLY_EMPTY = 1,
    } type;
};

struct ctl_dir {
    struct ctl_table_header header;
    struct rb_root root;
};

struct edac_device_ctl_info;

struct ctl_info_attribute {
    struct attribute attr;
    ssize_t (*show)(struct edac_device_ctl_info *, char *);
    ssize_t (*store)(struct edac_device_ctl_info *, const char *, size_t);
};

struct ctl_node {
    struct rb_node node;
    struct ctl_table_header *header;
};

typedef int proc_handler(const struct ctl_table *, int, void *, size_t *, loff_t *);

struct ctl_table_poll;

struct ctl_table {
    const char *procname;
    void *data;
    int maxlen;
    umode_t mode;
    proc_handler *proc_handler;
    struct ctl_table_poll *poll;
    void *extra1;
    void *extra2;
};

struct ctl_table_poll {
    atomic_t event;
    wait_queue_head_t wait;
};

struct ctl_table_set {
    int (*is_seen)(struct ctl_table_set *);
    struct ctl_dir dir;
};

struct ctl_table_root {
    struct ctl_table_set default_set;
    struct ctl_table_set * (*lookup)(struct ctl_table_root *);
    void (*set_ownership)(struct ctl_table_header *, kuid_t *, kgid_t *);
    int (*permissions)(struct ctl_table_header *, const struct ctl_table *);
};

struct netlink_policy_dump_state;

struct genl_family;

struct genl_op_iter;

struct ctrl_dump_policy_ctx {
    struct netlink_policy_dump_state *state;
    const struct genl_family *rt;
    struct genl_op_iter *op_iter;
    u32 op;
    u16 fam_id;
    u8 dump_map: 1;
    u8 single_op: 1;
};

struct ctrl_pos {
    long unsigned int refaulted;
    long unsigned int total;
    int gain;
};

struct ctx_rq_wait {
    struct completion comp;
    atomic_t count;
};

struct ctx_switch_entry {
    struct trace_entry ent;
    unsigned int prev_pid;
    unsigned int next_pid;
    unsigned int next_cpu;
    unsigned char prev_prio;
    unsigned char prev_state;
    unsigned char next_prio;
    unsigned char next_state;
};

struct cvt_timing {
    u8 code[3];
};

struct cyclecounter {
    u64 (*read)(const struct cyclecounter *);
    u64 mask;
    u32 mult;
    u32 shift;
};

struct d0_features {
    __be16 code;
    u8 r_version;
    u8 length;
    u8 features[0];
};

struct d0_geometry_features {
    u8 header[4];
    u8 reserved01;
    u8 reserved02[7];
    __be32 logical_block_size;
    __be64 alignment_granularity;
    __be64 lowest_aligned_lba;
};

struct d0_header {
    __be32 length;
    __be32 revision;
    __be32 reserved01;
    __be32 reserved02;
    u8 ignored[32];
};

struct d0_locking_features {
    u8 supported_features;
    u8 reserved01[3];
    __be32 reserved02;
    __be32 reserved03;
};

struct d0_opal_v100 {
    __be16 baseComID;
    __be16 numComIDs;
};

struct d0_opal_v200 {
    __be16 baseComID;
    __be16 numComIDs;
    u8 range_crossing;
    u8 num_locking_admin_auth[2];
    u8 num_locking_user_auth[2];
    u8 initialPIN;
    u8 revertedPIN;
    u8 reserved01;
    __be32 reserved02;
};

struct d0_single_user_mode {
    __be32 num_locking_objects;
    u8 reserved01;
    u8 reserved02;
    __be16 reserved03;
    __be32 reserved04;
};

struct d0_tper_features {
    u8 supported_features;
    u8 reserved01[3];
    __be32 reserved02;
    __be32 reserved03;
};

struct data_chunk {
    size_t size;
    size_t icg;
    size_t dst_icg;
    size_t src_icg;
};

struct data_dirent {
    uint32_t virtual_address;
    uint32_t size;
};

struct data_directory {
    struct data_dirent exports;
    struct data_dirent imports;
    struct data_dirent resources;
    struct data_dirent exceptions;
    struct data_dirent certs;
    struct data_dirent base_relocations;
    struct data_dirent debug;
    struct data_dirent arch;
    struct data_dirent global_ptr;
    struct data_dirent tls;
    struct data_dirent load_config;
    struct data_dirent bound_imports;
    struct data_dirent import_addrs;
    struct data_dirent delay_imports;
    struct data_dirent clr_runtime_hdr;
    struct data_dirent reserved;
};

struct dax_device;

struct dax_holder_operations {
    int (*notify_failure)(struct dax_device *, u64, u64, int);
};

struct xhci_dbc;

struct dbc_driver {
    int (*configure)(struct xhci_dbc *);
    void (*disconnect)(struct xhci_dbc *);
};

struct xhci_ring;

struct dbc_ep {
    struct xhci_dbc *dbc;
    struct list_head list_pending;
    struct xhci_ring *ring;
    unsigned int direction: 1;
    unsigned int halted: 1;
};

struct dbc_regs {
    __le32 capability;
    __le32 doorbell;
    __le32 ersts;
    __le32 __reserved_0;
    __le64 erstba;
    __le64 erdp;
    __le32 control;
    __le32 status;
    __le32 portsc;
    __le32 __reserved_1;
    __le64 dccp;
    __le32 devinfo1;
    __le32 devinfo2;
};

union xhci_trb;

struct dbc_request {
    void *buf;
    unsigned int length;
    dma_addr_t dma;
    void (*complete)(struct xhci_dbc *, struct dbc_request *);
    struct list_head list_pool;
    int status;
    unsigned int actual;
    struct xhci_dbc *dbc;
    struct list_head list_pending;
    dma_addr_t trb_dma;
    union xhci_trb *trb;
    unsigned int direction: 1;
};

struct dbc_str_descs {
    char string0[64];
    char manufacturer[64];
    char product[64];
    char serial[64];
};

struct dbg_reg_def_t {
    char *name;
    int size;
    int offset;
};

struct gov_attr_set {
    struct kobject kobj;
    struct list_head policy_list;
    struct mutex update_lock;
    int usage_count;
};

struct dbs_governor;

struct dbs_data {
    struct gov_attr_set attr_set;
    struct dbs_governor *gov;
    void *tuners;
    unsigned int ignore_nice_load;
    unsigned int sampling_rate;
    unsigned int sampling_down_factor;
    unsigned int up_threshold;
    unsigned int io_is_busy;
};

struct sysfs_ops;

struct kobj_type {
    void (*release)(struct kobject *);
    const struct sysfs_ops *sysfs_ops;
    const struct attribute_group **default_groups;
    const struct kobj_ns_type_operations * (*child_ns_type)(const struct kobject *);
    const void * (*namespace)(const struct kobject *);
    void (*get_ownership)(const struct kobject *, kuid_t *, kgid_t *);
};

struct dbs_governor {
    struct cpufreq_governor gov;
    struct kobj_type kobj_type;
    struct dbs_data *gdbs_data;
    unsigned int (*gov_dbs_update)(struct cpufreq_policy *);
    struct policy_dbs_info * (*alloc)(void);
    void (*free)(struct policy_dbs_info *);
    int (*init)(struct dbs_data *);
    void (*exit)(struct dbs_data *);
    void (*start)(struct cpufreq_policy *);
};

struct dcb_app {
    __u8 selector;
    __u8 priority;
    __u16 protocol;
};

struct dcb_app_type {
    int ifindex;
    struct dcb_app app;
    struct list_head list;
    u8 dcbx;
};

struct dcb_ieee_app_dscp_map {
    u8 map[64];
};

struct dcb_ieee_app_prio_map {
    u64 map[8];
};

struct dcb_peer_app_info {
    __u8 willing;
    __u8 error;
};

struct dcb_rewr_prio_pcp_map {
    u16 map[8];
};

struct dcbmsg {
    __u8 dcb_family;
    __u8 cmd;
    __u16 dcb_pad;
};

struct dcbnl_buffer {
    __u8 prio2buffer[8];
    __u32 buffer_size[8];
    __u32 total_size;
};

struct ieee_ets;

struct ieee_maxrate;

struct ieee_qcn;

struct ieee_qcn_stats;

struct ieee_pfc;

struct dcbnl_rtnl_ops {
    int (*ieee_getets)(struct net_device *, struct ieee_ets *);
    int (*ieee_setets)(struct net_device *, struct ieee_ets *);
    int (*ieee_getmaxrate)(struct net_device *, struct ieee_maxrate *);
    int (*ieee_setmaxrate)(struct net_device *, struct ieee_maxrate *);
    int (*ieee_getqcn)(struct net_device *, struct ieee_qcn *);
    int (*ieee_setqcn)(struct net_device *, struct ieee_qcn *);
    int (*ieee_getqcnstats)(struct net_device *, struct ieee_qcn_stats *);
    int (*ieee_getpfc)(struct net_device *, struct ieee_pfc *);
    int (*ieee_setpfc)(struct net_device *, struct ieee_pfc *);
    int (*ieee_getapp)(struct net_device *, struct dcb_app *);
    int (*ieee_setapp)(struct net_device *, struct dcb_app *);
    int (*ieee_delapp)(struct net_device *, struct dcb_app *);
    int (*ieee_peer_getets)(struct net_device *, struct ieee_ets *);
    int (*ieee_peer_getpfc)(struct net_device *, struct ieee_pfc *);
    u8 (*getstate)(struct net_device *);
    u8 (*setstate)(struct net_device *, u8);
    void (*getpermhwaddr)(struct net_device *, u8 *);
    void (*setpgtccfgtx)(struct net_device *, int, u8, u8, u8, u8);
    void (*setpgbwgcfgtx)(struct net_device *, int, u8);
    void (*setpgtccfgrx)(struct net_device *, int, u8, u8, u8, u8);
    void (*setpgbwgcfgrx)(struct net_device *, int, u8);
    void (*getpgtccfgtx)(struct net_device *, int, u8 *, u8 *, u8 *, u8 *);
    void (*getpgbwgcfgtx)(struct net_device *, int, u8 *);
    void (*getpgtccfgrx)(struct net_device *, int, u8 *, u8 *, u8 *, u8 *);
    void (*getpgbwgcfgrx)(struct net_device *, int, u8 *);
    void (*setpfccfg)(struct net_device *, int, u8);
    void (*getpfccfg)(struct net_device *, int, u8 *);
    u8 (*setall)(struct net_device *);
    u8 (*getcap)(struct net_device *, int, u8 *);
    int (*getnumtcs)(struct net_device *, int, u8 *);
    int (*setnumtcs)(struct net_device *, int, u8);
    u8 (*getpfcstate)(struct net_device *);
    void (*setpfcstate)(struct net_device *, u8);
    void (*getbcncfg)(struct net_device *, int, u32 *);
    void (*setbcncfg)(struct net_device *, int, u32);
    void (*getbcnrp)(struct net_device *, int, u8 *);
    void (*setbcnrp)(struct net_device *, int, u8);
    int (*setapp)(struct net_device *, u8, u16, u8);
    int (*getapp)(struct net_device *, u8, u16);
    u8 (*getfeatcfg)(struct net_device *, int, u8 *);
    u8 (*setfeatcfg)(struct net_device *, int, u8);
    u8 (*getdcbx)(struct net_device *);
    u8 (*setdcbx)(struct net_device *, u8);
    int (*peer_getappinfo)(struct net_device *, struct dcb_peer_app_info *, u16 *);
    int (*peer_getapptable)(struct net_device *, struct dcb_app *);
    int (*cee_peer_getpg)(struct net_device *, struct cee_pg *);
    int (*cee_peer_getpfc)(struct net_device *, struct cee_pfc *);
    int (*dcbnl_getbuffer)(struct net_device *, struct dcbnl_buffer *);
    int (*dcbnl_setbuffer)(struct net_device *, struct dcbnl_buffer *);
    int (*dcbnl_setapptrust)(struct net_device *, u8 *, int);
    int (*dcbnl_getapptrust)(struct net_device *, u8 *, int *);
    int (*dcbnl_setrewr)(struct net_device *, struct dcb_app *);
    int (*dcbnl_delrewr)(struct net_device *, struct dcb_app *);
};

struct dccp_hdr {
    __be16 dccph_sport;
    __be16 dccph_dport;
    __u8 dccph_doff;
    __u8 dccph_cscov: 4;
    __u8 dccph_ccval: 4;
    __sum16 dccph_checksum;
    __u8 dccph_x: 1;
    __u8 dccph_type: 4;
    __u8 dccph_reserved: 3;
    __u8 dccph_seq2;
    __be16 dccph_seq;
};

struct io_stats_per_prio {
    uint32_t inserted;
    uint32_t merged;
    uint32_t dispatched;
    atomic_t completed;
};

struct dd_per_prio {
    struct list_head dispatch;
    struct rb_root sort_list[2];
    struct list_head fifo_list[2];
    sector_t latest_pos[2];
    struct io_stats_per_prio stats;
};

struct ddebug_class_map {
    struct list_head link;
    struct module *mod;
    const char *mod_name;
    const char **class_names;
    const int length;
    const int base;
    enum class_map_type map_type;
};

struct ddebug_class_param {
    union {
        long unsigned int *bits;
        unsigned int *lvl;
    };
    char flags[8];
    const struct ddebug_class_map *map;
};

struct ddebug_table;

struct ddebug_iter {
    struct ddebug_table *table;
    int idx;
};

struct ddebug_query {
    const char *filename;
    const char *module;
    const char *function;
    const char *format;
    const char *class_string;
    unsigned int first_lineno;
    unsigned int last_lineno;
};

struct ddebug_table {
    struct list_head link;
    struct list_head maps;
    const char *mod_name;
    unsigned int num_ddebugs;
    struct _ddebug *ddebugs;
};

struct deadline_data {
    struct dd_per_prio per_prio[3];
    enum dd_data_dir last_dir;
    unsigned int batching;
    unsigned int starved;
    int fifo_expire[2];
    int fifo_batch;
    int writes_starved;
    int front_merges;
    u32 async_depth;
    int prio_aging_expire;
    spinlock_t lock;
};

struct debug_info {
    int suspended_step;
    int bps_disabled;
    int wps_disabled;
    struct perf_event *hbp_break[16];
    struct perf_event *hbp_watch[16];
};

struct debug_reply_data {
    struct ethnl_reply_data base;
    u32 msg_mask;
};

struct debugfs_blob_wrapper {
    void *data;
    long unsigned int size;
};

struct debugfs_cancellation {
    struct list_head list;
    void (*cancel)(struct dentry *, void *);
    void *cancel_data;
};

struct debugfs_devm_entry {
    int (*read)(struct seq_file *, void *);
    struct device *dev;
};

struct debugfs_fs_info {
    kuid_t uid;
    kgid_t gid;
    umode_t mode;
    unsigned int opts;
};

struct debugfs_short_fops;

struct debugfs_fsdata {
    const struct file_operations *real_fops;
    const struct debugfs_short_fops *short_fops;
    struct {
        refcount_t active_users;
        struct completion active_users_drained;
        struct mutex cancellations_mtx;
        struct list_head cancellations;
        unsigned int methods;
    };
};

typedef struct vfsmount * (*debugfs_automount_t)(struct dentry *, void *);

struct debugfs_inode_info {
    struct inode vfs_inode;
    union {
        const void *raw;
        const struct file_operations *real_fops;
        const struct debugfs_short_fops *short_fops;
        debugfs_automount_t automount;
    };
    const void *aux;
};

struct debugfs_reg32 {
    char *name;
    long unsigned int offset;
};

struct debugfs_regset32 {
    const struct debugfs_reg32 *regs;
    int nregs;
    void *base;
    struct device *dev;
};

struct debugfs_short_fops {
    ssize_t (*read)(struct file *, char *, size_t, loff_t *);
    ssize_t (*write)(struct file *, const char *, size_t, loff_t *);
    loff_t (*llseek)(struct file *, loff_t, int);
};

struct debugfs_u32_array {
    u32 *array;
    u32 n_elements;
};

struct debuggerinfo_struct {
    void *debuggerinfo;
    struct task_struct *task;
    int exception_state;
    int ret_state;
    int irq_depth;
    int enter_kgdb;
    bool rounding_up;
};

struct decomp_stream {
    void *stream;
    struct list_head list;
};

struct dma_fence;

struct dma_fence_cb;

typedef void (*dma_fence_func_t)(struct dma_fence *, struct dma_fence_cb *);

struct dma_fence_cb {
    struct list_head node;
    dma_fence_func_t func;
};

struct default_wait_cb {
    struct dma_fence_cb base;
    struct task_struct *task;
};

struct deferred_split {
    spinlock_t split_queue_lock;
    struct list_head split_queue;
    long unsigned int split_queue_len;
};

struct internal_state;

struct z_stream_s {
    const Byte *next_in;
    uLong avail_in;
    uLong total_in;
    Byte *next_out;
    uLong avail_out;
    uLong total_out;
    char *msg;
    struct internal_state *state;
    void *workspace;
    int data_type;
    uLong adler;
    uLong reserved;
};

struct deflate_ctx {
    struct z_stream_s comp_stream;
    struct z_stream_s decomp_stream;
};

typedef struct z_stream_s z_stream;

typedef z_stream *z_streamp;

struct static_tree_desc_s;

typedef struct static_tree_desc_s static_tree_desc;

struct tree_desc_s {
    ct_data *dyn_tree;
    int max_code;
    static_tree_desc *stat_desc;
};

struct deflate_state {
    z_streamp strm;
    int status;
    Byte *pending_buf;
    ulg pending_buf_size;
    Byte *pending_out;
    int pending;
    int noheader;
    Byte data_type;
    Byte method;
    int last_flush;
    uInt w_size;
    uInt w_bits;
    uInt w_mask;
    Byte *window;
    ulg window_size;
    Pos *prev;
    Pos *head;
    uInt ins_h;
    uInt hash_size;
    uInt hash_bits;
    uInt hash_mask;
    uInt hash_shift;
    long int block_start;
    uInt match_length;
    IPos prev_match;
    int match_available;
    uInt strstart;
    uInt match_start;
    uInt lookahead;
    uInt prev_length;
    uInt max_chain_length;
    uInt max_lazy_match;
    int level;
    int strategy;
    uInt good_match;
    int nice_match;
    struct ct_data_s dyn_ltree[573];
    struct ct_data_s dyn_dtree[61];
    struct ct_data_s bl_tree[39];
    struct tree_desc_s l_desc;
    struct tree_desc_s d_desc;
    struct tree_desc_s bl_desc;
    ush bl_count[16];
    int heap[573];
    int heap_len;
    int heap_max;
    uch depth[573];
    uch *l_buf;
    uInt lit_bufsize;
    uInt last_lit;
    ush *d_buf;
    ulg opt_len;
    ulg static_len;
    ulg compressed_len;
    uInt matches;
    int last_eob_len;
    ush bi_buf;
    int bi_valid;
};

struct deflate_workspace {
    deflate_state deflate_memory;
    Byte *window_memory;
    Pos *prev_memory;
    Pos *head_memory;
    char *overlay_memory;
};

typedef struct deflate_workspace deflate_workspace;

struct delayed_call {
    void (*fn)(void *);
    void *arg;
};

struct delayed_uprobe {
    struct list_head list;
    struct uprobe *uprobe;
    struct mm_struct *mm;
};

struct hlist_bl_node {
    struct hlist_bl_node *next;
    struct hlist_bl_node **pprev;
};

struct qstr {
    union {
        struct {
            u32 hash;
            u32 len;
        };
        u64 hash_len;
    };
    const unsigned char *name;
};

union shortname_store {
    unsigned char string[40];
    long unsigned int words[5];
};

struct lockref {
    union {
        __u64 lock_count;
        struct {
            spinlock_t lock;
            int count;
        };
    };
};

struct dentry_operations;

struct dentry {
    unsigned int d_flags;
    seqcount_spinlock_t d_seq;
    struct hlist_bl_node d_hash;
    struct dentry *d_parent;
    struct qstr d_name;
    struct inode *d_inode;
    union shortname_store d_shortname;
    const struct dentry_operations *d_op;
    struct super_block *d_sb;
    long unsigned int d_time;
    void *d_fsdata;
    struct lockref d_lockref;
    union {
        struct list_head d_lru;
        wait_queue_head_t *d_wait;
    };
    struct hlist_node d_sib;
    struct hlist_head d_children;
    union {
        struct hlist_node d_alias;
        struct hlist_bl_node d_in_lookup_hash;
        struct callback_head d_rcu;
    } d_u;
};

struct dentry__safe_trusted {
    struct inode *d_inode;
};

struct dentry_info_args {
    int parent_ino;
    int dname_len;
    int ino;
    int inode_len;
    char *dname;
};

struct dentry_operations {
    int (*d_revalidate)(struct inode *, const struct qstr *, struct dentry *, unsigned int);
    int (*d_weak_revalidate)(struct dentry *, unsigned int);
    int (*d_hash)(const struct dentry *, struct qstr *);
    int (*d_compare)(const struct dentry *, unsigned int, const char *, const struct qstr *);
    int (*d_delete)(const struct dentry *);
    int (*d_init)(struct dentry *);
    void (*d_release)(struct dentry *);
    void (*d_prune)(struct dentry *);
    void (*d_iput)(struct dentry *, struct inode *);
    char * (*d_dname)(struct dentry *, char *, int);
    struct vfsmount * (*d_automount)(struct path *);
    int (*d_manage)(const struct path *, bool);
    struct dentry * (*d_real)(struct dentry *, enum d_real_type);
    bool (*d_unalias_trylock)(const struct dentry *);
    void (*d_unalias_unlock)(const struct dentry *);
    long: 64;
};

struct dentry_stat_t {
    long int nr_dentry;
    long int nr_unused;
    long int age_limit;
    long int want_pages;
    long int nr_negative;
    long int dummy;
};

struct slab;

struct detached_freelist {
    struct slab *slab;
    void *tail;
    void *freelist;
    int cnt;
    struct kmem_cache *s;
};

struct detailed_data_monitor_range {
    u8 min_vfreq;
    u8 max_vfreq;
    u8 min_hfreq_khz;
    u8 max_hfreq_khz;
    u8 pixel_clock_mhz;
    u8 flags;
    union {
        struct {
            u8 reserved;
            u8 hfreq_start_khz;
            u8 c;
            __le16 m;
            u8 k;
            u8 j;
        } __attribute__((packed)) gtf2;
        struct {
            u8 version;
            u8 data1;
            u8 data2;
            u8 supported_aspects;
            u8 flags;
            u8 supported_scalings;
            u8 preferred_refresh;
        } cvt;
    } formula;
};

struct detailed_data_string {
    u8 str[13];
};

struct detailed_data_wpindex {
    u8 white_yx_lo;
    u8 white_x_hi;
    u8 white_y_hi;
    u8 gamma;
};

struct detailed_mode_closure {
    struct drm_connector *connector;
    const struct drm_edid *drm_edid;
    bool preferred;
    int modes;
};

struct std_timing {
    u8 hsize;
    u8 vfreq_aspect;
};

struct detailed_non_pixel {
    u8 pad1;
    u8 type;
    u8 pad2;
    union {
        struct detailed_data_string str;
        struct detailed_data_monitor_range range;
        struct detailed_data_wpindex color;
        struct std_timing timings[6];
        struct cvt_timing cvt[4];
    } data;
};

struct detailed_pixel_timing {
    u8 hactive_lo;
    u8 hblank_lo;
    u8 hactive_hblank_hi;
    u8 vactive_lo;
    u8 vblank_lo;
    u8 vactive_vblank_hi;
    u8 hsync_offset_lo;
    u8 hsync_pulse_width_lo;
    u8 vsync_offset_pulse_width_lo;
    u8 hsync_vsync_offset_pulse_width_hi;
    u8 width_mm_lo;
    u8 height_mm_lo;
    u8 width_height_mm_hi;
    u8 hborder;
    u8 vborder;
    u8 misc;
};

struct detailed_timing {
    __le16 pixel_clock;
    union {
        struct detailed_pixel_timing pixel_data;
        struct detailed_non_pixel other_data;
    } data;
};

struct dev_cgroup {
    struct cgroup_subsys_state css;
    struct list_head exceptions;
    enum devcg_behavior behavior;
};

struct dev_exception_item {
    u32 major;
    u32 minor;
    short int type;
    short int access;
    struct list_head list;
    struct callback_head rcu;
};

struct dev_ext_attribute {
    struct device_attribute attr;
    void *var;
};

struct dev_ifalias {
    struct callback_head rcuhead;
    char ifalias[0];
};

struct iommu_fault_param;

struct iommu_fwspec;

struct dev_iommu {
    struct mutex lock;
    struct iommu_fault_param *fault_param;
    struct iommu_fwspec *fwspec;
    struct iommu_device *iommu_dev;
    void *priv;
    u32 max_pasids;
    u32 attach_deferred: 1;
    u32 pci_32bit_workaround: 1;
    u32 require_direct: 1;
    u32 shadow_on_flush: 1;
};

struct dev_kfree_skb_cb {
    enum skb_drop_reason reason;
};

struct vmem_altmap {
    long unsigned int base_pfn;
    const long unsigned int end_pfn;
    const long unsigned int reserve;
    long unsigned int free;
    long unsigned int align;
    long unsigned int alloc;
    bool inaccessible;
};

struct dev_pagemap_ops;

struct dev_pagemap {
    struct vmem_altmap altmap;
    struct percpu_ref ref;
    struct completion done;
    enum memory_type type;
    unsigned int flags;
    long unsigned int vmemmap_shift;
    const struct dev_pagemap_ops *ops;
    void *owner;
    int nr_range;
    union {
        struct range range;
        struct {
            struct {} __empty_ranges;
            struct range ranges[0];
        };
    };
};

struct vm_fault;

struct dev_pagemap_ops {
    void (*page_free)(struct page *);
    vm_fault_t (*migrate_to_ram)(struct vm_fault *);
    int (*memory_failure)(struct dev_pagemap *, long unsigned int, long unsigned int, int);
};

struct pinctrl;

struct pinctrl_state;

struct dev_pin_info {
    struct pinctrl *p;
    struct pinctrl_state *default_state;
    struct pinctrl_state *init_state;
    struct pinctrl_state *sleep_state;
    struct pinctrl_state *idle_state;
};

struct dev_pm_domain_attach_data {
    const char * const *pd_names;
    const u32 num_pd_names;
    const u32 pd_flags;
};

struct device_link;

struct dev_pm_domain_list {
    struct device **pd_devs;
    struct device_link **pd_links;
    u32 *opp_tokens;
    u32 num_pds;
};

struct dev_pm_opp_supply;

struct dev_pm_opp_icc_bw;

struct dev_pm_opp {
    struct list_head node;
    struct kref kref;
    bool available;
    bool dynamic;
    bool turbo;
    bool suspend;
    bool removed;
    long unsigned int *rates;
    unsigned int level;
    struct dev_pm_opp_supply *supplies;
    struct dev_pm_opp_icc_bw *bandwidth;
    long unsigned int clock_latency_ns;
    struct dev_pm_opp **required_opps;
    struct opp_table *opp_table;
    struct device_node *np;
    struct dentry *dentry;
    const char *of_name;
};

typedef int (*config_clks_t)(struct device *, struct opp_table *, struct dev_pm_opp *, void *, bool);

typedef int (*config_regulators_t)(struct device *, struct dev_pm_opp *, struct dev_pm_opp *, struct regulator **, unsigned int);

struct dev_pm_opp_config {
    const char * const *clk_names;
    config_clks_t config_clks;
    const char *prop_name;
    config_regulators_t config_regulators;
    const unsigned int *supported_hw;
    unsigned int supported_hw_count;
    const char * const *regulator_names;
    struct device *required_dev;
    unsigned int required_dev_index;
};

struct dev_pm_opp_data {
    bool turbo;
    unsigned int level;
    long unsigned int freq;
    long unsigned int u_volt;
};

struct dev_pm_opp_icc_bw {
    u32 avg;
    u32 peak;
};

struct dev_pm_opp_supply {
    long unsigned int u_volt;
    long unsigned int u_volt_min;
    long unsigned int u_volt_max;
    long unsigned int u_amp;
    long unsigned int u_watt;
};

struct pm_qos_flags {
    struct list_head list;
    s32 effective_flags;
};

struct dev_pm_qos_request;

struct dev_pm_qos {
    struct pm_qos_constraints resume_latency;
    struct pm_qos_constraints latency_tolerance;
    struct freq_constraints freq;
    struct pm_qos_flags flags;
    struct dev_pm_qos_request *resume_latency_req;
    struct dev_pm_qos_request *latency_tolerance_req;
    struct dev_pm_qos_request *flags_req;
};

struct pm_qos_flags_request {
    struct list_head node;
    s32 flags;
};

struct dev_pm_qos_request {
    enum dev_pm_qos_req_type type;
    union {
        struct plist_node pnode;
        struct pm_qos_flags_request flr;
        struct freq_qos_request freq;
    } data;
    struct device *dev;
};

struct dev_power_governor {
    bool (*power_down_ok)(struct dev_pm_domain *);
    bool (*suspend_ok)(struct device *);
};

struct dev_printk_info {
    char subsystem[16];
    char device[48];
};

struct devcd_entry {
    struct device devcd_dev;
    void *data;
    size_t datalen;
    struct mutex mutex;
    bool delete_work;
    struct module *owner;
    ssize_t (*read)(char *, loff_t, size_t, void *, size_t);
    void (*free)(void *);
    struct delayed_work del_wk;
    struct device *failing_dev;
};

struct devfreq_dev_status {
    long unsigned int total_time;
    long unsigned int busy_time;
    long unsigned int current_frequency;
    void *private_data;
};

struct devfreq_stats {
    unsigned int total_trans;
    unsigned int *trans_table;
    u64 *time_in_state;
    u64 last_update;
};

struct devfreq_dev_profile;

struct devfreq_governor;

struct devfreq {
    struct list_head node;
    struct mutex lock;
    struct device dev;
    struct devfreq_dev_profile *profile;
    const struct devfreq_governor *governor;
    struct opp_table *opp_table;
    struct notifier_block nb;
    struct delayed_work work;
    long unsigned int *freq_table;
    unsigned int max_state;
    long unsigned int previous_freq;
    struct devfreq_dev_status last_status;
    void *data;
    void *governor_data;
    struct dev_pm_qos_request user_min_freq_req;
    struct dev_pm_qos_request user_max_freq_req;
    long unsigned int scaling_min_freq;
    long unsigned int scaling_max_freq;
    bool stop_polling;
    long unsigned int suspend_freq;
    long unsigned int resume_freq;
    atomic_t suspend_count;
    struct devfreq_stats stats;
    struct srcu_notifier_head transition_notifier_list;
    struct thermal_cooling_device *cdev;
    struct notifier_block nb_min;
    struct notifier_block nb_max;
};

struct devfreq_cooling_power;

struct devfreq_cooling_device {
    struct thermal_cooling_device *cdev;
    struct thermal_cooling_device_ops cooling_ops;
    struct devfreq *devfreq;
    long unsigned int cooling_state;
    u32 *freq_table;
    size_t max_state;
    struct devfreq_cooling_power *power_ops;
    u32 res_util;
    int capped_state;
    struct dev_pm_qos_request req_max_freq;
    struct em_perf_domain *em_pd;
};

struct devfreq_cooling_power {
    int (*get_real_power)(struct devfreq *, u32 *, long unsigned int, long unsigned int);
};

struct devfreq_dev_profile {
    long unsigned int initial_freq;
    unsigned int polling_ms;
    enum devfreq_timer timer;
    int (*target)(struct device *, long unsigned int *, u32);
    int (*get_dev_status)(struct device *, struct devfreq_dev_status *);
    int (*get_cur_freq)(struct device *, long unsigned int *);
    void (*exit)(struct device *);
    long unsigned int *freq_table;
    unsigned int max_state;
    bool is_cooling_device;
};

struct devfreq_event_data {
    long unsigned int load_count;
    long unsigned int total_count;
};

struct devfreq_event_ops;

struct devfreq_event_desc {
    const char *name;
    u32 event_type;
    void *driver_data;
    const struct devfreq_event_ops *ops;
};

struct devfreq_event_dev {
    struct list_head node;
    struct device dev;
    struct mutex lock;
    u32 enable_count;
    const struct devfreq_event_desc *desc;
};

struct devfreq_event_ops {
    int (*enable)(struct devfreq_event_dev *);
    int (*disable)(struct devfreq_event_dev *);
    int (*reset)(struct devfreq_event_dev *);
    int (*set_event)(struct devfreq_event_dev *);
    int (*get_event)(struct devfreq_event_dev *, struct devfreq_event_data *);
};

struct devfreq_freqs {
    long unsigned int old;
    long unsigned int new;
};

struct devfreq_governor {
    struct list_head node;
    const char name[16];
    const u64 attrs;
    const u64 flags;
    int (*get_target_freq)(struct devfreq *, long unsigned int *);
    int (*event_handler)(struct devfreq *, unsigned int, void *);
};

struct devfreq_notifier_devres {
    struct devfreq *devfreq;
    struct notifier_block *nb;
    unsigned int list;
};

struct devfreq_passive_data {
    struct devfreq *parent;
    int (*get_target_freq)(struct devfreq *, long unsigned int *);
    enum devfreq_parent_dev_type parent_type;
    struct devfreq *this;
    struct notifier_block nb;
    struct list_head cpu_data_list;
};

struct device_attach_data {
    struct device *dev;
    bool check_async;
    bool want_async;
    bool have_async;
};

union device_attr_group_devres {
    const struct attribute_group *group;
    const struct attribute_group **groups;
};

struct device_link {
    struct device *supplier;
    struct list_head s_node;
    struct device *consumer;
    struct list_head c_node;
    struct device link_dev;
    enum device_link_state status;
    u32 flags;
    refcount_t rpm_active;
    struct kref kref;
    struct work_struct rm_work;
    bool supplier_preactivated;
};

struct fwnode_operations;

struct fwnode_handle {
    struct fwnode_handle *secondary;
    const struct fwnode_operations *ops;
    struct device *dev;
    struct list_head suppliers;
    struct list_head consumers;
    u8 flags;
};

struct property;

struct device_node {
    const char *name;
    phandle phandle;
    const char *full_name;
    struct fwnode_handle fwnode;
    struct property *properties;
    struct property *deadprops;
    struct device_node *parent;
    struct device_node *child;
    struct device_node *sibling;
    struct kobject kobj;
    long unsigned int _flags;
    void *data;
};

struct device_physical_location {
    enum device_physical_location_panel panel;
    enum device_physical_location_vertical_position vertical_position;
    enum device_physical_location_horizontal_position horizontal_position;
    bool dock;
    bool lid;
};

struct klist_node {
    void *n_klist;
    struct list_head n_node;
    struct kref n_ref;
};

struct device_private {
    struct klist klist_children;
    struct klist_node knode_parent;
    struct klist_node knode_driver;
    struct klist_node knode_bus;
    struct klist_node knode_class;
    struct list_head deferred_probe;
    const struct device_driver *async_driver;
    char *deferred_probe_reason;
    struct device *device;
    u8 dead: 1;
};

struct device_type {
    const char *name;
    const struct attribute_group **groups;
    int (*uevent)(const struct device *, struct kobj_uevent_env *);
    char * (*devnode)(const struct device *, umode_t *, kuid_t *, kgid_t *);
    void (*release)(struct device *);
    const struct dev_pm_ops *pm;
};

struct devinet_sysctl_table {
    struct ctl_table_header *sysctl_header;
    struct ctl_table devinet_vars[33];
};

struct ratelimit_state {
    raw_spinlock_t lock;
    int interval;
    int burst;
    int printed;
    int missed;
    unsigned int flags;
    long unsigned int begin;
};

struct printk_buffers {
    char outbuf[2048];
    char scratchbuf[1024];
};

struct devkmsg_user {
    atomic64_t seq;
    struct ratelimit_state rs;
    struct mutex lock;
    struct printk_buffers pbufs;
};

struct devlink_dev_stats {
    u32 reload_stats[6];
    u32 remote_reload_stats[6];
};

struct devlink_dpipe_headers;

struct devlink_ops;

struct devlink_rel;

struct devlink {
    u32 index;
    struct xarray ports;
    struct list_head rate_list;
    struct list_head sb_list;
    struct list_head dpipe_table_list;
    struct list_head resource_list;
    struct xarray params;
    struct list_head region_list;
    struct list_head reporter_list;
    struct devlink_dpipe_headers *dpipe_headers;
    struct list_head trap_list;
    struct list_head trap_group_list;
    struct list_head trap_policer_list;
    struct list_head linecard_list;
    const struct devlink_ops *ops;
    struct xarray snapshot_ids;
    struct devlink_dev_stats stats;
    struct device *dev;
    possible_net_t _net;
    struct mutex lock;
    struct lock_class_key lock_key;
    u8 reload_failed: 1;
    refcount_t refcount;
    struct rcu_work rwork;
    struct devlink_rel *rel;
    struct xarray nested_rels;
    char priv[0];
};

struct devlink_dpipe_header;

struct devlink_dpipe_action {
    enum devlink_dpipe_action_type type;
    unsigned int header_index;
    struct devlink_dpipe_header *header;
    unsigned int field_id;
};

struct genl_info;

struct devlink_dpipe_dump_ctx {
    struct genl_info *info;
    enum devlink_command cmd;
    struct sk_buff *skb;
    struct nlattr *nest;
    void *hdr;
};

struct devlink_dpipe_value;

struct devlink_dpipe_entry {
    u64 index;
    struct devlink_dpipe_value *match_values;
    unsigned int match_values_count;
    struct devlink_dpipe_value *action_values;
    unsigned int action_values_count;
    u64 counter;
    bool counter_valid;
};

struct devlink_dpipe_field {
    const char *name;
    unsigned int id;
    unsigned int bitwidth;
    enum devlink_dpipe_field_mapping_type mapping_type;
};

struct devlink_dpipe_header {
    const char *name;
    unsigned int id;
    struct devlink_dpipe_field *fields;
    unsigned int fields_count;
    bool global;
};

struct devlink_dpipe_headers {
    struct devlink_dpipe_header **headers;
    unsigned int headers_count;
};

struct devlink_dpipe_match {
    enum devlink_dpipe_match_type type;
    unsigned int header_index;
    struct devlink_dpipe_header *header;
    unsigned int field_id;
};

struct devlink_dpipe_table_ops;

struct devlink_dpipe_table {
    void *priv;
    struct list_head list;
    const char *name;
    bool counters_enabled;
    bool counter_control_extern;
    bool resource_valid;
    u64 resource_id;
    u64 resource_units;
    const struct devlink_dpipe_table_ops *table_ops;
    struct callback_head rcu;
};

struct devlink_dpipe_table_ops {
    int (*actions_dump)(void *, struct sk_buff *);
    int (*matches_dump)(void *, struct sk_buff *);
    int (*entries_dump)(void *, bool, struct devlink_dpipe_dump_ctx *);
    int (*counters_set_update)(void *, bool);
    u64 (*size_get)(void *);
};

struct devlink_dpipe_value {
    union {
        struct devlink_dpipe_action *action;
        struct devlink_dpipe_match *match;
    };
    unsigned int mapping_value;
    bool mapping_valid;
    unsigned int value_size;
    void *value;
    void *mask;
};

struct devlink_flash_component_lookup_ctx {
    const char *lookup_name;
    bool lookup_name_found;
};

struct devlink_flash_notify {
    const char *status_msg;
    const char *component;
    long unsigned int done;
    long unsigned int total;
    long unsigned int timeout;
};

struct devlink_flash_update_params {
    const struct firmware *fw;
    const char *component;
    u32 overwrite_mask;
};

struct devlink_fmsg {
    struct list_head item_list;
    int err;
    bool putting_binary;
};

struct devlink_fmsg_item {
    struct list_head list;
    int attrtype;
    u8 nla_type;
    u16 len;
    int value[0];
};

struct devlink_health_reporter_ops;

struct devlink_port;

struct devlink_health_reporter {
    struct list_head list;
    void *priv;
    const struct devlink_health_reporter_ops *ops;
    struct devlink *devlink;
    struct devlink_port *devlink_port;
    struct devlink_fmsg *dump_fmsg;
    u64 graceful_period;
    bool auto_recover;
    bool auto_dump;
    u8 health_state;
    u64 dump_ts;
    u64 dump_real_ts;
    u64 error_count;
    u64 recovery_count;
    u64 last_recovery_ts;
};

struct devlink_health_reporter_ops {
    char *name;
    int (*recover)(struct devlink_health_reporter *, void *, struct netlink_ext_ack *);
    int (*dump)(struct devlink_health_reporter *, struct devlink_fmsg *, void *, struct netlink_ext_ack *);
    int (*diagnose)(struct devlink_health_reporter *, struct devlink_fmsg *, struct netlink_ext_ack *);
    int (*test)(struct devlink_health_reporter *, struct netlink_ext_ack *);
};

struct devlink_info_req {
    struct sk_buff *msg;
    void (*version_cb)(const char *, enum devlink_info_version_type, void *);
    void *version_cb_priv;
};

struct devlink_linecard_ops;

struct devlink_linecard_type;

struct devlink_linecard {
    struct list_head list;
    struct devlink *devlink;
    unsigned int index;
    const struct devlink_linecard_ops *ops;
    void *priv;
    enum devlink_linecard_state state;
    struct mutex state_lock;
    const char *type;
    struct devlink_linecard_type *types;
    unsigned int types_count;
    u32 rel_index;
};

struct devlink_linecard_ops {
    int (*provision)(struct devlink_linecard *, void *, const char *, const void *, struct netlink_ext_ack *);
    int (*unprovision)(struct devlink_linecard *, void *, struct netlink_ext_ack *);
    bool (*same_provision)(struct devlink_linecard *, void *, const char *, const void *);
    unsigned int (*types_count)(struct devlink_linecard *, void *);
    void (*types_get)(struct devlink_linecard *, void *, unsigned int, const char **, const void **);
};

struct devlink_linecard_type {
    const char *type;
    const void *priv;
};

struct devlink_nl_dump_state {
    long unsigned int instance;
    int idx;
    union {
        struct {
            u64 start_offset;
        };
        struct {
            u64 dump_ts;
        };
    };
};

struct devlink_obj_desc;

struct devlink_nl_sock_priv {
    struct devlink_obj_desc *flt;
    spinlock_t flt_lock;
};

struct devlink_obj_desc {
    struct callback_head rcu;
    const char *bus_name;
    const char *dev_name;
    unsigned int port_index;
    bool port_index_valid;
    long int data[0];
};

struct devlink_sb_pool_info;

struct devlink_trap;

struct devlink_trap_group;

struct devlink_trap_policer;

struct devlink_port_new_attrs;

struct devlink_rate;

struct devlink_ops {
    u32 supported_flash_update_params;
    long unsigned int reload_actions;
    long unsigned int reload_limits;
    int (*reload_down)(struct devlink *, bool, enum devlink_reload_action, enum devlink_reload_limit, struct netlink_ext_ack *);
    int (*reload_up)(struct devlink *, enum devlink_reload_action, enum devlink_reload_limit, u32 *, struct netlink_ext_ack *);
    int (*sb_pool_get)(struct devlink *, unsigned int, u16, struct devlink_sb_pool_info *);
    int (*sb_pool_set)(struct devlink *, unsigned int, u16, u32, enum devlink_sb_threshold_type, struct netlink_ext_ack *);
    int (*sb_port_pool_get)(struct devlink_port *, unsigned int, u16, u32 *);
    int (*sb_port_pool_set)(struct devlink_port *, unsigned int, u16, u32, struct netlink_ext_ack *);
    int (*sb_tc_pool_bind_get)(struct devlink_port *, unsigned int, u16, enum devlink_sb_pool_type, u16 *, u32 *);
    int (*sb_tc_pool_bind_set)(struct devlink_port *, unsigned int, u16, enum devlink_sb_pool_type, u16, u32, struct netlink_ext_ack *);
    int (*sb_occ_snapshot)(struct devlink *, unsigned int);
    int (*sb_occ_max_clear)(struct devlink *, unsigned int);
    int (*sb_occ_port_pool_get)(struct devlink_port *, unsigned int, u16, u32 *, u32 *);
    int (*sb_occ_tc_port_bind_get)(struct devlink_port *, unsigned int, u16, enum devlink_sb_pool_type, u32 *, u32 *);
    int (*eswitch_mode_get)(struct devlink *, u16 *);
    int (*eswitch_mode_set)(struct devlink *, u16, struct netlink_ext_ack *);
    int (*eswitch_inline_mode_get)(struct devlink *, u8 *);
    int (*eswitch_inline_mode_set)(struct devlink *, u8, struct netlink_ext_ack *);
    int (*eswitch_encap_mode_get)(struct devlink *, enum devlink_eswitch_encap_mode *);
    int (*eswitch_encap_mode_set)(struct devlink *, enum devlink_eswitch_encap_mode, struct netlink_ext_ack *);
    int (*info_get)(struct devlink *, struct devlink_info_req *, struct netlink_ext_ack *);
    int (*flash_update)(struct devlink *, struct devlink_flash_update_params *, struct netlink_ext_ack *);
    int (*trap_init)(struct devlink *, const struct devlink_trap *, void *);
    void (*trap_fini)(struct devlink *, const struct devlink_trap *, void *);
    int (*trap_action_set)(struct devlink *, const struct devlink_trap *, enum devlink_trap_action, struct netlink_ext_ack *);
    int (*trap_group_init)(struct devlink *, const struct devlink_trap_group *);
    int (*trap_group_set)(struct devlink *, const struct devlink_trap_group *, const struct devlink_trap_policer *, struct netlink_ext_ack *);
    int (*trap_group_action_set)(struct devlink *, const struct devlink_trap_group *, enum devlink_trap_action, struct netlink_ext_ack *);
    int (*trap_drop_counter_get)(struct devlink *, const struct devlink_trap *, u64 *);
    int (*trap_policer_init)(struct devlink *, const struct devlink_trap_policer *);
    void (*trap_policer_fini)(struct devlink *, const struct devlink_trap_policer *);
    int (*trap_policer_set)(struct devlink *, const struct devlink_trap_policer *, u64, u64, struct netlink_ext_ack *);
    int (*trap_policer_counter_get)(struct devlink *, const struct devlink_trap_policer *, u64 *);
    int (*port_new)(struct devlink *, const struct devlink_port_new_attrs *, struct netlink_ext_ack *, struct devlink_port **);
    int (*rate_leaf_tx_share_set)(struct devlink_rate *, void *, u64, struct netlink_ext_ack *);
    int (*rate_leaf_tx_max_set)(struct devlink_rate *, void *, u64, struct netlink_ext_ack *);
    int (*rate_leaf_tx_priority_set)(struct devlink_rate *, void *, u32, struct netlink_ext_ack *);
    int (*rate_leaf_tx_weight_set)(struct devlink_rate *, void *, u32, struct netlink_ext_ack *);
    int (*rate_node_tx_share_set)(struct devlink_rate *, void *, u64, struct netlink_ext_ack *);
    int (*rate_node_tx_max_set)(struct devlink_rate *, void *, u64, struct netlink_ext_ack *);
    int (*rate_node_tx_priority_set)(struct devlink_rate *, void *, u32, struct netlink_ext_ack *);
    int (*rate_node_tx_weight_set)(struct devlink_rate *, void *, u32, struct netlink_ext_ack *);
    int (*rate_node_new)(struct devlink_rate *, void **, struct netlink_ext_ack *);
    int (*rate_node_del)(struct devlink_rate *, void *, struct netlink_ext_ack *);
    int (*rate_leaf_parent_set)(struct devlink_rate *, struct devlink_rate *, void *, void *, struct netlink_ext_ack *);
    int (*rate_node_parent_set)(struct devlink_rate *, struct devlink_rate *, void *, void *, struct netlink_ext_ack *);
    bool (*selftest_check)(struct devlink *, unsigned int, struct netlink_ext_ack *);
    enum devlink_selftest_status (*selftest_run)(struct devlink *, unsigned int, struct netlink_ext_ack *);
};

struct devlink_param_gset_ctx;

union devlink_param_value;

struct devlink_param {
    u32 id;
    const char *name;
    bool generic;
    enum devlink_param_type type;
    long unsigned int supported_cmodes;
    int (*get)(struct devlink *, u32, struct devlink_param_gset_ctx *);
    int (*set)(struct devlink *, u32, struct devlink_param_gset_ctx *, struct netlink_ext_ack *);
    int (*validate)(struct devlink *, u32, union devlink_param_value, struct netlink_ext_ack *);
};

union devlink_param_value {
    u8 vu8;
    u16 vu16;
    u32 vu32;
    char vstr[32];
    bool vbool;
};

struct devlink_param_gset_ctx {
    union devlink_param_value val;
    enum devlink_param_cmode cmode;
};

struct devlink_param_item {
    struct list_head list;
    const struct devlink_param *param;
    union devlink_param_value driverinit_value;
    bool driverinit_value_valid;
    union devlink_param_value driverinit_value_new;
    bool driverinit_value_new_valid;
};

struct netdev_phys_item_id {
    unsigned char id[32];
    unsigned char id_len;
};

struct devlink_port_phys_attrs {
    u32 port_number;
    u32 split_subport_number;
};

struct devlink_port_pci_pf_attrs {
    u32 controller;
    u16 pf;
    u8 external: 1;
};

struct devlink_port_pci_vf_attrs {
    u32 controller;
    u16 pf;
    u16 vf;
    u8 external: 1;
};

struct devlink_port_pci_sf_attrs {
    u32 controller;
    u32 sf;
    u16 pf;
    u8 external: 1;
};

struct devlink_port_attrs {
    u8 split: 1;
    u8 splittable: 1;
    u32 lanes;
    enum devlink_port_flavour flavour;
    struct netdev_phys_item_id switch_id;
    union {
        struct devlink_port_phys_attrs phys;
        struct devlink_port_pci_pf_attrs pci_pf;
        struct devlink_port_pci_vf_attrs pci_vf;
        struct devlink_port_pci_sf_attrs pci_sf;
    };
};

struct devlink_port_ops;

struct ib_device;

struct devlink_port {
    struct list_head list;
    struct list_head region_list;
    struct devlink *devlink;
    const struct devlink_port_ops *ops;
    unsigned int index;
    spinlock_t type_lock;
    enum devlink_port_type type;
    enum devlink_port_type desired_type;
    union {
        struct {
            struct net_device *netdev;
            int ifindex;
            char ifname[16];
        } type_eth;
        struct {
            struct ib_device *ibdev;
        } type_ib;
    };
    struct devlink_port_attrs attrs;
    u8 attrs_set: 1;
    u8 switch_port: 1;
    u8 registered: 1;
    u8 initialized: 1;
    struct delayed_work type_warn_dw;
    struct list_head reporter_list;
    struct devlink_rate *devlink_rate;
    struct devlink_linecard *linecard;
    u32 rel_index;
};

struct devlink_port_new_attrs {
    enum devlink_port_flavour flavour;
    unsigned int port_index;
    u32 controller;
    u32 sfnum;
    u16 pfnum;
    u8 port_index_valid: 1;
    u8 controller_valid: 1;
    u8 sfnum_valid: 1;
};

struct devlink_port_ops {
    int (*port_split)(struct devlink *, struct devlink_port *, unsigned int, struct netlink_ext_ack *);
    int (*port_unsplit)(struct devlink *, struct devlink_port *, struct netlink_ext_ack *);
    int (*port_type_set)(struct devlink_port *, enum devlink_port_type);
    int (*port_del)(struct devlink *, struct devlink_port *, struct netlink_ext_ack *);
    int (*port_fn_hw_addr_get)(struct devlink_port *, u8 *, int *, struct netlink_ext_ack *);
    int (*port_fn_hw_addr_set)(struct devlink_port *, const u8 *, int, struct netlink_ext_ack *);
    int (*port_fn_roce_get)(struct devlink_port *, bool *, struct netlink_ext_ack *);
    int (*port_fn_roce_set)(struct devlink_port *, bool, struct netlink_ext_ack *);
    int (*port_fn_migratable_get)(struct devlink_port *, bool *, struct netlink_ext_ack *);
    int (*port_fn_migratable_set)(struct devlink_port *, bool, struct netlink_ext_ack *);
    int (*port_fn_state_get)(struct devlink_port *, enum devlink_port_fn_state *, enum devlink_port_fn_opstate *, struct netlink_ext_ack *);
    int (*port_fn_state_set)(struct devlink_port *, enum devlink_port_fn_state, struct netlink_ext_ack *);
    int (*port_fn_ipsec_crypto_get)(struct devlink_port *, bool *, struct netlink_ext_ack *);
    int (*port_fn_ipsec_crypto_set)(struct devlink_port *, bool, struct netlink_ext_ack *);
    int (*port_fn_ipsec_packet_get)(struct devlink_port *, bool *, struct netlink_ext_ack *);
    int (*port_fn_ipsec_packet_set)(struct devlink_port *, bool, struct netlink_ext_ack *);
    int (*port_fn_max_io_eqs_get)(struct devlink_port *, u32 *, struct netlink_ext_ack *);
    int (*port_fn_max_io_eqs_set)(struct devlink_port *, u32, struct netlink_ext_ack *);
};

struct devlink_port_region_ops {
    const char *name;
    void (*destructor)(const void *);
    int (*snapshot)(struct devlink_port *, const struct devlink_port_region_ops *, struct netlink_ext_ack *, u8 **);
    int (*read)(struct devlink_port *, const struct devlink_port_region_ops *, struct netlink_ext_ack *, u64, u32, u8 *);
    void *priv;
};

struct devlink_rate {
    struct list_head list;
    enum devlink_rate_type type;
    struct devlink *devlink;
    void *priv;
    u64 tx_share;
    u64 tx_max;
    struct devlink_rate *parent;
    union {
        struct devlink_port *devlink_port;
        struct {
            char *name;
            refcount_t refcnt;
        };
    };
    u32 tx_priority;
    u32 tx_weight;
};

struct devlink_region_ops;

struct devlink_region {
    struct devlink *devlink;
    struct devlink_port *port;
    struct list_head list;
    union {
        const struct devlink_region_ops *ops;
        const struct devlink_port_region_ops *port_ops;
    };
    struct mutex snapshot_lock;
    struct list_head snapshot_list;
    u32 max_snapshots;
    u32 cur_snapshots;
    u64 size;
};

struct devlink_region_ops {
    const char *name;
    void (*destructor)(const void *);
    int (*snapshot)(struct devlink *, const struct devlink_region_ops *, struct netlink_ext_ack *, u8 **);
    int (*read)(struct devlink *, const struct devlink_region_ops *, struct netlink_ext_ack *, u64, u32, u8 *);
    void *priv;
};

typedef void devlink_rel_notify_cb_t(struct devlink *, u32);

typedef void devlink_rel_cleanup_cb_t(struct devlink *, u32, u32);

struct devlink_rel {
    u32 index;
    refcount_t refcount;
    u32 devlink_index;
    struct {
        u32 devlink_index;
        u32 obj_index;
        devlink_rel_notify_cb_t *notify_cb;
        devlink_rel_cleanup_cb_t *cleanup_cb;
        struct delayed_work notify_work;
    } nested_in;
};

struct devlink_reload_combination {
    enum devlink_reload_action action;
    enum devlink_reload_limit limit;
};

struct devlink_resource_size_params {
    u64 size_min;
    u64 size_max;
    u64 size_granularity;
    enum devlink_resource_unit unit;
};

typedef u64 devlink_resource_occ_get_t(void *);

struct devlink_resource {
    const char *name;
    u64 id;
    u64 size;
    u64 size_new;
    bool size_valid;
    struct devlink_resource *parent;
    struct devlink_resource_size_params size_params;
    struct list_head list;
    struct list_head resource_list;
    devlink_resource_occ_get_t *occ_get;
    void *occ_get_priv;
};

struct devlink_sb {
    struct list_head list;
    unsigned int index;
    u32 size;
    u16 ingress_pools_count;
    u16 egress_pools_count;
    u16 ingress_tc_count;
    u16 egress_tc_count;
};

struct devlink_sb_pool_info {
    enum devlink_sb_pool_type pool_type;
    u32 size;
    enum devlink_sb_threshold_type threshold_type;
    u32 cell_size;
};

struct devlink_snapshot {
    struct list_head list;
    struct devlink_region *region;
    u8 *data;
    u32 id;
};

struct devlink_stats {
    u64_stats_t rx_bytes;
    u64_stats_t rx_packets;
    struct u64_stats_sync syncp;
};

struct devlink_trap {
    enum devlink_trap_type type;
    enum devlink_trap_action init_action;
    bool generic;
    u16 id;
    const char *name;
    u16 init_group_id;
    u32 metadata_cap;
};

struct devlink_trap_group {
    const char *name;
    u16 id;
    bool generic;
    u32 init_policer_id;
};

struct devlink_trap_policer_item;

struct devlink_trap_group_item {
    const struct devlink_trap_group *group;
    struct devlink_trap_policer_item *policer_item;
    struct list_head list;
    struct devlink_stats *stats;
};

struct devlink_trap_item {
    const struct devlink_trap *trap;
    struct devlink_trap_group_item *group_item;
    struct list_head list;
    enum devlink_trap_action action;
    struct devlink_stats *stats;
    void *priv;
};

struct flow_action_cookie;

struct devlink_trap_metadata {
    const char *trap_name;
    const char *trap_group_name;
    struct net_device *input_dev;
    netdevice_tracker dev_tracker;
    const struct flow_action_cookie *fa_cookie;
    enum devlink_trap_type trap_type;
};

struct devlink_trap_policer {
    u32 id;
    u64 init_rate;
    u64 init_burst;
    u64 max_rate;
    u64 min_rate;
    u64 max_burst;
    u64 min_burst;
};

struct devlink_trap_policer_item {
    const struct devlink_trap_policer *policer;
    u64 rate;
    u64 burst;
    struct list_head list;
};

struct devm_clk_state {
    struct clk *clk;
    void (*exit)(struct clk *);
};

struct of_regulator_match;

struct devm_of_regulator_matches {
    struct of_regulator_match *matches;
    unsigned int num_matches;
};

typedef void (*dr_release_t)(struct device *, void *);

struct devres_node {
    struct list_head entry;
    dr_release_t release;
    const char *name;
    size_t size;
};

struct devres {
    struct devres_node node;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    u8 data[0];
};

struct devres_group {
    struct devres_node node[2];
    void *id;
    int color;
};

struct dh {
    const void *key;
    const void *p;
    const void *g;
    unsigned int key_size;
    unsigned int p_size;
    unsigned int g_size;
};

struct gcry_mpi;

typedef struct gcry_mpi *MPI;

struct dh_ctx {
    MPI p;
    MPI g;
    MPI xa;
};

struct dh_safe_prime {
    unsigned int max_strength;
    unsigned int p_size;
    const char *p;
};

struct dh_safe_prime_instance_ctx {
    struct crypto_kpp_spawn dh_spawn;
    const struct dh_safe_prime *safe_prime;
};

struct dh_safe_prime_tfm_ctx {
    struct crypto_kpp *dh_tfm;
};

struct dictionary {
    uint8_t *buf;
    size_t start;
    size_t pos;
    size_t full;
    size_t limit;
    size_t end;
    uint32_t size;
    uint32_t size_max;
    uint32_t allocated;
    enum xz_mode mode;
};

struct die_args {
    struct pt_regs *regs;
    const char *str;
    long int err;
    int trapnr;
    int signr;
};

struct digest_info {
    const char *alg;
    const u8 *digest;
    size_t digest_len;
};

struct dim_cq_moder {
    u16 usec;
    u16 pkts;
    u16 comps;
    u8 cq_period_mode;
    struct callback_head rcu;
};

struct dim_irq_moder {
    u8 profile_flags;
    u8 coal_flags;
    u8 dim_rx_mode;
    u8 dim_tx_mode;
    struct dim_cq_moder *rx_profile;
    struct dim_cq_moder *tx_profile;
    void (*rx_dim_work)(struct work_struct *);
    void (*tx_dim_work)(struct work_struct *);
};

struct dimm_info {
    struct device dev;
    char label[32];
    unsigned int location[3];
    struct mem_ctl_info *mci;
    unsigned int idx;
    u32 grain;
    enum dev_type dtype;
    enum mem_type mtype;
    enum edac_type edac_mode;
    u32 nr_pages;
    unsigned int csrow;
    unsigned int cschannel;
    u16 smbios_handle;
    u32 ce_count;
    u32 ue_count;
};

typedef int dio_iodone_t(struct kiocb *, loff_t, ssize_t, void *);

struct dio {
    int flags;
    blk_opf_t opf;
    struct gendisk *bio_disk;
    struct inode *inode;
    loff_t i_size;
    dio_iodone_t *end_io;
    bool is_pinned;
    void *private;
    spinlock_t bio_lock;
    int page_errors;
    int is_async;
    bool defer_completion;
    bool should_dirty;
    int io_error;
    long unsigned int refcount;
    struct bio *bio_list;
    struct task_struct *waiter;
    struct kiocb *iocb;
    ssize_t result;
    union {
        struct page *pages[64];
        struct work_struct complete_work;
    };
    long: 64;
};

typedef int get_block_t(struct inode *, sector_t, struct buffer_head *, int);

struct dio_submit {
    struct bio *bio;
    unsigned int blkbits;
    unsigned int blkfactor;
    unsigned int start_zero_done;
    int pages_in_io;
    sector_t block_in_file;
    unsigned int blocks_available;
    int reap_counter;
    sector_t final_block_in_request;
    int boundary;
    get_block_t *get_block;
    loff_t logical_offset_in_bio;
    sector_t final_block_in_bio;
    sector_t next_block_for_io;
    struct page *cur_page;
    unsigned int cur_page_offset;
    unsigned int cur_page_len;
    sector_t cur_page_block;
    loff_t cur_page_fs_offset;
    struct iov_iter *iter;
    unsigned int head;
    unsigned int tail;
    size_t from;
    size_t to;
};

struct dir_entry {
    struct list_head list;
    time64_t mtime;
    char name[0];
};

struct fname;

struct dir_private_info {
    struct rb_root root;
    struct rb_node *curr_node;
    struct fname *extra_fname;
    loff_t last_pos;
    __u32 curr_hash;
    __u32 curr_minor_hash;
    __u32 next_hash;
    u64 cookie;
    bool initialized;
};

struct wb_domain;

struct dirty_throttle_control {
    struct wb_domain *dom;
    struct dirty_throttle_control *gdtc;
    struct bdi_writeback *wb;
    struct fprop_local_percpu *wb_completions;
    long unsigned int avail;
    long unsigned int dirty;
    long unsigned int thresh;
    long unsigned int bg_thresh;
    long unsigned int limit;
    long unsigned int wb_dirty;
    long unsigned int wb_thresh;
    long unsigned int wb_bg_thresh;
    long unsigned int pos_ratio;
    bool freerun;
    bool dirty_exceeded;
};

struct disk_comp_opts {
    __le32 dictionary_size;
    __le32 flags;
};

struct disk_events {
    struct list_head node;
    struct gendisk *disk;
    spinlock_t lock;
    struct mutex block_mutex;
    int block;
    unsigned int pending;
    unsigned int clearing;
    long int poll_msecs;
    struct delayed_work dwork;
};

struct disk_report_zones_cb_args {
    struct gendisk *disk;
    report_zones_cb user_cb;
    void *user_data;
};

struct disk_stats {
    u64 nsecs[4];
    long unsigned int sectors[4];
    long unsigned int ios[4];
    long unsigned int merges[4];
    long unsigned int io_ticks;
    local_t in_flight[2];
};

struct dispatch_rq_data {
    struct blk_mq_hw_ctx *hctx;
    struct request *rq;
};

struct timing_entry {
    u32 min;
    u32 typ;
    u32 max;
};

struct display_timing {
    struct timing_entry pixelclock;
    struct timing_entry hactive;
    struct timing_entry hfront_porch;
    struct timing_entry hback_porch;
    struct timing_entry hsync_len;
    struct timing_entry vactive;
    struct timing_entry vfront_porch;
    struct timing_entry vback_porch;
    struct timing_entry vsync_len;
    enum display_flags flags;
};

struct display_timings {
    unsigned int num_timings;
    unsigned int native_mode;
    struct display_timing **timings;
};

struct displayid_block {
    u8 tag;
    u8 rev;
    u8 num_bytes;
};

struct displayid_detailed_timings_1 {
    u8 pixel_clock[3];
    u8 flags;
    u8 hactive[2];
    u8 hblank[2];
    u8 hsync[2];
    u8 hsw[2];
    u8 vactive[2];
    u8 vblank[2];
    u8 vsync[2];
    u8 vsw[2];
};

struct displayid_detailed_timing_block {
    struct displayid_block base;
    struct displayid_detailed_timings_1 timings[0];
};

struct displayid_header {
    u8 rev;
    u8 bytes;
    u8 prod_id;
    u8 ext_count;
};

struct displayid_tiled_block {
    struct displayid_block base;
    u8 tile_cap;
    u8 topo[3];
    u8 tile_size[4];
    u8 tile_pixel_bezel[5];
    u8 topology_id[8];
};

struct displayid_vesa_vendor_specific_block {
    struct displayid_block base;
    u8 oui[3];
    u8 data_structure_type;
    u8 mso;
};

struct dl_bw {
    raw_spinlock_t lock;
    u64 bw;
    u64 total_bw;
};

struct dl_rq {
    struct rb_root_cached root;
    unsigned int dl_nr_running;
    struct {
        u64 curr;
        u64 next;
    } earliest_dl;
    bool overloaded;
    struct rb_root_cached pushable_dl_tasks_root;
    u64 running_bw;
    u64 this_bw;
    u64 extra_bw;
    u64 max_bw;
    u64 bw_ratio;
};

struct dm_kobject_holder {
    struct kobject kobj;
    struct completion completion;
};

struct dm_verity_digest {
    const char *alg;
    const u8 *digest;
    size_t digest_len;
};

struct dma_block {
    struct dma_block *next_block;
    dma_addr_t dma;
};

struct iosys_map {
    union {
        void *vaddr_iomem;
        void *vaddr;
    };
    bool is_iomem;
};

struct dma_buf_poll_cb_t {
    struct dma_fence_cb cb;
    wait_queue_head_t *poll;
    __poll_t active;
};

struct dma_buf_ops;

struct dma_resv;

struct dma_buf {
    size_t size;
    struct file *file;
    struct list_head attachments;
    const struct dma_buf_ops *ops;
    unsigned int vmapping_counter;
    struct iosys_map vmap_ptr;
    const char *exp_name;
    const char *name;
    spinlock_t name_lock;
    struct module *owner;
    struct list_head list_node;
    void *priv;
    struct dma_resv *resv;
    wait_queue_head_t poll;
    struct dma_buf_poll_cb_t cb_in;
    struct dma_buf_poll_cb_t cb_out;
};

struct dma_buf_attachment;

struct dma_buf_attach_ops {
    bool allow_peer2peer;
    void (*move_notify)(struct dma_buf_attachment *);
};

struct dma_buf_attachment {
    struct dma_buf *dmabuf;
    struct device *dev;
    struct list_head node;
    struct sg_table *sgt;
    enum dma_data_direction dir;
    bool peer2peer;
    const struct dma_buf_attach_ops *importer_ops;
    void *importer_priv;
    void *priv;
};

struct dma_buf_export_info {
    const char *exp_name;
    struct module *owner;
    const struct dma_buf_ops *ops;
    size_t size;
    int flags;
    struct dma_resv *resv;
    void *priv;
};

struct dma_buf_export_sync_file {
    __u32 flags;
    __s32 fd;
};

struct dma_buf_import_sync_file {
    __u32 flags;
    __s32 fd;
};

struct dma_buf_ops {
    bool cache_sgt_mapping;
    int (*attach)(struct dma_buf *, struct dma_buf_attachment *);
    void (*detach)(struct dma_buf *, struct dma_buf_attachment *);
    int (*pin)(struct dma_buf_attachment *);
    void (*unpin)(struct dma_buf_attachment *);
    struct sg_table * (*map_dma_buf)(struct dma_buf_attachment *, enum dma_data_direction);
    void (*unmap_dma_buf)(struct dma_buf_attachment *, struct sg_table *, enum dma_data_direction);
    void (*release)(struct dma_buf *);
    int (*begin_cpu_access)(struct dma_buf *, enum dma_data_direction);
    int (*end_cpu_access)(struct dma_buf *, enum dma_data_direction);
    int (*mmap)(struct dma_buf *, struct vm_area_struct *);
    int (*vmap)(struct dma_buf *, struct iosys_map *);
    void (*vunmap)(struct dma_buf *, struct iosys_map *);
};

struct dma_buf_sync {
    __u64 flags;
};

struct dma_chan_dev {
    struct dma_chan *chan;
    struct device device;
    int dev_id;
    bool chan_dma_dev;
};

struct dma_chan_percpu {
    long unsigned int memcpy_count;
    long unsigned int bytes_transferred;
};

struct dma_chan_tbl_ent {
    struct dma_chan *chan;
};

struct dma_coherent_mem {
    void *virt_base;
    dma_addr_t device_base;
    long unsigned int pfn_base;
    int size;
    long unsigned int *bitmap;
    spinlock_t spinlock;
    bool use_dev_dma_pfn_offset;
};

struct dma_descriptor_metadata_ops {
    int (*attach)(struct dma_async_tx_descriptor *, void *, size_t);
    void * (*get_ptr)(struct dma_async_tx_descriptor *, size_t *, size_t *);
    int (*set_len)(struct dma_async_tx_descriptor *, size_t);
};

struct dma_devres {
    size_t size;
    void *vaddr;
    dma_addr_t dma_handle;
    long unsigned int attrs;
};

struct dma_fence_ops;

struct dma_fence {
    spinlock_t *lock;
    const struct dma_fence_ops *ops;
    union {
        struct list_head cb_list;
        ktime_t timestamp;
        struct callback_head rcu;
    };
    u64 context;
    u64 seqno;
    long unsigned int flags;
    struct kref refcount;
    int error;
};

struct dma_fence_array;

struct dma_fence_array_cb {
    struct dma_fence_cb cb;
    struct dma_fence_array *array;
};

struct dma_fence_array {
    struct dma_fence base;
    spinlock_t lock;
    unsigned int num_fences;
    atomic_t num_pending;
    struct dma_fence **fences;
    struct irq_work work;
    struct dma_fence_array_cb callbacks[0];
};

struct dma_fence_chain {
    struct dma_fence base;
    struct dma_fence *prev;
    u64 prev_seqno;
    struct dma_fence *fence;
    union {
        struct dma_fence_cb cb;
        struct irq_work work;
    };
    spinlock_t lock;
};

struct dma_fence_ops {
    bool use_64bit_seqno;
    const char * (*get_driver_name)(struct dma_fence *);
    const char * (*get_timeline_name)(struct dma_fence *);
    bool (*enable_signaling)(struct dma_fence *);
    bool (*signaled)(struct dma_fence *);
    long int (*wait)(struct dma_fence *, bool, long int);
    void (*release)(struct dma_fence *);
    void (*fence_value_str)(struct dma_fence *, char *, int);
    void (*timeline_value_str)(struct dma_fence *, char *, int);
    void (*set_deadline)(struct dma_fence *, ktime_t);
};

struct dma_fence_unwrap {
    struct dma_fence *chain;
    struct dma_fence *array;
    unsigned int index;
};

struct dma_heap_ops;

struct dma_heap {
    const char *name;
    const struct dma_heap_ops *ops;
    void *priv;
    dev_t heap_devt;
    struct list_head list;
    struct cdev heap_cdev;
};

struct dma_heap_allocation_data {
    __u64 len;
    __u32 fd;
    __u32 fd_flags;
    __u64 heap_flags;
};

struct dma_heap_attachment {
    struct device *dev;
    struct sg_table *table;
    struct list_head list;
    bool mapped;
};

struct sg_table {
    struct scatterlist *sgl;
    unsigned int nents;
    unsigned int orig_nents;
};

struct dma_heap_attachment___2 {
    struct device *dev;
    struct sg_table table;
    struct list_head list;
    bool mapped;
};

struct dma_heap_export_info {
    const char *name;
    const struct dma_heap_ops *ops;
    void *priv;
};

struct dma_heap_ops {
    struct dma_buf * (*allocate)(struct dma_heap *, long unsigned int, u32, u64);
};

struct dma_interleaved_template {
    dma_addr_t src_start;
    dma_addr_t dst_start;
    enum dma_transfer_direction dir;
    bool src_inc;
    bool dst_inc;
    bool src_sgl;
    bool dst_sgl;
    size_t numf;
    size_t frame_size;
    struct data_chunk sgl[0];
};

struct dma_map_ops {
    void * (*alloc)(struct device *, size_t, dma_addr_t *, gfp_t, long unsigned int);
    void (*free)(struct device *, size_t, void *, dma_addr_t, long unsigned int);
    struct page * (*alloc_pages_op)(struct device *, size_t, dma_addr_t *, enum dma_data_direction, gfp_t);
    void (*free_pages)(struct device *, size_t, struct page *, dma_addr_t, enum dma_data_direction);
    int (*mmap)(struct device *, struct vm_area_struct *, void *, dma_addr_t, size_t, long unsigned int);
    int (*get_sgtable)(struct device *, struct sg_table *, void *, dma_addr_t, size_t, long unsigned int);
    dma_addr_t (*map_page)(struct device *, struct page *, long unsigned int, size_t, enum dma_data_direction, long unsigned int);
    void (*unmap_page)(struct device *, dma_addr_t, size_t, enum dma_data_direction, long unsigned int);
    int (*map_sg)(struct device *, struct scatterlist *, int, enum dma_data_direction, long unsigned int);
    void (*unmap_sg)(struct device *, struct scatterlist *, int, enum dma_data_direction, long unsigned int);
    dma_addr_t (*map_resource)(struct device *, phys_addr_t, size_t, enum dma_data_direction, long unsigned int);
    void (*unmap_resource)(struct device *, dma_addr_t, size_t, enum dma_data_direction, long unsigned int);
    void (*sync_single_for_cpu)(struct device *, dma_addr_t, size_t, enum dma_data_direction);
    void (*sync_single_for_device)(struct device *, dma_addr_t, size_t, enum dma_data_direction);
    void (*sync_sg_for_cpu)(struct device *, struct scatterlist *, int, enum dma_data_direction);
    void (*sync_sg_for_device)(struct device *, struct scatterlist *, int, enum dma_data_direction);
    void (*cache_sync)(struct device *, void *, size_t, enum dma_data_direction);
    int (*dma_supported)(struct device *, u64);
    u64 (*get_required_mask)(struct device *);
    size_t (*max_mapping_size)(struct device *);
    size_t (*opt_mapping_size)(void);
    long unsigned int (*get_merge_boundary)(struct device *);
};

struct dma_page {
    struct list_head page_list;
    void *vaddr;
    dma_addr_t dma;
};

struct dma_pool {
    struct list_head page_list;
    spinlock_t lock;
    struct dma_block *next_block;
    size_t nr_blocks;
    size_t nr_active;
    size_t nr_pages;
    struct device *dev;
    unsigned int size;
    unsigned int allocation;
    unsigned int boundary;
    char name[32];
    struct list_head pools;
};

struct ww_acquire_ctx;

struct ww_mutex {
    struct mutex base;
    struct ww_acquire_ctx *ctx;
};

struct dma_resv_list;

struct dma_resv {
    struct ww_mutex lock;
    struct dma_resv_list *fences;
};

struct dma_resv_iter {
    struct dma_resv *obj;
    enum dma_resv_usage usage;
    struct dma_fence *fence;
    enum dma_resv_usage fence_usage;
    unsigned int index;
    struct dma_resv_list *fences;
    unsigned int num_fences;
    bool is_restarted;
};

struct dma_resv_list {
    struct callback_head rcu;
    u32 num_fences;
    u32 max_fences;
    struct dma_fence *table[0];
};

struct dma_router {
    struct device *dev;
    void (*route_free)(struct device *, void *);
};

struct dma_sgt_handle {
    struct sg_table sgt;
    struct page **pages;
};

struct dma_slave_caps {
    u32 src_addr_widths;
    u32 dst_addr_widths;
    u32 directions;
    u32 min_burst;
    u32 max_burst;
    u32 max_sg_burst;
    bool cmd_pause;
    bool cmd_resume;
    bool cmd_terminate;
    enum dma_residue_granularity residue_granularity;
    bool descriptor_reuse;
};

struct dma_slave_map {
    const char *devname;
    const char *slave;
    void *param;
};

struct dma_tx_state {
    dma_cookie_t last;
    dma_cookie_t used;
    u32 residue;
    u32 in_flight_bytes;
};

struct dma_vec {
    dma_addr_t addr;
    size_t len;
};

struct dmabuf_cmsg {
    __u64 frag_offset;
    __u32 frag_size;
    __u32 frag_token;
    __u32 dmabuf_id;
    __u32 flags;
};

struct net_iov;

struct net_devmem_dmabuf_binding;

struct dmabuf_genpool_chunk_owner {
    long unsigned int base_virtual;
    dma_addr_t base_dma_addr;
    struct net_iov *niovs;
    size_t num_niovs;
    struct net_devmem_dmabuf_binding *binding;
};

struct dmabuf_token {
    __u32 token_start;
    __u32 token_count;
};

struct dmaengine_desc_callback {
    dma_async_tx_callback callback;
    dma_async_tx_callback_result callback_result;
    void *callback_param;
};

struct dmaengine_unmap_data {
    u16 map_cnt;
    u8 to_cnt;
    u8 from_cnt;
    u8 bidi_cnt;
    struct device *dev;
    struct kref kref;
    size_t len;
    dma_addr_t addr[0];
};

struct dmaengine_unmap_pool {
    struct kmem_cache *cache;
    const char *name;
    mempool_t *pool;
    size_t size;
};

struct page_counter {
    atomic_long_t usage;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    struct cacheline_padding _pad1_;
    long unsigned int emin;
    atomic_long_t min_usage;
    atomic_long_t children_min_usage;
    long unsigned int elow;
    atomic_long_t low_usage;
    atomic_long_t children_low_usage;
    long unsigned int watermark;
    long unsigned int local_watermark;
    long unsigned int failcnt;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    struct cacheline_padding _pad2_;
    bool protection_support;
    long unsigned int min;
    long unsigned int low;
    long unsigned int high;
    long unsigned int max;
    struct page_counter *parent;
    long: 64;
    long: 64;
};

struct dmem_cgroup_region;

struct dmemcg_state;

struct dmem_cgroup_pool_state {
    struct dmem_cgroup_region *region;
    struct dmemcg_state *cs;
    struct list_head css_node;
    struct list_head region_node;
    struct callback_head rcu;
    struct page_counter cnt;
    bool inited;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
};

struct dmem_cgroup_region {
    struct kref ref;
    struct callback_head rcu;
    struct list_head region_node;
    struct list_head pools;
    u64 size;
    char *name;
    bool unregistered;
};

struct dmemcg_state {
    struct cgroup_subsys_state css;
    struct list_head pools;
};

struct dmi_device {
    struct list_head list;
    int type;
    const char *name;
    void *device_data;
};

struct dmi_dev_onboard {
    struct dmi_device dev;
    int instance;
    int segment;
    int bus;
    int devfn;
};

struct dmi_device_attribute {
    struct device_attribute dev_attr;
    int field;
};

struct dmi_header {
    u8 type;
    u8 length;
    u16 handle;
};

struct dmi_memdev_info {
    const char *device;
    const char *bank;
    u64 size;
    u16 handle;
    u8 type;
};

struct dmi_strmatch {
    unsigned char slot: 7;
    unsigned char exact_match: 1;
    char substr[79];
};

struct dmi_system_id {
    int (*callback)(const struct dmi_system_id *);
    const char *ident;
    struct dmi_strmatch matches[4];
    void *driver_data;
};

struct fb_videomode;

struct dmt_videomode {
    u32 dmt_id;
    u32 std_2byte_code;
    u32 cvt_3byte_code;
    const struct fb_videomode *mode;
};

struct dnotify_struct;

struct dnotify_mark {
    struct fsnotify_mark fsn_mark;
    struct dnotify_struct *dn;
};

typedef void *fl_owner_t;

struct dnotify_struct {
    struct dnotify_struct *dn_next;
    __u32 dn_mask;
    int dn_fd;
    struct file *dn_filp;
    fl_owner_t dn_owner;
};

struct dns_payload_header {
    __u8 zero;
    __u8 content;
    __u8 version;
};

struct dns_server_list_v1_header {
    struct dns_payload_header hdr;
    __u8 source;
    __u8 status;
    __u8 nr_servers;
};

struct do_proc_dointvec_minmax_conv_param {
    int *min;
    int *max;
};

struct do_proc_douintvec_minmax_conv_param {
    unsigned int *min;
    unsigned int *max;
};

struct double_list {
    struct list_head *top;
    struct list_head *bottom;
};

struct dp_sdp_header {
    u8 HB0;
    u8 HB1;
    u8 HB2;
    u8 HB3;
};

struct dp_sdp {
    struct dp_sdp_header sdp_header;
    u8 db[32];
};

struct dpll_device {
    u32 id;
    u32 device_idx;
    u64 clock_id;
    struct module *module;
    enum dpll_type type;
    struct xarray pin_refs;
    refcount_t refcount;
    struct list_head registration_list;
};

struct dpll_device_ops {
    int (*mode_get)(const struct dpll_device *, void *, enum dpll_mode *, struct netlink_ext_ack *);
    int (*lock_status_get)(const struct dpll_device *, void *, enum dpll_lock_status *, enum dpll_lock_status_error *, struct netlink_ext_ack *);
    int (*temp_get)(const struct dpll_device *, void *, s32 *, struct netlink_ext_ack *);
    int (*clock_quality_level_get)(const struct dpll_device *, void *, long unsigned int *, struct netlink_ext_ack *);
};

struct dpll_device_registration {
    struct list_head list;
    const struct dpll_device_ops *ops;
    void *priv;
};

struct dpll_dump_ctx {
    long unsigned int idx;
};

struct dpll_pin_phase_adjust_range {
    s32 min;
    s32 max;
};

struct dpll_pin_frequency;

struct dpll_pin_properties {
    const char *board_label;
    const char *panel_label;
    const char *package_label;
    enum dpll_pin_type type;
    long unsigned int capabilities;
    u32 freq_supported_num;
    struct dpll_pin_frequency *freq_supported;
    struct dpll_pin_phase_adjust_range phase_range;
};

struct dpll_pin {
    u32 id;
    u32 pin_idx;
    u64 clock_id;
    struct module *module;
    struct xarray dpll_refs;
    struct xarray parent_refs;
    struct dpll_pin_properties prop;
    refcount_t refcount;
    struct callback_head rcu;
};

struct dpll_pin_esync {
    u64 freq;
    const struct dpll_pin_frequency *range;
    u8 range_num;
    u8 pulse;
};

struct dpll_pin_frequency {
    u64 min;
    u64 max;
};

struct dpll_pin_ops {
    int (*frequency_set)(const struct dpll_pin *, void *, const struct dpll_device *, void *, const u64, struct netlink_ext_ack *);
    int (*frequency_get)(const struct dpll_pin *, void *, const struct dpll_device *, void *, u64 *, struct netlink_ext_ack *);
    int (*direction_set)(const struct dpll_pin *, void *, const struct dpll_device *, void *, const enum dpll_pin_direction, struct netlink_ext_ack *);
    int (*direction_get)(const struct dpll_pin *, void *, const struct dpll_device *, void *, enum dpll_pin_direction *, struct netlink_ext_ack *);
    int (*state_on_pin_get)(const struct dpll_pin *, void *, const struct dpll_pin *, void *, enum dpll_pin_state *, struct netlink_ext_ack *);
    int (*state_on_dpll_get)(const struct dpll_pin *, void *, const struct dpll_device *, void *, enum dpll_pin_state *, struct netlink_ext_ack *);
    int (*state_on_pin_set)(const struct dpll_pin *, void *, const struct dpll_pin *, void *, const enum dpll_pin_state, struct netlink_ext_ack *);
    int (*state_on_dpll_set)(const struct dpll_pin *, void *, const struct dpll_device *, void *, const enum dpll_pin_state, struct netlink_ext_ack *);
    int (*prio_get)(const struct dpll_pin *, void *, const struct dpll_device *, void *, u32 *, struct netlink_ext_ack *);
    int (*prio_set)(const struct dpll_pin *, void *, const struct dpll_device *, void *, const u32, struct netlink_ext_ack *);
    int (*phase_offset_get)(const struct dpll_pin *, void *, const struct dpll_device *, void *, s64 *, struct netlink_ext_ack *);
    int (*phase_adjust_get)(const struct dpll_pin *, void *, const struct dpll_device *, void *, s32 *, struct netlink_ext_ack *);
    int (*phase_adjust_set)(const struct dpll_pin *, void *, const struct dpll_device *, void *, const s32, struct netlink_ext_ack *);
    int (*ffo_get)(const struct dpll_pin *, void *, const struct dpll_device *, void *, s64 *, struct netlink_ext_ack *);
    int (*esync_set)(const struct dpll_pin *, void *, const struct dpll_device *, void *, u64, struct netlink_ext_ack *);
    int (*esync_get)(const struct dpll_pin *, void *, const struct dpll_device *, void *, struct dpll_pin_esync *, struct netlink_ext_ack *);
};

struct dpll_pin_ref {
    union {
        struct dpll_device *dpll;
        struct dpll_pin *pin;
    };
    struct list_head registration_list;
    refcount_t refcount;
};

struct dpll_pin_registration {
    struct list_head list;
    const struct dpll_pin_ops *ops;
    void *priv;
    void *cookie;
};

struct dql {
    unsigned int num_queued;
    unsigned int adj_limit;
    unsigned int last_obj_cnt;
    short unsigned int stall_thrs;
    long unsigned int history_head;
    long unsigned int history[4];
    long: 64;
    unsigned int limit;
    unsigned int num_completed;
    unsigned int prev_ovlimit;
    unsigned int prev_num_queued;
    unsigned int prev_last_obj_cnt;
    unsigned int lowest_slack;
    long unsigned int slack_start_time;
    unsigned int max_limit;
    unsigned int min_limit;
    unsigned int slack_hold_time;
    short unsigned int stall_max;
    long unsigned int last_reap;
    long unsigned int stall_cnt;
};

struct dqstats {
    long unsigned int stat[8];
    struct percpu_counter counter[8];
};

struct kqid {
    union {
        kuid_t uid;
        kgid_t gid;
        kprojid_t projid;
    };
    enum quota_type type;
};

struct mem_dqblk {
    qsize_t dqb_bhardlimit;
    qsize_t dqb_bsoftlimit;
    qsize_t dqb_curspace;
    qsize_t dqb_rsvspace;
    qsize_t dqb_ihardlimit;
    qsize_t dqb_isoftlimit;
    qsize_t dqb_curinodes;
    time64_t dqb_btime;
    time64_t dqb_itime;
};

struct dquot {
    struct hlist_node dq_hash;
    struct list_head dq_inuse;
    struct list_head dq_free;
    struct list_head dq_dirty;
    struct mutex dq_lock;
    spinlock_t dq_dqb_lock;
    atomic_t dq_count;
    struct super_block *dq_sb;
    struct kqid dq_id;
    loff_t dq_off;
    long unsigned int dq_flags;
    struct mem_dqblk dq_dqb;
};

struct dquot_operations {
    int (*write_dquot)(struct dquot *);
    struct dquot * (*alloc_dquot)(struct super_block *, int);
    void (*destroy_dquot)(struct dquot *);
    int (*acquire_dquot)(struct dquot *);
    int (*release_dquot)(struct dquot *);
    int (*mark_dirty)(struct dquot *);
    int (*write_info)(struct super_block *, int);
    qsize_t * (*get_reserved_space)(struct inode *);
    int (*get_projid)(struct inode *, kprojid_t *);
    int (*get_inode_usage)(struct inode *, qsize_t *);
    int (*get_next_id)(struct super_block *, struct kqid *);
};

struct dquot_warn {
    struct super_block *w_sb;
    struct kqid w_dq_id;
    short int w_type;
};

struct drbg_core {
    drbg_flag_t flags;
    __u8 statelen;
    __u8 blocklen_bytes;
    char cra_name[128];
    char backend_cra_name[128];
};

struct drbg_string {
    const unsigned char *buf;
    size_t len;
    struct list_head list;
};

struct drbg_state_ops;

struct drbg_state {
    struct mutex drbg_mutex;
    unsigned char *V;
    unsigned char *Vbuf;
    unsigned char *C;
    unsigned char *Cbuf;
    size_t reseed_ctr;
    size_t reseed_threshold;
    unsigned char *scratchpad;
    unsigned char *scratchpadbuf;
    void *priv_data;
    struct crypto_skcipher *ctr_handle;
    struct skcipher_request *ctr_req;
    __u8 *outscratchpadbuf;
    __u8 *outscratchpad;
    struct crypto_wait ctr_wait;
    struct scatterlist sg_in;
    struct scatterlist sg_out;
    enum drbg_seed_state seeded;
    long unsigned int last_seed_time;
    bool pr;
    bool fips_primed;
    unsigned char *prev;
    struct crypto_rng *jent;
    const struct drbg_state_ops *d_ops;
    const struct drbg_core *core;
    struct drbg_string test_data;
};

struct drbg_state_ops {
    int (*update)(struct drbg_state *, struct list_head *, int);
    int (*generate)(struct drbg_state *, unsigned char *, unsigned int, struct list_head *);
    int (*crypto_init)(struct drbg_state *);
    int (*crypto_fini)(struct drbg_state *);
};

struct driver_attribute {
    struct attribute attr;
    ssize_t (*show)(struct device_driver *, char *);
    ssize_t (*store)(struct device_driver *, const char *, size_t);
};

struct usbnet;

struct usb_interface;

struct driver_info {
    char *description;
    int flags;
    int (*bind)(struct usbnet *, struct usb_interface *);
    void (*unbind)(struct usbnet *, struct usb_interface *);
    int (*reset)(struct usbnet *);
    int (*stop)(struct usbnet *);
    int (*check_connect)(struct usbnet *);
    int (*manage_power)(struct usbnet *, int);
    void (*status)(struct usbnet *, struct urb *);
    int (*link_reset)(struct usbnet *);
    int (*rx_fixup)(struct usbnet *, struct sk_buff *);
    struct sk_buff * (*tx_fixup)(struct usbnet *, struct sk_buff *, gfp_t);
    void (*recover)(struct usbnet *);
    int (*early_init)(struct usbnet *);
    void (*indication)(struct usbnet *, void *, int);
    void (*set_rx_mode)(struct usbnet *);
    int in;
    int out;
    long unsigned int data;
};

struct module_kobject;

struct driver_private {
    struct kobject kobj;
    struct klist klist_devices;
    struct klist_node knode_bus;
    struct module_kobject *mkobj;
    struct device_driver *driver;
};

struct drm_device;

struct drm_modeset_acquire_ctx;

struct drm_atomic_state {
    struct kref ref;
    struct drm_device *dev;
    bool allow_modeset: 1;
    bool legacy_cursor_update: 1;
    bool async_update: 1;
    bool duplicated: 1;
    struct __drm_planes_state *planes;
    struct __drm_crtcs_state *crtcs;
    int num_connector;
    struct __drm_connnectors_state *connectors;
    int num_private_objs;
    struct __drm_private_objs_state *private_objs;
    struct drm_modeset_acquire_ctx *acquire_ctx;
    struct drm_crtc_commit *fake_commit;
    struct work_struct commit_work;
};

struct drm_auth {
    drm_magic_t magic;
};

struct drm_modeset_lock {
    struct ww_mutex mutex;
    struct list_head head;
};

struct drm_private_state_funcs;

struct drm_private_obj {
    struct list_head head;
    struct drm_modeset_lock lock;
    struct drm_private_state *state;
    const struct drm_private_state_funcs *funcs;
};

struct drm_encoder;

struct drm_bridge_timings;

struct drm_bridge_funcs;

struct i2c_adapter;

struct drm_bridge {
    struct drm_private_obj base;
    struct drm_device *dev;
    struct drm_encoder *encoder;
    struct list_head chain_node;
    struct device_node *of_node;
    struct list_head list;
    const struct drm_bridge_timings *timings;
    const struct drm_bridge_funcs *funcs;
    void *driver_private;
    enum drm_bridge_ops ops;
    int type;
    bool interlace_allowed;
    bool ycbcr_420_allowed;
    bool pre_enable_prev_first;
    struct i2c_adapter *ddc;
    struct mutex hpd_mutex;
    void (*hpd_cb)(void *, enum drm_connector_status);
    void *hpd_data;
    const char *vendor;
    const char *product;
    unsigned int supported_formats;
    unsigned int max_bpc;
    struct device *hdmi_audio_dev;
    int hdmi_audio_max_i2s_playback_channels;
    unsigned int hdmi_audio_spdif_playback: 1;
    int hdmi_audio_dai_port;
};

struct hdmi_codec_daifmt;

struct hdmi_codec_params;

struct drm_display_info;

struct drm_display_mode;

struct drm_bridge_state;

struct drm_bridge_funcs {
    int (*attach)(struct drm_bridge *, enum drm_bridge_attach_flags);
    void (*detach)(struct drm_bridge *);
    enum drm_mode_status (*mode_valid)(struct drm_bridge *, const struct drm_display_info *, const struct drm_display_mode *);
    bool (*mode_fixup)(struct drm_bridge *, const struct drm_display_mode *, struct drm_display_mode *);
    void (*disable)(struct drm_bridge *);
    void (*post_disable)(struct drm_bridge *);
    void (*mode_set)(struct drm_bridge *, const struct drm_display_mode *, const struct drm_display_mode *);
    void (*pre_enable)(struct drm_bridge *);
    void (*enable)(struct drm_bridge *);
    void (*atomic_pre_enable)(struct drm_bridge *, struct drm_bridge_state *);
    void (*atomic_enable)(struct drm_bridge *, struct drm_bridge_state *);
    void (*atomic_disable)(struct drm_bridge *, struct drm_bridge_state *);
    void (*atomic_post_disable)(struct drm_bridge *, struct drm_bridge_state *);
    struct drm_bridge_state * (*atomic_duplicate_state)(struct drm_bridge *);
    void (*atomic_destroy_state)(struct drm_bridge *, struct drm_bridge_state *);
    u32 * (*atomic_get_output_bus_fmts)(struct drm_bridge *, struct drm_bridge_state *, struct drm_crtc_state *, struct drm_connector_state *, unsigned int *);
    u32 * (*atomic_get_input_bus_fmts)(struct drm_bridge *, struct drm_bridge_state *, struct drm_crtc_state *, struct drm_connector_state *, u32, unsigned int *);
    int (*atomic_check)(struct drm_bridge *, struct drm_bridge_state *, struct drm_crtc_state *, struct drm_connector_state *);
    struct drm_bridge_state * (*atomic_reset)(struct drm_bridge *);
    enum drm_connector_status (*detect)(struct drm_bridge *);
    int (*get_modes)(struct drm_bridge *, struct drm_connector *);
    const struct drm_edid * (*edid_read)(struct drm_bridge *, struct drm_connector *);
    void (*hpd_notify)(struct drm_bridge *, enum drm_connector_status);
    void (*hpd_enable)(struct drm_bridge *);
    void (*hpd_disable)(struct drm_bridge *);
    enum drm_mode_status (*hdmi_tmds_char_rate_valid)(const struct drm_bridge *, const struct drm_display_mode *, long long unsigned int);
    int (*hdmi_clear_infoframe)(struct drm_bridge *, enum hdmi_infoframe_type);
    int (*hdmi_write_infoframe)(struct drm_bridge *, enum hdmi_infoframe_type, const u8 *, size_t);
    int (*hdmi_audio_startup)(struct drm_connector *, struct drm_bridge *);
    int (*hdmi_audio_prepare)(struct drm_connector *, struct drm_bridge *, struct hdmi_codec_daifmt *, struct hdmi_codec_params *);
    void (*hdmi_audio_shutdown)(struct drm_connector *, struct drm_bridge *);
    int (*hdmi_audio_mute_stream)(struct drm_connector *, struct drm_bridge *, bool, int);
    void (*debugfs_init)(struct drm_bridge *, struct dentry *);
};

struct drm_private_state {
    struct drm_atomic_state *state;
    struct drm_private_obj *obj;
};

struct drm_bus_cfg {
    u32 format;
    u32 flags;
};

struct drm_bridge_state {
    struct drm_private_state base;
    struct drm_bridge *bridge;
    struct drm_bus_cfg input_bus_cfg;
    struct drm_bus_cfg output_bus_cfg;
};

struct drm_bridge_timings {
    u32 input_bus_flags;
    u32 setup_time_ps;
    u32 hold_time_ps;
    bool dual_link;
};

struct drm_client {
    int idx;
    int auth;
    long unsigned int pid;
    long unsigned int uid;
    long unsigned int magic;
    long unsigned int iocs;
};

struct drm_client32 {
    int idx;
    int auth;
    u32 pid;
    u32 uid;
    u32 magic;
    u32 iocs;
};

typedef struct drm_client32 drm_client32_t;

struct drm_client_dev;

struct drm_gem_object;

struct drm_framebuffer;

struct drm_client_buffer {
    struct drm_client_dev *client;
    u32 pitch;
    struct drm_gem_object *gem;
    struct iosys_map map;
    struct drm_framebuffer *fb;
};

struct drm_client_funcs;

struct drm_file;

struct drm_mode_set;

struct drm_client_dev {
    struct drm_device *dev;
    const char *name;
    struct list_head list;
    const struct drm_client_funcs *funcs;
    struct drm_file *file;
    struct mutex modeset_mutex;
    struct drm_mode_set *modesets;
    bool suspended;
    bool hotplug_failed;
};

struct drm_client_funcs {
    struct module *owner;
    void (*unregister)(struct drm_client_dev *);
    int (*restore)(struct drm_client_dev *);
    int (*hotplug)(struct drm_client_dev *);
    int (*suspend)(struct drm_client_dev *, bool);
    int (*resume)(struct drm_client_dev *, bool);
};

struct drm_client_offset {
    int x;
    int y;
};

struct drm_clip_rect {
    short unsigned int x1;
    short unsigned int y1;
    short unsigned int x2;
    short unsigned int y2;
};

struct drm_connector_tv_margins {
    unsigned int bottom;
    unsigned int left;
    unsigned int right;
    unsigned int top;
};

struct drm_cmdline_mode {
    char name[32];
    bool specified;
    bool refresh_specified;
    bool bpp_specified;
    unsigned int pixel_clock;
    int xres;
    int yres;
    int bpp;
    int refresh;
    bool rb;
    bool interlace;
    bool cvt;
    bool margins;
    enum drm_connector_force force;
    unsigned int rotation_reflection;
    enum drm_panel_orientation panel_orientation;
    struct drm_connector_tv_margins tv_margins;
    enum drm_connector_tv_mode tv_mode;
    bool tv_mode_specified;
};

struct drm_color_lut {
    __u16 red;
    __u16 green;
    __u16 blue;
    __u16 reserved;
};

struct drm_conn_prop_enum_list {
    int type;
    const char *name;
    struct ida ida;
};

struct drm_object_properties;

struct drm_mode_object {
    uint32_t id;
    uint32_t type;
    struct drm_object_properties *properties;
    struct kref refcount;
    void (*free_cb)(struct kref *);
};

struct drm_scrambling {
    bool supported;
    bool low_rates;
};

struct drm_scdc {
    bool supported;
    bool read_request;
    struct drm_scrambling scrambling;
};

struct drm_hdmi_dsc_cap {
    bool v_1p2;
    bool native_420;
    bool all_bpp;
    u8 bpc_supported;
    u8 max_slices;
    int clk_per_slice;
    u8 max_lanes;
    u8 max_frl_rate_per_lane;
    u8 total_chunk_kbytes;
};

struct drm_hdmi_info {
    struct drm_scdc scdc;
    long unsigned int y420_vdb_modes[4];
    long unsigned int y420_cmdb_modes[4];
    u8 y420_dc_modes;
    u8 max_frl_rate_per_lane;
    u8 max_lanes;
    struct drm_hdmi_dsc_cap dsc_cap;
};

struct drm_monitor_range_info {
    u16 min_vfreq;
    u16 max_vfreq;
};

struct drm_luminance_range_info {
    u32 min_luminance;
    u32 max_luminance;
};

struct drm_display_info {
    unsigned int width_mm;
    unsigned int height_mm;
    unsigned int bpc;
    enum subpixel_order subpixel_order;
    int panel_orientation;
    u32 color_formats;
    const u32 *bus_formats;
    unsigned int num_bus_formats;
    u32 bus_flags;
    int max_tmds_clock;
    bool dvi_dual;
    bool is_hdmi;
    bool has_audio;
    bool has_hdmi_infoframe;
    bool rgb_quant_range_selectable;
    u8 edid_hdmi_rgb444_dc_modes;
    u8 edid_hdmi_ycbcr444_dc_modes;
    u8 cea_rev;
    struct drm_hdmi_info hdmi;
    bool non_desktop;
    struct drm_monitor_range_info monitor_range;
    struct drm_luminance_range_info luminance_range;
    u8 mso_stream_count;
    u8 mso_pixel_overlap;
    u32 max_dsc_bpp;
    u8 *vics;
    int vics_len;
    u32 quirks;
    u16 source_physical_address;
};

struct drm_property;

struct drm_object_properties {
    int count;
    struct drm_property *properties[64];
    uint64_t values[64];
};

struct drm_privacy_screen;

struct hdr_static_metadata {
    __u8 eotf;
    __u8 metadata_type;
    __u16 max_cll;
    __u16 max_fall;
    __u16 min_cll;
};

struct hdr_sink_metadata {
    __u32 metadata_type;
    union {
        struct hdr_static_metadata hdmi_type1;
    };
};

struct hdmi_any_infoframe {
    enum hdmi_infoframe_type type;
    unsigned char version;
    unsigned char length;
};

struct hdmi_avi_infoframe {
    enum hdmi_infoframe_type type;
    unsigned char version;
    unsigned char length;
    bool itc;
    unsigned char pixel_repeat;
    enum hdmi_colorspace colorspace;
    enum hdmi_scan_mode scan_mode;
    enum hdmi_colorimetry colorimetry;
    enum hdmi_picture_aspect picture_aspect;
    enum hdmi_active_aspect active_aspect;
    enum hdmi_extended_colorimetry extended_colorimetry;
    enum hdmi_quantization_range quantization_range;
    enum hdmi_nups nups;
    unsigned char video_code;
    enum hdmi_ycc_quantization_range ycc_quantization_range;
    enum hdmi_content_type content_type;
    short unsigned int top_bar;
    short unsigned int bottom_bar;
    short unsigned int left_bar;
    short unsigned int right_bar;
};

struct hdmi_spd_infoframe {
    enum hdmi_infoframe_type type;
    unsigned char version;
    unsigned char length;
    char vendor[8];
    char product[16];
    enum hdmi_spd_sdi sdi;
};

struct hdmi_vendor_infoframe {
    enum hdmi_infoframe_type type;
    unsigned char version;
    unsigned char length;
    unsigned int oui;
    u8 vic;
    enum hdmi_3d_structure s3d_struct;
    unsigned int s3d_ext_data;
};

union hdmi_vendor_any_infoframe {
    struct {
        enum hdmi_infoframe_type type;
        unsigned char version;
        unsigned char length;
        unsigned int oui;
    } any;
    struct hdmi_vendor_infoframe hdmi;
};

struct hdmi_audio_infoframe {
    enum hdmi_infoframe_type type;
    unsigned char version;
    unsigned char length;
    unsigned char channels;
    enum hdmi_audio_coding_type coding_type;
    enum hdmi_audio_sample_size sample_size;
    enum hdmi_audio_sample_frequency sample_frequency;
    enum hdmi_audio_coding_type_ext coding_type_ext;
    unsigned char channel_allocation;
    unsigned char level_shift_value;
    bool downmix_inhibit;
};

struct hdmi_drm_infoframe {
    enum hdmi_infoframe_type type;
    unsigned char version;
    unsigned char length;
    enum hdmi_eotf eotf;
    enum hdmi_metadata_type metadata_type;
    struct {
        u16 x;
        u16 y;
    } display_primaries[3];
    struct {
        u16 x;
        u16 y;
    } white_point;
    u16 max_display_mastering_luminance;
    u16 min_display_mastering_luminance;
    u16 max_cll;
    u16 max_fall;
};

union hdmi_infoframe {
    struct hdmi_any_infoframe any;
    struct hdmi_avi_infoframe avi;
    struct hdmi_spd_infoframe spd;
    union hdmi_vendor_any_infoframe vendor;
    struct hdmi_audio_infoframe audio;
    struct hdmi_drm_infoframe drm;
};

struct drm_connector_hdmi_infoframe {
    union hdmi_infoframe data;
    bool set;
};

struct drm_connector_hdmi_funcs;

struct drm_connector_hdmi {
    unsigned char vendor[8];
    unsigned char product[16];
    long unsigned int supported_formats;
    const struct drm_connector_hdmi_funcs *funcs;
    struct {
        struct mutex lock;
        struct drm_connector_hdmi_infoframe audio;
    } infoframes;
};

struct drm_connector_hdmi_audio_funcs;

struct drm_connector_hdmi_audio {
    const struct drm_connector_hdmi_audio_funcs *funcs;
    struct platform_device *codec_pdev;
    struct mutex lock;
    void (*plugged_cb)(struct device *, bool);
    struct device *plugged_cb_dev;
    bool last_state;
    int dai_port;
};

struct drm_connector_funcs;

struct drm_property_blob;

struct drm_connector_helper_funcs;

struct drm_tile_group;

struct drm_connector {
    struct drm_device *dev;
    struct device *kdev;
    struct device_attribute *attr;
    struct fwnode_handle *fwnode;
    struct list_head head;
    struct list_head global_connector_list_entry;
    struct drm_mode_object base;
    char *name;
    struct mutex mutex;
    unsigned int index;
    int connector_type;
    int connector_type_id;
    bool interlace_allowed;
    bool doublescan_allowed;
    bool stereo_allowed;
    bool ycbcr_420_allowed;
    enum drm_connector_registration_state registration_state;
    struct list_head modes;
    enum drm_connector_status status;
    struct list_head probed_modes;
    struct drm_display_info display_info;
    const struct drm_connector_funcs *funcs;
    struct drm_property_blob *edid_blob_ptr;
    struct drm_object_properties properties;
    struct drm_property *scaling_mode_property;
    struct drm_property *vrr_capable_property;
    struct drm_property *colorspace_property;
    struct drm_property_blob *path_blob_ptr;
    unsigned int max_bpc;
    struct drm_property *max_bpc_property;
    struct drm_privacy_screen *privacy_screen;
    struct notifier_block privacy_screen_notifier;
    struct drm_property *privacy_screen_sw_state_property;
    struct drm_property *privacy_screen_hw_state_property;
    struct drm_property *broadcast_rgb_property;
    struct drm_property *rotation_property;
    uint8_t polled;
    int dpms;
    const struct drm_connector_helper_funcs *helper_private;
    struct drm_cmdline_mode cmdline_mode;
    enum drm_connector_force force;
    const struct drm_edid *edid_override;
    struct mutex edid_override_mutex;
    u64 epoch_counter;
    u32 possible_encoders;
    struct drm_encoder *encoder;
    uint8_t eld[128];
    struct mutex eld_mutex;
    bool latency_present[2];
    int video_latency[2];
    int audio_latency[2];
    struct i2c_adapter *ddc;
    int null_edid_counter;
    unsigned int bad_edid_counter;
    bool edid_corrupt;
    u8 real_edid_checksum;
    struct dentry *debugfs_entry;
    struct drm_connector_state *state;
    struct drm_property_blob *tile_blob_ptr;
    bool has_tile;
    struct drm_tile_group *tile_group;
    bool tile_is_single_monitor;
    uint8_t num_h_tile;
    uint8_t num_v_tile;
    uint8_t tile_h_loc;
    uint8_t tile_v_loc;
    uint16_t tile_h_size;
    uint16_t tile_v_size;
    struct llist_node free_node;
    struct hdr_sink_metadata hdr_sink_metadata;
    struct drm_connector_hdmi hdmi;
    struct drm_connector_hdmi_audio hdmi_audio;
};

struct drm_printer;

struct drm_connector_funcs {
    int (*dpms)(struct drm_connector *, int);
    void (*reset)(struct drm_connector *);
    enum drm_connector_status (*detect)(struct drm_connector *, bool);
    void (*force)(struct drm_connector *);
    int (*fill_modes)(struct drm_connector *, uint32_t, uint32_t);
    int (*set_property)(struct drm_connector *, struct drm_property *, uint64_t);
    int (*late_register)(struct drm_connector *);
    void (*early_unregister)(struct drm_connector *);
    void (*destroy)(struct drm_connector *);
    struct drm_connector_state * (*atomic_duplicate_state)(struct drm_connector *);
    void (*atomic_destroy_state)(struct drm_connector *, struct drm_connector_state *);
    int (*atomic_set_property)(struct drm_connector *, struct drm_connector_state *, struct drm_property *, uint64_t);
    int (*atomic_get_property)(struct drm_connector *, const struct drm_connector_state *, struct drm_property *, uint64_t *);
    void (*atomic_print_state)(struct drm_printer *, const struct drm_connector_state *);
    void (*oob_hotplug_event)(struct drm_connector *, enum drm_connector_status);
    void (*debugfs_init)(struct drm_connector *, struct dentry *);
};

struct drm_connector_hdmi_audio_funcs {
    int (*startup)(struct drm_connector *);
    int (*prepare)(struct drm_connector *, struct hdmi_codec_daifmt *, struct hdmi_codec_params *);
    void (*shutdown)(struct drm_connector *);
    int (*mute_stream)(struct drm_connector *, bool, int);
};

struct drm_connector_hdmi_funcs {
    enum drm_mode_status (*tmds_char_rate_valid)(const struct drm_connector *, const struct drm_display_mode *, long long unsigned int);
    int (*clear_infoframe)(struct drm_connector *, enum hdmi_infoframe_type);
    int (*write_infoframe)(struct drm_connector *, enum hdmi_infoframe_type, const u8 *, size_t);
    const struct drm_edid * (*read_edid)(struct drm_connector *);
};

struct drm_connector_hdmi_state {
    enum drm_hdmi_broadcast_rgb broadcast_rgb;
    struct {
        struct drm_connector_hdmi_infoframe avi;
        struct drm_connector_hdmi_infoframe hdr_drm;
        struct drm_connector_hdmi_infoframe spd;
        struct drm_connector_hdmi_infoframe hdmi;
    } infoframes;
    bool is_limited_range;
    unsigned int output_bpc;
    enum hdmi_colorspace output_format;
    long long unsigned int tmds_char_rate;
};

struct drm_writeback_connector;

struct drm_writeback_job;

struct drm_connector_helper_funcs {
    int (*get_modes)(struct drm_connector *);
    int (*detect_ctx)(struct drm_connector *, struct drm_modeset_acquire_ctx *, bool);
    enum drm_mode_status (*mode_valid)(struct drm_connector *, struct drm_display_mode *);
    int (*mode_valid_ctx)(struct drm_connector *, struct drm_display_mode *, struct drm_modeset_acquire_ctx *, enum drm_mode_status *);
    struct drm_encoder * (*best_encoder)(struct drm_connector *);
    struct drm_encoder * (*atomic_best_encoder)(struct drm_connector *, struct drm_atomic_state *);
    int (*atomic_check)(struct drm_connector *, struct drm_atomic_state *);
    void (*atomic_commit)(struct drm_connector *, struct drm_atomic_state *);
    int (*prepare_writeback_job)(struct drm_writeback_connector *, struct drm_writeback_job *);
    void (*cleanup_writeback_job)(struct drm_writeback_connector *, struct drm_writeback_job *);
    void (*enable_hpd)(struct drm_connector *);
    void (*disable_hpd)(struct drm_connector *);
};

struct drm_connector_list_iter {
    struct drm_device *dev;
    struct drm_connector *conn;
};

struct drm_tv_connector_state {
    enum drm_mode_subconnector select_subconnector;
    enum drm_mode_subconnector subconnector;
    struct drm_connector_tv_margins margins;
    unsigned int legacy_mode;
    unsigned int mode;
    unsigned int brightness;
    unsigned int contrast;
    unsigned int flicker_reduction;
    unsigned int overscan;
    unsigned int saturation;
    unsigned int hue;
};

struct drm_connector_state {
    struct drm_connector *connector;
    struct drm_crtc *crtc;
    struct drm_encoder *best_encoder;
    enum drm_link_status link_status;
    struct drm_atomic_state *state;
    struct drm_crtc_commit *commit;
    struct drm_tv_connector_state tv;
    bool self_refresh_aware;
    enum hdmi_picture_aspect picture_aspect_ratio;
    unsigned int content_type;
    unsigned int hdcp_content_type;
    unsigned int scaling_mode;
    unsigned int content_protection;
    enum drm_colorspace colorspace;
    struct drm_writeback_job *writeback_job;
    u8 max_requested_bpc;
    u8 max_bpc;
    enum drm_privacy_screen_status privacy_screen_sw_state;
    struct drm_property_blob *hdr_output_metadata;
    struct drm_connector_hdmi_state hdmi;
    u32 rotation;
};

struct drm_display_mode {
    int clock;
    u16 hdisplay;
    u16 hsync_start;
    u16 hsync_end;
    u16 htotal;
    u16 hskew;
    u16 vdisplay;
    u16 vsync_start;
    u16 vsync_end;
    u16 vtotal;
    u16 vscan;
    u32 flags;
    int crtc_clock;
    u16 crtc_hdisplay;
    u16 crtc_hblank_start;
    u16 crtc_hblank_end;
    u16 crtc_hsync_start;
    u16 crtc_hsync_end;
    u16 crtc_htotal;
    u16 crtc_hskew;
    u16 crtc_vdisplay;
    u16 crtc_vblank_start;
    u16 crtc_vblank_end;
    u16 crtc_vsync_start;
    u16 crtc_vsync_end;
    u16 crtc_vtotal;
    u16 width_mm;
    u16 height_mm;
    u8 type;
    bool expose_to_userspace;
    struct list_head head;
    char name[32];
    enum drm_mode_status status;
    enum hdmi_picture_aspect picture_aspect_ratio;
};

struct drm_crtc_crc_entry;

struct drm_crtc_crc {
    spinlock_t lock;
    const char *source;
    bool opened;
    bool overflow;
    struct drm_crtc_crc_entry *entries;
    int head;
    int tail;
    size_t values_cnt;
    wait_queue_head_t wq;
};

struct drm_self_refresh_data;

struct drm_crtc_funcs;

struct drm_crtc_helper_funcs;

struct drm_crtc {
    struct drm_device *dev;
    struct device_node *port;
    struct list_head head;
    char *name;
    struct drm_modeset_lock mutex;
    struct drm_mode_object base;
    struct drm_plane *primary;
    struct drm_plane *cursor;
    unsigned int index;
    int cursor_x;
    int cursor_y;
    bool enabled;
    struct drm_display_mode mode;
    struct drm_display_mode hwmode;
    int x;
    int y;
    const struct drm_crtc_funcs *funcs;
    uint32_t gamma_size;
    uint16_t *gamma_store;
    const struct drm_crtc_helper_funcs *helper_private;
    struct drm_object_properties properties;
    struct drm_property *scaling_filter_property;
    struct drm_crtc_state *state;
    struct list_head commit_list;
    spinlock_t commit_lock;
    struct dentry *debugfs_entry;
    struct drm_crtc_crc crc;
    unsigned int fence_context;
    spinlock_t fence_lock;
    long unsigned int fence_seqno;
    char timeline_name[32];
    struct drm_self_refresh_data *self_refresh_data;
};

struct drm_pending_vblank_event;

struct drm_crtc_commit {
    struct drm_crtc *crtc;
    struct kref ref;
    struct completion flip_done;
    struct completion hw_done;
    struct completion cleanup_done;
    struct list_head commit_entry;
    struct drm_pending_vblank_event *event;
    bool abort_completion;
};

struct drm_crtc_crc_entry {
    bool has_frame_counter;
    uint32_t frame;
    uint32_t crcs[10];
};

struct drm_crtc_funcs {
    void (*reset)(struct drm_crtc *);
    int (*cursor_set)(struct drm_crtc *, struct drm_file *, uint32_t, uint32_t, uint32_t);
    int (*cursor_set2)(struct drm_crtc *, struct drm_file *, uint32_t, uint32_t, uint32_t, int32_t, int32_t);
    int (*cursor_move)(struct drm_crtc *, int, int);
    int (*gamma_set)(struct drm_crtc *, u16 *, u16 *, u16 *, uint32_t, struct drm_modeset_acquire_ctx *);
    void (*destroy)(struct drm_crtc *);
    int (*set_config)(struct drm_mode_set *, struct drm_modeset_acquire_ctx *);
    int (*page_flip)(struct drm_crtc *, struct drm_framebuffer *, struct drm_pending_vblank_event *, uint32_t, struct drm_modeset_acquire_ctx *);
    int (*page_flip_target)(struct drm_crtc *, struct drm_framebuffer *, struct drm_pending_vblank_event *, uint32_t, uint32_t, struct drm_modeset_acquire_ctx *);
    int (*set_property)(struct drm_crtc *, struct drm_property *, uint64_t);
    struct drm_crtc_state * (*atomic_duplicate_state)(struct drm_crtc *);
    void (*atomic_destroy_state)(struct drm_crtc *, struct drm_crtc_state *);
    int (*atomic_set_property)(struct drm_crtc *, struct drm_crtc_state *, struct drm_property *, uint64_t);
    int (*atomic_get_property)(struct drm_crtc *, const struct drm_crtc_state *, struct drm_property *, uint64_t *);
    int (*late_register)(struct drm_crtc *);
    void (*early_unregister)(struct drm_crtc *);
    int (*set_crc_source)(struct drm_crtc *, const char *);
    int (*verify_crc_source)(struct drm_crtc *, const char *, size_t *);
    const char * const * (*get_crc_sources)(struct drm_crtc *, size_t *);
    void (*atomic_print_state)(struct drm_printer *, const struct drm_crtc_state *);
    u32 (*get_vblank_counter)(struct drm_crtc *);
    int (*enable_vblank)(struct drm_crtc *);
    void (*disable_vblank)(struct drm_crtc *);
    bool (*get_vblank_timestamp)(struct drm_crtc *, int *, ktime_t *, bool);
};

struct drm_crtc_get_sequence {
    __u32 crtc_id;
    __u32 active;
    __u64 sequence;
    __s64 sequence_ns;
};

struct drm_crtc_helper_funcs {
    void (*dpms)(struct drm_crtc *, int);
    void (*prepare)(struct drm_crtc *);
    void (*commit)(struct drm_crtc *);
    enum drm_mode_status (*mode_valid)(struct drm_crtc *, const struct drm_display_mode *);
    bool (*mode_fixup)(struct drm_crtc *, const struct drm_display_mode *, struct drm_display_mode *);
    int (*mode_set)(struct drm_crtc *, struct drm_display_mode *, struct drm_display_mode *, int, int, struct drm_framebuffer *);
    void (*mode_set_nofb)(struct drm_crtc *);
    int (*mode_set_base)(struct drm_crtc *, int, int, struct drm_framebuffer *);
    int (*mode_set_base_atomic)(struct drm_crtc *, struct drm_framebuffer *, int, int, enum mode_set_atomic);
    void (*disable)(struct drm_crtc *);
    int (*atomic_check)(struct drm_crtc *, struct drm_atomic_state *);
    void (*atomic_begin)(struct drm_crtc *, struct drm_atomic_state *);
    void (*atomic_flush)(struct drm_crtc *, struct drm_atomic_state *);
    void (*atomic_enable)(struct drm_crtc *, struct drm_atomic_state *);
    void (*atomic_disable)(struct drm_crtc *, struct drm_atomic_state *);
    bool (*get_scanout_position)(struct drm_crtc *, bool, int *, int *, ktime_t *, ktime_t *, const struct drm_display_mode *);
};

struct drm_crtc_queue_sequence {
    __u32 crtc_id;
    __u32 flags;
    __u64 sequence;
    __u64 user_data;
};

struct drm_crtc_state {
    struct drm_crtc *crtc;
    bool enable;
    bool active;
    bool planes_changed: 1;
    bool mode_changed: 1;
    bool active_changed: 1;
    bool connectors_changed: 1;
    bool zpos_changed: 1;
    bool color_mgmt_changed: 1;
    bool no_vblank: 1;
    u64 plane_mask;
    u32 connector_mask;
    u32 encoder_mask;
    struct drm_display_mode adjusted_mode;
    struct drm_display_mode mode;
    struct drm_property_blob *mode_blob;
    struct drm_property_blob *degamma_lut;
    struct drm_property_blob *ctm;
    struct drm_property_blob *gamma_lut;
    u32 target_vblank;
    bool async_flip;
    bool vrr_enabled;
    bool self_refresh_active;
    enum drm_scaling_filter scaling_filter;
    struct drm_pending_vblank_event *event;
    struct drm_crtc_commit *commit;
    struct drm_atomic_state *state;
};

struct drm_debugfs_info {
    const char *name;
    int (*show)(struct seq_file *, void *);
    u32 driver_features;
    void *data;
};

struct drm_debugfs_entry {
    struct drm_device *dev;
    struct drm_debugfs_info file;
    struct list_head list;
};

struct drm_mode_config_funcs;

struct drm_mode_config_helper_funcs;

struct drm_mode_config {
    struct mutex mutex;
    struct drm_modeset_lock connection_mutex;
    struct drm_modeset_acquire_ctx *acquire_ctx;
    struct mutex idr_mutex;
    struct idr object_idr;
    struct idr tile_idr;
    struct mutex fb_lock;
    int num_fb;
    struct list_head fb_list;
    spinlock_t connector_list_lock;
    int num_connector;
    struct ida connector_ida;
    struct list_head connector_list;
    struct llist_head connector_free_list;
    struct work_struct connector_free_work;
    int num_encoder;
    struct list_head encoder_list;
    int num_total_plane;
    struct list_head plane_list;
    struct raw_spinlock panic_lock;
    int num_crtc;
    struct list_head crtc_list;
    struct list_head property_list;
    struct list_head privobj_list;
    int min_width;
    int min_height;
    int max_width;
    int max_height;
    const struct drm_mode_config_funcs *funcs;
    bool poll_enabled;
    bool poll_running;
    bool delayed_event;
    struct delayed_work output_poll_work;
    struct mutex blob_lock;
    struct list_head property_blob_list;
    struct drm_property *edid_property;
    struct drm_property *dpms_property;
    struct drm_property *path_property;
    struct drm_property *tile_property;
    struct drm_property *link_status_property;
    struct drm_property *plane_type_property;
    struct drm_property *prop_src_x;
    struct drm_property *prop_src_y;
    struct drm_property *prop_src_w;
    struct drm_property *prop_src_h;
    struct drm_property *prop_crtc_x;
    struct drm_property *prop_crtc_y;
    struct drm_property *prop_crtc_w;
    struct drm_property *prop_crtc_h;
    struct drm_property *prop_fb_id;
    struct drm_property *prop_in_fence_fd;
    struct drm_property *prop_out_fence_ptr;
    struct drm_property *prop_crtc_id;
    struct drm_property *prop_fb_damage_clips;
    struct drm_property *prop_active;
    struct drm_property *prop_mode_id;
    struct drm_property *prop_vrr_enabled;
    struct drm_property *dvi_i_subconnector_property;
    struct drm_property *dvi_i_select_subconnector_property;
    struct drm_property *dp_subconnector_property;
    struct drm_property *tv_subconnector_property;
    struct drm_property *tv_select_subconnector_property;
    struct drm_property *legacy_tv_mode_property;
    struct drm_property *tv_mode_property;
    struct drm_property *tv_left_margin_property;
    struct drm_property *tv_right_margin_property;
    struct drm_property *tv_top_margin_property;
    struct drm_property *tv_bottom_margin_property;
    struct drm_property *tv_brightness_property;
    struct drm_property *tv_contrast_property;
    struct drm_property *tv_flicker_reduction_property;
    struct drm_property *tv_overscan_property;
    struct drm_property *tv_saturation_property;
    struct drm_property *tv_hue_property;
    struct drm_property *scaling_mode_property;
    struct drm_property *aspect_ratio_property;
    struct drm_property *content_type_property;
    struct drm_property *degamma_lut_property;
    struct drm_property *degamma_lut_size_property;
    struct drm_property *ctm_property;
    struct drm_property *gamma_lut_property;
    struct drm_property *gamma_lut_size_property;
    struct drm_property *suggested_x_property;
    struct drm_property *suggested_y_property;
    struct drm_property *non_desktop_property;
    struct drm_property *panel_orientation_property;
    struct drm_property *writeback_fb_id_property;
    struct drm_property *writeback_pixel_formats_property;
    struct drm_property *writeback_out_fence_ptr_property;
    struct drm_property *hdr_output_metadata_property;
    struct drm_property *content_protection_property;
    struct drm_property *hdcp_content_type_property;
    uint32_t preferred_depth;
    uint32_t prefer_shadow;
    bool quirk_addfb_prefer_xbgr_30bpp;
    bool quirk_addfb_prefer_host_byte_order;
    bool async_page_flip;
    bool fb_modifiers_not_supported;
    bool normalize_zpos;
    struct drm_property *modifiers_property;
    struct drm_property *size_hints_property;
    uint32_t cursor_width;
    uint32_t cursor_height;
    struct drm_atomic_state *suspend_state;
    const struct drm_mode_config_helper_funcs *helper_private;
};

struct drm_vram_mm;

struct drm_fb_helper;

struct drm_driver;

struct drm_minor;

struct drm_master;

struct drm_vblank_crtc;

struct drm_vma_offset_manager;

struct drm_device {
    int if_version;
    struct kref ref;
    struct device *dev;
    struct {
        struct list_head resources;
        void *final_kfree;
        spinlock_t lock;
    } managed;
    const struct drm_driver *driver;
    void *dev_private;
    struct drm_minor *primary;
    struct drm_minor *render;
    struct drm_minor *accel;
    bool registered;
    struct drm_master *master;
    u32 driver_features;
    bool unplugged;
    struct inode *anon_inode;
    char *unique;
    struct mutex struct_mutex;
    struct mutex master_mutex;
    atomic_t open_count;
    struct mutex filelist_mutex;
    struct list_head filelist;
    struct list_head filelist_internal;
    struct mutex clientlist_mutex;
    struct list_head clientlist;
    bool vblank_disable_immediate;
    struct drm_vblank_crtc *vblank;
    spinlock_t vblank_time_lock;
    spinlock_t vbl_lock;
    u32 max_vblank_count;
    struct list_head vblank_event_list;
    spinlock_t event_lock;
    unsigned int num_crtcs;
    struct drm_mode_config mode_config;
    struct mutex object_name_lock;
    struct idr object_name_idr;
    struct drm_vma_offset_manager *vma_offset_manager;
    struct drm_vram_mm *vram_mm;
    enum switch_power_state switch_power_state;
    struct drm_fb_helper *fb_helper;
    struct dentry *debugfs_root;
};

struct drm_dmi_panel_orientation_data {
    int width;
    int height;
    const char * const *bios_dates;
    int orientation;
};

struct drm_fb_helper_surface_size;

struct drm_mode_create_dumb;

struct drm_ioctl_desc;

struct drm_driver {
    int (*load)(struct drm_device *, long unsigned int);
    int (*open)(struct drm_device *, struct drm_file *);
    void (*postclose)(struct drm_device *, struct drm_file *);
    void (*unload)(struct drm_device *);
    void (*release)(struct drm_device *);
    void (*master_set)(struct drm_device *, struct drm_file *, bool);
    void (*master_drop)(struct drm_device *, struct drm_file *);
    void (*debugfs_init)(struct drm_minor *);
    struct drm_gem_object * (*gem_create_object)(struct drm_device *, size_t);
    int (*prime_handle_to_fd)(struct drm_device *, struct drm_file *, uint32_t, uint32_t, int *);
    int (*prime_fd_to_handle)(struct drm_device *, struct drm_file *, int, uint32_t *);
    struct drm_gem_object * (*gem_prime_import)(struct drm_device *, struct dma_buf *);
    struct drm_gem_object * (*gem_prime_import_sg_table)(struct drm_device *, struct dma_buf_attachment *, struct sg_table *);
    int (*dumb_create)(struct drm_file *, struct drm_device *, struct drm_mode_create_dumb *);
    int (*dumb_map_offset)(struct drm_file *, struct drm_device *, uint32_t, uint64_t *);
    int (*fbdev_probe)(struct drm_fb_helper *, struct drm_fb_helper_surface_size *);
    void (*show_fdinfo)(struct drm_printer *, struct drm_file *);
    int major;
    int minor;
    int patchlevel;
    char *name;
    char *desc;
    u32 driver_features;
    const struct drm_ioctl_desc *ioctls;
    int num_ioctls;
    const struct file_operations *fops;
};

struct drm_dsc_rc_range_parameters {
    u8 range_min_qp;
    u8 range_max_qp;
    u8 range_bpg_offset;
};

struct drm_dsc_config {
    u8 line_buf_depth;
    u8 bits_per_component;
    bool convert_rgb;
    u8 slice_count;
    u16 slice_width;
    u16 slice_height;
    bool simple_422;
    u16 pic_width;
    u16 pic_height;
    u8 rc_tgt_offset_high;
    u8 rc_tgt_offset_low;
    u16 bits_per_pixel;
    u8 rc_edge_factor;
    u8 rc_quant_incr_limit1;
    u8 rc_quant_incr_limit0;
    u16 initial_xmit_delay;
    u16 initial_dec_delay;
    bool block_pred_enable;
    u8 first_line_bpg_offset;
    u16 initial_offset;
    u16 rc_buf_thresh[14];
    struct drm_dsc_rc_range_parameters rc_range_params[15];
    u16 rc_model_size;
    u8 flatness_min_qp;
    u8 flatness_max_qp;
    u8 initial_scale_value;
    u16 scale_decrement_interval;
    u16 scale_increment_interval;
    u16 nfl_bpg_offset;
    u16 slice_bpg_offset;
    u16 final_offset;
    bool vbr_enable;
    u8 mux_word_size;
    u16 slice_chunk_size;
    u16 rc_bits;
    u8 dsc_version_minor;
    u8 dsc_version_major;
    bool native_422;
    bool native_420;
    u8 second_line_bpg_offset;
    u16 nsl_bpg_offset;
    u16 second_line_offset_adj;
};

struct drm_dsc_picture_parameter_set {
    u8 dsc_version;
    u8 pps_identifier;
    u8 pps_reserved;
    u8 pps_3;
    u8 pps_4;
    u8 bits_per_pixel_low;
    __be16 pic_height;
    __be16 pic_width;
    __be16 slice_height;
    __be16 slice_width;
    __be16 chunk_size;
    u8 initial_xmit_delay_high;
    u8 initial_xmit_delay_low;
    __be16 initial_dec_delay;
    u8 pps20_reserved;
    u8 initial_scale_value;
    __be16 scale_increment_interval;
    u8 scale_decrement_interval_high;
    u8 scale_decrement_interval_low;
    u8 pps26_reserved;
    u8 first_line_bpg_offset;
    __be16 nfl_bpg_offset;
    __be16 slice_bpg_offset;
    __be16 initial_offset;
    __be16 final_offset;
    u8 flatness_min_qp;
    u8 flatness_max_qp;
    __be16 rc_model_size;
    u8 rc_edge_factor;
    u8 rc_quant_incr_limit0;
    u8 rc_quant_incr_limit1;
    u8 rc_tgt_offset;
    u8 rc_buf_thresh[14];
    __be16 rc_range_parameters[15];
    u8 native_422_420;
    u8 second_line_bpg_offset;
    __be16 nsl_bpg_offset;
    __be16 second_line_offset_adj;
    u32 pps_long_94_reserved;
    u32 pps_long_98_reserved;
    u32 pps_long_102_reserved;
    u32 pps_long_106_reserved;
    u32 pps_long_110_reserved;
    u32 pps_long_114_reserved;
    u32 pps_long_118_reserved;
    u32 pps_long_122_reserved;
    __be16 pps_short_126_reserved;
} __attribute__((packed));

struct edid;

struct drm_edid {
    size_t size;
    const struct edid *edid;
};

struct drm_edid_ident {
    u32 panel_id;
    const char *name;
};

struct drm_edid_match_closure {
    const struct drm_edid_ident *ident;
    bool matched;
};

struct drm_edid_product_id {
    __be16 manufacturer_name;
    __le16 product_code;
    __le32 serial_number;
    u8 week_of_manufacture;
    u8 year_of_manufacture;
} __attribute__((packed));

struct drm_encoder_funcs;

struct drm_encoder_helper_funcs;

struct drm_encoder {
    struct drm_device *dev;
    struct list_head head;
    struct drm_mode_object base;
    char *name;
    int encoder_type;
    unsigned int index;
    uint32_t possible_crtcs;
    uint32_t possible_clones;
    struct drm_crtc *crtc;
    struct list_head bridge_chain;
    const struct drm_encoder_funcs *funcs;
    const struct drm_encoder_helper_funcs *helper_private;
    struct dentry *debugfs_entry;
};

struct drm_encoder_funcs {
    void (*reset)(struct drm_encoder *);
    void (*destroy)(struct drm_encoder *);
    int (*late_register)(struct drm_encoder *);
    void (*early_unregister)(struct drm_encoder *);
    void (*debugfs_init)(struct drm_encoder *, struct dentry *);
};

struct drm_encoder_helper_funcs {
    void (*dpms)(struct drm_encoder *, int);
    enum drm_mode_status (*mode_valid)(struct drm_encoder *, const struct drm_display_mode *);
    bool (*mode_fixup)(struct drm_encoder *, const struct drm_display_mode *, struct drm_display_mode *);
    void (*prepare)(struct drm_encoder *);
    void (*commit)(struct drm_encoder *);
    void (*mode_set)(struct drm_encoder *, struct drm_display_mode *, struct drm_display_mode *);
    void (*atomic_mode_set)(struct drm_encoder *, struct drm_crtc_state *, struct drm_connector_state *);
    enum drm_connector_status (*detect)(struct drm_encoder *, struct drm_connector *);
    void (*atomic_disable)(struct drm_encoder *, struct drm_atomic_state *);
    void (*atomic_enable)(struct drm_encoder *, struct drm_atomic_state *);
    void (*disable)(struct drm_encoder *);
    void (*enable)(struct drm_encoder *);
    int (*atomic_check)(struct drm_encoder *, struct drm_crtc_state *, struct drm_connector_state *);
};

struct drm_event {
    __u32 type;
    __u32 length;
};

struct drm_event_crtc_sequence {
    struct drm_event base;
    __u64 user_data;
    __s64 time_ns;
    __u64 sequence;
};

struct drm_event_vblank {
    struct drm_event base;
    __u64 user_data;
    __u32 tv_sec;
    __u32 tv_usec;
    __u32 sequence;
    __u32 crtc_id;
};

struct ww_acquire_ctx {
    struct task_struct *task;
    long unsigned int stamp;
    unsigned int acquired;
    short unsigned int wounded;
    short unsigned int is_wait_die;
};

struct drm_exec {
    u32 flags;
    struct ww_acquire_ctx ticket;
    unsigned int num_objects;
    unsigned int max_objects;
    struct drm_gem_object **objects;
    struct drm_gem_object *contended;
    struct drm_gem_object *prelocked;
};

struct drm_prime_file_private {
    struct mutex lock;
    struct rb_root dmabufs;
    struct rb_root handles;
};

struct drm_file {
    bool authenticated;
    bool stereo_allowed;
    bool universal_planes;
    bool atomic;
    bool aspect_ratio_allowed;
    bool writeback_connectors;
    bool was_master;
    bool is_master;
    bool supports_virtualized_cursor_plane;
    struct drm_master *master;
    spinlock_t master_lookup_lock;
    struct pid *pid;
    u64 client_id;
    drm_magic_t magic;
    struct list_head lhead;
    struct drm_minor *minor;
    struct idr object_idr;
    spinlock_t table_lock;
    struct idr syncobj_idr;
    spinlock_t syncobj_table_lock;
    struct file *filp;
    void *driver_priv;
    struct list_head fbs;
    struct mutex fbs_lock;
    struct list_head blobs;
    wait_queue_head_t event_wait;
    struct list_head pending_event_list;
    struct list_head event_list;
    int event_space;
    struct mutex event_read_lock;
    struct drm_prime_file_private prime;
    const char *client_name;
    struct mutex client_name_lock;
};

struct drm_format_info {
    u32 format;
    u8 depth;
    u8 num_planes;
    union {
        u8 cpp[4];
        u8 char_per_block[4];
    };
    u8 block_w[4];
    u8 block_h[4];
    u8 hsub;
    u8 vsub;
    bool has_alpha;
    bool is_yuv;
    bool is_color_indexed;
};

struct drm_format_modifier {
    __u64 formats;
    __u32 offset;
    __u32 pad;
    __u64 modifier;
};

struct drm_format_modifier_blob {
    __u32 version;
    __u32 flags;
    __u32 count_formats;
    __u32 formats_offset;
    __u32 count_modifiers;
    __u32 modifiers_offset;
};

struct drm_framebuffer_funcs;

struct drm_framebuffer {
    struct drm_device *dev;
    struct list_head head;
    struct drm_mode_object base;
    char comm[16];
    const struct drm_format_info *format;
    const struct drm_framebuffer_funcs *funcs;
    unsigned int pitches[4];
    unsigned int offsets[4];
    uint64_t modifier;
    unsigned int width;
    unsigned int height;
    int flags;
    struct list_head filp_head;
    struct drm_gem_object *obj[4];
};

struct drm_framebuffer_funcs {
    void (*destroy)(struct drm_framebuffer *);
    int (*create_handle)(struct drm_framebuffer *, struct drm_file *, unsigned int *);
    int (*dirty)(struct drm_framebuffer *, struct drm_file *, unsigned int, unsigned int, struct drm_clip_rect *, unsigned int);
};

struct drm_gem_close {
    __u32 handle;
    __u32 pad;
};

struct drm_gem_flink {
    __u32 handle;
    __u32 name;
};

struct drm_gem_lru {
    struct mutex *lock;
    long int count;
    struct list_head list;
};

struct drm_mm;

struct drm_mm_node {
    long unsigned int color;
    u64 start;
    u64 size;
    struct drm_mm *mm;
    struct list_head node_list;
    struct list_head hole_stack;
    struct rb_node rb;
    struct rb_node rb_hole_size;
    struct rb_node rb_hole_addr;
    u64 __subtree_last;
    u64 hole_size;
    u64 subtree_max_hole;
    long unsigned int flags;
};

struct drm_vma_offset_node {
    rwlock_t vm_lock;
    struct drm_mm_node vm_node;
    struct rb_root vm_files;
    void *driver_private;
};

struct drm_gem_object_funcs;

struct drm_gem_object {
    struct kref refcount;
    unsigned int handle_count;
    struct drm_device *dev;
    struct file *filp;
    struct drm_vma_offset_node vma_node;
    size_t size;
    int name;
    struct dma_buf *dma_buf;
    struct dma_buf_attachment *import_attach;
    struct dma_resv *resv;
    struct dma_resv _resv;
    struct {
        struct list_head list;
    } gpuva;
    const struct drm_gem_object_funcs *funcs;
    struct list_head lru_node;
    struct drm_gem_lru *lru;
};

struct vm_operations_struct;

struct drm_gem_object_funcs {
    void (*free)(struct drm_gem_object *);
    int (*open)(struct drm_gem_object *, struct drm_file *);
    void (*close)(struct drm_gem_object *, struct drm_file *);
    void (*print_info)(struct drm_printer *, unsigned int, const struct drm_gem_object *);
    struct dma_buf * (*export)(struct drm_gem_object *, int);
    int (*pin)(struct drm_gem_object *);
    void (*unpin)(struct drm_gem_object *);
    struct sg_table * (*get_sg_table)(struct drm_gem_object *);
    int (*vmap)(struct drm_gem_object *, struct iosys_map *);
    void (*vunmap)(struct drm_gem_object *, struct iosys_map *);
    int (*mmap)(struct drm_gem_object *, struct vm_area_struct *);
    int (*evict)(struct drm_gem_object *);
    enum drm_gem_object_status (*status)(struct drm_gem_object *);
    size_t (*rss)(struct drm_gem_object *);
    const struct vm_operations_struct *vm_ops;
};

struct drm_gem_open {
    __u32 name;
    __u32 handle;
    __u64 size;
};

struct drm_get_cap {
    __u64 capability;
    __u64 value;
};

struct drm_gpuvm;

struct drm_gpuvm_bo;

struct drm_gpuva {
    struct drm_gpuvm *vm;
    struct drm_gpuvm_bo *vm_bo;
    enum drm_gpuva_flags flags;
    struct {
        u64 addr;
        u64 range;
    } va;
    struct {
        u64 offset;
        struct drm_gem_object *obj;
        struct list_head entry;
    } gem;
    struct {
        struct rb_node node;
        struct list_head entry;
        u64 __subtree_last;
    } rb;
};

struct drm_gpuva_op_map {
    struct {
        u64 addr;
        u64 range;
    } va;
    struct {
        u64 offset;
        struct drm_gem_object *obj;
    } gem;
};

struct drm_gpuva_op_unmap;

struct drm_gpuva_op_remap {
    struct drm_gpuva_op_map *prev;
    struct drm_gpuva_op_map *next;
    struct drm_gpuva_op_unmap *unmap;
};

struct drm_gpuva_op_unmap {
    struct drm_gpuva *va;
    bool keep;
};

struct drm_gpuva_op_prefetch {
    struct drm_gpuva *va;
};

struct drm_gpuva_op {
    struct list_head entry;
    enum drm_gpuva_op_type op;
    union {
        struct drm_gpuva_op_map map;
        struct drm_gpuva_op_remap remap;
        struct drm_gpuva_op_unmap unmap;
        struct drm_gpuva_op_prefetch prefetch;
    };
};

struct drm_gpuvm_ops;

struct drm_gpuvm {
    const char *name;
    enum drm_gpuvm_flags flags;
    struct drm_device *drm;
    u64 mm_start;
    u64 mm_range;
    struct {
        struct rb_root_cached tree;
        struct list_head list;
    } rb;
    struct kref kref;
    struct drm_gpuva kernel_alloc_node;
    const struct drm_gpuvm_ops *ops;
    struct drm_gem_object *r_obj;
    struct {
        struct list_head list;
        struct list_head *local_list;
        spinlock_t lock;
    } extobj;
    struct {
        struct list_head list;
        struct list_head *local_list;
        spinlock_t lock;
    } evict;
};

struct drm_gpuvm_bo {
    struct drm_gpuvm *vm;
    struct drm_gem_object *obj;
    bool evicted;
    struct kref kref;
    struct {
        struct list_head gpuva;
        struct {
            struct list_head gem;
            struct list_head extobj;
            struct list_head evict;
        } entry;
    } list;
};

struct drm_gpuvm_ops {
    void (*vm_free)(struct drm_gpuvm *);
    struct drm_gpuva_op * (*op_alloc)(void);
    void (*op_free)(struct drm_gpuva_op *);
    struct drm_gpuvm_bo * (*vm_bo_alloc)(void);
    void (*vm_bo_free)(struct drm_gpuvm_bo *);
    int (*vm_bo_validate)(struct drm_gpuvm_bo *, struct drm_exec *);
    int (*sm_step_map)(struct drm_gpuva_op *, void *);
    int (*sm_step_remap)(struct drm_gpuva_op *, void *);
    int (*sm_step_unmap)(struct drm_gpuva_op *, void *);
};

struct drm_info_list {
    const char *name;
    int (*show)(struct seq_file *, void *);
    u32 driver_features;
    void *data;
};

struct drm_info_node {
    struct drm_minor *minor;
    const struct drm_info_list *info_ent;
    struct list_head list;
    struct dentry *dent;
};

typedef int drm_ioctl_t(struct drm_device *, void *, struct drm_file *);

struct drm_ioctl_desc {
    unsigned int cmd;
    enum drm_ioctl_flags flags;
    drm_ioctl_t *func;
    const char *name;
};

struct drm_master {
    struct kref refcount;
    struct drm_device *dev;
    char *unique;
    int unique_len;
    struct idr magic_map;
    void *driver_priv;
    struct drm_master *lessor;
    int lessee_id;
    struct list_head lessee_list;
    struct list_head lessees;
    struct idr leases;
    struct idr lessee_idr;
};

struct drm_memory_stats {
    u64 shared;
    u64 private;
    u64 resident;
    u64 purgeable;
    u64 active;
};

struct drm_minor {
    int index;
    int type;
    struct device *kdev;
    struct drm_device *dev;
    struct dentry *debugfs_symlink;
    struct dentry *debugfs_root;
};

struct drm_mm {
    void (*color_adjust)(const struct drm_mm_node *, long unsigned int, u64 *, u64 *);
    struct list_head hole_stack;
    struct drm_mm_node head_node;
    struct rb_root_cached interval_tree;
    struct rb_root_cached holes_size;
    struct rb_root holes_addr;
    long unsigned int scan_active;
};

struct drm_mm_scan {
    struct drm_mm *mm;
    u64 size;
    u64 alignment;
    u64 remainder_mask;
    u64 range_start;
    u64 range_end;
    u64 hit_start;
    u64 hit_end;
    long unsigned int color;
    enum drm_mm_insert_mode mode;
};

struct drm_mode_atomic {
    __u32 flags;
    __u32 count_objs;
    __u64 objs_ptr;
    __u64 count_props_ptr;
    __u64 props_ptr;
    __u64 prop_values_ptr;
    __u64 reserved;
    __u64 user_data;
};

struct drm_mode_card_res {
    __u64 fb_id_ptr;
    __u64 crtc_id_ptr;
    __u64 connector_id_ptr;
    __u64 encoder_id_ptr;
    __u32 count_fbs;
    __u32 count_crtcs;
    __u32 count_connectors;
    __u32 count_encoders;
    __u32 min_width;
    __u32 max_width;
    __u32 min_height;
    __u32 max_height;
};

struct drm_mode_closefb {
    __u32 fb_id;
    __u32 pad;
};

struct drm_mode_fb_cmd2;

struct drm_mode_config_funcs {
    struct drm_framebuffer * (*fb_create)(struct drm_device *, struct drm_file *, const struct drm_mode_fb_cmd2 *);
    const struct drm_format_info * (*get_format_info)(const struct drm_mode_fb_cmd2 *);
    enum drm_mode_status (*mode_valid)(struct drm_device *, const struct drm_display_mode *);
    int (*atomic_check)(struct drm_device *, struct drm_atomic_state *);
    int (*atomic_commit)(struct drm_device *, struct drm_atomic_state *, bool);
    struct drm_atomic_state * (*atomic_state_alloc)(struct drm_device *);
    void (*atomic_state_clear)(struct drm_atomic_state *);
    void (*atomic_state_free)(struct drm_atomic_state *);
};

struct drm_mode_config_helper_funcs {
    void (*atomic_commit_tail)(struct drm_atomic_state *);
    int (*atomic_commit_setup)(struct drm_atomic_state *);
};

struct drm_mode_connector_set_property {
    __u64 value;
    __u32 prop_id;
    __u32 connector_id;
};

struct drm_mode_create_blob {
    __u64 data;
    __u32 length;
    __u32 blob_id;
};

struct drm_mode_create_dumb {
    __u32 height;
    __u32 width;
    __u32 bpp;
    __u32 flags;
    __u32 handle;
    __u32 pitch;
    __u64 size;
};

struct drm_mode_create_lease {
    __u64 object_ids;
    __u32 object_count;
    __u32 flags;
    __u32 lessee_id;
    __u32 fd;
};

struct drm_mode_modeinfo {
    __u32 clock;
    __u16 hdisplay;
    __u16 hsync_start;
    __u16 hsync_end;
    __u16 htotal;
    __u16 hskew;
    __u16 vdisplay;
    __u16 vsync_start;
    __u16 vsync_end;
    __u16 vtotal;
    __u16 vscan;
    __u32 vrefresh;
    __u32 flags;
    __u32 type;
    char name[32];
};

struct drm_mode_crtc {
    __u64 set_connectors_ptr;
    __u32 count_connectors;
    __u32 crtc_id;
    __u32 fb_id;
    __u32 x;
    __u32 y;
    __u32 gamma_size;
    __u32 mode_valid;
    struct drm_mode_modeinfo mode;
};

struct drm_mode_crtc_lut {
    __u32 crtc_id;
    __u32 gamma_size;
    __u64 red;
    __u64 green;
    __u64 blue;
};

struct drm_mode_crtc_page_flip_target {
    __u32 crtc_id;
    __u32 fb_id;
    __u32 flags;
    __u32 sequence;
    __u64 user_data;
};

struct drm_mode_cursor {
    __u32 flags;
    __u32 crtc_id;
    __s32 x;
    __s32 y;
    __u32 width;
    __u32 height;
    __u32 handle;
};

struct drm_mode_cursor2 {
    __u32 flags;
    __u32 crtc_id;
    __s32 x;
    __s32 y;
    __u32 width;
    __u32 height;
    __u32 handle;
    __s32 hot_x;
    __s32 hot_y;
};

struct drm_mode_destroy_blob {
    __u32 blob_id;
};

struct drm_mode_destroy_dumb {
    __u32 handle;
};

struct drm_mode_fb_cmd {
    __u32 fb_id;
    __u32 width;
    __u32 height;
    __u32 pitch;
    __u32 bpp;
    __u32 depth;
    __u32 handle;
};

struct drm_mode_fb_cmd2 {
    __u32 fb_id;
    __u32 width;
    __u32 height;
    __u32 pixel_format;
    __u32 flags;
    __u32 handles[4];
    __u32 pitches[4];
    __u32 offsets[4];
    __u64 modifier[4];
};

struct drm_mode_fb_dirty_cmd {
    __u32 fb_id;
    __u32 flags;
    __u32 color;
    __u32 num_clips;
    __u64 clips_ptr;
};

struct drm_mode_get_blob {
    __u32 blob_id;
    __u32 length;
    __u64 data;
};

struct drm_mode_get_connector {
    __u64 encoders_ptr;
    __u64 modes_ptr;
    __u64 props_ptr;
    __u64 prop_values_ptr;
    __u32 count_modes;
    __u32 count_props;
    __u32 count_encoders;
    __u32 encoder_id;
    __u32 connector_id;
    __u32 connector_type;
    __u32 connector_type_id;
    __u32 connection;
    __u32 mm_width;
    __u32 mm_height;
    __u32 subpixel;
    __u32 pad;
};

struct drm_mode_get_encoder {
    __u32 encoder_id;
    __u32 encoder_type;
    __u32 crtc_id;
    __u32 possible_crtcs;
    __u32 possible_clones;
};

struct drm_mode_get_lease {
    __u32 count_objects;
    __u32 pad;
    __u64 objects_ptr;
};

struct drm_mode_get_plane {
    __u32 plane_id;
    __u32 crtc_id;
    __u32 fb_id;
    __u32 possible_crtcs;
    __u32 gamma_size;
    __u32 count_format_types;
    __u64 format_type_ptr;
};

struct drm_mode_get_plane_res {
    __u64 plane_id_ptr;
    __u32 count_planes;
};

struct drm_mode_get_property {
    __u64 values_ptr;
    __u64 enum_blob_ptr;
    __u32 prop_id;
    __u32 flags;
    char name[32];
    __u32 count_values;
    __u32 count_enum_blobs;
};

struct drm_mode_list_lessees {
    __u32 count_lessees;
    __u32 pad;
    __u64 lessees_ptr;
};

struct drm_mode_map_dumb {
    __u32 handle;
    __u32 pad;
    __u64 offset;
};

struct drm_mode_obj_get_properties {
    __u64 props_ptr;
    __u64 prop_values_ptr;
    __u32 count_props;
    __u32 obj_id;
    __u32 obj_type;
};

struct drm_mode_obj_set_property {
    __u64 value;
    __u32 prop_id;
    __u32 obj_id;
    __u32 obj_type;
};

struct drm_mode_property_enum {
    __u64 value;
    char name[32];
};

struct drm_mode_rect {
    __s32 x1;
    __s32 y1;
    __s32 x2;
    __s32 y2;
};

struct drm_mode_revoke_lease {
    __u32 lessee_id;
};

struct drm_mode_rmfb_work {
    struct work_struct work;
    struct list_head fbs;
};

struct drm_mode_set {
    struct drm_framebuffer *fb;
    struct drm_crtc *crtc;
    struct drm_display_mode *mode;
    uint32_t x;
    uint32_t y;
    struct drm_connector **connectors;
    size_t num_connectors;
};

struct drm_mode_set_plane {
    __u32 plane_id;
    __u32 crtc_id;
    __u32 fb_id;
    __u32 flags;
    __s32 crtc_x;
    __s32 crtc_y;
    __u32 crtc_w;
    __u32 crtc_h;
    __u32 src_x;
    __u32 src_y;
    __u32 src_h;
    __u32 src_w;
};

struct drm_modeset_acquire_ctx {
    struct ww_acquire_ctx ww_ctx;
    struct drm_modeset_lock *contended;
    depot_stack_handle_t stack_depot;
    struct list_head locked;
    bool trylock_only;
    bool interruptible;
};

struct drm_named_mode {
    const char *name;
    unsigned int pixel_clock_khz;
    unsigned int xres;
    unsigned int yres;
    unsigned int flags;
    unsigned int tv_mode;
};

struct sync_file;

struct drm_out_fence_state {
    s32 *out_fence_ptr;
    struct sync_file *sync_file;
    int fd;
};

struct drm_panel_funcs;

struct drm_panel {
    struct device *dev;
    struct backlight_device *backlight;
    const struct drm_panel_funcs *funcs;
    int connector_type;
    struct list_head list;
    struct list_head followers;
    struct mutex follower_lock;
    bool prepare_prev_first;
    bool prepared;
    bool enabled;
};

struct drm_panel_follower_funcs;

struct drm_panel_follower {
    const struct drm_panel_follower_funcs *funcs;
    struct list_head list;
    struct drm_panel *panel;
};

struct drm_panel_follower_funcs {
    int (*panel_prepared)(struct drm_panel_follower *);
    int (*panel_unpreparing)(struct drm_panel_follower *);
};

struct drm_panel_funcs {
    int (*prepare)(struct drm_panel *);
    int (*enable)(struct drm_panel *);
    int (*disable)(struct drm_panel *);
    int (*unprepare)(struct drm_panel *);
    int (*get_modes)(struct drm_panel *, struct drm_connector *);
    enum drm_panel_orientation (*get_orientation)(struct drm_panel *);
    int (*get_timings)(struct drm_panel *, unsigned int, struct display_timing *);
    void (*debugfs_init)(struct drm_panel *, struct dentry *);
};

struct drm_panic_line {
    u32 len;
    const char *txt;
};

struct drm_pending_event {
    struct completion *completion;
    void (*completion_release)(struct completion *);
    struct drm_event *event;
    struct dma_fence *fence;
    struct drm_file *file_priv;
    struct list_head link;
    struct list_head pending_link;
};

struct drm_pending_vblank_event {
    struct drm_pending_event base;
    unsigned int pipe;
    u64 sequence;
    union {
        struct drm_event base;
        struct drm_event_vblank vbl;
        struct drm_event_crtc_sequence seq;
    } event;
};

struct kmsg_dump_detail;

struct kmsg_dumper {
    struct list_head list;
    void (*dump)(struct kmsg_dumper *, struct kmsg_dump_detail *);
    enum kmsg_dump_reason max_reason;
    bool registered;
};

struct drm_plane_funcs;

struct drm_plane_helper_funcs;

struct drm_plane {
    struct drm_device *dev;
    struct list_head head;
    char *name;
    struct drm_modeset_lock mutex;
    struct drm_mode_object base;
    uint32_t possible_crtcs;
    uint32_t *format_types;
    unsigned int format_count;
    bool format_default;
    uint64_t *modifiers;
    unsigned int modifier_count;
    struct drm_crtc *crtc;
    struct drm_framebuffer *fb;
    struct drm_framebuffer *old_fb;
    const struct drm_plane_funcs *funcs;
    struct drm_object_properties properties;
    enum drm_plane_type type;
    unsigned int index;
    const struct drm_plane_helper_funcs *helper_private;
    struct drm_plane_state *state;
    struct drm_property *alpha_property;
    struct drm_property *zpos_property;
    struct drm_property *rotation_property;
    struct drm_property *blend_mode_property;
    struct drm_property *color_encoding_property;
    struct drm_property *color_range_property;
    struct drm_property *scaling_filter_property;
    struct drm_property *hotspot_x_property;
    struct drm_property *hotspot_y_property;
    struct kmsg_dumper kmsg_panic;
    struct drm_property *chroma_siting_h_property;
    struct drm_property *chroma_siting_v_property;
};

struct drm_plane_funcs {
    int (*update_plane)(struct drm_plane *, struct drm_crtc *, struct drm_framebuffer *, int, int, unsigned int, unsigned int, uint32_t, uint32_t, uint32_t, uint32_t, struct drm_modeset_acquire_ctx *);
    int (*disable_plane)(struct drm_plane *, struct drm_modeset_acquire_ctx *);
    void (*destroy)(struct drm_plane *);
    void (*reset)(struct drm_plane *);
    int (*set_property)(struct drm_plane *, struct drm_property *, uint64_t);
    struct drm_plane_state * (*atomic_duplicate_state)(struct drm_plane *);
    void (*atomic_destroy_state)(struct drm_plane *, struct drm_plane_state *);
    int (*atomic_set_property)(struct drm_plane *, struct drm_plane_state *, struct drm_property *, uint64_t);
    int (*atomic_get_property)(struct drm_plane *, const struct drm_plane_state *, struct drm_property *, uint64_t *);
    int (*late_register)(struct drm_plane *);
    void (*early_unregister)(struct drm_plane *);
    void (*atomic_print_state)(struct drm_printer *, const struct drm_plane_state *);
    bool (*format_mod_supported)(struct drm_plane *, uint32_t, uint64_t);
};

struct drm_scanout_buffer;

struct drm_plane_helper_funcs {
    int (*prepare_fb)(struct drm_plane *, struct drm_plane_state *);
    void (*cleanup_fb)(struct drm_plane *, struct drm_plane_state *);
    int (*begin_fb_access)(struct drm_plane *, struct drm_plane_state *);
    void (*end_fb_access)(struct drm_plane *, struct drm_plane_state *);
    int (*atomic_check)(struct drm_plane *, struct drm_atomic_state *);
    void (*atomic_update)(struct drm_plane *, struct drm_atomic_state *);
    void (*atomic_enable)(struct drm_plane *, struct drm_atomic_state *);
    void (*atomic_disable)(struct drm_plane *, struct drm_atomic_state *);
    int (*atomic_async_check)(struct drm_plane *, struct drm_atomic_state *);
    void (*atomic_async_update)(struct drm_plane *, struct drm_atomic_state *);
    int (*get_scanout_buffer)(struct drm_plane *, struct drm_scanout_buffer *);
    void (*panic_flush)(struct drm_plane *);
};

struct drm_plane_size_hint {
    __u16 width;
    __u16 height;
};

struct drm_rect {
    int x1;
    int y1;
    int x2;
    int y2;
};

struct drm_plane_state {
    struct drm_plane *plane;
    struct drm_crtc *crtc;
    struct drm_framebuffer *fb;
    struct dma_fence *fence;
    int32_t crtc_x;
    int32_t crtc_y;
    uint32_t crtc_w;
    uint32_t crtc_h;
    uint32_t src_x;
    uint32_t src_y;
    uint32_t src_h;
    uint32_t src_w;
    int32_t hotspot_x;
    int32_t hotspot_y;
    u16 alpha;
    uint16_t pixel_blend_mode;
    unsigned int rotation;
    unsigned int zpos;
    unsigned int normalized_zpos;
    enum drm_color_encoding color_encoding;
    enum drm_color_range color_range;
    int32_t chroma_siting_h;
    int32_t chroma_siting_v;
    struct drm_property_blob *fb_damage_clips;
    bool ignore_damage_clips;
    struct drm_rect src;
    struct drm_rect dst;
    bool visible;
    enum drm_scaling_filter scaling_filter;
    struct drm_crtc_commit *commit;
    struct drm_atomic_state *state;
    bool color_mgmt_changed: 1;
};

struct drm_prime_handle {
    __u32 handle;
    __u32 flags;
    __s32 fd;
};

struct drm_prime_member {
    struct dma_buf *dma_buf;
    uint32_t handle;
    struct rb_node dmabuf_rb;
    struct rb_node handle_rb;
};

struct drm_print_iterator {
    void *data;
    ssize_t start;
    ssize_t remain;
    ssize_t offset;
};

struct va_format;

struct drm_printer {
    void (*printfn)(struct drm_printer *, struct va_format *);
    void (*puts)(struct drm_printer *, const char *);
    void *arg;
    const void *origin;
    const char *prefix;
    struct {
        unsigned int series;
        unsigned int counter;
    } line;
    enum drm_debug_category category;
};

struct drm_private_state_funcs {
    struct drm_private_state * (*atomic_duplicate_state)(struct drm_private_obj *);
    void (*atomic_destroy_state)(struct drm_private_obj *, struct drm_private_state *);
    void (*atomic_print_state)(struct drm_printer *, const struct drm_private_state *);
};

struct drm_prop_enum_list {
    int type;
    const char *name;
};

struct drm_property {
    struct list_head head;
    struct drm_mode_object base;
    uint32_t flags;
    char name[32];
    uint32_t num_values;
    uint64_t *values;
    struct drm_device *dev;
    struct list_head enum_list;
};

struct drm_property_blob {
    struct drm_mode_object base;
    struct drm_device *dev;
    struct list_head head_global;
    struct list_head head_file;
    size_t length;
    void *data;
};

struct drm_property_enum {
    uint64_t value;
    struct list_head head;
    char name[32];
};

struct drm_scanout_buffer {
    const struct drm_format_info *format;
    struct iosys_map map[4];
    unsigned int width;
    unsigned int height;
    unsigned int pitch[4];
    void (*set_pixel)(struct drm_scanout_buffer *, unsigned int, unsigned int, u32);
};

struct drm_set_client_cap {
    __u64 capability;
    __u64 value;
};

struct drm_set_client_name {
    __u64 name_len;
    __u64 name;
};

struct drm_set_version {
    int drm_di_major;
    int drm_di_minor;
    int drm_dd_major;
    int drm_dd_minor;
};

struct drm_stats {
    long unsigned int count;
    struct {
        long unsigned int value;
        enum drm_stat_type type;
    } data[15];
};

struct drm_stats32 {
    u32 count;
    struct {
        u32 value;
        enum drm_stat_type type;
    } data[15];
};

typedef struct drm_stats32 drm_stats32_t;

struct drm_syncobj {
    struct kref refcount;
    struct dma_fence *fence;
    struct list_head cb_list;
    struct list_head ev_fd_list;
    spinlock_t lock;
    struct file *file;
};

struct drm_syncobj_array {
    __u64 handles;
    __u32 count_handles;
    __u32 pad;
};

struct drm_syncobj_create {
    __u32 handle;
    __u32 flags;
};

struct drm_syncobj_destroy {
    __u32 handle;
    __u32 pad;
};

struct drm_syncobj_eventfd {
    __u32 handle;
    __u32 flags;
    __u64 point;
    __s32 fd;
    __u32 pad;
};

struct drm_syncobj_handle {
    __u32 handle;
    __u32 flags;
    __s32 fd;
    __u32 pad;
};

struct drm_syncobj_timeline_array {
    __u64 handles;
    __u64 points;
    __u32 count_handles;
    __u32 flags;
};

struct drm_syncobj_timeline_wait {
    __u64 handles;
    __u64 points;
    __s64 timeout_nsec;
    __u32 count_handles;
    __u32 flags;
    __u32 first_signaled;
    __u32 pad;
    __u64 deadline_nsec;
};

struct drm_syncobj_transfer {
    __u32 src_handle;
    __u32 dst_handle;
    __u64 src_point;
    __u64 dst_point;
    __u32 flags;
    __u32 pad;
};

struct drm_syncobj_wait {
    __u64 handles;
    __s64 timeout_nsec;
    __u32 count_handles;
    __u32 flags;
    __u32 first_signaled;
    __u32 pad;
    __u64 deadline_nsec;
};

struct drm_tile_group {
    struct kref refcount;
    struct drm_device *dev;
    int id;
    u8 group_data[8];
};

struct drm_unique {
    __kernel_size_t unique_len;
    char *unique;
};

struct drm_unique32 {
    u32 unique_len;
    u32 unique;
};

typedef struct drm_unique32 drm_unique32_t;

struct drm_vblank_crtc_config {
    int offdelay_ms;
    bool disable_immediate;
};

struct kthread_worker;

struct drm_vblank_crtc {
    struct drm_device *dev;
    wait_queue_head_t queue;
    struct timer_list disable_timer;
    seqlock_t seqlock;
    atomic64_t count;
    ktime_t time;
    atomic_t refcount;
    u32 last;
    u32 max_vblank_count;
    unsigned int inmodeset;
    unsigned int pipe;
    int framedur_ns;
    int linedur_ns;
    struct drm_display_mode hwmode;
    struct drm_vblank_crtc_config config;
    bool enabled;
    struct kthread_worker *worker;
    struct list_head pending_work;
    wait_queue_head_t work_wait_queue;
};

struct kthread_work;

typedef void (*kthread_work_func_t)(struct kthread_work *);

struct kthread_work {
    struct list_head node;
    kthread_work_func_t func;
    struct kthread_worker *worker;
    int canceling;
};

struct drm_vblank_work {
    struct kthread_work base;
    struct drm_vblank_crtc *vblank;
    u64 count;
    int cancelling;
    struct list_head node;
};

struct drm_version {
    int version_major;
    int version_minor;
    int version_patchlevel;
    __kernel_size_t name_len;
    char *name;
    __kernel_size_t date_len;
    char *date;
    __kernel_size_t desc_len;
    char *desc;
};

struct drm_version_32 {
    int version_major;
    int version_minor;
    int version_patchlevel;
    u32 name_len;
    u32 name;
    u32 date_len;
    u32 date;
    u32 desc_len;
    u32 desc;
};

typedef struct drm_version_32 drm_version32_t;

struct drm_vma_offset_file {
    struct rb_node vm_rb;
    struct drm_file *vm_tag;
    long unsigned int vm_count;
};

struct drm_vma_offset_manager {
    rwlock_t vm_lock;
    struct drm_mm vm_addr_space_mm;
};

struct drm_wait_vblank_request {
    enum drm_vblank_seq_type type;
    unsigned int sequence;
    long unsigned int signal;
};

struct drm_wait_vblank_reply {
    enum drm_vblank_seq_type type;
    unsigned int sequence;
    long int tval_sec;
    long int tval_usec;
};

union drm_wait_vblank {
    struct drm_wait_vblank_request request;
    struct drm_wait_vblank_reply reply;
};

struct drm_wait_vblank_request32 {
    enum drm_vblank_seq_type type;
    unsigned int sequence;
    u32 signal;
};

struct drm_wait_vblank_reply32 {
    enum drm_vblank_seq_type type;
    unsigned int sequence;
    s32 tval_sec;
    s32 tval_usec;
};

union drm_wait_vblank32 {
    struct drm_wait_vblank_request32 request;
    struct drm_wait_vblank_reply32 reply;
};

typedef union drm_wait_vblank32 drm_wait_vblank32_t;

struct drm_writeback_connector {
    struct drm_connector base;
    struct drm_encoder encoder;
    struct drm_property_blob *pixel_formats_blob_ptr;
    spinlock_t job_lock;
    struct list_head job_queue;
    unsigned int fence_context;
    spinlock_t fence_lock;
    long unsigned int fence_seqno;
    char timeline_name[32];
};

struct drm_writeback_job {
    struct drm_writeback_connector *connector;
    bool prepared;
    struct work_struct cleanup_work;
    struct list_head list_entry;
    struct drm_framebuffer *fb;
    struct dma_fence *out_fence;
    void *priv;
};

typedef void (*drmres_release_t)(struct drm_device *, void *);

struct drmres_node {
    struct list_head entry;
    drmres_release_t release;
    const char *name;
    size_t size;
};

struct drmres {
    struct drmres_node node;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    u8 data[0];
};

struct drop_reason_list {
    const char * const *reasons;
    size_t n_reasons;
};

struct pci_driver;

struct pci_device_id;

struct drv_dev_and_id {
    struct pci_driver *drv;
    struct pci_dev *dev;
    const struct pci_device_id *id;
};

struct dsa_bridge {
    struct net_device *dev;
    unsigned int num;
    bool tx_fwd_offload;
    refcount_t refcount;
};

struct dsa_chip_data {
    struct device *host_dev;
    int sw_addr;
    struct device *netdev[12];
    int eeprom_len;
    struct device_node *of_node;
    char *port_names[12];
    struct device_node *port_dn[12];
    s8 rtable[4];
};

struct dsa_lag {
    struct net_device *dev;
    unsigned int id;
    struct mutex fdb_lock;
    struct list_head fdbs;
    refcount_t refcount;
};

struct dsa_port;

struct dsa_db {
    enum dsa_db_type type;
    union {
        const struct dsa_port *dp;
        struct dsa_lag lag;
        struct dsa_bridge bridge;
    };
};

struct dsa_switch;

struct dsa_device_ops {
    struct sk_buff * (*xmit)(struct sk_buff *, struct net_device *);
    struct sk_buff * (*rcv)(struct sk_buff *, struct net_device *);
    void (*flow_dissect)(const struct sk_buff *, __be16 *, int *);
    int (*connect)(struct dsa_switch *);
    void (*disconnect)(struct dsa_switch *);
    unsigned int needed_headroom;
    unsigned int needed_tailroom;
    const char *name;
    enum dsa_tag_protocol proto;
    bool promisc_on_conduit;
};

struct dsa_mall_mirror_tc_entry {
    u8 to_local_port;
    bool ingress;
};

struct dsa_mall_policer_tc_entry {
    u32 burst;
    u64 rate_bytes_per_sec;
};

struct dsa_platform_data {
    struct device *netdev;
    struct net_device *of_netdev;
    int nr_chips;
    struct dsa_chip_data *chip;
};

struct phylink;

struct phylink_link_state;

struct phylink_config {
    struct device *dev;
    enum phylink_op_type type;
    bool poll_fixed_state;
    bool mac_managed_pm;
    bool mac_requires_rxc;
    bool default_an_inband;
    bool eee_rx_clk_stop_enable;
    void (*get_fixed_state)(struct phylink_config *, struct phylink_link_state *);
    long unsigned int supported_interfaces[1];
    long unsigned int lpi_interfaces[1];
    long unsigned int mac_capabilities;
    long unsigned int lpi_capabilities;
    u32 lpi_timer_default;
    bool eee_enabled_default;
};

struct dsa_switch_tree;

struct ethtool_ops;

struct dsa_port {
    union {
        struct net_device *conduit;
        struct net_device *user;
    };
    const struct dsa_device_ops *tag_ops;
    struct dsa_switch_tree *dst;
    struct sk_buff * (*rcv)(struct sk_buff *, struct net_device *);
    struct dsa_switch *ds;
    unsigned int index;
    enum {
        DSA_PORT_TYPE_UNUSED = 0,
        DSA_PORT_TYPE_CPU = 1,
        DSA_PORT_TYPE_DSA = 2,
        DSA_PORT_TYPE_USER = 3,
    } type;
    const char *name;
    struct dsa_port *cpu_dp;
    u8 mac[6];
    u8 stp_state;
    u8 vlan_filtering: 1;
    u8 learning: 1;
    u8 lag_tx_enabled: 1;
    u8 conduit_admin_up: 1;
    u8 conduit_oper_up: 1;
    u8 cpu_port_in_lag: 1;
    u8 setup: 1;
    struct device_node *dn;
    unsigned int ageing_time;
    struct dsa_bridge *bridge;
    struct devlink_port devlink_port;
    struct phylink *pl;
    struct phylink_config pl_config;
    struct dsa_lag *lag;
    struct net_device *hsr_dev;
    struct list_head list;
    const struct ethtool_ops *orig_ethtool_ops;
    struct mutex addr_lists_lock;
    struct list_head fdbs;
    struct list_head mdbs;
    struct mutex vlans_lock;
    union {
        struct list_head vlans;
        struct list_head user_vlans;
    };
};

struct dsa_stubs {
    int (*conduit_hwtstamp_validate)(struct net_device *, const struct kernel_hwtstamp_config *, struct netlink_ext_ack *);
};

struct dsa_8021q_context;

struct dsa_switch_ops;

struct phylink_mac_ops;

struct dsa_switch {
    struct device *dev;
    struct dsa_switch_tree *dst;
    unsigned int index;
    u32 setup: 1;
    u32 vlan_filtering_is_global: 1;
    u32 needs_standalone_vlan_filtering: 1;
    u32 configure_vlan_while_not_filtering: 1;
    u32 untag_bridge_pvid: 1;
    u32 untag_vlan_aware_bridge_pvid: 1;
    u32 assisted_learning_on_cpu_port: 1;
    u32 vlan_filtering: 1;
    u32 mtu_enforcement_ingress: 1;
    u32 fdb_isolation: 1;
    u32 dscp_prio_mapping_is_global: 1;
    struct notifier_block nb;
    void *priv;
    void *tagger_data;
    struct dsa_chip_data *cd;
    const struct dsa_switch_ops *ops;
    const struct phylink_mac_ops *phylink_mac_ops;
    u32 phys_mii_mask;
    struct mii_bus *user_mii_bus;
    unsigned int ageing_time_min;
    unsigned int ageing_time_max;
    struct dsa_8021q_context *tag_8021q_ctx;
    struct devlink *devlink;
    unsigned int num_tx_queues;
    unsigned int num_lag_ids;
    unsigned int max_num_bridges;
    unsigned int num_ports;
};

typedef int dsa_fdb_dump_cb_t(const unsigned char *, u16, bool, void *);

struct ethtool_eth_phy_stats;

struct ethtool_eth_mac_stats;

struct ethtool_eth_ctrl_stats;

struct ethtool_rmon_stats;

struct ethtool_rmon_hist_range;

struct ethtool_ts_stats;

struct rtnl_link_stats64;

struct ethtool_pause_stats;

struct ethtool_test;

struct ethtool_wolinfo;

struct ethtool_mm_state;

struct ethtool_mm_cfg;

struct ethtool_mm_stats;

struct ethtool_eeprom;

struct ethtool_regs;

struct netdev_notifier_changeupper_info;

struct switchdev_mst_state;

struct switchdev_brport_flags;

struct switchdev_obj_port_vlan;

struct switchdev_vlan_msti;

struct switchdev_obj_port_mdb;

struct ethtool_rxnfc;

struct flow_cls_offload;

struct netdev_lag_upper_info;

struct ifreq;

struct switchdev_obj_mrp;

struct switchdev_obj_ring_role_mrp;

struct dsa_switch_ops {
    enum dsa_tag_protocol (*get_tag_protocol)(struct dsa_switch *, int, enum dsa_tag_protocol);
    int (*change_tag_protocol)(struct dsa_switch *, enum dsa_tag_protocol);
    int (*connect_tag_protocol)(struct dsa_switch *, enum dsa_tag_protocol);
    int (*port_change_conduit)(struct dsa_switch *, int, struct net_device *, struct netlink_ext_ack *);
    int (*setup)(struct dsa_switch *);
    void (*teardown)(struct dsa_switch *);
    int (*port_setup)(struct dsa_switch *, int);
    void (*port_teardown)(struct dsa_switch *, int);
    u32 (*get_phy_flags)(struct dsa_switch *, int);
    int (*phy_read)(struct dsa_switch *, int, int);
    int (*phy_write)(struct dsa_switch *, int, int, u16);
    void (*phylink_get_caps)(struct dsa_switch *, int, struct phylink_config *);
    void (*phylink_fixed_state)(struct dsa_switch *, int, struct phylink_link_state *);
    void (*get_strings)(struct dsa_switch *, int, u32, uint8_t *);
    void (*get_ethtool_stats)(struct dsa_switch *, int, uint64_t *);
    int (*get_sset_count)(struct dsa_switch *, int, int);
    void (*get_ethtool_phy_stats)(struct dsa_switch *, int, uint64_t *);
    void (*get_eth_phy_stats)(struct dsa_switch *, int, struct ethtool_eth_phy_stats *);
    void (*get_eth_mac_stats)(struct dsa_switch *, int, struct ethtool_eth_mac_stats *);
    void (*get_eth_ctrl_stats)(struct dsa_switch *, int, struct ethtool_eth_ctrl_stats *);
    void (*get_rmon_stats)(struct dsa_switch *, int, struct ethtool_rmon_stats *, const struct ethtool_rmon_hist_range **);
    void (*get_ts_stats)(struct dsa_switch *, int, struct ethtool_ts_stats *);
    void (*get_stats64)(struct dsa_switch *, int, struct rtnl_link_stats64 *);
    void (*get_pause_stats)(struct dsa_switch *, int, struct ethtool_pause_stats *);
    void (*self_test)(struct dsa_switch *, int, struct ethtool_test *, u64 *);
    void (*get_wol)(struct dsa_switch *, int, struct ethtool_wolinfo *);
    int (*set_wol)(struct dsa_switch *, int, struct ethtool_wolinfo *);
    int (*get_ts_info)(struct dsa_switch *, int, struct kernel_ethtool_ts_info *);
    int (*get_mm)(struct dsa_switch *, int, struct ethtool_mm_state *);
    int (*set_mm)(struct dsa_switch *, int, struct ethtool_mm_cfg *, struct netlink_ext_ack *);
    void (*get_mm_stats)(struct dsa_switch *, int, struct ethtool_mm_stats *);
    int (*port_get_default_prio)(struct dsa_switch *, int);
    int (*port_set_default_prio)(struct dsa_switch *, int, u8);
    int (*port_get_dscp_prio)(struct dsa_switch *, int, u8);
    int (*port_add_dscp_prio)(struct dsa_switch *, int, u8, u8);
    int (*port_del_dscp_prio)(struct dsa_switch *, int, u8, u8);
    int (*port_set_apptrust)(struct dsa_switch *, int, const u8 *, int);
    int (*port_get_apptrust)(struct dsa_switch *, int, u8 *, int *);
    int (*suspend)(struct dsa_switch *);
    int (*resume)(struct dsa_switch *);
    int (*port_enable)(struct dsa_switch *, int, struct phy_device *);
    void (*port_disable)(struct dsa_switch *, int);
    int (*port_set_mac_address)(struct dsa_switch *, int, const unsigned char *);
    struct dsa_port * (*preferred_default_local_cpu_port)(struct dsa_switch *);
    bool (*support_eee)(struct dsa_switch *, int);
    int (*set_mac_eee)(struct dsa_switch *, int, struct ethtool_keee *);
    int (*get_eeprom_len)(struct dsa_switch *);
    int (*get_eeprom)(struct dsa_switch *, struct ethtool_eeprom *, u8 *);
    int (*set_eeprom)(struct dsa_switch *, struct ethtool_eeprom *, u8 *);
    int (*get_regs_len)(struct dsa_switch *, int);
    void (*get_regs)(struct dsa_switch *, int, struct ethtool_regs *, void *);
    int (*port_prechangeupper)(struct dsa_switch *, int, struct netdev_notifier_changeupper_info *);
    int (*set_ageing_time)(struct dsa_switch *, unsigned int);
    int (*port_bridge_join)(struct dsa_switch *, int, struct dsa_bridge, bool *, struct netlink_ext_ack *);
    void (*port_bridge_leave)(struct dsa_switch *, int, struct dsa_bridge);
    void (*port_stp_state_set)(struct dsa_switch *, int, u8);
    int (*port_mst_state_set)(struct dsa_switch *, int, const struct switchdev_mst_state *);
    void (*port_fast_age)(struct dsa_switch *, int);
    int (*port_vlan_fast_age)(struct dsa_switch *, int, u16);
    int (*port_pre_bridge_flags)(struct dsa_switch *, int, struct switchdev_brport_flags, struct netlink_ext_ack *);
    int (*port_bridge_flags)(struct dsa_switch *, int, struct switchdev_brport_flags, struct netlink_ext_ack *);
    void (*port_set_host_flood)(struct dsa_switch *, int, bool, bool);
    int (*port_vlan_filtering)(struct dsa_switch *, int, bool, struct netlink_ext_ack *);
    int (*port_vlan_add)(struct dsa_switch *, int, const struct switchdev_obj_port_vlan *, struct netlink_ext_ack *);
    int (*port_vlan_del)(struct dsa_switch *, int, const struct switchdev_obj_port_vlan *);
    int (*vlan_msti_set)(struct dsa_switch *, struct dsa_bridge, const struct switchdev_vlan_msti *);
    int (*port_fdb_add)(struct dsa_switch *, int, const unsigned char *, u16, struct dsa_db);
    int (*port_fdb_del)(struct dsa_switch *, int, const unsigned char *, u16, struct dsa_db);
    int (*port_fdb_dump)(struct dsa_switch *, int, dsa_fdb_dump_cb_t *, void *);
    int (*lag_fdb_add)(struct dsa_switch *, struct dsa_lag, const unsigned char *, u16, struct dsa_db);
    int (*lag_fdb_del)(struct dsa_switch *, struct dsa_lag, const unsigned char *, u16, struct dsa_db);
    int (*port_mdb_add)(struct dsa_switch *, int, const struct switchdev_obj_port_mdb *, struct dsa_db);
    int (*port_mdb_del)(struct dsa_switch *, int, const struct switchdev_obj_port_mdb *, struct dsa_db);
    int (*get_rxnfc)(struct dsa_switch *, int, struct ethtool_rxnfc *, u32 *);
    int (*set_rxnfc)(struct dsa_switch *, int, struct ethtool_rxnfc *);
    int (*cls_flower_add)(struct dsa_switch *, int, struct flow_cls_offload *, bool);
    int (*cls_flower_del)(struct dsa_switch *, int, struct flow_cls_offload *, bool);
    int (*cls_flower_stats)(struct dsa_switch *, int, struct flow_cls_offload *, bool);
    int (*port_mirror_add)(struct dsa_switch *, int, struct dsa_mall_mirror_tc_entry *, bool, struct netlink_ext_ack *);
    void (*port_mirror_del)(struct dsa_switch *, int, struct dsa_mall_mirror_tc_entry *);
    int (*port_policer_add)(struct dsa_switch *, int, struct dsa_mall_policer_tc_entry *);
    void (*port_policer_del)(struct dsa_switch *, int);
    int (*port_setup_tc)(struct dsa_switch *, int, enum tc_setup_type, void *);
    int (*crosschip_bridge_join)(struct dsa_switch *, int, int, int, struct dsa_bridge, struct netlink_ext_ack *);
    void (*crosschip_bridge_leave)(struct dsa_switch *, int, int, int, struct dsa_bridge);
    int (*crosschip_lag_change)(struct dsa_switch *, int, int);
    int (*crosschip_lag_join)(struct dsa_switch *, int, int, struct dsa_lag, struct netdev_lag_upper_info *, struct netlink_ext_ack *);
    int (*crosschip_lag_leave)(struct dsa_switch *, int, int, struct dsa_lag);
    int (*port_hwtstamp_get)(struct dsa_switch *, int, struct ifreq *);
    int (*port_hwtstamp_set)(struct dsa_switch *, int, struct ifreq *);
    void (*port_txtstamp)(struct dsa_switch *, int, struct sk_buff *);
    bool (*port_rxtstamp)(struct dsa_switch *, int, struct sk_buff *, unsigned int);
    int (*devlink_param_get)(struct dsa_switch *, u32, struct devlink_param_gset_ctx *);
    int (*devlink_param_set)(struct dsa_switch *, u32, struct devlink_param_gset_ctx *);
    int (*devlink_info_get)(struct dsa_switch *, struct devlink_info_req *, struct netlink_ext_ack *);
    int (*devlink_sb_pool_get)(struct dsa_switch *, unsigned int, u16, struct devlink_sb_pool_info *);
    int (*devlink_sb_pool_set)(struct dsa_switch *, unsigned int, u16, u32, enum devlink_sb_threshold_type, struct netlink_ext_ack *);
    int (*devlink_sb_port_pool_get)(struct dsa_switch *, int, unsigned int, u16, u32 *);
    int (*devlink_sb_port_pool_set)(struct dsa_switch *, int, unsigned int, u16, u32, struct netlink_ext_ack *);
    int (*devlink_sb_tc_pool_bind_get)(struct dsa_switch *, int, unsigned int, u16, enum devlink_sb_pool_type, u16 *, u32 *);
    int (*devlink_sb_tc_pool_bind_set)(struct dsa_switch *, int, unsigned int, u16, enum devlink_sb_pool_type, u16, u32, struct netlink_ext_ack *);
    int (*devlink_sb_occ_snapshot)(struct dsa_switch *, unsigned int);
    int (*devlink_sb_occ_max_clear)(struct dsa_switch *, unsigned int);
    int (*devlink_sb_occ_port_pool_get)(struct dsa_switch *, int, unsigned int, u16, u32 *, u32 *);
    int (*devlink_sb_occ_tc_port_bind_get)(struct dsa_switch *, int, unsigned int, u16, enum devlink_sb_pool_type, u32 *, u32 *);
    int (*port_change_mtu)(struct dsa_switch *, int, int);
    int (*port_max_mtu)(struct dsa_switch *, int);
    int (*port_lag_change)(struct dsa_switch *, int);
    int (*port_lag_join)(struct dsa_switch *, int, struct dsa_lag, struct netdev_lag_upper_info *, struct netlink_ext_ack *);
    int (*port_lag_leave)(struct dsa_switch *, int, struct dsa_lag);
    int (*port_hsr_join)(struct dsa_switch *, int, struct net_device *, struct netlink_ext_ack *);
    int (*port_hsr_leave)(struct dsa_switch *, int, struct net_device *);
    int (*port_mrp_add)(struct dsa_switch *, int, const struct switchdev_obj_mrp *);
    int (*port_mrp_del)(struct dsa_switch *, int, const struct switchdev_obj_mrp *);
    int (*port_mrp_add_ring_role)(struct dsa_switch *, int, const struct switchdev_obj_ring_role_mrp *);
    int (*port_mrp_del_ring_role)(struct dsa_switch *, int, const struct switchdev_obj_ring_role_mrp *);
    int (*tag_8021q_vlan_add)(struct dsa_switch *, int, u16, u16);
    int (*tag_8021q_vlan_del)(struct dsa_switch *, int, u16);
    void (*conduit_state_change)(struct dsa_switch *, const struct net_device *, bool);
};

struct dsa_switch_tree {
    struct list_head list;
    struct list_head ports;
    struct raw_notifier_head nh;
    unsigned int index;
    struct kref refcount;
    struct dsa_lag **lags;
    const struct dsa_device_ops *tag_ops;
    enum dsa_tag_protocol default_proto;
    bool setup;
    struct dsa_platform_data *pd;
    struct list_head rtable;
    unsigned int lags_len;
    unsigned int last_switch;
};

struct dsm_output {
    u16 status;
    u8 function_specific_err;
    u8 vendor_specific_err;
    u32 state;
};

struct dst_cache_pcpu;

struct dst_cache {
    struct dst_cache_pcpu *cache;
    long unsigned int reset_ts;
};

struct dst_cache_pcpu {
    long unsigned int refresh_ts;
    struct dst_entry *dst;
    u32 cookie;
    union {
        struct in_addr in_saddr;
        struct in6_addr in6_saddr;
    };
};

struct dst_ops;

struct xfrm_state;

struct uncached_list;

struct lwtunnel_state;

struct dst_entry {
    struct net_device *dev;
    struct dst_ops *ops;
    long unsigned int _metrics;
    long unsigned int expires;
    struct xfrm_state *xfrm;
    int (*input)(struct sk_buff *);
    int (*output)(struct net *, struct sock *, struct sk_buff *);
    short unsigned int flags;
    short int obsolete;
    short unsigned int header_len;
    short unsigned int trailer_len;
    rcuref_t __rcuref;
    int __use;
    long unsigned int lastuse;
    struct callback_head callback_head;
    short int error;
    short int __pad;
    __u32 tclassid;
    netdevice_tracker dev_tracker;
    struct list_head rt_uncached;
    struct uncached_list *rt_uncached_list;
    struct lwtunnel_state *lwtstate;
};

struct dst_metrics {
    u32 metrics[17];
    refcount_t refcnt;
};

struct neighbour;

struct dst_ops {
    short unsigned int family;
    unsigned int gc_thresh;
    void (*gc)(struct dst_ops *);
    struct dst_entry * (*check)(struct dst_entry *, __u32);
    unsigned int (*default_advmss)(const struct dst_entry *);
    unsigned int (*mtu)(const struct dst_entry *);
    u32 * (*cow_metrics)(struct dst_entry *, long unsigned int);
    void (*destroy)(struct dst_entry *);
    void (*ifdown)(struct dst_entry *, struct net_device *);
    void (*negative_advice)(struct sock *, struct dst_entry *);
    void (*link_failure)(struct sk_buff *);
    void (*update_pmtu)(struct dst_entry *, struct sock *, struct sk_buff *, u32, bool);
    void (*redirect)(struct dst_entry *, struct sock *, struct sk_buff *);
    int (*local_out)(struct net *, struct sock *, struct sk_buff *);
    struct neighbour * (*neigh_lookup)(const struct dst_entry *, struct sk_buff *, const void *);
    void (*confirm_neigh)(const struct dst_entry *, const void *);
    struct kmem_cache *kmem_cachep;
    struct percpu_counter pcpuc_entries;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
};

struct uart_8250_port;

struct uart_8250_dma {
    int (*tx_dma)(struct uart_8250_port *);
    int (*rx_dma)(struct uart_8250_port *);
    void (*prepare_tx_dma)(struct uart_8250_port *);
    void (*prepare_rx_dma)(struct uart_8250_port *);
    dma_filter_fn fn;
    void *rx_param;
    void *tx_param;
    struct dma_slave_config rxconf;
    struct dma_slave_config txconf;
    struct dma_chan *rxchan;
    struct dma_chan *txchan;
    phys_addr_t rx_dma_addr;
    phys_addr_t tx_dma_addr;
    dma_addr_t rx_addr;
    dma_addr_t tx_addr;
    dma_cookie_t rx_cookie;
    dma_cookie_t tx_cookie;
    void *rx_buf;
    size_t rx_size;
    size_t tx_size;
    unsigned char tx_running;
    unsigned char tx_err;
    unsigned char rx_running;
};

struct dw8250_port_data {
    int line;
    struct uart_8250_dma dma;
    u32 cpr_value;
    u8 dlf_size;
    bool hw_rs485_support;
};

struct dw_axi_dma_hcfg;

struct dw_axi_dma {
    struct dma_device dma;
    struct dw_axi_dma_hcfg *hdata;
    struct device_dma_parameters dma_parms;
    struct axi_dma_chan *chan;
};

struct dw_axi_dma_hcfg {
    u32 nr_channels;
    u32 nr_masters;
    u32 m_data_width;
    u32 block_size[32];
    u32 priority[32];
    u32 axi_rw_burst_len;
    bool reg_map_8_channels;
    bool restrict_axi_burst_len;
    bool use_cfg2;
};

struct dx_countlimit {
    __le16 limit;
    __le16 count;
};

struct dx_entry {
    __le32 hash;
    __le32 block;
};

struct dx_frame {
    struct buffer_head *bh;
    struct dx_entry *entries;
    struct dx_entry *at;
};

struct dx_hash_info {
    u32 hash;
    u32 minor_hash;
    int hash_version;
    u32 *seed;
};

struct dx_map_entry {
    u32 hash;
    u16 offs;
    u16 size;
};

struct fake_dirent {
    __le32 inode;
    __le16 rec_len;
    u8 name_len;
    u8 file_type;
};

struct dx_node {
    struct fake_dirent fake;
    struct dx_entry entries[0];
};

struct dx_root_info {
    __le32 reserved_zero;
    u8 hash_version;
    u8 info_length;
    u8 indirect_levels;
    u8 unused_flags;
};

struct dx_root {
    struct fake_dirent dot;
    char dot_name[4];
    struct fake_dirent dotdot;
    char dotdot_name[4];
    struct dx_root_info info;
    struct dx_entry entries[0];
};

struct dx_tail {
    u32 dt_reserved;
    __le32 dt_checksum;
};

struct dyn_arch_ftrace {};

struct dyn_event_operations;

struct dyn_event {
    struct list_head list;
    struct dyn_event_operations *ops;
};

struct dyn_event_operations {
    struct list_head list;
    int (*create)(const char *);
    int (*show)(struct seq_file *, struct dyn_event *);
    bool (*is_busy)(struct dyn_event *);
    int (*free)(struct dyn_event *);
    bool (*match)(const char *, const char *, int, const char **, struct dyn_event *);
};

struct dyn_ftrace {
    long unsigned int ip;
    long unsigned int flags;
    struct dyn_arch_ftrace arch;
};

struct dynevent_arg {
    const char *str;
    char separator;
};

struct dynevent_arg_pair {
    const char *lhs;
    const char *rhs;
    char operator;
    char separator;
};

struct seq_buf {
    char *buffer;
    size_t size;
    size_t len;
};

struct dynevent_cmd;

typedef int (*dynevent_create_fn_t)(struct dynevent_cmd *);

struct dynevent_cmd {
    struct seq_buf seq;
    const char *event_name;
    unsigned int n_fields;
    enum dynevent_type type;
    dynevent_create_fn_t run_command;
    void *private_data;
};

struct usb_device;

struct each_dev_arg {
    void *data;
    int (*fn)(struct usb_device *, void *);
};

struct uart_icount {
    __u32 cts;
    __u32 dsr;
    __u32 rng;
    __u32 dcd;
    __u32 rx;
    __u32 tx;
    __u32 frame;
    __u32 overrun;
    __u32 parity;
    __u32 brk;
    __u32 buf_overrun;
};

struct serial_rs485 {
    __u32 flags;
    __u32 delay_rts_before_send;
    __u32 delay_rts_after_send;
    union {
        __u32 padding[5];
        struct {
            __u8 addr_recv;
            __u8 addr_dest;
            __u8 padding0[2];
            __u32 padding1[4];
        };
    };
};

struct serial_iso7816 {
    __u32 flags;
    __u32 tg;
    __u32 sc_fi;
    __u32 sc_di;
    __u32 clk;
    __u32 reserved[5];
};

struct ktermios;

struct uart_state;

struct uart_ops;

struct serial_port_device;

struct uart_port {
    spinlock_t lock;
    long unsigned int iobase;
    unsigned char *membase;
    unsigned int (*serial_in)(struct uart_port *, int);
    void (*serial_out)(struct uart_port *, int, int);
    void (*set_termios)(struct uart_port *, struct ktermios *, const struct ktermios *);
    void (*set_ldisc)(struct uart_port *, struct ktermios *);
    unsigned int (*get_mctrl)(struct uart_port *);
    void (*set_mctrl)(struct uart_port *, unsigned int);
    unsigned int (*get_divisor)(struct uart_port *, unsigned int, unsigned int *);
    void (*set_divisor)(struct uart_port *, unsigned int, unsigned int, unsigned int);
    int (*startup)(struct uart_port *);
    void (*shutdown)(struct uart_port *);
    void (*throttle)(struct uart_port *);
    void (*unthrottle)(struct uart_port *);
    int (*handle_irq)(struct uart_port *);
    void (*pm)(struct uart_port *, unsigned int, unsigned int);
    void (*handle_break)(struct uart_port *);
    int (*rs485_config)(struct uart_port *, struct ktermios *, struct serial_rs485 *);
    int (*iso7816_config)(struct uart_port *, struct serial_iso7816 *);
    unsigned int ctrl_id;
    unsigned int port_id;
    unsigned int irq;
    long unsigned int irqflags;
    unsigned int uartclk;
    unsigned int fifosize;
    unsigned char x_char;
    unsigned char regshift;
    unsigned char iotype;
    unsigned char quirks;
    unsigned int read_status_mask;
    unsigned int ignore_status_mask;
    struct uart_state *state;
    struct uart_icount icount;
    struct console *cons;
    upf_t flags;
    upstat_t status;
    bool hw_stopped;
    unsigned int mctrl;
    unsigned int frame_time;
    unsigned int type;
    const struct uart_ops *ops;
    unsigned int custom_divisor;
    unsigned int line;
    unsigned int minor;
    resource_size_t mapbase;
    resource_size_t mapsize;
    struct device *dev;
    struct serial_port_device *port_dev;
    long unsigned int sysrq;
    u8 sysrq_ch;
    unsigned char has_sysrq;
    unsigned char sysrq_seq;
    unsigned char hub6;
    unsigned char suspended;
    unsigned char console_reinit;
    const char *name;
    struct attribute_group *attr_group;
    const struct attribute_group **tty_groups;
    struct serial_rs485 rs485;
    struct serial_rs485 rs485_supported;
    struct gpio_desc *rs485_term_gpio;
    struct gpio_desc *rs485_rx_during_tx_gpio;
    struct serial_iso7816 iso7816;
    void *private_data;
};

struct earlycon_device {
    struct console *con;
    struct uart_port port;
    char options[32];
    unsigned int baud;
};

struct earlycon_id {
    char name[15];
    char name_term;
    char compatible[128];
    int (*setup)(struct earlycon_device *, const char *);
};

struct ebitmap_node {
    struct ebitmap_node *next;
    long unsigned int maps[6];
    u32 startbit;
};

struct ecc_point {
    u64 *x;
    u64 *y;
    u8 ndigits;
};

struct ecc_curve {
    char *name;
    u32 nbits;
    struct ecc_point g;
    u64 *p;
    u64 *n;
    u64 *a;
    u64 *b;
};

struct ecdh {
    char *key;
    short unsigned int key_size;
};

struct ecdh_ctx {
    unsigned int curve_id;
    unsigned int ndigits;
    u64 private_key[9];
};

struct ecryptfs_session_key {
    u32 flags;
    u32 encrypted_key_size;
    u32 decrypted_key_size;
    u8 encrypted_key[512];
    u8 decrypted_key[64];
};

struct ecryptfs_password {
    u32 password_bytes;
    s32 hash_algo;
    u32 hash_iterations;
    u32 session_key_encryption_key_bytes;
    u32 flags;
    u8 session_key_encryption_key[64];
    u8 signature[17];
    u8 salt[8];
};

struct ecryptfs_private_key {
    u32 key_size;
    u32 data_len;
    u8 signature[17];
    char pki_type[17];
    u8 data[0];
};

struct ecryptfs_auth_tok {
    u16 version;
    u16 token_type;
    u32 flags;
    struct ecryptfs_session_key session_key;
    u8 reserved[32];
    union {
        struct ecryptfs_password password;
        struct ecryptfs_private_key private_key;
    } token;
};

struct edac_dev_sysfs_attribute {
    struct attribute attr;
    ssize_t (*show)(struct edac_device_ctl_info *, char *);
    ssize_t (*store)(struct edac_device_ctl_info *, const char *, size_t);
};

struct edac_dev_sysfs_block_attribute {
    struct attribute attr;
    ssize_t (*show)(struct kobject *, struct attribute *, char *);
};

struct edac_device_counter {
    u32 ue_count;
    u32 ce_count;
};

struct edac_device_instance;

struct edac_device_block {
    struct edac_device_instance *instance;
    char name[32];
    struct edac_device_counter counters;
    int nr_attribs;
    struct edac_dev_sysfs_block_attribute *block_attributes;
    struct kobject kobj;
};

struct edac_device_ctl_info {
    struct list_head link;
    struct module *owner;
    int dev_idx;
    int log_ue;
    int log_ce;
    int panic_on_ue;
    unsigned int poll_msec;
    long unsigned int delay;
    struct edac_dev_sysfs_attribute *sysfs_attributes;
    const struct bus_type *edac_subsys;
    int op_state;
    struct delayed_work work;
    void (*edac_check)(struct edac_device_ctl_info *);
    struct device *dev;
    const char *mod_name;
    const char *ctl_name;
    const char *dev_name;
    void *pvt_info;
    long unsigned int start_time;
    char name[32];
    u32 nr_instances;
    struct edac_device_instance *instances;
    struct edac_device_block *blocks;
    struct edac_device_counter counters;
    struct kobject kobj;
};

struct edac_device_instance {
    struct edac_device_ctl_info *ctl;
    char name[35];
    struct edac_device_counter counters;
    u32 nr_blocks;
    struct edac_device_block *blocks;
    struct kobject kobj;
};

struct edac_mc_layer {
    enum edac_mc_layer_type type;
    unsigned int size;
    bool is_virt_csrow;
};

struct edac_pci_counter {
    atomic_t pe_count;
    atomic_t npe_count;
};

struct edac_pci_ctl_info {
    struct list_head link;
    int pci_idx;
    int op_state;
    struct delayed_work work;
    void (*edac_check)(struct edac_pci_ctl_info *);
    struct device *dev;
    const char *mod_name;
    const char *ctl_name;
    const char *dev_name;
    void *pvt_info;
    long unsigned int start_time;
    char name[32];
    struct edac_pci_counter counters;
    struct kobject kobj;
};

struct edac_pci_dev_attribute {
    struct attribute attr;
    void *value;
    ssize_t (*show)(void *, char *);
    ssize_t (*store)(void *, const char *, size_t);
};

struct edac_pci_gen_data {
    int edac_idx;
};

struct edac_raw_error_desc {
    char location[256];
    char label[296];
    long int grain;
    u16 error_count;
    enum hw_event_mc_err_type type;
    int top_layer;
    int mid_layer;
    int low_layer;
    long unsigned int page_frame_number;
    long unsigned int offset_in_page;
    long unsigned int syndrome;
    const char *msg;
    const char *other_detail;
};

struct est_timings {
    u8 t1;
    u8 t2;
    u8 mfg_rsvd;
};

struct edid {
    u8 header[8];
    union {
        struct drm_edid_product_id product_id;
        struct {
            u8 mfg_id[2];
            u8 prod_code[2];
            u32 serial;
            u8 mfg_week;
            u8 mfg_year;
        } __attribute__((packed));
    };
    u8 version;
    u8 revision;
    u8 input;
    u8 width_cm;
    u8 height_cm;
    u8 gamma;
    u8 features;
    u8 red_green_lo;
    u8 blue_white_lo;
    u8 red_x;
    u8 red_y;
    u8 green_x;
    u8 green_y;
    u8 blue_x;
    u8 blue_y;
    u8 white_x;
    u8 white_y;
    struct est_timings established_timings;
    struct std_timing standard_timings[8];
    struct detailed_timing detailed_timings[4];
    u8 extensions;
    u8 checksum;
};

struct edid_quirk {
    const struct drm_edid_ident ident;
    u32 quirks;
};

struct eee_config {
    u32 tx_lpi_timer;
    bool tx_lpi_enabled;
    bool eee_enabled;
};

struct eee_reply_data {
    struct ethnl_reply_data base;
    struct ethtool_keee eee;
};

struct eeprom_reply_data {
    struct ethnl_reply_data base;
    u32 length;
    u8 *data;
};

struct ethnl_req_info {
    struct net_device *dev;
    netdevice_tracker dev_tracker;
    u32 flags;
    u32 phy_index;
};

struct eeprom_req_info {
    struct ethnl_req_info base;
    u32 offset;
    u32 length;
    u8 page;
    u8 bank;
    u8 i2c_address;
};

struct efi_memory_map {
    phys_addr_t phys_map;
    void *map;
    void *map_end;
    int nr_map;
    long unsigned int desc_version;
    long unsigned int desc_size;
    long unsigned int flags;
};

struct efi {
    const efi_runtime_services_t *runtime;
    unsigned int runtime_version;
    unsigned int runtime_supported_mask;
    long unsigned int acpi;
    long unsigned int acpi20;
    long unsigned int smbios;
    long unsigned int smbios3;
    long unsigned int esrt;
    long unsigned int tpm_log;
    long unsigned int tpm_final_log;
    long unsigned int mokvar_table;
    long unsigned int coco_secret;
    long unsigned int unaccepted;
    efi_get_time_t *get_time;
    efi_set_time_t *set_time;
    efi_get_wakeup_time_t *get_wakeup_time;
    efi_set_wakeup_time_t *set_wakeup_time;
    efi_get_variable_t *get_variable;
    efi_get_next_variable_t *get_next_variable;
    efi_set_variable_t *set_variable;
    efi_set_variable_t *set_variable_nonblocking;
    efi_query_variable_info_t *query_variable_info;
    efi_query_variable_info_t *query_variable_info_nonblocking;
    efi_update_capsule_t *update_capsule;
    efi_query_capsule_caps_t *query_capsule_caps;
    efi_get_next_high_mono_count_t *get_next_high_mono_count;
    efi_reset_system_t *reset_system;
    struct efi_memory_map memmap;
    long unsigned int flags;
};

struct efi_boot_memmap {
    long unsigned int map_size;
    long unsigned int desc_size;
    u32 desc_ver;
    long unsigned int map_key;
    long unsigned int buff_size;
    efi_memory_desc_t map[0];
};

typedef void *efi_event_t;

typedef void (*efi_event_notify_t)(efi_event_t, void *);

union efi_boot_services {
    struct {
        efi_table_hdr_t hdr;
        void *raise_tpl;
        void *restore_tpl;
        efi_status_t (*allocate_pages)(int, int, long unsigned int, efi_physical_addr_t *);
        efi_status_t (*free_pages)(efi_physical_addr_t, long unsigned int);
        efi_status_t (*get_memory_map)(long unsigned int *, void *, long unsigned int *, long unsigned int *, u32 *);
        efi_status_t (*allocate_pool)(int, long unsigned int, void **);
        efi_status_t (*free_pool)(void *);
        efi_status_t (*create_event)(u32, long unsigned int, efi_event_notify_t, void *, efi_event_t *);
        efi_status_t (*set_timer)(efi_event_t, EFI_TIMER_DELAY, u64);
        efi_status_t (*wait_for_event)(long unsigned int, efi_event_t *, long unsigned int *);
        efi_status_t (*signal_event)(efi_event_t);
        efi_status_t (*close_event)(efi_event_t);
        void *check_event;
        void *install_protocol_interface;
        void *reinstall_protocol_interface;
        void *uninstall_protocol_interface;
        efi_status_t (*handle_protocol)(efi_handle_t, efi_guid_t *, void **);
        void *__reserved;
        void *register_protocol_notify;
        efi_status_t (*locate_handle)(int, efi_guid_t *, void *, long unsigned int *, efi_handle_t *);
        efi_status_t (*locate_device_path)(efi_guid_t *, efi_device_path_protocol_t **, efi_handle_t *);
        efi_status_t (*install_configuration_table)(efi_guid_t *, void *);
        efi_status_t (*load_image)(bool, efi_handle_t, efi_device_path_protocol_t *, void *, long unsigned int, efi_handle_t *);
        efi_status_t (*start_image)(efi_handle_t, long unsigned int *, efi_char16_t **);
        efi_status_t (*exit)(efi_handle_t, efi_status_t, long unsigned int, efi_char16_t *);
        efi_status_t (*unload_image)(efi_handle_t);
        efi_status_t (*exit_boot_services)(efi_handle_t, long unsigned int);
        void *get_next_monotonic_count;
        efi_status_t (*stall)(long unsigned int);
        void *set_watchdog_timer;
        void *connect_controller;
        efi_status_t (*disconnect_controller)(efi_handle_t, efi_handle_t, efi_handle_t);
        void *open_protocol;
        void *close_protocol;
        void *open_protocol_information;
        void *protocols_per_handle;
        efi_status_t (*locate_handle_buffer)(int, efi_guid_t *, void *, long unsigned int *, efi_handle_t **);
        efi_status_t (*locate_protocol)(efi_guid_t *, void *, void **);
        efi_status_t (*install_multiple_protocol_interfaces)(efi_handle_t *, ...);
        efi_status_t (*uninstall_multiple_protocol_interfaces)(efi_handle_t, ...);
        void *calculate_crc32;
        void (*copy_mem)(void *, const void *, long unsigned int);
        void (*set_mem)(void *, long unsigned int, unsigned char);
        efi_status_t (*create_event_ex)(u32, int, void *, void *, void *, efi_event_t *);
    };
    struct {
        efi_table_hdr_t hdr;
        u32 raise_tpl;
        u32 restore_tpl;
        u32 allocate_pages;
        u32 free_pages;
        u32 get_memory_map;
        u32 allocate_pool;
        u32 free_pool;
        u32 create_event;
        u32 set_timer;
        u32 wait_for_event;
        u32 signal_event;
        u32 close_event;
        u32 check_event;
        u32 install_protocol_interface;
        u32 reinstall_protocol_interface;
        u32 uninstall_protocol_interface;
        u32 handle_protocol;
        u32 __reserved;
        u32 register_protocol_notify;
        u32 locate_handle;
        u32 locate_device_path;
        u32 install_configuration_table;
        u32 load_image;
        u32 start_image;
        u32 exit;
        u32 unload_image;
        u32 exit_boot_services;
        u32 get_next_monotonic_count;
        u32 stall;
        u32 set_watchdog_timer;
        u32 connect_controller;
        u32 disconnect_controller;
        u32 open_protocol;
        u32 close_protocol;
        u32 open_protocol_information;
        u32 protocols_per_handle;
        u32 locate_handle_buffer;
        u32 locate_protocol;
        u32 install_multiple_protocol_interfaces;
        u32 uninstall_multiple_protocol_interfaces;
        u32 calculate_crc32;
        u32 copy_mem;
        u32 set_mem;
        u32 create_event_ex;
    } mixed_mode;
};

struct efi_cc_event {
    u32 event_size;
    struct {
        u32 header_size;
        u16 header_version;
        u32 mr_index;
        u32 event_type;
    } __attribute__((packed)) event_header;
} __attribute__((packed));

typedef struct efi_cc_event efi_cc_event_t;

union efi_cc_protocol;

typedef union efi_cc_protocol efi_cc_protocol_t;

union efi_cc_protocol {
    struct {
        efi_status_t (*get_capability)(efi_cc_protocol_t *, efi_cc_boot_service_cap_t *);
        efi_status_t (*get_event_log)(efi_cc_protocol_t *, efi_cc_event_log_format_t, efi_physical_addr_t *, efi_physical_addr_t *, efi_bool_t *);
        efi_status_t (*hash_log_extend_event)(efi_cc_protocol_t *, u64, efi_physical_addr_t, u64, const efi_cc_event_t *);
        efi_status_t (*map_pcr_to_mr_index)(efi_cc_protocol_t *, u32, efi_cc_mr_index_t *);
    };
    struct {
        u32 get_capability;
        u32 get_event_log;
        u32 hash_log_extend_event;
        u32 map_pcr_to_mr_index;
    } mixed_mode;
};

union efi_device_path_from_text_protocol {
    struct {
        efi_device_path_protocol_t * (*convert_text_to_device_node)(const efi_char16_t *);
        efi_device_path_protocol_t * (*convert_text_to_device_path)(const efi_char16_t *);
    };
    struct {
        u32 convert_text_to_device_node;
        u32 convert_text_to_device_path;
    } mixed_mode;
};

typedef union efi_device_path_from_text_protocol efi_device_path_from_text_protocol_t;

struct efi_error_code {
    efi_status_t status;
    int errno;
    const char *description;
};

struct efi_generic_dev_path {
    u8 type;
    u8 sub_type;
    u16 length;
};

struct efi_file_path_dev_path {
    struct efi_generic_dev_path header;
    efi_char16_t filename[0];
};

union efi_file_protocol;

typedef union efi_file_protocol efi_file_protocol_t;

union efi_file_protocol {
    struct {
        u64 revision;
        efi_status_t (*open)(efi_file_protocol_t *, efi_file_protocol_t **, efi_char16_t *, u64, u64);
        efi_status_t (*close)(efi_file_protocol_t *);
        efi_status_t (*delete)(efi_file_protocol_t *);
        efi_status_t (*read)(efi_file_protocol_t *, long unsigned int *, void *);
        efi_status_t (*write)(efi_file_protocol_t *, long unsigned int, void *);
        efi_status_t (*get_position)(efi_file_protocol_t *, u64 *);
        efi_status_t (*set_position)(efi_file_protocol_t *, u64);
        efi_status_t (*get_info)(efi_file_protocol_t *, efi_guid_t *, long unsigned int *, void *);
        efi_status_t (*set_info)(efi_file_protocol_t *, efi_guid_t *, long unsigned int, void *);
        efi_status_t (*flush)(efi_file_protocol_t *);
    };
    struct {
        u64 revision;
        u32 open;
        u32 close;
        u32 delete;
        u32 read;
        u32 write;
        u32 get_position;
        u32 set_position;
        u32 get_info;
        u32 set_info;
        u32 flush;
    } mixed_mode;
};

union efi_graphics_output_protocol;

typedef union efi_graphics_output_protocol efi_graphics_output_protocol_t;

union efi_graphics_output_protocol_mode;

typedef union efi_graphics_output_protocol_mode efi_graphics_output_protocol_mode_t;

union efi_graphics_output_protocol {
    struct {
        efi_status_t (*query_mode)(efi_graphics_output_protocol_t *, u32, long unsigned int *, efi_graphics_output_mode_info_t **);
        efi_status_t (*set_mode)(efi_graphics_output_protocol_t *, u32);
        void *blt;
        efi_graphics_output_protocol_mode_t *mode;
    };
    struct {
        u32 query_mode;
        u32 set_mode;
        u32 blt;
        u32 mode;
    } mixed_mode;
};

union efi_graphics_output_protocol_mode {
    struct {
        u32 max_mode;
        u32 mode;
        efi_graphics_output_mode_info_t *info;
        long unsigned int size_of_info;
        efi_physical_addr_t frame_buffer_base;
        long unsigned int frame_buffer_size;
    };
    struct {
        u32 max_mode;
        u32 mode;
        u32 info;
        u32 size_of_info;
        u64 frame_buffer_base;
        u32 frame_buffer_size;
    } mixed_mode;
};

union efi_load_file_protocol;

typedef union efi_load_file_protocol efi_load_file_protocol_t;

union efi_load_file_protocol {
    struct {
        efi_status_t (*load_file)(efi_load_file_protocol_t *, efi_device_path_protocol_t *, bool, long unsigned int *, void *);
    };
    struct {
        u32 load_file;
    } mixed_mode;
};

typedef union efi_load_file_protocol efi_load_file2_protocol_t;

union efi_memory_attribute_protocol;

typedef union efi_memory_attribute_protocol efi_memory_attribute_protocol_t;

union efi_memory_attribute_protocol {
    struct {
        efi_status_t (*get_memory_attributes)(efi_memory_attribute_protocol_t *, efi_physical_addr_t, u64, u64 *);
        efi_status_t (*set_memory_attributes)(efi_memory_attribute_protocol_t *, efi_physical_addr_t, u64, u64);
        efi_status_t (*clear_memory_attributes)(efi_memory_attribute_protocol_t *, efi_physical_addr_t, u64, u64);
    };
    struct {
        u32 get_memory_attributes;
        u32 set_memory_attributes;
        u32 clear_memory_attributes;
    } mixed_mode;
};

struct efi_memory_map_data {
    phys_addr_t phys_map;
    long unsigned int size;
    long unsigned int desc_version;
    long unsigned int desc_size;
    long unsigned int flags;
};

union efi_pci_io_protocol {
    struct {
        void *poll_mem;
        void *poll_io;
        efi_pci_io_protocol_access_t mem;
        efi_pci_io_protocol_access_t io;
        efi_pci_io_protocol_config_access_t pci;
        void *copy_mem;
        void *map;
        void *unmap;
        void *allocate_buffer;
        void *free_buffer;
        void *flush;
        efi_status_t (*get_location)(efi_pci_io_protocol_t *, long unsigned int *, long unsigned int *, long unsigned int *, long unsigned int *);
        void *attributes;
        void *get_bar_attributes;
        void *set_bar_attributes;
        uint64_t romsize;
        void *romimage;
    };
    struct {
        u32 poll_mem;
        u32 poll_io;
        efi_pci_io_protocol_access_32_t mem;
        efi_pci_io_protocol_access_32_t io;
        efi_pci_io_protocol_access_32_t pci;
        u32 copy_mem;
        u32 map;
        u32 unmap;
        u32 allocate_buffer;
        u32 free_buffer;
        u32 flush;
        u32 get_location;
        u32 attributes;
        u32 get_bar_attributes;
        u32 set_bar_attributes;
        u64 romsize;
        u32 romimage;
    } mixed_mode;
};

union efi_rng_protocol;

typedef union efi_rng_protocol efi_rng_protocol_t;

union efi_rng_protocol {
    struct {
        efi_status_t (*get_info)(efi_rng_protocol_t *, long unsigned int *, efi_guid_t *);
        efi_status_t (*get_rng)(efi_rng_protocol_t *, efi_guid_t *, long unsigned int, u8 *);
    };
    struct {
        u32 get_info;
        u32 get_rng;
    } mixed_mode;
};

union efi_rts_args {
    struct {
        efi_time_t *time;
        efi_time_cap_t *capabilities;
    } GET_TIME;
    struct {
        efi_time_t *time;
    } SET_TIME;
    struct {
        efi_bool_t *enabled;
        efi_bool_t *pending;
        efi_time_t *time;
    } GET_WAKEUP_TIME;
    struct {
        efi_bool_t enable;
        efi_time_t *time;
    } SET_WAKEUP_TIME;
    struct {
        efi_char16_t *name;
        efi_guid_t *vendor;
        u32 *attr;
        long unsigned int *data_size;
        void *data;
    } GET_VARIABLE;
    struct {
        long unsigned int *name_size;
        efi_char16_t *name;
        efi_guid_t *vendor;
    } GET_NEXT_VARIABLE;
    struct {
        efi_char16_t *name;
        efi_guid_t *vendor;
        u32 attr;
        long unsigned int data_size;
        void *data;
    } SET_VARIABLE;
    struct {
        u32 attr;
        u64 *storage_space;
        u64 *remaining_space;
        u64 *max_variable_size;
    } QUERY_VARIABLE_INFO;
    struct {
        u32 *high_count;
    } GET_NEXT_HIGH_MONO_COUNT;
    struct {
        efi_capsule_header_t **capsules;
        long unsigned int count;
        long unsigned int sg_list;
    } UPDATE_CAPSULE;
    struct {
        efi_capsule_header_t **capsules;
        long unsigned int count;
        u64 *max_size;
        int *reset_type;
    } QUERY_CAPSULE_CAPS;
    struct {
        efi_status_t (*acpi_prm_handler)(u64, void *);
        u64 param_buffer_addr;
        void *context;
    } ACPI_PRM_HANDLER;
};

struct efi_runtime_work {
    union efi_rts_args *args;
    efi_status_t status;
    struct work_struct work;
    enum efi_rts_ids efi_rts_id;
    struct completion efi_rts_comp;
    const void *caller;
};

union efi_simple_file_system_protocol;

typedef union efi_simple_file_system_protocol efi_simple_file_system_protocol_t;

union efi_simple_file_system_protocol {
    struct {
        u64 revision;
        efi_status_t (*open_volume)(efi_simple_file_system_protocol_t *, efi_file_protocol_t **);
    };
    struct {
        u64 revision;
        u32 open_volume;
    } mixed_mode;
};

union efi_simple_text_input_protocol {
    struct {
        void *reset;
        efi_status_t (*read_keystroke)(efi_simple_text_input_protocol_t *, efi_input_key_t *);
        efi_event_t wait_for_key;
    };
    struct {
        u32 reset;
        u32 read_keystroke;
        u32 wait_for_key;
    } mixed_mode;
};

union efi_simple_text_output_protocol {
    struct {
        void *reset;
        efi_status_t (*output_string)(efi_simple_text_output_protocol_t *, efi_char16_t *);
        void *test_string;
    };
    struct {
        u32 reset;
        u32 output_string;
        u32 test_string;
    } mixed_mode;
};

union efi_smbios_protocol;

typedef union efi_smbios_protocol efi_smbios_protocol_t;

struct efi_smbios_record;

union efi_smbios_protocol {
    struct {
        efi_status_t (*add)(efi_smbios_protocol_t *, efi_handle_t, u16 *, struct efi_smbios_record *);
        efi_status_t (*update_string)(efi_smbios_protocol_t *, u16 *, long unsigned int *, u8 *);
        efi_status_t (*remove)(efi_smbios_protocol_t *, u16);
        efi_status_t (*get_next)(efi_smbios_protocol_t *, u16 *, u8 *, struct efi_smbios_record **, efi_handle_t *);
        u8 major_version;
        u8 minor_version;
    };
    struct {
        u32 add;
        u32 update_string;
        u32 remove;
        u32 get_next;
        u8 major_version;
        u8 minor_version;
    } mixed_mode;
};

struct efi_smbios_record {
    u8 type;
    u8 length;
    u16 handle;
};

struct efi_smbios_type4_record {
    struct efi_smbios_record header;
    u8 socket;
    u8 processor_type;
    u8 processor_family;
    u8 processor_manufacturer;
    u8 processor_id[8];
    u8 processor_version;
    u8 voltage;
    u16 external_clock;
    u16 max_speed;
    u16 current_speed;
    u8 status;
    u8 processor_upgrade;
    u16 l1_cache_handle;
    u16 l2_cache_handle;
    u16 l3_cache_handle;
    u8 serial_number;
    u8 asset_tag;
    u8 part_number;
    u8 core_count;
    u8 enabled_core_count;
    u8 thread_count;
    u16 processor_characteristics;
    u16 processor_family2;
    u16 core_count2;
    u16 enabled_core_count2;
    u16 thread_count2;
    u16 thread_enabled;
};

struct efi_system_resource_entry_v1 {
    efi_guid_t fw_class;
    u32 fw_type;
    u32 fw_version;
    u32 lowest_supported_fw_version;
    u32 capsule_flags;
    u32 last_attempt_version;
    u32 last_attempt_status;
};

struct efi_system_resource_table {
    u32 fw_resource_count;
    u32 fw_resource_count_max;
    u64 fw_resource_version;
    u8 entries[0];
};

struct efi_tcg2_event {
    u32 event_size;
    struct {
        u32 header_size;
        u16 header_version;
        u32 pcr_index;
        u32 event_type;
    } __attribute__((packed)) event_header;
} __attribute__((packed));

typedef struct efi_tcg2_event efi_tcg2_event_t;

struct efi_tcg2_final_events_table {
    u64 version;
    u64 nr_events;
    u8 events[0];
};

union efi_tcg2_protocol;

typedef union efi_tcg2_protocol efi_tcg2_protocol_t;

union efi_tcg2_protocol {
    struct {
        void *get_capability;
        efi_status_t (*get_event_log)(efi_tcg2_protocol_t *, efi_tcg2_event_log_format, efi_physical_addr_t *, efi_physical_addr_t *, efi_bool_t *);
        efi_status_t (*hash_log_extend_event)(efi_tcg2_protocol_t *, u64, efi_physical_addr_t, u64, const efi_tcg2_event_t *);
        void *submit_command;
        void *get_active_pcr_banks;
        void *set_active_pcr_banks;
        void *get_result_of_set_active_pcr_banks;
    };
    struct {
        u32 get_capability;
        u32 get_event_log;
        u32 hash_log_extend_event;
        u32 submit_command;
        u32 get_active_pcr_banks;
        u32 set_active_pcr_banks;
        u32 get_result_of_set_active_pcr_banks;
    } mixed_mode;
};

struct efi_unaccepted_memory {
    u32 version;
    u32 unit_size;
    u64 phys_base;
    u64 size;
    long unsigned int bitmap[0];
};

struct efi_vendor_dev_path {
    struct efi_generic_dev_path header;
    efi_guid_t vendorguid;
    u8 vendordata[0];
};

union efistub_event {
    efi_tcg2_event_t tcg2_data;
    efi_cc_event_t cc_data;
};

struct tdTCG_PCClientTaggedEvent {
    u32 tagged_event_id;
    u32 tagged_event_data_size;
    u8 tagged_event_data[0];
};

typedef struct tdTCG_PCClientTaggedEvent TCG_PCClientTaggedEvent;

struct efistub_measured_event {
    union efistub_event event_data;
    TCG_PCClientTaggedEvent tagged_event;
} __attribute__((packed));

typedef efi_status_t efi_query_variable_store_t(u32, long unsigned int, bool);

struct efivar_operations {
    efi_get_variable_t *get_variable;
    efi_get_next_variable_t *get_next_variable;
    efi_set_variable_t *set_variable;
    efi_set_variable_t *set_variable_nonblocking;
    efi_query_variable_store_t *query_variable_store;
    efi_query_variable_info_t *query_variable_info;
};

struct efivars {
    struct kset *kset;
    const struct efivar_operations *ops;
};

struct elevator_queue;

struct io_cq;

struct elevator_mq_ops {
    int (*init_sched)(struct request_queue *, struct elevator_type *);
    void (*exit_sched)(struct elevator_queue *);
    int (*init_hctx)(struct blk_mq_hw_ctx *, unsigned int);
    void (*exit_hctx)(struct blk_mq_hw_ctx *, unsigned int);
    void (*depth_updated)(struct blk_mq_hw_ctx *);
    bool (*allow_merge)(struct request_queue *, struct request *, struct bio *);
    bool (*bio_merge)(struct request_queue *, struct bio *, unsigned int);
    int (*request_merge)(struct request_queue *, struct request **, struct bio *);
    void (*request_merged)(struct request_queue *, struct request *, enum elv_merge);
    void (*requests_merged)(struct request_queue *, struct request *, struct request *);
    void (*limit_depth)(blk_opf_t, struct blk_mq_alloc_data *);
    void (*prepare_request)(struct request *);
    void (*finish_request)(struct request *);
    void (*insert_requests)(struct blk_mq_hw_ctx *, struct list_head *, blk_insert_t);
    struct request * (*dispatch_request)(struct blk_mq_hw_ctx *);
    bool (*has_work)(struct blk_mq_hw_ctx *);
    void (*completed_request)(struct request *, u64);
    void (*requeue_request)(struct request *);
    struct request * (*former_request)(struct request_queue *, struct request *);
    struct request * (*next_request)(struct request_queue *, struct request *);
    void (*init_icq)(struct io_cq *);
    void (*exit_icq)(struct io_cq *);
};

struct elevator_queue {
    struct elevator_type *type;
    void *elevator_data;
    struct kobject kobj;
    struct mutex sysfs_lock;
    long unsigned int flags;
    struct hlist_head hash[64];
};

struct elv_fs_entry;

struct elevator_type {
    struct kmem_cache *icq_cache;
    struct elevator_mq_ops ops;
    size_t icq_size;
    size_t icq_align;
    const struct elv_fs_entry *elevator_attrs;
    const char *elevator_name;
    const char *elevator_alias;
    struct module *elevator_owner;
    const struct blk_mq_debugfs_attr *queue_debugfs_attrs;
    const struct blk_mq_debugfs_attr *hctx_debugfs_attrs;
    char icq_cache_name[22];
    struct list_head list;
};

struct elf32_hdr {
    unsigned char e_ident[16];
    Elf32_Half e_type;
    Elf32_Half e_machine;
    Elf32_Word e_version;
    Elf32_Addr e_entry;
    Elf32_Off e_phoff;
    Elf32_Off e_shoff;
    Elf32_Word e_flags;
    Elf32_Half e_ehsize;
    Elf32_Half e_phentsize;
    Elf32_Half e_phnum;
    Elf32_Half e_shentsize;
    Elf32_Half e_shnum;
    Elf32_Half e_shstrndx;
};

typedef struct elf32_hdr Elf32_Ehdr;

struct elf32_note {
    Elf32_Word n_namesz;
    Elf32_Word n_descsz;
    Elf32_Word n_type;
};

typedef struct elf32_note Elf32_Nhdr;

struct elf32_phdr {
    Elf32_Word p_type;
    Elf32_Off p_offset;
    Elf32_Addr p_vaddr;
    Elf32_Addr p_paddr;
    Elf32_Word p_filesz;
    Elf32_Word p_memsz;
    Elf32_Word p_flags;
    Elf32_Word p_align;
};

typedef struct elf32_phdr Elf32_Phdr;

struct elf32_shdr {
    Elf32_Word sh_name;
    Elf32_Word sh_type;
    Elf32_Word sh_flags;
    Elf32_Addr sh_addr;
    Elf32_Off sh_offset;
    Elf32_Word sh_size;
    Elf32_Word sh_link;
    Elf32_Word sh_info;
    Elf32_Word sh_addralign;
    Elf32_Word sh_entsize;
};

struct elf64_hdr {
    unsigned char e_ident[16];
    Elf64_Half e_type;
    Elf64_Half e_machine;
    Elf64_Word e_version;
    Elf64_Addr e_entry;
    Elf64_Off e_phoff;
    Elf64_Off e_shoff;
    Elf64_Word e_flags;
    Elf64_Half e_ehsize;
    Elf64_Half e_phentsize;
    Elf64_Half e_phnum;
    Elf64_Half e_shentsize;
    Elf64_Half e_shnum;
    Elf64_Half e_shstrndx;
};

typedef struct elf64_hdr Elf64_Ehdr;

struct elf64_note {
    Elf64_Word n_namesz;
    Elf64_Word n_descsz;
    Elf64_Word n_type;
};

typedef struct elf64_note Elf64_Nhdr;

struct elf64_phdr {
    Elf64_Word p_type;
    Elf64_Word p_flags;
    Elf64_Off p_offset;
    Elf64_Addr p_vaddr;
    Elf64_Addr p_paddr;
    Elf64_Xword p_filesz;
    Elf64_Xword p_memsz;
    Elf64_Xword p_align;
};

typedef struct elf64_phdr Elf64_Phdr;

struct elf64_rela {
    Elf64_Addr r_offset;
    Elf64_Xword r_info;
    Elf64_Sxword r_addend;
};

typedef struct elf64_rela Elf64_Rela;

struct elf64_shdr {
    Elf64_Word sh_name;
    Elf64_Word sh_type;
    Elf64_Xword sh_flags;
    Elf64_Addr sh_addr;
    Elf64_Off sh_offset;
    Elf64_Xword sh_size;
    Elf64_Word sh_link;
    Elf64_Word sh_info;
    Elf64_Xword sh_addralign;
    Elf64_Xword sh_entsize;
};

typedef struct elf64_shdr Elf64_Shdr;

struct elf64_sym {
    Elf64_Word st_name;
    unsigned char st_info;
    unsigned char st_other;
    Elf64_Half st_shndx;
    Elf64_Addr st_value;
    Elf64_Xword st_size;
};

typedef struct elf64_sym Elf64_Sym;

struct memelfnote {
    const char *name;
    int type;
    unsigned int datasz;
    void *data;
};

struct elf_thread_core_info;

struct elf_note_info {
    struct elf_thread_core_info *thread;
    struct memelfnote psinfo;
    struct memelfnote signote;
    struct memelfnote auxv;
    struct memelfnote files;
    compat_siginfo_t csigdata;
    size_t size;
    int thread_notes;
};

struct siginfo {
    union {
        struct {
            int si_signo;
            int si_errno;
            int si_code;
            union __sifields _sifields;
        };
        int _si_pad[32];
    };
};

typedef struct siginfo siginfo_t;

struct elf_thread_core_info___2;

struct elf_note_info___2 {
    struct elf_thread_core_info___2 *thread;
    struct memelfnote psinfo;
    struct memelfnote signote;
    struct memelfnote auxv;
    struct memelfnote files;
    siginfo_t csigdata;
    size_t size;
    int thread_notes;
};

struct elf_prpsinfo {
    char pr_state;
    char pr_sname;
    char pr_zomb;
    char pr_nice;
    long unsigned int pr_flag;
    __kernel_uid_t pr_uid;
    __kernel_gid_t pr_gid;
    pid_t pr_pid;
    pid_t pr_ppid;
    pid_t pr_pgrp;
    pid_t pr_sid;
    char pr_fname[16];
    char pr_psargs[80];
};

struct elf_siginfo {
    int si_signo;
    int si_code;
    int si_errno;
};

struct elf_prstatus_common {
    struct elf_siginfo pr_info;
    short int pr_cursig;
    long unsigned int pr_sigpend;
    long unsigned int pr_sighold;
    pid_t pr_pid;
    pid_t pr_ppid;
    pid_t pr_pgrp;
    pid_t pr_sid;
    struct __kernel_old_timeval pr_utime;
    struct __kernel_old_timeval pr_stime;
    struct __kernel_old_timeval pr_cutime;
    struct __kernel_old_timeval pr_cstime;
};

struct elf_prstatus {
    struct elf_prstatus_common common;
    elf_gregset_t pr_reg;
    int pr_fpvalid;
};

struct elf_thread_core_info___2 {
    struct elf_thread_core_info___2 *next;
    struct task_struct *task;
    struct elf_prstatus prstatus;
    struct memelfnote notes[0];
};

struct elf_thread_core_info {
    struct elf_thread_core_info *next;
    struct task_struct *task;
    struct compat_elf_prstatus prstatus;
    struct memelfnote notes[0];
};

struct elv_fs_entry {
    struct attribute attr;
    ssize_t (*show)(struct elevator_queue *, char *);
    ssize_t (*store)(struct elevator_queue *, const char *, size_t);
};

struct em_data_callback {};

struct em_perf_table;

struct em_perf_domain {
    struct em_perf_table *em_table;
    int nr_perf_states;
    int min_perf_state;
    int max_perf_state;
    long unsigned int flags;
    long unsigned int cpus[0];
};

struct em_perf_state {
    long unsigned int performance;
    long unsigned int frequency;
    long unsigned int power;
    long unsigned int cost;
    long unsigned int flags;
};

struct em_perf_table {
    struct callback_head rcu;
    struct kref kref;
    struct em_perf_state state[0];
};

struct en_clk_desc {
    int id;
    const char *name;
    u32 base_reg;
    u8 base_bits;
    u8 base_shift;
    union {
        const unsigned int *base_values;
        unsigned int base_value;
    };
    size_t n_base_values;
    u16 div_reg;
    u8 div_bits;
    u8 div_shift;
    u16 div_val0;
    u8 div_step;
    u8 div_offset;
};

struct en_clk_gate {
    void *base;
    struct clk_hw hw;
};

struct en_clk_soc_data {
    u32 num_clocks;
    const struct clk_ops pcie_ops;
    int (*hw_init)(struct platform_device *, struct clk_hw_onecell_data *);
};

struct en_rst_data {
    const u16 *bank_ofs;
    const u16 *idx_map;
    void *base;
    struct reset_controller_dev rcdev;
};

struct trace_event_file;

struct enable_trigger_data {
    struct trace_event_file *file;
    bool enable;
    bool hist;
};

union trap_config {
    u64 val;
    struct {
        long unsigned int cgt: 10;
        long unsigned int fgt: 4;
        long unsigned int bit: 6;
        long unsigned int pol: 1;
        long unsigned int fgf: 5;
        long unsigned int sri: 10;
        long unsigned int unused: 27;
        long unsigned int mbz: 1;
    };
};

struct encoding_to_trap_config {
    const u32 encoding;
    const u32 end;
    const union trap_config tc;
    const unsigned int line;
};

struct encrypted_key_payload {
    struct callback_head rcu;
    char *format;
    char *master_desc;
    char *datalen;
    u8 *iv;
    u8 *encrypted_data;
    short unsigned int datablob_len;
    short unsigned int decrypted_datalen;
    short unsigned int payload_datalen;
    short unsigned int encrypted_key_format;
    u8 *decrypted_data;
    u8 payload_data[0];
};

struct energy_env {
    long unsigned int task_busy_time;
    long unsigned int pd_busy_time;
    long unsigned int cpu_cap;
    long unsigned int pd_cap;
};

struct enet_cb {
    struct sk_buff *skb;
    void *bd_addr;
    dma_addr_t dma_addr;
    __u32 dma_len;
};

struct entropy_timer_state {
    long unsigned int entropy;
    struct timer_list timer;
    atomic_t samples;
    unsigned int samples_per_bit;
};

struct usb_endpoint_descriptor;

struct ep_device {
    struct usb_endpoint_descriptor *desc;
    struct usb_device *udev;
    struct device dev;
};

typedef struct poll_table_struct poll_table;

struct epitem;

struct ep_pqueue {
    poll_table pt;
    struct epitem *epi;
};

struct epoll_filefd {
    struct file *file;
    int fd;
} __attribute__((packed));

struct epoll_event {
    __poll_t events;
    __u64 data;
};

struct eppoll_entry;

struct eventpoll;

struct wakeup_source;

struct epitem {
    union {
        struct rb_node rbn;
        struct callback_head rcu;
    };
    struct list_head rdllink;
    struct epitem *next;
    struct epoll_filefd ffd;
    bool dying;
    struct eppoll_entry *pwqlist;
    struct eventpoll *ep;
    struct hlist_node fllink;
    struct wakeup_source *ws;
    struct epoll_event event;
};

struct epitems_head {
    struct hlist_head epitems;
    struct epitems_head *next;
};

struct epoll_params {
    __u32 busy_poll_usecs;
    __u16 busy_poll_budget;
    __u8 prefer_busy_poll;
    __u8 __pad;
};

struct eppoll_entry {
    struct eppoll_entry *next;
    struct epitem *base;
    wait_queue_entry_t wait;
    wait_queue_head_t *whead;
};

struct trace_eprobe;

struct eprobe_data {
    struct trace_event_file *file;
    struct trace_eprobe *ep;
};

struct eprobe_trace_entry_head {
    struct trace_entry ent;
};

struct err_info {
    const char **errs;
    u8 type;
    u16 pos;
    u64 ts;
};

struct error_info {
    short unsigned int code12;
    short unsigned int size;
};

struct error_info2 {
    unsigned char code1;
    unsigned char code2_min;
    unsigned char code2_max;
    const char *str;
    const char *fmt;
};

struct erspan_md2 {
    __be32 timestamp;
    __be16 sgt;
    __u8 hwid_upper: 2;
    __u8 ft: 5;
    __u8 p: 1;
    __u8 o: 1;
    __u8 gra: 2;
    __u8 dir: 1;
    __u8 hwid: 4;
};

struct erspan_metadata {
    int version;
    union {
        __be32 index;
        struct erspan_md2 md2;
    } u;
};

struct strp_stats {
    long long unsigned int msgs;
    long long unsigned int bytes;
    unsigned int mem_fail;
    unsigned int need_more_hdr;
    unsigned int msg_too_big;
    unsigned int msg_timeouts;
    unsigned int bad_hdr_len;
};

typedef int (*sk_read_actor_t)(read_descriptor_t *, struct sk_buff *, unsigned int, size_t);

struct strparser;

struct strp_callbacks {
    int (*parse_msg)(struct strparser *, struct sk_buff *);
    void (*rcv_msg)(struct strparser *, struct sk_buff *);
    int (*read_sock)(struct strparser *, read_descriptor_t *, sk_read_actor_t);
    int (*read_sock_done)(struct strparser *, int);
    void (*abort_parser)(struct strparser *, int);
    void (*lock)(struct strparser *);
    void (*unlock)(struct strparser *);
};

struct strparser {
    struct sock *sk;
    u32 stopped: 1;
    u32 paused: 1;
    u32 aborted: 1;
    u32 interrupted: 1;
    u32 unrecov_intr: 1;
    struct sk_buff **skb_nextp;
    struct sk_buff *skb_head;
    unsigned int need_bytes;
    struct delayed_work msg_timer_work;
    struct work_struct work;
    struct strp_stats stats;
    struct strp_callbacks cb;
};

struct espintcp_msg {
    struct sk_buff *skb;
    struct sk_msg skmsg;
    int offset;
    int len;
};

struct espintcp_ctx {
    struct strparser strp;
    struct sk_buff_head ike_queue;
    struct sk_buff_head out_queue;
    struct espintcp_msg partial;
    void (*saved_data_ready)(struct sock *);
    void (*saved_write_space)(struct sock *);
    void (*saved_destruct)(struct sock *);
    struct work_struct work;
    bool tx_running;
};

struct esr_context {
    struct _aarch64_ctx head;
    __u64 esr;
};

struct esre_entry;

struct esre_attribute {
    struct attribute attr;
    ssize_t (*show)(struct esre_entry *, char *);
};

struct esre_entry {
    union {
        struct efi_system_resource_entry_v1 *esre1;
    } esre;
    struct kobject kobj;
    struct list_head list;
};

struct ethnl_request_ops;

struct ethnl_dump_ctx {
    const struct ethnl_request_ops *ops;
    struct ethnl_req_info *req_info;
    struct ethnl_reply_data *reply_data;
    long unsigned int pos_ifindex;
};

struct ethnl_module_fw_flash_ntf_params {
    u32 portid;
    u32 seq;
    bool closed_sock;
};

struct phy_req_info;

struct ethnl_phy_dump_ctx {
    struct phy_req_info *phy_req_info;
    long unsigned int ifindex;
    long unsigned int phy_index;
};

struct ethnl_request_ops {
    u8 request_cmd;
    u8 reply_cmd;
    u16 hdr_attr;
    unsigned int req_info_size;
    unsigned int reply_data_size;
    bool allow_nodev_do;
    u8 set_ntf_cmd;
    int (*parse_request)(struct ethnl_req_info *, struct nlattr **, struct netlink_ext_ack *);
    int (*prepare_data)(const struct ethnl_req_info *, struct ethnl_reply_data *, const struct genl_info *);
    int (*reply_size)(const struct ethnl_req_info *, const struct ethnl_reply_data *);
    int (*fill_reply)(struct sk_buff *, const struct ethnl_req_info *, const struct ethnl_reply_data *);
    void (*cleanup_data)(struct ethnl_reply_data *);
    int (*set_validate)(struct ethnl_req_info *, struct genl_info *);
    int (*set)(struct ethnl_req_info *, struct genl_info *);
};

struct ethnl_sock_priv {
    struct net_device *dev;
    u32 portid;
    enum ethnl_sock_type type;
};

struct tsinfo_req_info;

struct tsinfo_reply_data;

struct ethnl_tsinfo_dump_ctx {
    struct tsinfo_req_info *req_info;
    struct tsinfo_reply_data *reply_data;
    long unsigned int pos_ifindex;
    bool netdev_dump_done;
    long unsigned int pos_phyindex;
    enum hwtstamp_provider_qualifier pos_phcqualifier;
};

struct ethnl_tunnel_info_dump_ctx {
    struct ethnl_req_info req_info;
    long unsigned int ifindex;
};

struct ethtool_c33_pse_ext_state_info {
    enum ethtool_c33_pse_ext_state c33_pse_ext_state;
    union {
        enum ethtool_c33_pse_ext_substate_error_condition error_condition;
        enum ethtool_c33_pse_ext_substate_mr_pse_enable mr_pse_enable;
        enum ethtool_c33_pse_ext_substate_option_detect_ted option_detect_ted;
        enum ethtool_c33_pse_ext_substate_option_vport_lim option_vport_lim;
        enum ethtool_c33_pse_ext_substate_ovld_detected ovld_detected;
        enum ethtool_c33_pse_ext_substate_power_not_available power_not_available;
        enum ethtool_c33_pse_ext_substate_short_detected short_detected;
        u32 __c33_pse_ext_substate;
    };
};

struct ethtool_c33_pse_pw_limit_range {
    u32 min;
    u32 max;
};

struct ethtool_cmd {
    __u32 cmd;
    __u32 supported;
    __u32 advertising;
    __u16 speed;
    __u8 duplex;
    __u8 port;
    __u8 phy_address;
    __u8 transceiver;
    __u8 autoneg;
    __u8 mdio_support;
    __u32 maxtxpkt;
    __u32 maxrxpkt;
    __u16 speed_hi;
    __u8 eth_tp_mdix;
    __u8 eth_tp_mdix_ctrl;
    __u32 lp_advertising;
    __u32 reserved[2];
};

struct ethtool_cmis_cdb {
    u8 cmis_rev;
    u8 read_write_len_ext;
    u16 max_completion_time;
};

struct ethtool_cmis_cdb_request {
    __be16 id;
    union {
        struct {
            __be16 epl_len;
            u8 lpl_len;
            u8 chk_code;
            u8 resv1;
            u8 resv2;
            u8 payload[120];
        };
        struct {
            __be16 epl_len;
            u8 lpl_len;
            u8 chk_code;
            u8 resv1;
            u8 resv2;
            u8 payload[120];
        } body;
    };
    u8 *epl;
};

struct ethtool_cmis_cdb_cmd_args {
    struct ethtool_cmis_cdb_request req;
    u16 max_duration;
    u8 read_write_len_ext;
    u8 msleep_pre_rpl;
    u8 rpl_exp_len;
    u8 flags;
    char *err_msg;
};

struct ethtool_cmis_cdb_rpl_hdr {
    u8 rpl_len;
    u8 rpl_chk_code;
};

struct ethtool_cmis_cdb_rpl {
    struct ethtool_cmis_cdb_rpl_hdr hdr;
    u8 payload[120];
};

struct ethtool_module_fw_flash_params {
    __be32 password;
    u8 password_valid: 1;
};

struct ethtool_cmis_fw_update_params {
    struct net_device *dev;
    struct ethtool_module_fw_flash_params params;
    struct ethnl_module_fw_flash_ntf_params ntf_params;
    const struct firmware *fw;
};

struct ethtool_flash {
    __u32 cmd;
    __u32 region;
    char data[128];
};

struct ethtool_drvinfo {
    __u32 cmd;
    char driver[32];
    char version[32];
    char fw_version[32];
    char bus_info[32];
    char erom_version[32];
    char reserved2[12];
    __u32 n_priv_flags;
    __u32 n_stats;
    __u32 testinfo_len;
    __u32 eedump_len;
    __u32 regdump_len;
};

struct ethtool_devlink_compat {
    struct devlink *devlink;
    union {
        struct ethtool_flash efl;
        struct ethtool_drvinfo info;
    };
};

struct ethtool_dump {
    __u32 cmd;
    __u32 version;
    __u32 flag;
    __u32 len;
    __u8 data[0];
};

struct ethtool_eee {
    __u32 cmd;
    __u32 supported;
    __u32 advertised;
    __u32 lp_advertised;
    __u32 eee_active;
    __u32 eee_enabled;
    __u32 tx_lpi_enabled;
    __u32 tx_lpi_timer;
    __u32 reserved[2];
};

struct ethtool_eeprom {
    __u32 cmd;
    __u32 magic;
    __u32 offset;
    __u32 len;
    __u8 data[0];
};

struct ethtool_eth_ctrl_stats {
    enum ethtool_mac_stats_src src;
    union {
        struct {
            u64 MACControlFramesTransmitted;
            u64 MACControlFramesReceived;
            u64 UnsupportedOpcodesReceived;
        };
        struct {
            u64 MACControlFramesTransmitted;
            u64 MACControlFramesReceived;
            u64 UnsupportedOpcodesReceived;
        } stats;
    };
};

struct ethtool_eth_mac_stats {
    enum ethtool_mac_stats_src src;
    union {
        struct {
            u64 FramesTransmittedOK;
            u64 SingleCollisionFrames;
            u64 MultipleCollisionFrames;
            u64 FramesReceivedOK;
            u64 FrameCheckSequenceErrors;
            u64 AlignmentErrors;
            u64 OctetsTransmittedOK;
            u64 FramesWithDeferredXmissions;
            u64 LateCollisions;
            u64 FramesAbortedDueToXSColls;
            u64 FramesLostDueToIntMACXmitError;
            u64 CarrierSenseErrors;
            u64 OctetsReceivedOK;
            u64 FramesLostDueToIntMACRcvError;
            u64 MulticastFramesXmittedOK;
            u64 BroadcastFramesXmittedOK;
            u64 FramesWithExcessiveDeferral;
            u64 MulticastFramesReceivedOK;
            u64 BroadcastFramesReceivedOK;
            u64 InRangeLengthErrors;
            u64 OutOfRangeLengthField;
            u64 FrameTooLongErrors;
        };
        struct {
            u64 FramesTransmittedOK;
            u64 SingleCollisionFrames;
            u64 MultipleCollisionFrames;
            u64 FramesReceivedOK;
            u64 FrameCheckSequenceErrors;
            u64 AlignmentErrors;
            u64 OctetsTransmittedOK;
            u64 FramesWithDeferredXmissions;
            u64 LateCollisions;
            u64 FramesAbortedDueToXSColls;
            u64 FramesLostDueToIntMACXmitError;
            u64 CarrierSenseErrors;
            u64 OctetsReceivedOK;
            u64 FramesLostDueToIntMACRcvError;
            u64 MulticastFramesXmittedOK;
            u64 BroadcastFramesXmittedOK;
            u64 FramesWithExcessiveDeferral;
            u64 MulticastFramesReceivedOK;
            u64 BroadcastFramesReceivedOK;
            u64 InRangeLengthErrors;
            u64 OutOfRangeLengthField;
            u64 FrameTooLongErrors;
        } stats;
    };
};

struct ethtool_eth_phy_stats {
    enum ethtool_mac_stats_src src;
    union {
        struct {
            u64 SymbolErrorDuringCarrier;
        };
        struct {
            u64 SymbolErrorDuringCarrier;
        } stats;
    };
};

struct ethtool_fec_stat {
    u64 total;
    u64 lanes[8];
};

struct ethtool_fec_stats {
    struct ethtool_fec_stat corrected_blocks;
    struct ethtool_fec_stat uncorrectable_blocks;
    struct ethtool_fec_stat corrected_bits;
};

struct ethtool_fecparam {
    __u32 cmd;
    __u32 active_fec;
    __u32 fec;
    __u32 reserved;
};

struct ethtool_forced_speed_map {
    u32 speed;
    long unsigned int caps[2];
    const u32 *cap_arr;
    u32 arr_size;
};

struct ethtool_get_features_block {
    __u32 available;
    __u32 requested;
    __u32 active;
    __u32 never_changed;
};

struct ethtool_gfeatures {
    __u32 cmd;
    __u32 size;
    struct ethtool_get_features_block features[0];
};

struct ethtool_gstrings {
    __u32 cmd;
    __u32 string_set;
    __u32 len;
    __u8 data[0];
};

struct ethtool_link_ext_state_info {
    enum ethtool_link_ext_state link_ext_state;
    union {
        enum ethtool_link_ext_substate_autoneg autoneg;
        enum ethtool_link_ext_substate_link_training link_training;
        enum ethtool_link_ext_substate_link_logical_mismatch link_logical_mismatch;
        enum ethtool_link_ext_substate_bad_signal_integrity bad_signal_integrity;
        enum ethtool_link_ext_substate_cable_issue cable_issue;
        enum ethtool_link_ext_substate_module module;
        u32 __link_ext_substate;
    };
};

struct ethtool_link_ext_stats {
    u64 link_down_events;
};

struct ethtool_link_settings {
    __u32 cmd;
    __u32 speed;
    __u8 duplex;
    __u8 port;
    __u8 phy_address;
    __u8 autoneg;
    __u8 mdio_support;
    __u8 eth_tp_mdix;
    __u8 eth_tp_mdix_ctrl;
    __s8 link_mode_masks_nwords;
    __u8 transceiver;
    __u8 master_slave_cfg;
    __u8 master_slave_state;
    __u8 rate_matching;
    __u32 reserved[7];
};

struct ethtool_link_ksettings {
    struct ethtool_link_settings base;
    struct {
        long unsigned int supported[2];
        long unsigned int advertising[2];
        long unsigned int lp_advertising[2];
    } link_modes;
    u32 lanes;
};

struct ethtool_link_usettings {
    struct ethtool_link_settings base;
    struct {
        __u32 supported[4];
        __u32 advertising[4];
        __u32 lp_advertising[4];
    } link_modes;
};

struct ethtool_mm_cfg {
    u32 verify_time;
    bool verify_enabled;
    bool tx_enabled;
    bool pmac_enabled;
    u32 tx_min_frag_size;
};

struct ethtool_mm_state {
    u32 verify_time;
    u32 max_verify_time;
    enum ethtool_mm_verify_status verify_status;
    bool tx_enabled;
    bool tx_active;
    bool pmac_enabled;
    bool verify_enabled;
    u32 tx_min_frag_size;
    u32 rx_min_frag_size;
};

struct ethtool_mm_stats {
    u64 MACMergeFrameAssErrorCount;
    u64 MACMergeFrameSmdErrorCount;
    u64 MACMergeFrameAssOkCount;
    u64 MACMergeFragCountRx;
    u64 MACMergeFragCountTx;
    u64 MACMergeHoldCount;
};

struct ethtool_modinfo {
    __u32 cmd;
    __u32 type;
    __u32 eeprom_len;
    __u32 reserved[8];
};

struct ethtool_module_eeprom {
    u32 offset;
    u32 length;
    u8 page;
    u8 bank;
    u8 i2c_address;
    u8 *data;
};

struct ethtool_module_fw_flash {
    struct list_head list;
    netdevice_tracker dev_tracker;
    struct work_struct work;
    struct ethtool_cmis_fw_update_params fw_update;
};

struct ethtool_module_power_mode_params {
    enum ethtool_module_power_mode_policy policy;
    enum ethtool_module_power_mode mode;
};

struct ethtool_netdev_state {
    struct xarray rss_ctx;
    struct mutex rss_lock;
    unsigned int wol_enabled: 1;
    unsigned int module_fw_flash_in_progress: 1;
};

struct ethtool_ringparam;

struct kernel_ethtool_ringparam;

struct ethtool_pauseparam;

struct ethtool_stats;

struct ethtool_rxfh_param;

struct ethtool_rxfh_context;

struct ethtool_tunable;

struct ethtool_ops {
    u32 cap_link_lanes_supported: 1;
    u32 cap_rss_ctx_supported: 1;
    u32 cap_rss_sym_xor_supported: 1;
    u32 rxfh_per_ctx_key: 1;
    u32 cap_rss_rxnfc_adds: 1;
    u32 rxfh_indir_space;
    u16 rxfh_key_space;
    u16 rxfh_priv_size;
    u32 rxfh_max_num_contexts;
    u32 supported_coalesce_params;
    u32 supported_ring_params;
    u32 supported_hwtstamp_qualifiers;
    void (*get_drvinfo)(struct net_device *, struct ethtool_drvinfo *);
    int (*get_regs_len)(struct net_device *);
    void (*get_regs)(struct net_device *, struct ethtool_regs *, void *);
    void (*get_wol)(struct net_device *, struct ethtool_wolinfo *);
    int (*set_wol)(struct net_device *, struct ethtool_wolinfo *);
    u32 (*get_msglevel)(struct net_device *);
    void (*set_msglevel)(struct net_device *, u32);
    int (*nway_reset)(struct net_device *);
    u32 (*get_link)(struct net_device *);
    int (*get_link_ext_state)(struct net_device *, struct ethtool_link_ext_state_info *);
    void (*get_link_ext_stats)(struct net_device *, struct ethtool_link_ext_stats *);
    int (*get_eeprom_len)(struct net_device *);
    int (*get_eeprom)(struct net_device *, struct ethtool_eeprom *, u8 *);
    int (*set_eeprom)(struct net_device *, struct ethtool_eeprom *, u8 *);
    int (*get_coalesce)(struct net_device *, struct ethtool_coalesce *, struct kernel_ethtool_coalesce *, struct netlink_ext_ack *);
    int (*set_coalesce)(struct net_device *, struct ethtool_coalesce *, struct kernel_ethtool_coalesce *, struct netlink_ext_ack *);
    void (*get_ringparam)(struct net_device *, struct ethtool_ringparam *, struct kernel_ethtool_ringparam *, struct netlink_ext_ack *);
    int (*set_ringparam)(struct net_device *, struct ethtool_ringparam *, struct kernel_ethtool_ringparam *, struct netlink_ext_ack *);
    void (*get_pause_stats)(struct net_device *, struct ethtool_pause_stats *);
    void (*get_pauseparam)(struct net_device *, struct ethtool_pauseparam *);
    int (*set_pauseparam)(struct net_device *, struct ethtool_pauseparam *);
    void (*self_test)(struct net_device *, struct ethtool_test *, u64 *);
    void (*get_strings)(struct net_device *, u32, u8 *);
    int (*set_phys_id)(struct net_device *, enum ethtool_phys_id_state);
    void (*get_ethtool_stats)(struct net_device *, struct ethtool_stats *, u64 *);
    int (*begin)(struct net_device *);
    void (*complete)(struct net_device *);
    u32 (*get_priv_flags)(struct net_device *);
    int (*set_priv_flags)(struct net_device *, u32);
    int (*get_sset_count)(struct net_device *, int);
    int (*get_rxnfc)(struct net_device *, struct ethtool_rxnfc *, u32 *);
    int (*set_rxnfc)(struct net_device *, struct ethtool_rxnfc *);
    int (*flash_device)(struct net_device *, struct ethtool_flash *);
    int (*reset)(struct net_device *, u32 *);
    u32 (*get_rxfh_key_size)(struct net_device *);
    u32 (*get_rxfh_indir_size)(struct net_device *);
    int (*get_rxfh)(struct net_device *, struct ethtool_rxfh_param *);
    int (*set_rxfh)(struct net_device *, struct ethtool_rxfh_param *, struct netlink_ext_ack *);
    int (*create_rxfh_context)(struct net_device *, struct ethtool_rxfh_context *, const struct ethtool_rxfh_param *, struct netlink_ext_ack *);
    int (*modify_rxfh_context)(struct net_device *, struct ethtool_rxfh_context *, const struct ethtool_rxfh_param *, struct netlink_ext_ack *);
    int (*remove_rxfh_context)(struct net_device *, struct ethtool_rxfh_context *, u32, struct netlink_ext_ack *);
    void (*get_channels)(struct net_device *, struct ethtool_channels *);
    int (*set_channels)(struct net_device *, struct ethtool_channels *);
    int (*get_dump_flag)(struct net_device *, struct ethtool_dump *);
    int (*get_dump_data)(struct net_device *, struct ethtool_dump *, void *);
    int (*set_dump)(struct net_device *, struct ethtool_dump *);
    int (*get_ts_info)(struct net_device *, struct kernel_ethtool_ts_info *);
    void (*get_ts_stats)(struct net_device *, struct ethtool_ts_stats *);
    int (*get_module_info)(struct net_device *, struct ethtool_modinfo *);
    int (*get_module_eeprom)(struct net_device *, struct ethtool_eeprom *, u8 *);
    int (*get_eee)(struct net_device *, struct ethtool_keee *);
    int (*set_eee)(struct net_device *, struct ethtool_keee *);
    int (*get_tunable)(struct net_device *, const struct ethtool_tunable *, void *);
    int (*set_tunable)(struct net_device *, const struct ethtool_tunable *, const void *);
    int (*get_per_queue_coalesce)(struct net_device *, u32, struct ethtool_coalesce *);
    int (*set_per_queue_coalesce)(struct net_device *, u32, struct ethtool_coalesce *);
    int (*get_link_ksettings)(struct net_device *, struct ethtool_link_ksettings *);
    int (*set_link_ksettings)(struct net_device *, const struct ethtool_link_ksettings *);
    void (*get_fec_stats)(struct net_device *, struct ethtool_fec_stats *);
    int (*get_fecparam)(struct net_device *, struct ethtool_fecparam *);
    int (*set_fecparam)(struct net_device *, struct ethtool_fecparam *);
    void (*get_ethtool_phy_stats)(struct net_device *, struct ethtool_stats *, u64 *);
    int (*get_phy_tunable)(struct net_device *, const struct ethtool_tunable *, void *);
    int (*set_phy_tunable)(struct net_device *, const struct ethtool_tunable *, const void *);
    int (*get_module_eeprom_by_page)(struct net_device *, const struct ethtool_module_eeprom *, struct netlink_ext_ack *);
    int (*set_module_eeprom_by_page)(struct net_device *, const struct ethtool_module_eeprom *, struct netlink_ext_ack *);
    void (*get_eth_phy_stats)(struct net_device *, struct ethtool_eth_phy_stats *);
    void (*get_eth_mac_stats)(struct net_device *, struct ethtool_eth_mac_stats *);
    void (*get_eth_ctrl_stats)(struct net_device *, struct ethtool_eth_ctrl_stats *);
    void (*get_rmon_stats)(struct net_device *, struct ethtool_rmon_stats *, const struct ethtool_rmon_hist_range **);
    int (*get_module_power_mode)(struct net_device *, struct ethtool_module_power_mode_params *, struct netlink_ext_ack *);
    int (*set_module_power_mode)(struct net_device *, const struct ethtool_module_power_mode_params *, struct netlink_ext_ack *);
    int (*get_mm)(struct net_device *, struct ethtool_mm_state *);
    int (*set_mm)(struct net_device *, struct ethtool_mm_cfg *, struct netlink_ext_ack *);
    void (*get_mm_stats)(struct net_device *, struct ethtool_mm_stats *);
};

struct ethtool_pause_stats {
    enum ethtool_mac_stats_src src;
    union {
        struct {
            u64 tx_pause_frames;
            u64 rx_pause_frames;
        };
        struct {
            u64 tx_pause_frames;
            u64 rx_pause_frames;
        } stats;
    };
};

struct ethtool_pauseparam {
    __u32 cmd;
    __u32 autoneg;
    __u32 rx_pause;
    __u32 tx_pause;
};

struct ethtool_per_queue_op {
    __u32 cmd;
    __u32 sub_command;
    __u32 queue_mask[128];
    char data[0];
};

struct ethtool_perm_addr {
    __u32 cmd;
    __u32 size;
    __u8 data[0];
};

struct phy_plca_cfg;

struct phy_plca_status;

struct phy_tdr_config;

struct ethtool_phy_ops {
    int (*get_sset_count)(struct phy_device *);
    int (*get_strings)(struct phy_device *, u8 *);
    int (*get_stats)(struct phy_device *, struct ethtool_stats *, u64 *);
    int (*get_plca_cfg)(struct phy_device *, struct phy_plca_cfg *);
    int (*set_plca_cfg)(struct phy_device *, const struct phy_plca_cfg *, struct netlink_ext_ack *);
    int (*get_plca_status)(struct phy_device *, struct phy_plca_status *);
    int (*start_cable_test)(struct phy_device *, struct netlink_ext_ack *);
    int (*start_cable_test_tdr)(struct phy_device *, struct netlink_ext_ack *, const struct phy_tdr_config *);
};

struct ethtool_phy_stats {
    u64 rx_packets;
    u64 rx_bytes;
    u64 rx_errors;
    u64 tx_packets;
    u64 tx_bytes;
    u64 tx_errors;
};

struct ethtool_pse_control_status {
    enum ethtool_podl_pse_admin_state podl_admin_state;
    enum ethtool_podl_pse_pw_d_status podl_pw_status;
    enum ethtool_c33_pse_admin_state c33_admin_state;
    enum ethtool_c33_pse_pw_d_status c33_pw_status;
    u32 c33_pw_class;
    u32 c33_actual_pw;
    struct ethtool_c33_pse_ext_state_info c33_ext_state_info;
    u32 c33_avail_pw_limit;
    struct ethtool_c33_pse_pw_limit_range *c33_pw_limit_ranges;
    u32 c33_pw_limit_nb_ranges;
};

struct ethtool_regs {
    __u32 cmd;
    __u32 version;
    __u32 len;
    __u8 data[0];
};

struct ethtool_ringparam {
    __u32 cmd;
    __u32 rx_max_pending;
    __u32 rx_mini_max_pending;
    __u32 rx_jumbo_max_pending;
    __u32 tx_max_pending;
    __u32 rx_pending;
    __u32 rx_mini_pending;
    __u32 rx_jumbo_pending;
    __u32 tx_pending;
};

struct ethtool_rmon_hist_range {
    u16 low;
    u16 high;
};

struct ethtool_rmon_stats {
    enum ethtool_mac_stats_src src;
    union {
        struct {
            u64 undersize_pkts;
            u64 oversize_pkts;
            u64 fragments;
            u64 jabbers;
            u64 hist[10];
            u64 hist_tx[10];
        };
        struct {
            u64 undersize_pkts;
            u64 oversize_pkts;
            u64 fragments;
            u64 jabbers;
            u64 hist[10];
            u64 hist_tx[10];
        } stats;
    };
};

struct flow_dissector_key_basic {
    __be16 n_proto;
    u8 ip_proto;
    u8 padding;
};

struct flow_dissector_key_ipv4_addrs {
    __be32 src;
    __be32 dst;
};

struct flow_dissector_key_ipv6_addrs {
    struct in6_addr src;
    struct in6_addr dst;
};

struct flow_dissector_key_ports {
    union {
        __be32 ports;
        struct {
            __be16 src;
            __be16 dst;
        };
    };
};

struct flow_dissector_key_ip {
    __u8 tos;
    __u8 ttl;
};

struct flow_dissector_key_vlan {
    union {
        struct {
            u16 vlan_id: 12;
            u16 vlan_dei: 1;
            u16 vlan_priority: 3;
        };
        __be16 vlan_tci;
    };
    __be16 vlan_tpid;
    __be16 vlan_eth_type;
    u16 padding;
};

struct flow_dissector_key_eth_addrs {
    unsigned char dst[6];
    unsigned char src[6];
};

struct ethtool_rx_flow_key {
    struct flow_dissector_key_basic basic;
    union {
        struct flow_dissector_key_ipv4_addrs ipv4;
        struct flow_dissector_key_ipv6_addrs ipv6;
    };
    struct flow_dissector_key_ports tp;
    struct flow_dissector_key_ip ip;
    struct flow_dissector_key_vlan vlan;
    struct flow_dissector_key_eth_addrs eth_addrs;
};

struct flow_dissector {
    long long unsigned int used_keys;
    short unsigned int offset[33];
};

struct ethtool_rx_flow_match {
    struct flow_dissector dissector;
    struct ethtool_rx_flow_key key;
    struct ethtool_rx_flow_key mask;
};

struct flow_rule;

struct ethtool_rx_flow_rule {
    struct flow_rule *rule;
    long unsigned int priv[0];
};

struct ethtool_rx_flow_spec_input {
    const struct ethtool_rx_flow_spec *fs;
    u32 rss_ctx;
};

struct ethtool_rxfh {
    __u32 cmd;
    __u32 rss_context;
    __u32 indir_size;
    __u32 key_size;
    __u8 hfunc;
    __u8 input_xfrm;
    __u8 rsvd8[2];
    __u32 rsvd32;
    __u32 rss_config[0];
};

struct ethtool_rxfh_context {
    u32 indir_size;
    u32 key_size;
    u16 priv_size;
    u8 hfunc;
    u8 input_xfrm;
    u8 indir_configured: 1;
    u8 key_configured: 1;
    u32 key_off;
    long: 0;
    u8 data[0];
};

struct ethtool_rxfh_param {
    u8 hfunc;
    u32 indir_size;
    u32 *indir;
    u32 key_size;
    u8 *key;
    u32 rss_context;
    u8 rss_delete;
    u8 input_xfrm;
};

struct ethtool_rxnfc {
    __u32 cmd;
    __u32 flow_type;
    __u64 data;
    struct ethtool_rx_flow_spec fs;
    union {
        __u32 rule_cnt;
        __u32 rss_context;
    };
    __u32 rule_locs[0];
};

struct ethtool_set_features_block {
    __u32 valid;
    __u32 requested;
};

struct ethtool_sfeatures {
    __u32 cmd;
    __u32 size;
    struct ethtool_set_features_block features[0];
};

struct ethtool_sset_info {
    __u32 cmd;
    __u32 reserved;
    __u64 sset_mask;
    __u32 data[0];
};

struct ethtool_stats {
    __u32 cmd;
    __u32 n_stats;
    __u64 data[0];
};

struct ethtool_test {
    __u32 cmd;
    __u32 flags;
    __u32 reserved;
    __u32 len;
    __u64 data[0];
};

struct ethtool_ts_info {
    __u32 cmd;
    __u32 so_timestamping;
    __s32 phc_index;
    __u32 tx_types;
    __u32 tx_reserved[3];
    __u32 rx_filters;
    __u32 rx_reserved[3];
};

struct ethtool_ts_stats {
    union {
        struct {
            u64 pkts;
            u64 onestep_pkts_unconfirmed;
            u64 lost;
            u64 err;
        };
        struct {
            u64 pkts;
            u64 onestep_pkts_unconfirmed;
            u64 lost;
            u64 err;
        } tx_stats;
    };
};

struct ethtool_tunable {
    __u32 cmd;
    __u32 id;
    __u32 type_id;
    __u32 len;
    void *data[0];
};

struct ethtool_value {
    __u32 cmd;
    __u32 data;
};

struct ethtool_wolinfo {
    __u32 cmd;
    __u32 supported;
    __u32 wolopts;
    __u8 sopass[6];
};

struct input_dev;

struct input_handler;

struct input_value;

struct input_handle {
    void *private;
    int open;
    const char *name;
    struct input_dev *dev;
    struct input_handler *handler;
    unsigned int (*handle_events)(struct input_handle *, struct input_value *, unsigned int);
    struct list_head d_node;
    struct list_head h_node;
};

struct evdev_client;

struct evdev {
    int open;
    struct input_handle handle;
    struct evdev_client *grab;
    struct list_head client_list;
    spinlock_t client_lock;
    struct mutex mutex;
    struct device dev;
    struct cdev cdev;
    bool exist;
};

struct input_event {
    __kernel_ulong_t __sec;
    __kernel_ulong_t __usec;
    __u16 type;
    __u16 code;
    __s32 value;
};

struct fasync_struct;

struct evdev_client {
    unsigned int head;
    unsigned int tail;
    unsigned int packet_head;
    spinlock_t buffer_lock;
    wait_queue_head_t wait;
    struct fasync_struct *fasync;
    struct evdev *evdev;
    struct list_head node;
    enum input_clock_type clk_type;
    bool revoked;
    long unsigned int *evmasks[32];
    unsigned int bufsize;
    struct input_event buffer[0];
};

struct event_trigger_data;

struct event_trigger_ops;

struct event_command {
    struct list_head list;
    char *name;
    enum event_trigger_type trigger_type;
    int flags;
    int (*parse)(struct event_command *, struct trace_event_file *, char *, char *, char *);
    int (*reg)(char *, struct event_trigger_data *, struct trace_event_file *);
    void (*unreg)(char *, struct event_trigger_data *, struct trace_event_file *);
    void (*unreg_all)(struct trace_event_file *);
    int (*set_filter)(char *, struct event_trigger_data *, struct trace_event_file *);
    struct event_trigger_ops * (*get_trigger_ops)(char *, char *);
};

struct event_file_link {
    struct trace_event_file *file;
    struct list_head list;
};

struct prog_entry;

struct event_filter {
    struct prog_entry *prog;
    char *filter_string;
};

struct perf_cpu_context;

struct perf_event_context;

typedef void (*event_f)(struct perf_event *, struct perf_cpu_context *, struct perf_event_context *, void *);

struct event_function_struct {
    struct perf_event *event;
    event_f func;
    void *data;
};

struct its_vm;

struct its_vlpi_map;

struct event_lpi_map {
    long unsigned int *lpi_map;
    u16 *col_map;
    irq_hw_number_t lpi_base;
    int nr_lpis;
    raw_spinlock_t vlpi_lock;
    struct its_vm *vm;
    struct its_vlpi_map *vlpi_maps;
    int nr_vlpis;
};

struct event_mod_load {
    struct list_head list;
    char *module;
    char *match;
    char *system;
    char *event;
};

struct event_probe_data {
    struct trace_event_file *file;
    long unsigned int count;
    int ref;
    bool enable;
};

struct event_subsystem {
    struct list_head list;
    const char *name;
    struct event_filter *filter;
    int ref_count;
};

struct event_trigger_data {
    long unsigned int count;
    int ref;
    int flags;
    struct event_trigger_ops *ops;
    struct event_command *cmd_ops;
    struct event_filter *filter;
    char *filter_str;
    void *private_data;
    bool paused;
    bool paused_tmp;
    struct list_head list;
    char *name;
    struct list_head named_list;
    struct event_trigger_data *named_data;
};

struct event_trigger_ops {
    void (*trigger)(struct event_trigger_data *, struct trace_buffer *, void *, struct ring_buffer_event *);
    int (*init)(struct event_trigger_data *);
    void (*free)(struct event_trigger_data *);
    int (*print)(struct seq_file *, struct event_trigger_data *);
};

struct eventfd_ctx {
    struct kref kref;
    wait_queue_head_t wqh;
    __u64 count;
    unsigned int flags;
    int id;
};

struct eventfs_attr {
    int mode;
    kuid_t uid;
    kgid_t gid;
};

typedef int (*eventfs_callback)(const char *, umode_t *, void **, const struct file_operations **);

typedef void (*eventfs_release)(const char *, void *);

struct eventfs_entry {
    const char *name;
    eventfs_callback callback;
    eventfs_release release;
};

struct eventfs_inode {
    union {
        struct list_head list;
        struct callback_head rcu;
    };
    struct list_head children;
    const struct eventfs_entry *entries;
    const char *name;
    struct eventfs_attr *entry_attrs;
    void *data;
    struct eventfs_attr attr;
    struct kref kref;
    unsigned int is_freed: 1;
    unsigned int is_events: 1;
    unsigned int nr_entries: 30;
    unsigned int ino;
};

struct eventfs_root_inode {
    struct eventfs_inode ei;
    struct dentry *events_dir;
};

struct eventpoll {
    struct mutex mtx;
    wait_queue_head_t wq;
    wait_queue_head_t poll_wait;
    struct list_head rdllist;
    rwlock_t lock;
    struct rb_root_cached rbr;
    struct epitem *ovflist;
    struct wakeup_source *ws;
    struct user_struct *user;
    struct file *file;
    u64 gen;
    struct hlist_head refs;
    refcount_t refcount;
    unsigned int napi_id;
    u32 busy_poll_usecs;
    u16 busy_poll_budget;
    bool prefer_busy_poll;
};

struct ima_digest_data_hdr {
    u8 algo;
    u8 length;
    union {
        struct {
            u8 unused;
            u8 type;
        } sha1;
        struct {
            u8 type;
            u8 algo;
        } ng;
        u8 data[2];
    } xattr;
};

struct evm_digest {
    struct ima_digest_data_hdr hdr;
    char digest[64];
};

struct integrity_inode_attributes {
    u64 version;
    long unsigned int ino;
    dev_t dev;
};

struct evm_iint_cache {
    long unsigned int flags;
    enum integrity_status evm_status: 4;
    struct integrity_inode_attributes metadata_inode;
};

struct evm_ima_xattr_data_hdr {
    u8 type;
};

struct evm_ima_xattr_data {
    union {
        struct {
            u8 type;
        };
        struct evm_ima_xattr_data_hdr hdr;
    };
    u8 data[0];
};

struct evm_xattr {
    struct evm_ima_xattr_data_hdr data;
    u8 digest[20];
};

struct exception_table_entry {
    int insn;
    int fixup;
    short int type;
    short int data;
};

struct execmem_range {
    long unsigned int start;
    long unsigned int end;
    long unsigned int fallback_start;
    long unsigned int fallback_end;
    pgprot_t pgprot;
    unsigned int alignment;
    enum execmem_range_flags flags;
};

struct execmem_info {
    struct execmem_range ranges[5];
};

struct execute_work {
    struct work_struct work;
};

struct exit_boot_struct {
    struct efi_boot_memmap *boot_memmap;
    efi_memory_desc_t *runtime_map;
    int runtime_entry_count;
    void *new_fdt_addr;
};

struct fid;

struct iomap;

struct handle_to_path_ctx;

struct export_operations {
    int (*encode_fh)(struct inode *, __u32 *, int *, struct inode *);
    struct dentry * (*fh_to_dentry)(struct super_block *, struct fid *, int, int);
    struct dentry * (*fh_to_parent)(struct super_block *, struct fid *, int, int);
    int (*get_name)(struct dentry *, char *, struct dentry *);
    struct dentry * (*get_parent)(struct dentry *);
    int (*commit_metadata)(struct inode *);
    int (*get_uuid)(struct super_block *, u8 *, u32 *, u64 *);
    int (*map_blocks)(struct inode *, loff_t, u64, struct iomap *, bool, u32 *);
    int (*commit_blocks)(struct inode *, struct iomap *, int, struct iattr *);
    int (*permission)(struct handle_to_path_ctx *, unsigned int);
    struct file * (*open)(struct path *, unsigned int);
    long unsigned int flags;
};

struct expresswire_timing {
    long unsigned int poweroff_us;
    long unsigned int detect_delay_us;
    long unsigned int detect_us;
    long unsigned int data_start_us;
    long unsigned int end_of_data_low_us;
    long unsigned int end_of_data_high_us;
    long unsigned int short_bitset_us;
    long unsigned int long_bitset_us;
};

struct expresswire_common_props {
    struct gpio_desc *ctrl_gpio;
    struct expresswire_timing timing;
};

struct ext4_free_extent {
    ext4_lblk_t fe_logical;
    ext4_grpblk_t fe_start;
    ext4_group_t fe_group;
    ext4_grpblk_t fe_len;
};

struct ext4_prealloc_space;

struct ext4_locality_group;

struct ext4_allocation_context {
    struct inode *ac_inode;
    struct super_block *ac_sb;
    struct ext4_free_extent ac_o_ex;
    struct ext4_free_extent ac_g_ex;
    struct ext4_free_extent ac_b_ex;
    struct ext4_free_extent ac_f_ex;
    ext4_grpblk_t ac_orig_goal_len;
    __u32 ac_flags;
    __u32 ac_groups_linear_remaining;
    __u16 ac_groups_scanned;
    __u16 ac_found;
    __u16 ac_cX_found[5];
    __u16 ac_tail;
    __u16 ac_buddy;
    __u8 ac_status;
    __u8 ac_criteria;
    __u8 ac_2order;
    __u8 ac_op;
    struct folio *ac_bitmap_folio;
    struct folio *ac_buddy_folio;
    struct ext4_prealloc_space *ac_pa;
    struct ext4_locality_group *ac_lg;
};

struct ext4_allocation_request {
    struct inode *inode;
    unsigned int len;
    ext4_lblk_t logical;
    ext4_lblk_t lleft;
    ext4_lblk_t lright;
    ext4_fsblk_t goal;
    ext4_fsblk_t pleft;
    ext4_fsblk_t pright;
    unsigned int flags;
};

struct ext4_attr {
    struct attribute attr;
    short int attr_id;
    short int attr_ptr;
    short unsigned int attr_size;
    union {
        int offset;
        void *explicit_ptr;
    } u;
};

struct ext4_group_info;

struct ext4_buddy {
    struct folio *bd_buddy_folio;
    void *bd_buddy;
    struct folio *bd_bitmap_folio;
    void *bd_bitmap;
    struct ext4_group_info *bd_info;
    struct super_block *bd_sb;
    __u16 bd_blkbits;
    ext4_group_t bd_group;
};

struct ext4_dir_entry {
    __le32 inode;
    __le16 rec_len;
    __le16 name_len;
    char name[255];
};

struct ext4_dir_entry_2 {
    __le32 inode;
    __le16 rec_len;
    __u8 name_len;
    __u8 file_type;
    char name[255];
};

struct ext4_dir_entry_hash {
    __le32 hash;
    __le32 minor_hash;
};

struct ext4_dir_entry_tail {
    __le32 det_reserved_zero1;
    __le16 det_rec_len;
    __u8 det_reserved_zero2;
    __u8 det_reserved_ft;
    __le32 det_checksum;
};

struct ext4_err_translation {
    int code;
    int errno;
};

struct ext4_es_stats {
    long unsigned int es_stats_shrunk;
    struct percpu_counter es_stats_cache_hits;
    struct percpu_counter es_stats_cache_misses;
    u64 es_stats_scan_time;
    u64 es_stats_max_scan_time;
    struct percpu_counter es_stats_all_cnt;
    struct percpu_counter es_stats_shk_cnt;
};

struct extent_status;

struct ext4_es_tree {
    struct rb_root root;
    struct extent_status *cache_es;
};

struct ext4_extent;

struct ext4_extent_idx;

struct ext4_extent_header;

struct ext4_ext_path {
    ext4_fsblk_t p_block;
    __u16 p_depth;
    __u16 p_maxdepth;
    struct ext4_extent *p_ext;
    struct ext4_extent_idx *p_idx;
    struct ext4_extent_header *p_hdr;
    struct buffer_head *p_bh;
};

struct ext4_extent {
    __le32 ee_block;
    __le16 ee_len;
    __le16 ee_start_hi;
    __le32 ee_start_lo;
};

struct ext4_extent_header {
    __le16 eh_magic;
    __le16 eh_entries;
    __le16 eh_max;
    __le16 eh_depth;
    __le32 eh_generation;
};

struct ext4_extent_idx {
    __le32 ei_block;
    __le32 ei_leaf_lo;
    __le16 ei_leaf_hi;
    __u16 ei_unused;
};

struct ext4_extent_tail {
    __le32 et_checksum;
};

struct ext4_fc_add_range {
    __le32 fc_ino;
    __u8 fc_ex[12];
};

struct ext4_fc_alloc_region {
    ext4_lblk_t lblk;
    ext4_fsblk_t pblk;
    int ino;
    int len;
};

struct ext4_fc_del_range {
    __le32 fc_ino;
    __le32 fc_lblk;
    __le32 fc_len;
};

struct ext4_fc_dentry_info {
    __le32 fc_parent_ino;
    __le32 fc_ino;
    __u8 fc_dname[0];
};

struct name_snapshot {
    struct qstr name;
    union shortname_store inline_name;
};

struct ext4_fc_dentry_update {
    int fcd_op;
    int fcd_parent;
    int fcd_ino;
    struct name_snapshot fcd_name;
    struct list_head fcd_list;
    struct list_head fcd_dilist;
};

struct ext4_fc_head {
    __le32 fc_features;
    __le32 fc_tid;
};

struct ext4_fc_inode {
    __le32 fc_ino;
    __u8 fc_raw_inode[0];
};

struct ext4_fc_replay_state {
    int fc_replay_num_tags;
    int fc_replay_expected_off;
    int fc_current_pass;
    int fc_cur_tag;
    int fc_crc;
    struct ext4_fc_alloc_region *fc_regions;
    int fc_regions_size;
    int fc_regions_used;
    int fc_regions_valid;
    int *fc_modified_inodes;
    int fc_modified_inodes_used;
    int fc_modified_inodes_size;
};

struct ext4_fc_stats {
    unsigned int fc_ineligible_reason_count[10];
    long unsigned int fc_num_commits;
    long unsigned int fc_ineligible_commits;
    long unsigned int fc_failed_commits;
    long unsigned int fc_skipped_commits;
    long unsigned int fc_numblks;
    u64 s_fc_avg_commit_time;
};

struct ext4_fc_tail {
    __le32 fc_tid;
    __le32 fc_crc;
};

struct ext4_fc_tl {
    __le16 fc_tag;
    __le16 fc_len;
};

struct ext4_fc_tl_mem {
    u16 fc_tag;
    u16 fc_len;
};

struct fscrypt_str {
    unsigned char *name;
    u32 len;
};

struct ext4_filename {
    const struct qstr *usr_fname;
    struct fscrypt_str disk_name;
    struct dx_hash_info hinfo;
    struct fscrypt_str crypto_buf;
    struct qstr cf_name;
};

struct ext4_free_data {
    struct list_head efd_list;
    struct rb_node efd_node;
    ext4_group_t efd_group;
    ext4_grpblk_t efd_start_cluster;
    ext4_grpblk_t efd_count;
    tid_t efd_tid;
};

union fscrypt_policy;

struct fscrypt_dummy_policy {
    const union fscrypt_policy *policy;
};

struct ext4_fs_context {
    char *s_qf_names[3];
    struct fscrypt_dummy_policy dummy_enc_policy;
    int s_jquota_fmt;
    short unsigned int qname_spec;
    long unsigned int vals_s_flags;
    long unsigned int mask_s_flags;
    long unsigned int journal_devnum;
    long unsigned int s_commit_interval;
    long unsigned int s_stripe;
    unsigned int s_inode_readahead_blks;
    unsigned int s_want_extra_isize;
    unsigned int s_li_wait_mult;
    unsigned int s_max_dir_size_kb;
    unsigned int journal_ioprio;
    unsigned int vals_s_mount_opt;
    unsigned int mask_s_mount_opt;
    unsigned int vals_s_mount_opt2;
    unsigned int mask_s_mount_opt2;
    unsigned int opt_flags;
    unsigned int spec;
    u32 s_max_batch_time;
    u32 s_min_batch_time;
    kuid_t s_resuid;
    kgid_t s_resgid;
    ext4_fsblk_t s_sb_block;
};

struct ext4_fsmap {
    struct list_head fmr_list;
    dev_t fmr_device;
    uint32_t fmr_flags;
    uint64_t fmr_physical;
    uint64_t fmr_owner;
    uint64_t fmr_length;
};

struct ext4_fsmap_head {
    uint32_t fmh_iflags;
    uint32_t fmh_oflags;
    unsigned int fmh_count;
    unsigned int fmh_entries;
    struct ext4_fsmap fmh_keys[2];
};

struct ext4_getfsmap_info;

struct ext4_getfsmap_dev {
    int (*gfd_fn)(struct super_block *, struct ext4_fsmap *, struct ext4_getfsmap_info *);
    u32 gfd_dev;
};

typedef int (*ext4_fsmap_format_t)(struct ext4_fsmap *, void *);

struct ext4_getfsmap_info {
    struct ext4_fsmap_head *gfi_head;
    ext4_fsmap_format_t gfi_formatter;
    void *gfi_format_arg;
    ext4_fsblk_t gfi_next_fsblk;
    u32 gfi_dev;
    ext4_group_t gfi_agno;
    struct ext4_fsmap gfi_low;
    struct ext4_fsmap gfi_high;
    struct ext4_fsmap gfi_lastfree;
    struct list_head gfi_meta_list;
    bool gfi_last;
};

struct ext4_group_desc {
    __le32 bg_block_bitmap_lo;
    __le32 bg_inode_bitmap_lo;
    __le32 bg_inode_table_lo;
    __le16 bg_free_blocks_count_lo;
    __le16 bg_free_inodes_count_lo;
    __le16 bg_used_dirs_count_lo;
    __le16 bg_flags;
    __le32 bg_exclude_bitmap_lo;
    __le16 bg_block_bitmap_csum_lo;
    __le16 bg_inode_bitmap_csum_lo;
    __le16 bg_itable_unused_lo;
    __le16 bg_checksum;
    __le32 bg_block_bitmap_hi;
    __le32 bg_inode_bitmap_hi;
    __le32 bg_inode_table_hi;
    __le16 bg_free_blocks_count_hi;
    __le16 bg_free_inodes_count_hi;
    __le16 bg_used_dirs_count_hi;
    __le16 bg_itable_unused_hi;
    __le32 bg_exclude_bitmap_hi;
    __le16 bg_block_bitmap_csum_hi;
    __le16 bg_inode_bitmap_csum_hi;
    __u32 bg_reserved;
};

struct ext4_group_info {
    long unsigned int bb_state;
    struct rb_root bb_free_root;
    ext4_grpblk_t bb_first_free;
    ext4_grpblk_t bb_free;
    ext4_grpblk_t bb_fragments;
    int bb_avg_fragment_size_order;
    ext4_grpblk_t bb_largest_free_order;
    ext4_group_t bb_group;
    struct list_head bb_prealloc_list;
    struct rw_semaphore alloc_sem;
    struct list_head bb_avg_fragment_size_node;
    struct list_head bb_largest_free_order_node;
    ext4_grpblk_t bb_counters[0];
};

struct ext4_iloc {
    struct buffer_head *bh;
    long unsigned int offset;
    ext4_group_t block_group;
};

struct ext4_inode {
    __le16 i_mode;
    __le16 i_uid;
    __le32 i_size_lo;
    __le32 i_atime;
    __le32 i_ctime;
    __le32 i_mtime;
    __le32 i_dtime;
    __le16 i_gid;
    __le16 i_links_count;
    __le32 i_blocks_lo;
    __le32 i_flags;
    union {
        struct {
            __le32 l_i_version;
        } linux1;
        struct {
            __u32 h_i_translator;
        } hurd1;
        struct {
            __u32 m_i_reserved1;
        } masix1;
    } osd1;
    __le32 i_block[15];
    __le32 i_generation;
    __le32 i_file_acl_lo;
    __le32 i_size_high;
    __le32 i_obso_faddr;
    union {
        struct {
            __le16 l_i_blocks_high;
            __le16 l_i_file_acl_high;
            __le16 l_i_uid_high;
            __le16 l_i_gid_high;
            __le16 l_i_checksum_lo;
            __le16 l_i_reserved;
        } linux2;
        struct {
            __le16 h_i_reserved1;
            __u16 h_i_mode_high;
            __u16 h_i_uid_high;
            __u16 h_i_gid_high;
            __u32 h_i_author;
        } hurd2;
        struct {
            __le16 h_i_reserved1;
            __le16 m_i_file_acl_high;
            __u32 m_i_reserved2[2];
        } masix2;
    } osd2;
    __le16 i_extra_isize;
    __le16 i_checksum_hi;
    __le32 i_ctime_extra;
    __le32 i_mtime_extra;
    __le32 i_atime_extra;
    __le32 i_crtime;
    __le32 i_crtime_extra;
    __le32 i_version_hi;
    __le32 i_projid;
};

struct ext4_pending_tree {
    struct rb_root root;
};

struct jbd2_inode;

struct ext4_inode_info {
    __le32 i_data[15];
    __u32 i_dtime;
    ext4_fsblk_t i_file_acl;
    ext4_group_t i_block_group;
    ext4_lblk_t i_dir_start_lookup;
    long unsigned int i_flags;
    struct rw_semaphore xattr_sem;
    union {
        struct list_head i_orphan;
        unsigned int i_orphan_idx;
    };
    struct list_head i_fc_dilist;
    struct list_head i_fc_list;
    ext4_lblk_t i_fc_lblk_start;
    ext4_lblk_t i_fc_lblk_len;
    atomic_t i_fc_updates;
    atomic_t i_unwritten;
    wait_queue_head_t i_fc_wait;
    struct mutex i_fc_lock;
    loff_t i_disksize;
    struct rw_semaphore i_data_sem;
    struct inode vfs_inode;
    struct jbd2_inode *jinode;
    spinlock_t i_raw_lock;
    struct timespec64 i_crtime;
    atomic_t i_prealloc_active;
    unsigned int i_reserved_data_blocks;
    struct rb_root i_prealloc_node;
    rwlock_t i_prealloc_lock;
    struct ext4_es_tree i_es_tree;
    rwlock_t i_es_lock;
    struct list_head i_es_list;
    unsigned int i_es_all_nr;
    unsigned int i_es_shk_nr;
    ext4_lblk_t i_es_shrink_lblk;
    ext4_group_t i_last_alloc_group;
    struct ext4_pending_tree i_pending_tree;
    __u16 i_extra_isize;
    u16 i_inline_off;
    u16 i_inline_size;
    qsize_t i_reserved_quota;
    spinlock_t i_completed_io_lock;
    struct list_head i_rsv_conversion_list;
    struct work_struct i_rsv_conversion_work;
    spinlock_t i_block_reservation_lock;
    tid_t i_sync_tid;
    tid_t i_datasync_tid;
    struct dquot *i_dquot[3];
    __u32 i_csum_seed;
    kprojid_t i_projid;
};

struct jbd2_journal_handle;

typedef struct jbd2_journal_handle handle_t;

struct ext4_io_end {
    struct list_head list;
    handle_t *handle;
    struct inode *inode;
    struct bio *bio;
    unsigned int flag;
    refcount_t count;
    struct list_head list_vec;
};

typedef struct ext4_io_end ext4_io_end_t;

struct ext4_io_end_vec {
    struct list_head list;
    loff_t offset;
    ssize_t size;
};

struct ext4_io_submit {
    struct writeback_control *io_wbc;
    struct bio *io_bio;
    ext4_io_end_t *io_end;
    sector_t io_next_block;
};

struct ext4_journal_cb_entry {
    struct list_head jce_list;
    void (*jce_func)(struct super_block *, struct ext4_journal_cb_entry *, int);
};

struct jbd2_buffer_trigger_type {
    void (*t_frozen)(struct jbd2_buffer_trigger_type *, struct buffer_head *, void *, size_t);
    void (*t_abort)(struct jbd2_buffer_trigger_type *, struct buffer_head *);
};

struct ext4_journal_trigger {
    struct jbd2_buffer_trigger_type tr_triggers;
    struct super_block *sb;
};

struct ext4_lazy_init {
    long unsigned int li_state;
    struct list_head li_request_list;
    struct mutex li_list_mtx;
};

struct ext4_li_request {
    struct super_block *lr_super;
    enum ext4_li_mode lr_mode;
    ext4_group_t lr_first_not_zeroed;
    ext4_group_t lr_next_group;
    struct list_head lr_request;
    long unsigned int lr_next_sched;
    long unsigned int lr_timeout;
};

struct ext4_locality_group {
    struct mutex lg_mutex;
    struct list_head lg_prealloc_list[10];
    spinlock_t lg_prealloc_lock;
};

struct ext4_map_blocks {
    ext4_fsblk_t m_pblk;
    ext4_lblk_t m_lblk;
    unsigned int m_len;
    unsigned int m_flags;
};

struct ext4_mount_options {
    long unsigned int s_mount_opt;
    long unsigned int s_mount_opt2;
    kuid_t s_resuid;
    kgid_t s_resgid;
    long unsigned int s_commit_interval;
    u32 s_min_batch_time;
    u32 s_max_batch_time;
    int s_jquota_fmt;
    char *s_qf_names[3];
};

struct ext4_new_group_data;

struct ext4_new_flex_group_data {
    struct ext4_new_group_data *groups;
    __u16 *bg_flags;
    ext4_group_t resize_bg;
    ext4_group_t count;
};

struct ext4_new_group_data {
    __u32 group;
    __u64 block_bitmap;
    __u64 inode_bitmap;
    __u64 inode_table;
    __u32 blocks_count;
    __u16 reserved_blocks;
    __u16 mdata_blocks;
    __u32 free_clusters_count;
};

struct ext4_new_group_input {
    __u32 group;
    __u64 block_bitmap;
    __u64 inode_bitmap;
    __u64 inode_table;
    __u32 blocks_count;
    __u16 reserved_blocks;
    __u16 unused;
};

struct ext4_orphan_block {
    atomic_t ob_free_entries;
    struct buffer_head *ob_bh;
};

struct ext4_orphan_block_tail {
    __le32 ob_magic;
    __le32 ob_checksum;
};

struct ext4_orphan_info {
    int of_blocks;
    __u32 of_csum_seed;
    struct ext4_orphan_block *of_binfo;
};

struct ext4_prealloc_space {
    union {
        struct rb_node inode_node;
        struct list_head lg_list;
    } pa_node;
    struct list_head pa_group_list;
    union {
        struct list_head pa_tmp_list;
        struct callback_head pa_rcu;
    } u;
    spinlock_t pa_lock;
    atomic_t pa_count;
    unsigned int pa_deleted;
    ext4_fsblk_t pa_pstart;
    ext4_lblk_t pa_lstart;
    ext4_grpblk_t pa_len;
    ext4_grpblk_t pa_free;
    short unsigned int pa_type;
    union {
        rwlock_t *inode_lock;
        spinlock_t *lg_lock;
    } pa_node_lock;
    struct inode *pa_inode;
};

struct ext4_rcu_ptr {
    struct callback_head rcu;
    void *ptr;
};

struct ext4_renament {
    struct inode *dir;
    struct dentry *dentry;
    struct inode *inode;
    bool is_dir;
    int dir_nlink_delta;
    struct buffer_head *bh;
    struct ext4_dir_entry_2 *de;
    int inlined;
    struct buffer_head *dir_bh;
    struct ext4_dir_entry_2 *parent_de;
    int dir_inlined;
};

struct ext4_sb_encodings {
    __u16 magic;
    char *name;
    unsigned int version;
};

struct rcu_sync {
    int gp_state;
    int gp_count;
    wait_queue_head_t gp_wait;
    struct callback_head cb_head;
};

struct percpu_rw_semaphore {
    struct rcu_sync rss;
    unsigned int *read_count;
    struct rcuwait writer;
    wait_queue_head_t waiters;
    atomic_t block;
};

struct ext4_super_block;

struct proc_dir_entry;

struct journal_s;

struct ext4_system_blocks;

struct flex_groups;

struct shrinker;

struct mb_cache;

struct ext4_sb_info {
    long unsigned int s_desc_size;
    long unsigned int s_inodes_per_block;
    long unsigned int s_blocks_per_group;
    long unsigned int s_clusters_per_group;
    long unsigned int s_inodes_per_group;
    long unsigned int s_itb_per_group;
    long unsigned int s_gdb_count;
    long unsigned int s_desc_per_block;
    ext4_group_t s_groups_count;
    ext4_group_t s_blockfile_groups;
    long unsigned int s_overhead;
    unsigned int s_cluster_ratio;
    unsigned int s_cluster_bits;
    loff_t s_bitmap_maxbytes;
    struct buffer_head *s_sbh;
    struct ext4_super_block *s_es;
    struct buffer_head **s_group_desc;
    unsigned int s_mount_opt;
    unsigned int s_mount_opt2;
    long unsigned int s_mount_flags;
    unsigned int s_def_mount_opt;
    unsigned int s_def_mount_opt2;
    ext4_fsblk_t s_sb_block;
    atomic64_t s_resv_clusters;
    kuid_t s_resuid;
    kgid_t s_resgid;
    short unsigned int s_mount_state;
    short unsigned int s_pad;
    int s_addr_per_block_bits;
    int s_desc_per_block_bits;
    int s_inode_size;
    int s_first_ino;
    unsigned int s_inode_readahead_blks;
    unsigned int s_inode_goal;
    u32 s_hash_seed[4];
    int s_def_hash_version;
    int s_hash_unsigned;
    struct percpu_counter s_freeclusters_counter;
    struct percpu_counter s_freeinodes_counter;
    struct percpu_counter s_dirs_counter;
    struct percpu_counter s_dirtyclusters_counter;
    struct percpu_counter s_sra_exceeded_retry_limit;
    struct blockgroup_lock *s_blockgroup_lock;
    struct proc_dir_entry *s_proc;
    struct kobject s_kobj;
    struct completion s_kobj_unregister;
    struct super_block *s_sb;
    struct buffer_head *s_mmp_bh;
    struct journal_s *s_journal;
    long unsigned int s_ext4_flags;
    struct mutex s_orphan_lock;
    struct list_head s_orphan;
    struct ext4_orphan_info s_orphan_info;
    long unsigned int s_commit_interval;
    u32 s_max_batch_time;
    u32 s_min_batch_time;
    struct file *s_journal_bdev_file;
    char *s_qf_names[3];
    int s_jquota_fmt;
    unsigned int s_want_extra_isize;
    struct ext4_system_blocks *s_system_blks;
    struct ext4_group_info ***s_group_info;
    struct inode *s_buddy_cache;
    spinlock_t s_md_lock;
    short unsigned int *s_mb_offsets;
    unsigned int *s_mb_maxs;
    unsigned int s_group_info_size;
    unsigned int s_mb_free_pending;
    struct list_head s_freed_data_list[2];
    struct list_head s_discard_list;
    struct work_struct s_discard_work;
    atomic_t s_retry_alloc_pending;
    struct list_head *s_mb_avg_fragment_size;
    rwlock_t *s_mb_avg_fragment_size_locks;
    struct list_head *s_mb_largest_free_orders;
    rwlock_t *s_mb_largest_free_orders_locks;
    long unsigned int s_stripe;
    unsigned int s_mb_max_linear_groups;
    unsigned int s_mb_stream_request;
    unsigned int s_mb_max_to_scan;
    unsigned int s_mb_min_to_scan;
    unsigned int s_mb_stats;
    unsigned int s_mb_order2_reqs;
    unsigned int s_mb_group_prealloc;
    unsigned int s_max_dir_size_kb;
    long unsigned int s_mb_last_group;
    long unsigned int s_mb_last_start;
    unsigned int s_mb_prefetch;
    unsigned int s_mb_prefetch_limit;
    unsigned int s_mb_best_avail_max_trim_order;
    atomic_t s_bal_reqs;
    atomic_t s_bal_success;
    atomic_t s_bal_allocated;
    atomic_t s_bal_ex_scanned;
    atomic_t s_bal_cX_ex_scanned[5];
    atomic_t s_bal_groups_scanned;
    atomic_t s_bal_goals;
    atomic_t s_bal_len_goals;
    atomic_t s_bal_breaks;
    atomic_t s_bal_2orders;
    atomic_t s_bal_p2_aligned_bad_suggestions;
    atomic_t s_bal_goal_fast_bad_suggestions;
    atomic_t s_bal_best_avail_bad_suggestions;
    atomic64_t s_bal_cX_groups_considered[5];
    atomic64_t s_bal_cX_hits[5];
    atomic64_t s_bal_cX_failed[5];
    atomic_t s_mb_buddies_generated;
    atomic64_t s_mb_generation_time;
    atomic_t s_mb_lost_chunks;
    atomic_t s_mb_preallocated;
    atomic_t s_mb_discarded;
    atomic_t s_lock_busy;
    struct ext4_locality_group *s_locality_groups;
    long unsigned int s_sectors_written_start;
    u64 s_kbytes_written;
    unsigned int s_extent_max_zeroout_kb;
    unsigned int s_log_groups_per_flex;
    struct flex_groups **s_flex_groups;
    ext4_group_t s_flex_groups_allocated;
    struct workqueue_struct *rsv_conversion_wq;
    struct timer_list s_err_report;
    struct ext4_li_request *s_li_request;
    unsigned int s_li_wait_mult;
    struct task_struct *s_mmp_tsk;
    long unsigned int s_last_trim_minblks;
    __u32 s_csum_seed;
    struct shrinker *s_es_shrinker;
    struct list_head s_es_list;
    long int s_es_nr_inode;
    struct ext4_es_stats s_es_stats;
    struct mb_cache *s_ea_block_cache;
    struct mb_cache *s_ea_inode_cache;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    spinlock_t s_es_lock;
    struct ext4_journal_trigger s_journal_triggers[1];
    struct ratelimit_state s_err_ratelimit_state;
    struct ratelimit_state s_warning_ratelimit_state;
    struct ratelimit_state s_msg_ratelimit_state;
    atomic_t s_warning_count;
    atomic_t s_msg_count;
    struct fscrypt_dummy_policy s_dummy_enc_policy;
    struct percpu_rw_semaphore s_writepages_rwsem;
    struct dax_device *s_daxdev;
    u64 s_dax_part_off;
    errseq_t s_bdev_wb_err;
    spinlock_t s_bdev_wb_lock;
    spinlock_t s_error_lock;
    int s_add_error_count;
    int s_first_error_code;
    __u32 s_first_error_line;
    __u32 s_first_error_ino;
    __u64 s_first_error_block;
    const char *s_first_error_func;
    time64_t s_first_error_time;
    int s_last_error_code;
    __u32 s_last_error_line;
    __u32 s_last_error_ino;
    __u64 s_last_error_block;
    const char *s_last_error_func;
    time64_t s_last_error_time;
    struct work_struct s_sb_upd_work;
    unsigned int s_awu_min;
    unsigned int s_awu_max;
    atomic_t s_fc_subtid;
    struct list_head s_fc_q[2];
    struct list_head s_fc_dentry_q[2];
    unsigned int s_fc_bytes;
    spinlock_t s_fc_lock;
    struct buffer_head *s_fc_bh;
    struct ext4_fc_stats s_fc_stats;
    tid_t s_fc_ineligible_tid;
    struct ext4_fc_replay_state s_fc_replay_state;
};

struct ext4_super_block {
    __le32 s_inodes_count;
    __le32 s_blocks_count_lo;
    __le32 s_r_blocks_count_lo;
    __le32 s_free_blocks_count_lo;
    __le32 s_free_inodes_count;
    __le32 s_first_data_block;
    __le32 s_log_block_size;
    __le32 s_log_cluster_size;
    __le32 s_blocks_per_group;
    __le32 s_clusters_per_group;
    __le32 s_inodes_per_group;
    __le32 s_mtime;
    __le32 s_wtime;
    __le16 s_mnt_count;
    __le16 s_max_mnt_count;
    __le16 s_magic;
    __le16 s_state;
    __le16 s_errors;
    __le16 s_minor_rev_level;
    __le32 s_lastcheck;
    __le32 s_checkinterval;
    __le32 s_creator_os;
    __le32 s_rev_level;
    __le16 s_def_resuid;
    __le16 s_def_resgid;
    __le32 s_first_ino;
    __le16 s_inode_size;
    __le16 s_block_group_nr;
    __le32 s_feature_compat;
    __le32 s_feature_incompat;
    __le32 s_feature_ro_compat;
    __u8 s_uuid[16];
    char s_volume_name[16];
    char s_last_mounted[64];
    __le32 s_algorithm_usage_bitmap;
    __u8 s_prealloc_blocks;
    __u8 s_prealloc_dir_blocks;
    __le16 s_reserved_gdt_blocks;
    __u8 s_journal_uuid[16];
    __le32 s_journal_inum;
    __le32 s_journal_dev;
    __le32 s_last_orphan;
    __le32 s_hash_seed[4];
    __u8 s_def_hash_version;
    __u8 s_jnl_backup_type;
    __le16 s_desc_size;
    __le32 s_default_mount_opts;
    __le32 s_first_meta_bg;
    __le32 s_mkfs_time;
    __le32 s_jnl_blocks[17];
    __le32 s_blocks_count_hi;
    __le32 s_r_blocks_count_hi;
    __le32 s_free_blocks_count_hi;
    __le16 s_min_extra_isize;
    __le16 s_want_extra_isize;
    __le32 s_flags;
    __le16 s_raid_stride;
    __le16 s_mmp_update_interval;
    __le64 s_mmp_block;
    __le32 s_raid_stripe_width;
    __u8 s_log_groups_per_flex;
    __u8 s_checksum_type;
    __u8 s_encryption_level;
    __u8 s_reserved_pad;
    __le64 s_kbytes_written;
    __le32 s_snapshot_inum;
    __le32 s_snapshot_id;
    __le64 s_snapshot_r_blocks_count;
    __le32 s_snapshot_list;
    __le32 s_error_count;
    __le32 s_first_error_time;
    __le32 s_first_error_ino;
    __le64 s_first_error_block;
    __u8 s_first_error_func[32];
    __le32 s_first_error_line;
    __le32 s_last_error_time;
    __le32 s_last_error_ino;
    __le32 s_last_error_line;
    __le64 s_last_error_block;
    __u8 s_last_error_func[32];
    __u8 s_mount_opts[64];
    __le32 s_usr_quota_inum;
    __le32 s_grp_quota_inum;
    __le32 s_overhead_clusters;
    __le32 s_backup_bgs[2];
    __u8 s_encrypt_algos[4];
    __u8 s_encrypt_pw_salt[16];
    __le32 s_lpf_ino;
    __le32 s_prj_quota_inum;
    __le32 s_checksum_seed;
    __u8 s_wtime_hi;
    __u8 s_mtime_hi;
    __u8 s_mkfs_time_hi;
    __u8 s_lastcheck_hi;
    __u8 s_first_error_time_hi;
    __u8 s_last_error_time_hi;
    __u8 s_first_error_errcode;
    __u8 s_last_error_errcode;
    __le16 s_encoding;
    __le16 s_encoding_flags;
    __le32 s_orphan_file_inum;
    __le32 s_reserved[94];
    __le32 s_checksum;
};

struct ext4_system_blocks {
    struct rb_root root;
    struct callback_head rcu;
};

struct ext4_system_zone {
    struct rb_node node;
    ext4_fsblk_t start_blk;
    unsigned int count;
    u32 ino;
};

struct ext4_xattr_entry;

struct ext4_xattr_search {
    struct ext4_xattr_entry *first;
    void *base;
    void *end;
    struct ext4_xattr_entry *here;
    int not_found;
};

struct ext4_xattr_block_find {
    struct ext4_xattr_search s;
    struct buffer_head *bh;
};

struct ext4_xattr_entry {
    __u8 e_name_len;
    __u8 e_name_index;
    __le16 e_value_offs;
    __le32 e_value_inum;
    __le32 e_value_size;
    __le32 e_hash;
    char e_name[0];
};

struct ext4_xattr_header {
    __le32 h_magic;
    __le32 h_refcount;
    __le32 h_blocks;
    __le32 h_hash;
    __le32 h_checksum;
    __u32 h_reserved[3];
};

struct ext4_xattr_ibody_find {
    struct ext4_xattr_search s;
    struct ext4_iloc iloc;
};

struct ext4_xattr_ibody_header {
    __le32 h_magic;
};

struct ext4_xattr_info {
    const char *name;
    const void *value;
    size_t value_len;
    int name_index;
    int in_inode;
};

struct ext4_xattr_inode_array {
    unsigned int count;
    struct inode *inodes[0];
};

struct ext_arg {
    size_t argsz;
    struct timespec64 ts;
    const sigset_t *sig;
    ktime_t min_time;
    bool ts_set;
};

struct msg_msg;

struct ext_wait_queue {
    struct task_struct *task;
    struct list_head list;
    struct msg_msg *msg;
    int state;
};

union extcon_property_value {
    int intval;
};

struct extcon_dev;

struct extcon_cable {
    struct extcon_dev *edev;
    int cable_index;
    struct attribute_group attr_g;
    struct device_attribute attr_name;
    struct device_attribute attr_state;
    struct attribute *attrs[3];
    union extcon_property_value usb_propval[3];
    union extcon_property_value chg_propval[1];
    union extcon_property_value jack_propval[1];
    union extcon_property_value disp_propval[2];
    long unsigned int usb_bits[1];
    long unsigned int chg_bits[1];
    long unsigned int jack_bits[1];
    long unsigned int disp_bits[1];
};

struct extcon_dev {
    const char *name;
    const unsigned int *supported_cable;
    const u32 *mutually_exclusive;
    struct device dev;
    unsigned int id;
    struct raw_notifier_head nh_all;
    struct raw_notifier_head *nh;
    struct list_head entry;
    int max_supported;
    spinlock_t lock;
    u32 state;
    struct device_type extcon_dev_type;
    struct extcon_cable *cables;
    struct attribute_group attr_g_muex;
    struct attribute **attrs_muex;
    struct device_attribute *d_attrs_muex;
};

struct extcon_dev_notifier_devres {
    struct extcon_dev *edev;
    unsigned int id;
    struct notifier_block *nb;
};

struct extent_status {
    struct rb_node rb_node;
    ext4_lblk_t es_lblk;
    ext4_lblk_t es_len;
    ext4_fsblk_t es_pblk;
};

struct external_name {
    atomic_t count;
    struct callback_head head;
    unsigned char name[0];
};

struct extra_context {
    struct _aarch64_ctx head;
    __u64 datap;
    __u32 size;
    __u32 __reserved[3];
};

struct f_owner_ex {
    int type;
    __kernel_pid_t pid;
};

struct fan_fsid {
    struct super_block *sb;
    __kernel_fsid_t id;
    bool weak;
};

struct fsnotify_event {
    struct list_head list;
};

struct fanotify_event {
    struct fsnotify_event fse;
    struct hlist_node merge_list;
    u32 mask;
    struct {
        unsigned int type: 3;
        unsigned int hash: 29;
    };
    struct pid *pid;
};

struct fanotify_fh {
    u8 type;
    u8 len;
    u8 flags;
    u8 pad;
    unsigned char buf[0];
};

struct fanotify_error_event {
    struct fanotify_event fae;
    s32 error;
    u32 err_count;
    __kernel_fsid_t fsid;
    struct {
        struct fanotify_fh object_fh;
        unsigned char _inline_fh_buf[128];
    };
};

struct fanotify_event_info_header {
    __u8 info_type;
    __u8 pad;
    __u16 len;
};

struct fanotify_event_info_error {
    struct fanotify_event_info_header hdr;
    __s32 error;
    __u32 error_count;
};

struct fanotify_event_info_fid {
    struct fanotify_event_info_header hdr;
    __kernel_fsid_t fsid;
    unsigned char handle[0];
};

struct fanotify_event_info_pidfd {
    struct fanotify_event_info_header hdr;
    __s32 pidfd;
};

struct fanotify_event_info_range {
    struct fanotify_event_info_header hdr;
    __u32 pad;
    __u64 offset;
    __u64 count;
};

struct fanotify_event_metadata {
    __u32 event_len;
    __u8 vers;
    __u8 reserved;
    __u16 metadata_len;
    __u64 mask;
    __s32 fd;
    __s32 pid;
};

struct fanotify_fid_event {
    struct fanotify_event fae;
    __kernel_fsid_t fsid;
    struct {
        struct fanotify_fh object_fh;
        unsigned char _inline_fh_buf[12];
    };
};

struct fanotify_group_private_data {
    struct hlist_head *merge_hash;
    struct list_head access_list;
    wait_queue_head_t access_waitq;
    int flags;
    int f_flags;
    struct ucounts *ucounts;
    mempool_t error_events_pool;
};

struct fanotify_info {
    u8 dir_fh_totlen;
    u8 dir2_fh_totlen;
    u8 file_fh_totlen;
    u8 name_len;
    u8 name2_len;
    u8 pad[3];
    unsigned char buf[0];
};

struct fanotify_mark {
    struct fsnotify_mark fsn_mark;
    __kernel_fsid_t fsid;
};

struct fanotify_name_event {
    struct fanotify_event fae;
    __kernel_fsid_t fsid;
    struct fanotify_info info;
};

struct fanotify_path_event {
    struct fanotify_event fae;
    struct path path;
};

struct fanotify_response_info_header {
    __u8 type;
    __u8 pad;
    __u16 len;
};

struct fanotify_response_info_audit_rule {
    struct fanotify_response_info_header hdr;
    __u32 rule_number;
    __u32 subj_trust;
    __u32 obj_trust;
};

struct fanotify_perm_event {
    struct fanotify_event fae;
    struct path path;
    const loff_t *ppos;
    size_t count;
    u32 response;
    short unsigned int state;
    int fd;
    union {
        struct fanotify_response_info_header hdr;
        struct fanotify_response_info_audit_rule audit_rule;
    };
};

struct fanotify_response {
    __s32 fd;
    __u32 response;
};

struct fanout_args {
    __u16 id;
    __u16 type_flags;
    __u32 max_num_members;
};

struct fast_pool {
    long unsigned int pool[4];
    long unsigned int last;
    unsigned int count;
    struct timer_list mix;
};

struct request_sock;

struct tcp_fastopen_context;

struct fastopen_queue {
    struct request_sock *rskq_rst_head;
    struct request_sock *rskq_rst_tail;
    spinlock_t lock;
    int qlen;
    int max_qlen;
    struct tcp_fastopen_context *ctx;
};

struct fasync_struct {
    rwlock_t fa_lock;
    int magic;
    int fa_fd;
    struct fasync_struct *fa_next;
    struct file *fa_file;
    struct callback_head fa_rcu;
};

struct fat_bios_param_block {
    u16 fat_sector_size;
    u8 fat_sec_per_clus;
    u16 fat_reserved;
    u8 fat_fats;
    u16 fat_dir_entries;
    u16 fat_sectors;
    u16 fat_fat_length;
    u32 fat_total_sect;
    u8 fat16_state;
    u32 fat16_vol_id;
    u32 fat32_length;
    u32 fat32_root_cluster;
    u16 fat32_info_sector;
    u8 fat32_state;
    u32 fat32_vol_id;
};

struct fat_boot_fsinfo {
    __le32 signature1;
    __le32 reserved1[120];
    __le32 signature2;
    __le32 free_clusters;
    __le32 next_cluster;
    __le32 reserved2[4];
};

struct fat_boot_sector {
    __u8 ignored[3];
    __u8 system_id[8];
    __u8 sector_size[2];
    __u8 sec_per_clus;
    __le16 reserved;
    __u8 fats;
    __u8 dir_entries[2];
    __u8 sectors[2];
    __u8 media;
    __le16 fat_length;
    __le16 secs_track;
    __le16 heads;
    __le32 hidden;
    __le32 total_sect;
    union {
        struct {
            __u8 drive_number;
            __u8 state;
            __u8 signature;
            __u8 vol_id[4];
            __u8 vol_label[11];
            __u8 fs_type[8];
        } fat16;
        struct {
            __le32 length;
            __le16 flags;
            __u8 version[2];
            __le32 root_cluster;
            __le16 info_sector;
            __le16 backup_boot;
            __le16 reserved2[6];
            __u8 drive_number;
            __u8 state;
            __u8 signature;
            __u8 vol_id[4];
            __u8 vol_label[11];
            __u8 fs_type[8];
        } fat32;
    };
};

struct fat_cache {
    struct list_head cache_list;
    int nr_contig;
    int fcluster;
    int dcluster;
};

struct fat_cache_id {
    unsigned int id;
    int nr_contig;
    int fcluster;
    int dcluster;
};

struct fat_entry {
    int entry;
    union {
        u8 *ent12_p[2];
        __le16 *ent16_p;
        __le32 *ent32_p;
    } u;
    int nr_bhs;
    struct buffer_head *bhs[2];
    struct inode *fat_inode;
};

struct fat_fid {
    u32 i_gen;
    u32 i_pos_low;
    u16 i_pos_hi;
    u16 parent_i_pos_hi;
    u32 parent_i_pos_low;
    u32 parent_i_gen;
};

struct fat_floppy_defaults {
    unsigned int nr_sectors;
    unsigned int sec_per_clus;
    unsigned int dir_entries;
    unsigned int media;
    unsigned int fat_length;
};

struct fat_ioctl_filldir_callback {
    struct dir_context ctx;
    void *dirent;
    int result;
    const char *longname;
    int long_len;
    const char *shortname;
    int short_len;
};

struct fat_mount_options {
    kuid_t fs_uid;
    kgid_t fs_gid;
    short unsigned int fs_fmask;
    short unsigned int fs_dmask;
    short unsigned int codepage;
    int time_offset;
    char *iocharset;
    short unsigned int shortname;
    unsigned char name_check;
    unsigned char errors;
    unsigned char nfs;
    short unsigned int allow_utime;
    unsigned int quiet: 1;
    unsigned int showexec: 1;
    unsigned int sys_immutable: 1;
    unsigned int dotsOK: 1;
    unsigned int isvfat: 1;
    unsigned int utf8: 1;
    unsigned int unicode_xlate: 1;
    unsigned int numtail: 1;
    unsigned int flush: 1;
    unsigned int nocase: 1;
    unsigned int usefree: 1;
    unsigned int tz_set: 1;
    unsigned int rodir: 1;
    unsigned int discard: 1;
    unsigned int dos1xfloppy: 1;
    unsigned int debug: 1;
};

struct msdos_dir_entry;

struct fat_slot_info {
    loff_t i_pos;
    loff_t slot_off;
    int nr_slots;
    struct msdos_dir_entry *de;
    struct buffer_head *bh;
};

struct fatent_operations {
    void (*ent_blocknr)(struct super_block *, int, int *, sector_t *);
    void (*ent_set_ptr)(struct fat_entry *, int);
    int (*ent_bread)(struct super_block *, struct fat_entry *, int, sector_t);
    int (*ent_get)(struct fat_entry *);
    void (*ent_put)(struct fat_entry *, int);
    int (*ent_next)(struct fat_entry *);
};

struct fatent_ra {
    sector_t cur;
    sector_t limit;
    unsigned int ra_blocks;
    sector_t ra_advance;
    sector_t ra_next;
    sector_t ra_limit;
};

struct fault_info {
    int (*fn)(long unsigned int, long unsigned int, struct pt_regs *);
    int sig;
    int code;
    const char *name;
};

struct faux_device {
    struct device dev;
};

struct faux_device_ops {
    int (*probe)(struct faux_device *);
    void (*remove)(struct faux_device *);
};

struct faux_object {
    struct faux_device faux_dev;
    const struct faux_device_ops *faux_ops;
};

struct fb_bitfield {
    __u32 offset;
    __u32 length;
    __u32 msb_right;
};

struct fb_blit_caps {
    long unsigned int x[1];
    long unsigned int y[2];
    u32 len;
    u32 flags;
};

struct fb_chroma {
    __u32 redx;
    __u32 greenx;
    __u32 bluex;
    __u32 whitex;
    __u32 redy;
    __u32 greeny;
    __u32 bluey;
    __u32 whitey;
};

struct fb_cmap {
    __u32 start;
    __u32 len;
    __u16 *red;
    __u16 *green;
    __u16 *blue;
    __u16 *transp;
};

struct fb_cmap32 {
    u32 start;
    u32 len;
    compat_caddr_t red;
    compat_caddr_t green;
    compat_caddr_t blue;
    compat_caddr_t transp;
};

struct fb_cmap_user {
    __u32 start;
    __u32 len;
    __u16 *red;
    __u16 *green;
    __u16 *blue;
    __u16 *transp;
};

struct fb_con2fbmap {
    __u32 console;
    __u32 framebuffer;
};

struct fb_copyarea {
    __u32 dx;
    __u32 dy;
    __u32 width;
    __u32 height;
    __u32 sx;
    __u32 sy;
};

struct fbcurpos {
    __u16 x;
    __u16 y;
};

struct fb_image {
    __u32 dx;
    __u32 dy;
    __u32 width;
    __u32 height;
    __u32 fg_color;
    __u32 bg_color;
    __u8 depth;
    const char *data;
    struct fb_cmap cmap;
};

struct fb_cursor {
    __u16 set;
    __u16 enable;
    __u16 rop;
    const char *mask;
    struct fbcurpos hot;
    struct fb_image image;
};

struct fb_cvt_data {
    u32 xres;
    u32 yres;
    u32 refresh;
    u32 f_refresh;
    u32 pixclock;
    u32 hperiod;
    u32 hblank;
    u32 hfreq;
    u32 htotal;
    u32 vtotal;
    u32 vsync;
    u32 hsync;
    u32 h_front_porch;
    u32 h_back_porch;
    u32 v_front_porch;
    u32 v_back_porch;
    u32 h_margin;
    u32 v_margin;
    u32 interlace;
    u32 aspect_ratio;
    u32 active_pixels;
    u32 flags;
    u32 status;
};

struct fb_info;

struct fb_deferred_io {
    long unsigned int delay;
    bool sort_pagereflist;
    int open_count;
    struct mutex lock;
    struct list_head pagereflist;
    struct page * (*get_page)(struct fb_info *, long unsigned int);
    void (*deferred_io)(struct fb_info *, struct list_head *);
};

struct fb_deferred_io_pageref {
    struct page *page;
    long unsigned int offset;
    struct list_head list;
};

struct fb_event {
    struct fb_info *info;
    void *data;
};

struct fb_fillrect {
    __u32 dx;
    __u32 dy;
    __u32 width;
    __u32 height;
    __u32 color;
    __u32 rop;
};

struct fb_fix_screeninfo {
    char id[16];
    long unsigned int smem_start;
    __u32 smem_len;
    __u32 type;
    __u32 type_aux;
    __u32 visual;
    __u16 xpanstep;
    __u16 ypanstep;
    __u16 ywrapstep;
    __u32 line_length;
    long unsigned int mmio_start;
    __u32 mmio_len;
    __u32 accel;
    __u16 capabilities;
    __u16 reserved[2];
};

struct fb_fix_screeninfo32 {
    char id[16];
    compat_caddr_t smem_start;
    u32 smem_len;
    u32 type;
    u32 type_aux;
    u32 visual;
    u16 xpanstep;
    u16 ypanstep;
    u16 ywrapstep;
    u32 line_length;
    compat_caddr_t mmio_start;
    u32 mmio_len;
    u32 accel;
    u16 reserved[3];
};

struct fb_var_screeninfo {
    __u32 xres;
    __u32 yres;
    __u32 xres_virtual;
    __u32 yres_virtual;
    __u32 xoffset;
    __u32 yoffset;
    __u32 bits_per_pixel;
    __u32 grayscale;
    struct fb_bitfield red;
    struct fb_bitfield green;
    struct fb_bitfield blue;
    struct fb_bitfield transp;
    __u32 nonstd;
    __u32 activate;
    __u32 height;
    __u32 width;
    __u32 accel_flags;
    __u32 pixclock;
    __u32 left_margin;
    __u32 right_margin;
    __u32 upper_margin;
    __u32 lower_margin;
    __u32 hsync_len;
    __u32 vsync_len;
    __u32 sync;
    __u32 vmode;
    __u32 rotate;
    __u32 colorspace;
    __u32 reserved[4];
};

struct fb_monspecs {
    struct fb_chroma chroma;
    struct fb_videomode *modedb;
    __u8 manufacturer[4];
    __u8 monitor[14];
    __u8 serial_no[14];
    __u8 ascii[14];
    __u32 modedb_len;
    __u32 model;
    __u32 serial;
    __u32 year;
    __u32 week;
    __u32 hfmin;
    __u32 hfmax;
    __u32 dclkmin;
    __u32 dclkmax;
    __u16 input;
    __u16 dpms;
    __u16 signal;
    __u16 vfmin;
    __u16 vfmax;
    __u16 gamma;
    __u16 gtf: 1;
    __u16 misc;
    __u8 version;
    __u8 revision;
    __u8 max_x;
    __u8 max_y;
};

struct fb_pixmap {
    u8 *addr;
    u32 size;
    u32 offset;
    u32 buf_align;
    u32 scan_align;
    u32 access_align;
    u32 flags;
    long unsigned int blit_x[1];
    long unsigned int blit_y[2];
    void (*writeio)(struct fb_info *, void *, void *, unsigned int);
    void (*readio)(struct fb_info *, void *, void *, unsigned int);
};

struct lcd_device;

struct fb_ops;

struct fb_tile_ops;

struct fb_info {
    refcount_t count;
    int node;
    int flags;
    int fbcon_rotate_hint;
    struct mutex lock;
    struct mutex mm_lock;
    struct fb_var_screeninfo var;
    struct fb_fix_screeninfo fix;
    struct fb_monspecs monspecs;
    struct fb_pixmap pixmap;
    struct fb_pixmap sprite;
    struct fb_cmap cmap;
    struct list_head modelist;
    struct fb_videomode *mode;
    struct backlight_device *bl_dev;
    struct mutex bl_curve_mutex;
    u8 bl_curve[128];
    struct lcd_device *lcd_dev;
    struct delayed_work deferred_work;
    long unsigned int npagerefs;
    struct fb_deferred_io_pageref *pagerefs;
    struct fb_deferred_io *fbdefio;
    const struct fb_ops *fbops;
    struct device *device;
    struct device *dev;
    int class_flag;
    struct fb_tile_ops *tileops;
    union {
        char *screen_base;
        char *screen_buffer;
    };
    long unsigned int screen_size;
    void *pseudo_palette;
    u32 state;
    void *fbcon_par;
    void *par;
    bool skip_vt_switch;
    bool skip_panic;
    bool custom_fb_num;
};

struct fb_videomode {
    const char *name;
    u32 refresh;
    u32 xres;
    u32 yres;
    u32 pixclock;
    u32 left_margin;
    u32 right_margin;
    u32 upper_margin;
    u32 lower_margin;
    u32 hsync_len;
    u32 vsync_len;
    u32 sync;
    u32 vmode;
    u32 flag;
};

struct fb_modelist {
    struct list_head list;
    struct fb_videomode mode;
};

struct fb_ops {
    struct module *owner;
    int (*fb_open)(struct fb_info *, int);
    int (*fb_release)(struct fb_info *, int);
    ssize_t (*fb_read)(struct fb_info *, char *, size_t, loff_t *);
    ssize_t (*fb_write)(struct fb_info *, const char *, size_t, loff_t *);
    int (*fb_check_var)(struct fb_var_screeninfo *, struct fb_info *);
    int (*fb_set_par)(struct fb_info *);
    int (*fb_setcolreg)(unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, struct fb_info *);
    int (*fb_setcmap)(struct fb_cmap *, struct fb_info *);
    int (*fb_blank)(int, struct fb_info *);
    int (*fb_pan_display)(struct fb_var_screeninfo *, struct fb_info *);
    void (*fb_fillrect)(struct fb_info *, const struct fb_fillrect *);
    void (*fb_copyarea)(struct fb_info *, const struct fb_copyarea *);
    void (*fb_imageblit)(struct fb_info *, const struct fb_image *);
    int (*fb_cursor)(struct fb_info *, struct fb_cursor *);
    int (*fb_sync)(struct fb_info *);
    int (*fb_ioctl)(struct fb_info *, unsigned int, long unsigned int);
    int (*fb_compat_ioctl)(struct fb_info *, unsigned int, long unsigned int);
    int (*fb_mmap)(struct fb_info *, struct vm_area_struct *);
    void (*fb_get_caps)(struct fb_info *, struct fb_blit_caps *, struct fb_var_screeninfo *);
    void (*fb_destroy)(struct fb_info *);
    int (*fb_debug_enter)(struct fb_info *);
    int (*fb_debug_leave)(struct fb_info *);
};

struct fb_tilemap;

struct fb_tilearea;

struct fb_tilerect;

struct fb_tileblit;

struct fb_tilecursor;

struct fb_tile_ops {
    void (*fb_settile)(struct fb_info *, struct fb_tilemap *);
    void (*fb_tilecopy)(struct fb_info *, struct fb_tilearea *);
    void (*fb_tilefill)(struct fb_info *, struct fb_tilerect *);
    void (*fb_tileblit)(struct fb_info *, struct fb_tileblit *);
    void (*fb_tilecursor)(struct fb_info *, struct fb_tilecursor *);
    int (*fb_get_tilemax)(struct fb_info *);
};

struct fb_tilearea {
    __u32 sx;
    __u32 sy;
    __u32 dx;
    __u32 dy;
    __u32 width;
    __u32 height;
};

struct fb_tileblit {
    __u32 sx;
    __u32 sy;
    __u32 width;
    __u32 height;
    __u32 fg;
    __u32 bg;
    __u32 length;
    __u32 *indices;
};

struct fb_tilecursor {
    __u32 sx;
    __u32 sy;
    __u32 mode;
    __u32 shape;
    __u32 fg;
    __u32 bg;
};

struct fb_tilemap {
    __u32 width;
    __u32 height;
    __u32 depth;
    __u32 length;
    const __u8 *data;
};

struct fb_tilerect {
    __u32 sx;
    __u32 sy;
    __u32 width;
    __u32 height;
    __u32 index;
    __u32 fg;
    __u32 bg;
    __u32 rop;
};

struct fbcon_display {
    const u_char *fontdata;
    int userfont;
    u_short inverse;
    short int yscroll;
    int vrows;
    int cursor_shape;
    int con_rotate;
    u32 xres_virtual;
    u32 yres_virtual;
    u32 height;
    u32 width;
    u32 bits_per_pixel;
    u32 grayscale;
    u32 nonstd;
    u32 accel_flags;
    u32 rotate;
    struct fb_bitfield red;
    struct fb_bitfield green;
    struct fb_bitfield blue;
    struct fb_bitfield transp;
    const struct fb_videomode *mode;
};

struct fbcon_ops {
    void (*bmove)(struct vc_data *, struct fb_info *, int, int, int, int, int, int);
    void (*clear)(struct vc_data *, struct fb_info *, int, int, int, int);
    void (*putcs)(struct vc_data *, struct fb_info *, const short unsigned int *, int, int, int, int, int);
    void (*clear_margins)(struct vc_data *, struct fb_info *, int, int);
    void (*cursor)(struct vc_data *, struct fb_info *, bool, int, int);
    int (*update_start)(struct fb_info *);
    int (*rotate_font)(struct fb_info *, struct vc_data *);
    struct fb_var_screeninfo var;
    struct delayed_work cursor_work;
    struct fb_cursor cursor_state;
    struct fbcon_display *p;
    struct fb_info *info;
    int currcon;
    int cur_blink_jiffies;
    int cursor_flash;
    int cursor_reset;
    int blank_state;
    int graphics;
    int save_graphics;
    bool initialized;
    int rotate;
    int cur_rotate;
    char *cursor_data;
    u8 *fontbuffer;
    u8 *fontdata;
    u8 *cursor_src;
    u32 cursor_size;
    u32 fd_size;
};

struct fc_log {
    refcount_t usage;
    u8 head;
    u8 tail;
    u8 need_free;
    struct module *owner;
    char *buffer[8];
};

struct fd {
    long unsigned int word;
};

typedef struct fd class_fd_pos_t;

typedef struct fd class_fd_raw_t;

typedef struct fd class_fd_t;

struct fd_data {
    fmode_t mode;
    unsigned int fd;
};

struct fd_range {
    unsigned int from;
    unsigned int to;
};

struct fdt_errtabent {
    const char *str;
};

struct fdt_header {
    fdt32_t magic;
    fdt32_t totalsize;
    fdt32_t off_dt_struct;
    fdt32_t off_dt_strings;
    fdt32_t off_mem_rsvmap;
    fdt32_t version;
    fdt32_t last_comp_version;
    fdt32_t boot_cpuid_phys;
    fdt32_t size_dt_strings;
    fdt32_t size_dt_struct;
};

struct fdt_node_header {
    fdt32_t tag;
    char name[0];
};

struct fdt_property {
    fdt32_t tag;
    fdt32_t len;
    fdt32_t nameoff;
    char data[0];
};

struct fdt_reserve_entry {
    fdt64_t address;
    fdt64_t size;
};

struct fdtable {
    unsigned int max_fds;
    struct file **fd;
    long unsigned int *close_on_exec;
    long unsigned int *open_fds;
    long unsigned int *full_fds_bits;
    struct callback_head rcu;
};

struct features_reply_data {
    struct ethnl_reply_data base;
    u32 hw[2];
    u32 wanted[2];
    u32 active[2];
    u32 nochange[2];
    u32 all[2];
};

struct fec_stat_grp {
    u64 stats[9];
    u8 cnt;
};

struct fec_reply_data {
    struct ethnl_reply_data base;
    long unsigned int fec_link_modes[2];
    u32 active_fec;
    u8 fec_auto;
    struct fec_stat_grp corr;
    struct fec_stat_grp uncorr;
    struct fec_stat_grp corr_bits;
};

struct fentry_trace_entry_head {
    struct trace_entry ent;
    long unsigned int ip;
};

struct fetch_insn {
    enum fetch_op op;
    union {
        unsigned int param;
        struct {
            unsigned int size;
            int offset;
        };
        struct {
            unsigned char basesize;
            unsigned char lshift;
            unsigned char rshift;
        };
        long unsigned int immediate;
        void *data;
    };
};

struct trace_seq;

typedef int (*print_type_func_t)(struct trace_seq *, void *, void *);

struct fetch_type {
    const char *name;
    size_t size;
    bool is_signed;
    bool is_string;
    print_type_func_t print;
    const char *fmt;
    const char *fmttype;
};

struct fexit_trace_entry_head {
    struct trace_entry ent;
    long unsigned int func;
    long unsigned int ret_ip;
};

struct ff_condition_effect {
    __u16 right_saturation;
    __u16 left_saturation;
    __s16 right_coeff;
    __s16 left_coeff;
    __u16 deadband;
    __s16 center;
};

struct ff_envelope {
    __u16 attack_length;
    __u16 attack_level;
    __u16 fade_length;
    __u16 fade_level;
};

struct ff_constant_effect {
    __s16 level;
    struct ff_envelope envelope;
};

struct ff_effect;

struct ff_device {
    int (*upload)(struct input_dev *, struct ff_effect *, struct ff_effect *);
    int (*erase)(struct input_dev *, int);
    int (*playback)(struct input_dev *, int, int);
    void (*set_gain)(struct input_dev *, u16);
    void (*set_autocenter)(struct input_dev *, u16);
    void (*destroy)(struct ff_device *);
    void *private;
    long unsigned int ffbit[2];
    struct mutex mutex;
    int max_effects;
    struct ff_effect *effects;
    struct file *effect_owners[0];
};

struct ff_trigger {
    __u16 button;
    __u16 interval;
};

struct ff_replay {
    __u16 length;
    __u16 delay;
};

struct ff_ramp_effect {
    __s16 start_level;
    __s16 end_level;
    struct ff_envelope envelope;
};

struct ff_periodic_effect {
    __u16 waveform;
    __u16 period;
    __s16 magnitude;
    __s16 offset;
    __u16 phase;
    struct ff_envelope envelope;
    __u32 custom_len;
    __s16 *custom_data;
};

struct ff_rumble_effect {
    __u16 strong_magnitude;
    __u16 weak_magnitude;
};

struct ff_effect {
    __u16 type;
    __s16 id;
    __u16 direction;
    struct ff_trigger trigger;
    struct ff_replay replay;
    union {
        struct ff_constant_effect constant;
        struct ff_ramp_effect ramp;
        struct ff_periodic_effect periodic;
        struct ff_condition_effect condition[2];
        struct ff_rumble_effect rumble;
    } u;
};

struct ff_periodic_effect_compat {
    __u16 waveform;
    __u16 period;
    __s16 magnitude;
    __s16 offset;
    __u16 phase;
    struct ff_envelope envelope;
    __u32 custom_len;
    compat_uptr_t custom_data;
};

struct ff_effect_compat {
    __u16 type;
    __s16 id;
    __u16 direction;
    struct ff_trigger trigger;
    struct ff_replay replay;
    union {
        struct ff_constant_effect constant;
        struct ff_ramp_effect ramp;
        struct ff_periodic_effect_compat periodic;
        struct ff_condition_effect condition[2];
        struct ff_rumble_effect rumble;
    } u;
};

struct ffa_mem_region_addr_range {
    u64 address;
    u32 pg_cnt;
    u32 reserved;
};

struct ffa_composite_mem_region {
    u32 total_pg_cnt;
    u32 addr_range_cnt;
    u64 reserved;
    struct ffa_mem_region_addr_range constituents[0];
};

struct ffa_mem_region {
    u16 sender_id;
    u16 attributes;
    u32 flags;
    u64 handle;
    u64 tag;
    u32 ep_mem_size;
    u32 ep_count;
    u32 ep_mem_offset;
    u32 reserved[3];
};

struct ffa_mem_region_attributes {
    u16 receiver;
    u8 attrs;
    u8 flag;
    u32 composite_off;
    u64 reserved;
};

struct fgraph_cpu_data {
    pid_t last_pid;
    int depth;
    int depth_irq;
    int ignore;
    long unsigned int enter_funcs[50];
};

struct ftrace_graph_ent {
    long unsigned int func;
    int depth;
} __attribute__((packed));

struct ftrace_graph_ent_entry {
    struct trace_entry ent;
    struct ftrace_graph_ent graph_ent;
};

struct fgraph_retaddr_ent {
    long unsigned int func;
    int depth;
    long unsigned int retaddr;
} __attribute__((packed));

struct fgraph_retaddr_ent_entry {
    struct trace_entry ent;
    struct fgraph_retaddr_ent graph_ent;
};

struct ftrace_graph_ret {
    long unsigned int func;
    long unsigned int retval;
    int depth;
    unsigned int overrun;
};

struct ftrace_graph_ret_entry {
    struct trace_entry ent;
    struct ftrace_graph_ret ret;
    long long unsigned int calltime;
    long long unsigned int rettime;
};

struct fgraph_data {
    struct fgraph_cpu_data *cpu_data;
    union {
        struct ftrace_graph_ent_entry ent;
        struct fgraph_retaddr_ent_entry rent;
    } ent;
    struct ftrace_graph_ret_entry ret;
    int failed;
    int cpu;
    long: 0;
} __attribute__((packed));

struct fgraph_ops;

typedef int (*trace_func_graph_ent_t)(struct ftrace_graph_ent *, struct fgraph_ops *, struct ftrace_regs *);

typedef void (*trace_func_graph_ret_t)(struct ftrace_graph_ret *, struct fgraph_ops *, struct ftrace_regs *);

typedef void (*ftrace_func_t)(long unsigned int, long unsigned int, struct ftrace_ops *, struct ftrace_regs *);

struct ftrace_hash;

struct ftrace_ops_hash {
    struct ftrace_hash *notrace_hash;
    struct ftrace_hash *filter_hash;
    struct mutex regex_lock;
};

typedef int (*ftrace_ops_func_t)(struct ftrace_ops *, enum ftrace_ops_cmd);

struct ftrace_ops {
    ftrace_func_t func;
    struct ftrace_ops *next;
    long unsigned int flags;
    void *private;
    ftrace_func_t saved_func;
    struct ftrace_ops_hash local_hash;
    struct ftrace_ops_hash *func_hash;
    struct ftrace_ops_hash old_hash;
    long unsigned int trampoline;
    long unsigned int trampoline_size;
    struct list_head list;
    struct list_head subop_list;
    ftrace_ops_func_t ops_func;
    struct ftrace_ops *managed;
    long unsigned int direct_call;
};

struct fgraph_ops {
    trace_func_graph_ent_t entryfunc;
    trace_func_graph_ret_t retfunc;
    struct ftrace_ops ops;
    void *private;
    trace_func_graph_ent_t saved_func;
    int idx;
};

struct fgraph_times {
    long long unsigned int calltime;
    long long unsigned int sleeptime;
};

struct fib_kuid_range {
    kuid_t start;
    kuid_t end;
};

struct fib_rule_port_range {
    __u16 start;
    __u16 end;
};

struct fib_rule {
    struct list_head list;
    int iifindex;
    int oifindex;
    u32 mark;
    u32 mark_mask;
    u32 flags;
    u32 table;
    u8 action;
    u8 l3mdev;
    u8 proto;
    u8 ip_proto;
    u32 target;
    __be64 tun_id;
    struct fib_rule *ctarget;
    struct net *fr_net;
    refcount_t refcnt;
    u32 pref;
    int suppress_ifgroup;
    int suppress_prefixlen;
    char iifname[16];
    char oifname[16];
    struct fib_kuid_range uid_range;
    struct fib_rule_port_range sport_range;
    struct fib_rule_port_range dport_range;
    struct callback_head rcu;
};

struct fib4_rule {
    struct fib_rule common;
    u8 dst_len;
    u8 src_len;
    dscp_t dscp;
    u8 dscp_full: 1;
    __be32 src;
    __be32 srcmask;
    __be32 dst;
    __be32 dstmask;
    u32 tclassid;
};

struct fib6_node;

struct fib6_walker {
    struct list_head lh;
    struct fib6_node *root;
    struct fib6_node *node;
    struct fib6_info *leaf;
    enum fib6_walk_state state;
    unsigned int skip;
    unsigned int count;
    unsigned int skip_in_node;
    int (*func)(struct fib6_walker *);
    void *args;
};

struct fib6_cleaner {
    struct fib6_walker w;
    struct net *net;
    int (*func)(struct fib6_info *, void *);
    int sernum;
    void *arg;
    bool skip_notify;
};

struct nlmsghdr;

struct nl_info {
    struct nlmsghdr *nlh;
    struct net *nl_net;
    u32 portid;
    u8 skip_notify: 1;
    u8 skip_notify_kernel: 1;
};

struct fib6_config {
    u32 fc_table;
    u32 fc_metric;
    int fc_dst_len;
    int fc_src_len;
    int fc_ifindex;
    u32 fc_flags;
    u32 fc_protocol;
    u16 fc_type;
    u16 fc_delete_all_nh: 1;
    u16 fc_ignore_dev_down: 1;
    u16 __unused: 14;
    u32 fc_nh_id;
    struct in6_addr fc_dst;
    struct in6_addr fc_src;
    struct in6_addr fc_prefsrc;
    struct in6_addr fc_gateway;
    long unsigned int fc_expires;
    struct nlattr *fc_mx;
    int fc_mx_len;
    int fc_mp_len;
    struct nlattr *fc_mp;
    struct nl_info fc_nlinfo;
    struct nlattr *fc_encap;
    u16 fc_encap_type;
    bool fc_is_fdb;
};

struct fib6_dump_arg {
    struct net *net;
    struct notifier_block *nb;
    struct netlink_ext_ack *extack;
};

struct fib_notifier_info {
    int family;
    struct netlink_ext_ack *extack;
};

struct fib6_entry_notifier_info {
    struct fib_notifier_info info;
    struct fib6_info *rt;
    unsigned int nsiblings;
};

struct fib6_gc_args {
    int timeout;
    int more;
};

struct rt6key {
    struct in6_addr addr;
    int plen;
};

struct rtable;

struct fnhe_hash_bucket;

struct fib_nh_common {
    struct net_device *nhc_dev;
    netdevice_tracker nhc_dev_tracker;
    int nhc_oif;
    unsigned char nhc_scope;
    u8 nhc_family;
    u8 nhc_gw_family;
    unsigned char nhc_flags;
    struct lwtunnel_state *nhc_lwtstate;
    union {
        __be32 ipv4;
        struct in6_addr ipv6;
    } nhc_gw;
    int nhc_weight;
    atomic_t nhc_upper_bound;
    struct rtable **nhc_pcpu_rth_output;
    struct rtable *nhc_rth_input;
    struct fnhe_hash_bucket *nhc_exceptions;
};

struct rt6_info;

struct rt6_exception_bucket;

struct fib6_nh {
    struct fib_nh_common nh_common;
    long unsigned int last_probe;
    struct rt6_info **rt6i_pcpu;
    struct rt6_exception_bucket *rt6i_exception_bucket;
};

struct fib6_table;

struct nexthop;

struct fib6_info {
    struct fib6_table *fib6_table;
    struct fib6_info *fib6_next;
    struct fib6_node *fib6_node;
    union {
        struct list_head fib6_siblings;
        struct list_head nh_list;
    };
    unsigned int fib6_nsiblings;
    refcount_t fib6_ref;
    long unsigned int expires;
    struct hlist_node gc_link;
    struct dst_metrics *fib6_metrics;
    struct rt6key fib6_dst;
    u32 fib6_flags;
    struct rt6key fib6_src;
    struct rt6key fib6_prefsrc;
    u32 fib6_metric;
    u8 fib6_protocol;
    u8 fib6_type;
    u8 offload;
    u8 trap;
    u8 offload_failed;
    u8 should_flush: 1;
    u8 dst_nocount: 1;
    u8 dst_nopolicy: 1;
    u8 fib6_destroying: 1;
    u8 unused: 4;
    struct callback_head rcu;
    struct nexthop *nh;
    struct fib6_nh fib6_nh[0];
};

struct fib6_nh_age_excptn_arg {
    struct fib6_gc_args *gc_args;
    long unsigned int now;
};

struct fib6_nh_del_cached_rt_arg {
    struct fib6_config *cfg;
    struct fib6_info *f6i;
};

struct fib6_nh_dm_arg {
    struct net *net;
    const struct in6_addr *saddr;
    int oif;
    int flags;
    struct fib6_nh *nh;
};

struct rt6_rtnl_dump_arg;

struct fib6_nh_exception_dump_walker {
    struct rt6_rtnl_dump_arg *dump;
    struct fib6_info *rt;
    unsigned int flags;
    unsigned int skip;
    unsigned int count;
};

struct fib6_nh_excptn_arg {
    struct rt6_info *rt;
    int plen;
};

struct fib6_nh_frl_arg {
    u32 flags;
    int oif;
    int strict;
    int *mpri;
    bool *do_rr;
    struct fib6_nh *nh;
};

struct fib6_nh_match_arg {
    const struct net_device *dev;
    const struct in6_addr *gw;
    struct fib6_nh *match;
};

struct fib6_nh_pcpu_arg {
    struct fib6_info *from;
    const struct fib6_table *table;
};

struct fib6_result;

struct flowi6;

struct fib6_nh_rd_arg {
    struct fib6_result *res;
    struct flowi6 *fl6;
    const struct in6_addr *gw;
    struct rt6_info **ret;
};

struct fib6_node {
    struct fib6_node *parent;
    struct fib6_node *left;
    struct fib6_node *right;
    struct fib6_node *subtree;
    struct fib6_info *leaf;
    __u16 fn_bit;
    __u16 fn_flags;
    int fn_sernum;
    struct fib6_info *rr_ptr;
    struct callback_head rcu;
};

struct fib6_result {
    struct fib6_nh *nh;
    struct fib6_info *f6i;
    u32 fib6_flags;
    u8 fib6_type;
    struct rt6_info *rt6;
};

struct fib6_rule {
    struct fib_rule common;
    struct rt6key src;
    struct rt6key dst;
    __be32 flowlabel;
    __be32 flowlabel_mask;
    dscp_t dscp;
    u8 dscp_full: 1;
};

struct inet_peer_base {
    struct rb_root rb_root;
    seqlock_t lock;
    int total;
};

struct fib6_table {
    struct hlist_node tb6_hlist;
    u32 tb6_id;
    spinlock_t tb6_lock;
    struct fib6_node tb6_root;
    struct inet_peer_base tb6_peers;
    unsigned int flags;
    unsigned int fib_seq;
    struct hlist_head tb6_gc_hlist;
};

struct fib_info;

struct fib_alias {
    struct hlist_node fa_list;
    struct fib_info *fa_info;
    dscp_t fa_dscp;
    u8 fa_type;
    u8 fa_state;
    u8 fa_slen;
    u32 tb_id;
    s16 fa_default;
    u8 offload;
    u8 trap;
    u8 offload_failed;
    struct callback_head rcu;
};

struct rtnexthop;

struct fib_config {
    u8 fc_dst_len;
    dscp_t fc_dscp;
    u8 fc_protocol;
    u8 fc_scope;
    u8 fc_type;
    u8 fc_gw_family;
    u32 fc_table;
    __be32 fc_dst;
    union {
        __be32 fc_gw4;
        struct in6_addr fc_gw6;
    };
    int fc_oif;
    u32 fc_flags;
    u32 fc_priority;
    __be32 fc_prefsrc;
    u32 fc_nh_id;
    struct nlattr *fc_mx;
    struct rtnexthop *fc_mp;
    int fc_mx_len;
    int fc_mp_len;
    u32 fc_flow;
    u32 fc_nlflags;
    struct nl_info fc_nlinfo;
    struct nlattr *fc_encap;
    u16 fc_encap_type;
};

struct fib_dump_filter {
    u32 table_id;
    bool filter_set;
    bool dump_routes;
    bool dump_exceptions;
    bool rtnl_held;
    unsigned char protocol;
    unsigned char rt_type;
    unsigned int flags;
    struct net_device *dev;
};

struct fib_entry_notifier_info {
    struct fib_notifier_info info;
    u32 dst;
    int dst_len;
    struct fib_info *fi;
    dscp_t dscp;
    u8 type;
    u32 tb_id;
};

struct fib_nh {
    struct fib_nh_common nh_common;
    struct hlist_node nh_hash;
    struct fib_info *nh_parent;
    __u32 nh_tclassid;
    __be32 nh_saddr;
    int nh_saddr_genid;
};

struct fib_info {
    struct hlist_node fib_hash;
    struct hlist_node fib_lhash;
    struct list_head nh_list;
    struct net *fib_net;
    refcount_t fib_treeref;
    refcount_t fib_clntref;
    unsigned int fib_flags;
    unsigned char fib_dead;
    unsigned char fib_protocol;
    unsigned char fib_scope;
    unsigned char fib_type;
    __be32 fib_prefsrc;
    u32 fib_tb_id;
    u32 fib_priority;
    struct dst_metrics *fib_metrics;
    int fib_nhs;
    bool fib_nh_is_v6;
    bool nh_updated;
    bool pfsrc_removed;
    struct nexthop *nh;
    struct callback_head rcu;
    struct fib_nh fib_nh[0];
};

struct fib_lookup_arg {
    void *lookup_ptr;
    const void *lookup_data;
    void *result;
    struct fib_rule *rule;
    u32 table;
    int flags;
};

struct fib_nh_exception {
    struct fib_nh_exception *fnhe_next;
    int fnhe_genid;
    __be32 fnhe_daddr;
    u32 fnhe_pmtu;
    bool fnhe_mtu_locked;
    __be32 fnhe_gw;
    long unsigned int fnhe_expires;
    struct rtable *fnhe_rth_input;
    struct rtable *fnhe_rth_output;
    long unsigned int fnhe_stamp;
    struct callback_head rcu;
};

struct fib_nh_notifier_info {
    struct fib_notifier_info info;
    struct fib_nh *fib_nh;
};

struct fib_notifier_net {
    struct list_head fib_notifier_ops;
    struct atomic_notifier_head fib_chain;
};

struct fib_notifier_ops {
    int family;
    struct list_head list;
    unsigned int (*fib_seq_read)(const struct net *);
    int (*fib_dump)(struct net *, struct notifier_block *, struct netlink_ext_ack *);
    struct module *owner;
    struct callback_head rcu;
};

struct fib_prop {
    int error;
    u8 scope;
};

struct fib_table;

struct fib_result {
    __be32 prefix;
    unsigned char prefixlen;
    unsigned char nh_sel;
    unsigned char type;
    unsigned char scope;
    u32 tclassid;
    dscp_t dscp;
    struct fib_nh_common *nhc;
    struct fib_info *fi;
    struct fib_table *table;
    struct hlist_head *fa_head;
};

struct fib_result_nl {
    __be32 fl_addr;
    u32 fl_mark;
    unsigned char fl_tos;
    unsigned char fl_scope;
    unsigned char tb_id_in;
    unsigned char tb_id;
    unsigned char prefixlen;
    unsigned char nh_sel;
    unsigned char type;
    unsigned char scope;
    int err;
};

struct key_vector;

struct fib_route_iter {
    struct seq_net_private p;
    struct fib_table *main_tb;
    struct key_vector *tnode;
    loff_t pos;
    t_key key;
};

struct fib_rt_info {
    struct fib_info *fi;
    u32 tb_id;
    __be32 dst;
    int dst_len;
    dscp_t dscp;
    u8 type;
    u8 offload: 1;
    u8 trap: 1;
    u8 offload_failed: 1;
    u8 unused: 5;
};

struct fib_rule_hdr {
    __u8 family;
    __u8 dst_len;
    __u8 src_len;
    __u8 tos;
    __u8 table;
    __u8 res1;
    __u8 res2;
    __u8 action;
    __u32 flags;
};

struct fib_rule_notifier_info {
    struct fib_notifier_info info;
    struct fib_rule *rule;
};

struct fib_rule_uid_range {
    __u32 start;
    __u32 end;
};

struct flowi;

struct fib_rules_ops {
    int family;
    struct list_head list;
    int rule_size;
    int addr_size;
    int unresolved_rules;
    int nr_goto_rules;
    unsigned int fib_rules_seq;
    int (*action)(struct fib_rule *, struct flowi *, int, struct fib_lookup_arg *);
    bool (*suppress)(struct fib_rule *, int, struct fib_lookup_arg *);
    int (*match)(struct fib_rule *, struct flowi *, int);
    int (*configure)(struct fib_rule *, struct sk_buff *, struct fib_rule_hdr *, struct nlattr **, struct netlink_ext_ack *);
    int (*delete)(struct fib_rule *);
    int (*compare)(struct fib_rule *, struct fib_rule_hdr *, struct nlattr **);
    int (*fill)(struct fib_rule *, struct sk_buff *, struct fib_rule_hdr *);
    size_t (*nlmsg_payload)(struct fib_rule *);
    void (*flush_cache)(struct fib_rules_ops *);
    int nlgroup;
    struct list_head rules_list;
    struct module *owner;
    struct net *fro_net;
    struct callback_head rcu;
};

struct fib_table {
    struct hlist_node tb_hlist;
    u32 tb_id;
    int tb_num_default;
    struct callback_head rcu;
    long unsigned int *tb_data;
    long unsigned int __data[0];
};

struct fib_trie_iter {
    struct seq_net_private p;
    struct fib_table *tb;
    struct key_vector *tnode;
    unsigned int index;
    unsigned int depth;
};

struct fid {
    union {
        struct {
            u32 ino;
            u32 gen;
            u32 parent_ino;
            u32 parent_gen;
        } i32;
        struct {
            u64 ino;
            u32 gen;
        } __attribute__((packed)) i64;
        struct {
            u32 block;
            u16 partref;
            u16 parent_partref;
            u32 generation;
            u32 parent_block;
            u32 parent_generation;
        } udf;
        struct {
            struct {} __empty_raw;
            __u32 raw[0];
        };
    };
};

struct field_var {
    struct hist_field *var;
    struct hist_field *val;
};

struct field_var_hist {
    struct hist_trigger_data *hist_data;
    char *cmd;
};

struct fiemap_extent {
    __u64 fe_logical;
    __u64 fe_physical;
    __u64 fe_length;
    __u64 fe_reserved64[2];
    __u32 fe_flags;
    __u32 fe_reserved[3];
};

struct fiemap {
    __u64 fm_start;
    __u64 fm_length;
    __u32 fm_flags;
    __u32 fm_mapped_extents;
    __u32 fm_extent_count;
    __u32 fm_reserved;
    struct fiemap_extent fm_extents[0];
};

struct fiemap_extent_info {
    unsigned int fi_flags;
    unsigned int fi_extents_mapped;
    unsigned int fi_extents_max;
    struct fiemap_extent *fi_extents_start;
};

struct file__safe_trusted {
    struct inode *f_inode;
};

struct file_clone_range {
    __s64 src_fd;
    __u64 src_offset;
    __u64 src_length;
    __u64 dest_offset;
};

struct file_dedupe_range_info {
    __s64 dest_fd;
    __u64 dest_offset;
    __u64 bytes_deduped;
    __s32 status;
    __u32 reserved;
};

struct file_dedupe_range {
    __u64 src_offset;
    __u64 src_length;
    __u16 dest_count;
    __u16 reserved1;
    __u32 reserved2;
    struct file_dedupe_range_info info[0];
};

struct file_handle {
    __u32 handle_bytes;
    int handle_type;
    unsigned char f_handle[0];
};

struct file_lock_core {
    struct file_lock_core *flc_blocker;
    struct list_head flc_list;
    struct hlist_node flc_link;
    struct list_head flc_blocked_requests;
    struct list_head flc_blocked_member;
    fl_owner_t flc_owner;
    unsigned int flc_flags;
    unsigned char flc_type;
    pid_t flc_pid;
    int flc_link_cpu;
    wait_queue_head_t flc_wait;
    struct file *flc_file;
};

struct lease_manager_operations;

struct file_lease {
    struct file_lock_core c;
    struct fasync_struct *fl_fasync;
    long unsigned int fl_break_time;
    long unsigned int fl_downgrade_time;
    const struct lease_manager_operations *fl_lmops;
};

struct nlm_lockowner;

struct nfs_lock_info {
    u32 state;
    struct nlm_lockowner *owner;
    struct list_head list;
};

struct nfs4_lock_state;

struct nfs4_lock_info {
    struct nfs4_lock_state *owner;
};

struct file_lock_operations;

struct lock_manager_operations;

struct file_lock {
    struct file_lock_core c;
    loff_t fl_start;
    loff_t fl_end;
    const struct file_lock_operations *fl_ops;
    const struct lock_manager_operations *fl_lmops;
    union {
        struct nfs_lock_info nfs_fl;
        struct nfs4_lock_info nfs4_fl;
        struct {
            struct list_head link;
            int state;
            unsigned int debug_id;
        } afs;
        struct {
            struct inode *inode;
        } ceph;
    } fl_u;
};

struct file_lock_context {
    spinlock_t flc_lock;
    struct list_head flc_flock;
    struct list_head flc_posix;
    struct list_head flc_lease;
};

struct file_lock_list_struct {
    spinlock_t lock;
    struct hlist_head hlist;
};

struct file_lock_operations {
    void (*fl_copy_lock)(struct file_lock *, struct file_lock *);
    void (*fl_release_private)(struct file_lock *);
};

struct io_uring_cmd;

struct file_operations {
    struct module *owner;
    fop_flags_t fop_flags;
    loff_t (*llseek)(struct file *, loff_t, int);
    ssize_t (*read)(struct file *, char *, size_t, loff_t *);
    ssize_t (*write)(struct file *, const char *, size_t, loff_t *);
    ssize_t (*read_iter)(struct kiocb *, struct iov_iter *);
    ssize_t (*write_iter)(struct kiocb *, struct iov_iter *);
    int (*iopoll)(struct kiocb *, struct io_comp_batch *, unsigned int);
    int (*iterate_shared)(struct file *, struct dir_context *);
    __poll_t (*poll)(struct file *, struct poll_table_struct *);
    long int (*unlocked_ioctl)(struct file *, unsigned int, long unsigned int);
    long int (*compat_ioctl)(struct file *, unsigned int, long unsigned int);
    int (*mmap)(struct file *, struct vm_area_struct *);
    int (*open)(struct inode *, struct file *);
    int (*flush)(struct file *, fl_owner_t);
    int (*release)(struct inode *, struct file *);
    int (*fsync)(struct file *, loff_t, loff_t, int);
    int (*fasync)(int, struct file *, int);
    int (*lock)(struct file *, int, struct file_lock *);
    long unsigned int (*get_unmapped_area)(struct file *, long unsigned int, long unsigned int, long unsigned int, long unsigned int);
    int (*check_flags)(int);
    int (*flock)(struct file *, int, struct file_lock *);
    ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *, size_t, unsigned int);
    ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *, size_t, unsigned int);
    void (*splice_eof)(struct file *);
    int (*setlease)(struct file *, int, struct file_lease **, void **);
    long int (*fallocate)(struct file *, int, loff_t, loff_t);
    void (*show_fdinfo)(struct seq_file *, struct file *);
    ssize_t (*copy_file_range)(struct file *, loff_t, struct file *, loff_t, size_t, unsigned int);
    loff_t (*remap_file_range)(struct file *, loff_t, struct file *, loff_t, loff_t, unsigned int);
    int (*fadvise)(struct file *, loff_t, loff_t, int);
    int (*uring_cmd)(struct io_uring_cmd *, unsigned int);
    int (*uring_cmd_iopoll)(struct io_uring_cmd *, struct io_comp_batch *, unsigned int);
};

struct tpm_chip;

struct tpm_space;

struct file_priv {
    struct tpm_chip *chip;
    struct tpm_space *space;
    struct mutex buffer_mutex;
    struct timer_list user_read_timer;
    struct work_struct timeout_work;
    struct work_struct async_work;
    wait_queue_head_t async_wait;
    ssize_t response_length;
    bool response_read;
    bool command_enqueued;
    u8 data_buffer[4096];
};

struct file_range {
    const struct path *path;
    loff_t pos;
    size_t count;
};

struct file_region {
    struct list_head link;
    long int from;
    long int to;
    struct page_counter *reservation_counter;
    struct cgroup_subsys_state *css;
};

struct file_security_struct {
    u32 sid;
    u32 fown_sid;
    u32 isid;
    u32 pseqno;
};

struct fs_context;

struct fs_parameter_spec;

struct file_system_type {
    const char *name;
    int fs_flags;
    int (*init_fs_context)(struct fs_context *);
    const struct fs_parameter_spec *parameters;
    struct dentry * (*mount)(struct file_system_type *, int, const char *, void *);
    void (*kill_sb)(struct super_block *);
    struct module *owner;
    struct file_system_type *next;
    struct hlist_head fs_supers;
    struct lock_class_key s_lock_key;
    struct lock_class_key s_umount_key;
    struct lock_class_key s_vfs_rename_key;
    struct lock_class_key s_writers_key[3];
    struct lock_class_key i_lock_key;
    struct lock_class_key i_mutex_key;
    struct lock_class_key invalidate_lock_key;
    struct lock_class_key i_mutex_dir_key;
};

struct fileattr {
    u32 flags;
    u32 fsx_xflags;
    u32 fsx_extsize;
    u32 fsx_nextents;
    u32 fsx_projid;
    u32 fsx_cowextsize;
    bool flags_valid: 1;
    bool fsx_valid: 1;
};

struct filename {
    const char *name;
    const char *uptr;
    atomic_t refcnt;
    struct audit_names *aname;
    const char iname[0];
};

struct filename_trans_datum {
    struct ebitmap stypes;
    u32 otype;
    struct filename_trans_datum *next;
};

struct filename_trans_key {
    u32 ttype;
    u16 tclass;
    const char *name;
};

struct files_stat_struct {
    long unsigned int nr_files;
    long unsigned int nr_free_files;
    long unsigned int max_files;
};

struct files_struct {
    atomic_t count;
    bool resize_in_progress;
    wait_queue_head_t resize_wait;
    struct fdtable *fdt;
    struct fdtable fdtab;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    spinlock_t file_lock;
    unsigned int next_fd;
    long unsigned int close_on_exec_init[1];
    long unsigned int open_fds_init[1];
    long unsigned int full_fds_bits_init[1];
    struct file *fd_array[64];
    long: 64;
    long: 64;
    long: 64;
    long: 64;
};

struct filter_list {
    struct list_head list;
    struct event_filter *filter;
};

struct filter_match_data {
    const char *filter;
    const char *notfilter;
    size_t index;
    size_t size;
    long unsigned int *addrs;
    struct module **mods;
};

struct filter_parse_error {
    int lasterr;
    int lasterr_pos;
};

struct regex;

struct ftrace_event_field;

struct filter_pred {
    struct regex *regex;
    struct cpumask *mask;
    short unsigned int *ops;
    struct ftrace_event_field *field;
    u64 val;
    u64 val2;
    enum filter_pred_fn fn_num;
    int offset;
    int not;
    int op;
};

struct find_interface_arg {
    int minor;
    struct device_driver *drv;
};

struct kernel_symbol;

struct find_symbol_arg {
    const char *name;
    bool gplok;
    bool warn;
    struct module *owner;
    const u32 *crc;
    const struct kernel_symbol *sym;
    enum mod_license license;
};

struct finfo {
    efi_file_info_t info;
    efi_char16_t filename[256];
};

struct firmware {
    size_t size;
    const u8 *data;
    void *priv;
};

struct firmware_cache {
    spinlock_t lock;
    struct list_head head;
    int state;
};

struct firmware_work {
    struct work_struct work;
    struct module *module;
    const char *name;
    struct device *device;
    void *context;
    void (*cont)(const struct firmware *, void *);
    u32 opt_flags;
};

struct fixed_dev_type {
    bool has_enable_clock;
    bool has_performance_state;
};

struct fixed_mdio_bus {
    struct mii_bus *mii_bus;
    struct list_head phys;
};

struct fixed_phy_status {
    int link;
    int speed;
    int duplex;
    int pause;
    int asym_pause;
};

struct fixed_phy {
    int addr;
    struct phy_device *phydev;
    struct fixed_phy_status status;
    bool no_carrier;
    int (*link_update)(struct net_device *, struct fixed_phy_status *);
    struct list_head node;
    struct gpio_desc *link_gpiod;
};

struct regulator_init_data;

struct fixed_voltage_config {
    const char *supply_name;
    const char *input_supply;
    int microvolts;
    unsigned int startup_delay;
    unsigned int off_on_delay;
    unsigned int enabled_at_boot: 1;
    struct regulator_init_data *init_data;
};

struct regulator_state {
    int uV;
    int min_uV;
    int max_uV;
    unsigned int mode;
    int enabled;
    bool changeable;
};

struct notification_limit {
    int prot;
    int err;
    int warn;
};

struct regulation_constraints {
    const char *name;
    int min_uV;
    int max_uV;
    int uV_offset;
    int min_uA;
    int max_uA;
    int ilim_uA;
    int pw_budget_mW;
    int system_load;
    u32 *max_spread;
    int max_uV_step;
    unsigned int valid_modes_mask;
    unsigned int valid_ops_mask;
    int input_uV;
    struct regulator_state state_disk;
    struct regulator_state state_mem;
    struct regulator_state state_standby;
    struct notification_limit over_curr_limits;
    struct notification_limit over_voltage_limits;
    struct notification_limit under_voltage_limits;
    struct notification_limit temp_limits;
    suspend_state_t initial_state;
    unsigned int initial_mode;
    unsigned int ramp_delay;
    unsigned int settling_time;
    unsigned int settling_time_up;
    unsigned int settling_time_down;
    unsigned int enable_time;
    unsigned int uv_less_critical_window_ms;
    unsigned int active_discharge;
    unsigned int always_on: 1;
    unsigned int boot_on: 1;
    unsigned int apply_uV: 1;
    unsigned int ramp_disable: 1;
    unsigned int soft_start: 1;
    unsigned int pull_down: 1;
    unsigned int system_critical: 1;
    unsigned int over_current_protection: 1;
    unsigned int over_current_detection: 1;
    unsigned int over_voltage_detection: 1;
    unsigned int under_voltage_detection: 1;
    unsigned int over_temp_detection: 1;
};

struct regulator_consumer_supply;

struct regulator_init_data {
    const char *supply_regulator;
    struct regulation_constraints constraints;
    int num_consumer_supplies;
    struct regulator_consumer_supply *consumer_supplies;
    void *driver_data;
};

struct pdev_archdata {};

struct platform_device_id;

struct mfd_cell;

struct platform_device {
    const char *name;
    int id;
    bool id_auto;
    struct device dev;
    u64 platform_dma_mask;
    struct device_dma_parameters dma_parms;
    u32 num_resources;
    struct resource *resource;
    const struct platform_device_id *id_entry;
    const char *driver_override;
    struct mfd_cell *mfd_cell;
    struct pdev_archdata archdata;
};

struct fixed_regulator_data {
    struct fixed_voltage_config cfg;
    struct regulator_init_data init_data;
    struct platform_device pdev;
};

struct regulator_config;

struct regulator_ops;

struct linear_range;

struct regulator_desc {
    const char *name;
    const char *supply_name;
    const char *of_match;
    bool of_match_full_name;
    const char *regulators_node;
    int (*of_parse_cb)(struct device_node *, const struct regulator_desc *, struct regulator_config *);
    int (*init_cb)(struct regulator_dev *, struct regulator_config *);
    int id;
    unsigned int continuous_voltage_range: 1;
    unsigned int n_voltages;
    unsigned int n_current_limits;
    const struct regulator_ops *ops;
    int irq;
    enum regulator_type type;
    struct module *owner;
    unsigned int min_uV;
    unsigned int uV_step;
    unsigned int linear_min_sel;
    int fixed_uV;
    unsigned int ramp_delay;
    int min_dropout_uV;
    const struct linear_range *linear_ranges;
    const unsigned int *linear_range_selectors_bitfield;
    int n_linear_ranges;
    const unsigned int *volt_table;
    const unsigned int *curr_table;
    unsigned int vsel_range_reg;
    unsigned int vsel_range_mask;
    bool range_applied_by_vsel;
    unsigned int vsel_reg;
    unsigned int vsel_mask;
    unsigned int vsel_step;
    unsigned int csel_reg;
    unsigned int csel_mask;
    unsigned int apply_reg;
    unsigned int apply_bit;
    unsigned int enable_reg;
    unsigned int enable_mask;
    unsigned int enable_val;
    unsigned int disable_val;
    bool enable_is_inverted;
    unsigned int bypass_reg;
    unsigned int bypass_mask;
    unsigned int bypass_val_on;
    unsigned int bypass_val_off;
    unsigned int active_discharge_on;
    unsigned int active_discharge_off;
    unsigned int active_discharge_mask;
    unsigned int active_discharge_reg;
    unsigned int soft_start_reg;
    unsigned int soft_start_mask;
    unsigned int soft_start_val_on;
    unsigned int pull_down_reg;
    unsigned int pull_down_mask;
    unsigned int pull_down_val_on;
    unsigned int ramp_reg;
    unsigned int ramp_mask;
    const unsigned int *ramp_delay_table;
    unsigned int n_ramp_values;
    unsigned int enable_time;
    unsigned int off_on_delay;
    unsigned int poll_enabled_time;
    unsigned int (*of_map_mode)(unsigned int);
};

struct fixed_voltage_data {
    struct regulator_desc desc;
    struct regulator_dev *dev;
    struct clk *enable_clock;
    unsigned int enable_counter;
    int performance_state;
};

struct flag_settings {
    unsigned int flags;
    unsigned int mask;
};

struct flagsbuf {
    char buf[8];
};

struct flex_groups {
    atomic64_t free_clusters;
    atomic_t free_inodes;
    atomic_t used_dirs;
};

struct flock {
    short int l_type;
    short int l_whence;
    __kernel_off_t l_start;
    __kernel_off_t l_len;
    __kernel_pid_t l_pid;
};

struct flock64 {
    short int l_type;
    short int l_whence;
    __kernel_loff_t l_start;
    __kernel_loff_t l_len;
    __kernel_pid_t l_pid;
};

typedef void (*action_destr)(void *);

struct nf_flowtable;

struct ip_tunnel_info;

struct psample_group;

struct flow_action_entry {
    enum flow_action_id id;
    u32 hw_index;
    long unsigned int cookie;
    u64 miss_cookie;
    enum flow_action_hw_stats hw_stats;
    action_destr destructor;
    void *destructor_priv;
    union {
        u32 chain_index;
        struct net_device *dev;
        struct {
            u16 vid;
            __be16 proto;
            u8 prio;
        } vlan;
        struct {
            unsigned char dst[6];
            unsigned char src[6];
        } vlan_push_eth;
        struct {
            enum flow_action_mangle_base htype;
            u32 offset;
            u32 mask;
            u32 val;
        } mangle;
        struct ip_tunnel_info *tunnel;
        u32 csum_flags;
        u32 mark;
        u16 ptype;
        u16 rx_queue;
        u32 priority;
        struct {
            u32 ctx;
            u32 index;
            u8 vf;
        } queue;
        struct {
            struct psample_group *psample_group;
            u32 rate;
            u32 trunc_size;
            bool truncate;
        } sample;
        struct {
            u32 burst;
            u64 rate_bytes_ps;
            u64 peakrate_bytes_ps;
            u32 avrate;
            u16 overhead;
            u64 burst_pkt;
            u64 rate_pkt_ps;
            u32 mtu;
            struct {
                enum flow_action_id act_id;
                u32 extval;
            } exceed;
            struct {
                enum flow_action_id act_id;
                u32 extval;
            } notexceed;
        } police;
        struct {
            int action;
            u16 zone;
            struct nf_flowtable *flow_table;
        } ct;
        struct {
            long unsigned int cookie;
            u32 mark;
            u32 labels[4];
            bool orig_dir;
        } ct_metadata;
        struct {
            u32 label;
            __be16 proto;
            u8 tc;
            u8 bos;
            u8 ttl;
        } mpls_push;
        struct {
            __be16 proto;
        } mpls_pop;
        struct {
            u32 label;
            u8 tc;
            u8 bos;
            u8 ttl;
        } mpls_mangle;
        struct {
            s32 prio;
            u64 basetime;
            u64 cycletime;
            u64 cycletimeext;
            u32 num_entries;
            struct action_gate_entry *entries;
        } gate;
        struct {
            u16 sid;
        } pppoe;
    };
    struct flow_action_cookie *user_cookie;
};

struct flow_action {
    unsigned int num_entries;
    struct flow_action_entry entries[0];
};

struct flow_action_cookie {
    u32 cookie_len;
    u8 cookie[0];
};

struct flow_block {
    struct list_head cb_list;
};

typedef int flow_setup_cb_t(enum tc_setup_type, void *, void *);

struct flow_block_cb;

struct flow_block_indr {
    struct list_head list;
    struct net_device *dev;
    struct Qdisc *sch;
    enum flow_block_binder_type binder_type;
    void *data;
    void *cb_priv;
    void (*cleanup)(struct flow_block_cb *);
};

struct flow_block_cb {
    struct list_head driver_list;
    struct list_head list;
    flow_setup_cb_t *cb;
    void *cb_ident;
    void *cb_priv;
    void (*release)(void *);
    struct flow_block_indr indr;
    unsigned int refcnt;
};

struct flow_block_offload {
    enum flow_block_command command;
    enum flow_block_binder_type binder_type;
    bool block_shared;
    bool unlocked_driver_cb;
    struct net *net;
    struct flow_block *block;
    struct list_head cb_list;
    struct list_head *driver_block_list;
    struct netlink_ext_ack *extack;
    struct Qdisc *sch;
    struct list_head *cb_list_head;
};

struct flow_cls_common_offload {
    u32 chain_index;
    __be16 protocol;
    u32 prio;
    bool skip_sw;
    struct netlink_ext_ack *extack;
};

struct flow_stats {
    u64 pkts;
    u64 bytes;
    u64 drops;
    u64 lastused;
    enum flow_action_hw_stats used_hw_stats;
    bool used_hw_stats_valid;
};

struct flow_cls_offload {
    struct flow_cls_common_offload common;
    enum flow_cls_command command;
    bool use_act_stats;
    long unsigned int cookie;
    struct flow_rule *rule;
    struct flow_stats stats;
    u32 classid;
};

struct flow_dissector_key {
    enum flow_dissector_key_id key_id;
    size_t offset;
};

struct flow_dissector_key_tipc {
    __be32 key;
};

struct flow_dissector_key_addrs {
    union {
        struct flow_dissector_key_ipv4_addrs v4addrs;
        struct flow_dissector_key_ipv6_addrs v6addrs;
        struct flow_dissector_key_tipc tipckey;
    };
};

struct flow_dissector_key_arp {
    __u32 sip;
    __u32 tip;
    __u8 op;
    unsigned char sha[6];
    unsigned char tha[6];
};

struct flow_dissector_key_cfm {
    u8 mdl_ver;
    u8 opcode;
};

struct flow_dissector_key_control {
    u16 thoff;
    u16 addr_type;
    u32 flags;
};

struct flow_dissector_key_ct {
    u16 ct_state;
    u16 ct_zone;
    u32 ct_mark;
    u32 ct_labels[4];
};

struct flow_dissector_key_enc_opts {
    u8 data[255];
    u8 len;
    u32 dst_opt_type;
};

struct flow_dissector_key_hash {
    u32 hash;
};

struct flow_dissector_key_icmp {
    struct {
        u8 type;
        u8 code;
    };
    u16 id;
};

struct flow_dissector_key_ipsec {
    __be32 spi;
};

struct flow_dissector_key_keyid {
    __be32 keyid;
};

struct flow_dissector_key_l2tpv3 {
    __be32 session_id;
};

struct flow_dissector_key_meta {
    int ingress_ifindex;
    u16 ingress_iftype;
    u8 l2_miss;
};

struct flow_dissector_mpls_lse {
    u32 mpls_ttl: 8;
    u32 mpls_bos: 1;
    u32 mpls_tc: 3;
    u32 mpls_label: 20;
};

struct flow_dissector_key_mpls {
    struct flow_dissector_mpls_lse ls[7];
    u8 used_lses;
};

struct flow_dissector_key_num_of_vlans {
    u8 num_of_vlans;
};

struct flow_dissector_key_ports_range {
    union {
        struct flow_dissector_key_ports tp;
        struct {
            struct flow_dissector_key_ports tp_min;
            struct flow_dissector_key_ports tp_max;
        };
    };
};

struct flow_dissector_key_pppoe {
    __be16 session_id;
    __be16 ppp_proto;
    __be16 type;
};

struct flow_dissector_key_tags {
    u32 flow_label;
};

struct flow_dissector_key_tcp {
    __be16 flags;
};

struct flow_indir_dev_info {
    void *data;
    struct net_device *dev;
    struct Qdisc *sch;
    enum tc_setup_type type;
    void (*cleanup)(struct flow_block_cb *);
    struct list_head list;
    enum flow_block_command command;
    enum flow_block_binder_type binder_type;
    struct list_head *cb_list;
};

typedef int flow_indr_block_bind_cb_t(struct net_device *, struct Qdisc *, void *, enum tc_setup_type, void *, void *, void (*)(struct flow_block_cb *));

struct flow_indr_dev {
    struct list_head list;
    flow_indr_block_bind_cb_t *cb;
    void *cb_priv;
    refcount_t refcnt;
};

struct flow_keys {
    struct flow_dissector_key_control control;
    struct flow_dissector_key_basic basic;
    struct flow_dissector_key_tags tags;
    struct flow_dissector_key_vlan vlan;
    struct flow_dissector_key_vlan cvlan;
    struct flow_dissector_key_keyid keyid;
    struct flow_dissector_key_ports ports;
    struct flow_dissector_key_icmp icmp;
    struct flow_dissector_key_addrs addrs;
    long: 0;
};

struct flow_keys_basic {
    struct flow_dissector_key_control control;
    struct flow_dissector_key_basic basic;
};

struct flow_keys_digest {
    u8 data[16];
};

struct flow_match {
    struct flow_dissector *dissector;
    void *mask;
    void *key;
};

struct flow_match_arp {
    struct flow_dissector_key_arp *key;
    struct flow_dissector_key_arp *mask;
};

struct flow_match_basic {
    struct flow_dissector_key_basic *key;
    struct flow_dissector_key_basic *mask;
};

struct flow_match_control {
    struct flow_dissector_key_control *key;
    struct flow_dissector_key_control *mask;
};

struct flow_match_ct {
    struct flow_dissector_key_ct *key;
    struct flow_dissector_key_ct *mask;
};

struct flow_match_enc_keyid {
    struct flow_dissector_key_keyid *key;
    struct flow_dissector_key_keyid *mask;
};

struct flow_match_enc_opts {
    struct flow_dissector_key_enc_opts *key;
    struct flow_dissector_key_enc_opts *mask;
};

struct flow_match_eth_addrs {
    struct flow_dissector_key_eth_addrs *key;
    struct flow_dissector_key_eth_addrs *mask;
};

struct flow_match_icmp {
    struct flow_dissector_key_icmp *key;
    struct flow_dissector_key_icmp *mask;
};

struct flow_match_ip {
    struct flow_dissector_key_ip *key;
    struct flow_dissector_key_ip *mask;
};

struct flow_match_ipsec {
    struct flow_dissector_key_ipsec *key;
    struct flow_dissector_key_ipsec *mask;
};

struct flow_match_ipv4_addrs {
    struct flow_dissector_key_ipv4_addrs *key;
    struct flow_dissector_key_ipv4_addrs *mask;
};

struct flow_match_ipv6_addrs {
    struct flow_dissector_key_ipv6_addrs *key;
    struct flow_dissector_key_ipv6_addrs *mask;
};

struct flow_match_l2tpv3 {
    struct flow_dissector_key_l2tpv3 *key;
    struct flow_dissector_key_l2tpv3 *mask;
};

struct flow_match_meta {
    struct flow_dissector_key_meta *key;
    struct flow_dissector_key_meta *mask;
};

struct flow_match_mpls {
    struct flow_dissector_key_mpls *key;
    struct flow_dissector_key_mpls *mask;
};

struct flow_match_ports {
    struct flow_dissector_key_ports *key;
    struct flow_dissector_key_ports *mask;
};

struct flow_match_ports_range {
    struct flow_dissector_key_ports_range *key;
    struct flow_dissector_key_ports_range *mask;
};

struct flow_match_pppoe {
    struct flow_dissector_key_pppoe *key;
    struct flow_dissector_key_pppoe *mask;
};

struct flow_match_tcp {
    struct flow_dissector_key_tcp *key;
    struct flow_dissector_key_tcp *mask;
};

struct flow_match_vlan {
    struct flow_dissector_key_vlan *key;
    struct flow_dissector_key_vlan *mask;
};

struct flow_offload_action {
    struct netlink_ext_ack *extack;
    enum offload_act_command command;
    enum flow_action_id id;
    u32 index;
    long unsigned int cookie;
    struct flow_stats stats;
    struct flow_action action;
};

struct flow_rule {
    struct flow_match match;
    struct flow_action action;
};

struct flowi_tunnel {
    __be64 tun_id;
};

struct flowi_common {
    int flowic_oif;
    int flowic_iif;
    int flowic_l3mdev;
    __u32 flowic_mark;
    __u8 flowic_tos;
    __u8 flowic_scope;
    __u8 flowic_proto;
    __u8 flowic_flags;
    __u32 flowic_secid;
    kuid_t flowic_uid;
    __u32 flowic_multipath_hash;
    struct flowi_tunnel flowic_tun_key;
};

union flowi_uli {
    struct {
        __be16 dport;
        __be16 sport;
    } ports;
    struct {
        __u8 type;
        __u8 code;
    } icmpt;
    __be32 gre_key;
    struct {
        __u8 type;
    } mht;
};

struct flowi4 {
    struct flowi_common __fl_common;
    __be32 saddr;
    __be32 daddr;
    union flowi_uli uli;
};

struct flowi6 {
    struct flowi_common __fl_common;
    struct in6_addr daddr;
    struct in6_addr saddr;
    __be32 flowlabel;
    union flowi_uli uli;
    __u32 mp_hash;
};

struct flowi {
    union {
        struct flowi_common __fl_common;
        struct flowi4 ip4;
        struct flowi6 ip6;
    } u;
};

struct flush_backlogs {
    cpumask_t flush_cpus;
    struct work_struct w[0];
};

struct flush_busy_ctx_data {
    struct blk_mq_hw_ctx *hctx;
    struct list_head *list;
};

struct fmt {
    const char *str;
    unsigned char state;
    unsigned char size;
};

struct fname {
    __u32 hash;
    __u32 minor_hash;
    struct rb_node rb_hash;
    struct fname *next;
    __u32 inode;
    __u8 name_len;
    __u8 file_type;
    char name[0];
};

struct fnhe_hash_bucket {
    struct fib_nh_exception *chain;
};

struct page_pool;

struct page {
    long unsigned int flags;
    union {
        struct {
            union {
                struct list_head lru;
                struct {
                    void *__filler;
                    unsigned int mlock_count;
                };
                struct list_head buddy_list;
                struct list_head pcp_list;
            };
            struct address_space *mapping;
            union {
                long unsigned int index;
                long unsigned int share;
            };
            long unsigned int private;
        };
        struct {
            long unsigned int pp_magic;
            struct page_pool *pp;
            long unsigned int _pp_mapping_pad;
            long unsigned int dma_addr;
            atomic_long_t pp_ref_count;
        };
        struct {
            long unsigned int compound_head;
        };
        struct {
            struct dev_pagemap *pgmap;
            void *zone_device_data;
        };
        struct callback_head callback_head;
    };
    union {
        unsigned int page_type;
        atomic_t _mapcount;
    };
    atomic_t _refcount;
    long unsigned int memcg_data;
};

struct folio {
    union {
        struct {
            long unsigned int flags;
            union {
                struct list_head lru;
                struct {
                    void *__filler;
                    unsigned int mlock_count;
                };
            };
            struct address_space *mapping;
            long unsigned int index;
            union {
                void *private;
                swp_entry_t swap;
            };
            atomic_t _mapcount;
            atomic_t _refcount;
            long unsigned int memcg_data;
        };
        struct page page;
    };
    union {
        struct {
            long unsigned int _flags_1;
            long unsigned int _head_1;
            atomic_t _large_mapcount;
            atomic_t _entire_mapcount;
            atomic_t _nr_pages_mapped;
            atomic_t _pincount;
            unsigned int _folio_nr_pages;
        };
        struct page __page_1;
    };
    union {
        struct {
            long unsigned int _flags_2;
            long unsigned int _head_2;
            void *_hugetlb_subpool;
            void *_hugetlb_cgroup;
            void *_hugetlb_cgroup_rsvd;
            void *_hugetlb_hwpoison;
        };
        struct {
            long unsigned int _flags_2a;
            long unsigned int _head_2a;
            struct list_head _deferred_list;
        };
        struct page __page_2;
    };
};

struct folio_iter {
    struct folio *folio;
    size_t offset;
    size_t length;
    struct folio *_next;
    size_t _seg_count;
    int _i;
};

struct folio_queue {
    struct folio_batch vec;
    u8 orders[31];
    struct folio_queue *next;
    struct folio_queue *prev;
    long unsigned int marks;
    long unsigned int marks2;
    long unsigned int marks3;
    unsigned int rreq_id;
    unsigned int debug_id;
};

struct folio_referenced_arg {
    int mapcount;
    int referenced;
    long unsigned int vm_flags;
    struct mem_cgroup *memcg;
};

struct folio_walk {
    struct page *page;
    enum folio_walk_level level;
    union {
        pte_t *ptep;
        pud_t *pudp;
        pmd_t *pmdp;
    };
    union {
        pte_t pte;
        pud_t pud;
        pmd_t pmd;
    };
    struct vm_area_struct *vma;
    spinlock_t *ptl;
};

struct follow_page_context {
    struct dev_pagemap *pgmap;
    unsigned int page_mask;
};

struct follow_pfnmap_args {
    struct vm_area_struct *vma;
    long unsigned int address;
    spinlock_t *lock;
    pte_t *ptep;
    long unsigned int pfn;
    long unsigned int addr_mask;
    pgprot_t pgprot;
    bool writable;
    bool special;
};

struct font_data {
    unsigned int extra[4];
    const unsigned char data[0];
};

struct font_desc {
    int idx;
    const char *name;
    unsigned int width;
    unsigned int height;
    unsigned int charcount;
    const void *data;
    int pref;
};

struct format_state___2 {
    unsigned char state;
    unsigned char size;
    unsigned char flags_or_double_size;
    unsigned char base;
};

struct fown_struct {
    struct file *file;
    rwlock_t lock;
    struct pid *pid;
    enum pid_type pid_type;
    kuid_t uid;
    kuid_t euid;
    int signum;
};

struct fpmr_context {
    struct _aarch64_ctx head;
    __u64 fpmr;
};

struct fprobe_addr_list {
    int index;
    int size;
    long unsigned int *addrs;
};

struct fprobe_hlist_node {
    struct hlist_node hlist;
    long unsigned int addr;
    struct fprobe *fp;
};

struct fprobe_hlist {
    struct hlist_node hlist;
    struct callback_head rcu;
    struct fprobe *fp;
    int size;
    struct fprobe_hlist_node array[0];
};

struct fprop_global {
    struct percpu_counter events;
    unsigned int period;
    seqcount_t sequence;
};

struct fpsimd_context {
    struct _aarch64_ctx head;
    __u32 fpsr;
    __u32 fpcr;
    __int128 unsigned vregs[32];
};

typedef u32 (*rht_hashfn_t)(const void *, u32, u32);

typedef u32 (*rht_obj_hashfn_t)(const void *, u32, u32);

struct rhashtable_compare_arg;

typedef int (*rht_obj_cmpfn_t)(struct rhashtable_compare_arg *, const void *);

struct rhashtable_params {
    u16 nelem_hint;
    u16 key_len;
    u16 key_offset;
    u16 head_offset;
    unsigned int max_size;
    u16 min_size;
    bool automatic_shrinking;
    rht_hashfn_t hashfn;
    rht_obj_hashfn_t obj_hashfn;
    rht_obj_cmpfn_t obj_cmpfn;
};

struct rhashtable {
    struct bucket_table *tbl;
    unsigned int key_len;
    unsigned int max_elems;
    struct rhashtable_params p;
    bool rhlist;
    struct work_struct run_work;
    struct mutex mutex;
    spinlock_t lock;
    atomic_t nelems;
};

struct inet_frags;

struct fqdir {
    long int high_thresh;
    long int low_thresh;
    int timeout;
    int max_dist;
    struct inet_frags *f;
    struct net *net;
    bool dead;
    long: 64;
    long: 64;
    struct rhashtable rhashtable;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    atomic_long_t mem;
    struct work_struct destroy_work;
    struct llist_node free_list;
    long: 64;
    long: 64;
};

struct frag_hdr {
    __u8 nexthdr;
    __u8 reserved;
    __be16 frag_off;
    __be32 identification;
};

struct frag_v4_compare_key {
    __be32 saddr;
    __be32 daddr;
    u32 user;
    u32 vif;
    __be16 id;
    u16 protocol;
};

struct frag_v6_compare_key {
    struct in6_addr saddr;
    struct in6_addr daddr;
    u32 user;
    __be32 id;
    u32 iif;
};

struct inet_frag_queue {
    struct rhash_head node;
    union {
        struct frag_v4_compare_key v4;
        struct frag_v6_compare_key v6;
    } key;
    struct timer_list timer;
    spinlock_t lock;
    refcount_t refcnt;
    struct rb_root rb_fragments;
    struct sk_buff *fragments_tail;
    struct sk_buff *last_run_head;
    ktime_t stamp;
    int len;
    int meat;
    u8 tstamp_type;
    __u8 flags;
    u16 max_size;
    struct fqdir *fqdir;
    struct callback_head rcu;
};

struct frag_queue {
    struct inet_frag_queue q;
    int iif;
    __u16 nhoffset;
    u8 ecn;
};

struct fragment {
    struct device_node *overlay;
    struct device_node *target;
};

struct frame_tail {
    struct frame_tail *fp;
    long unsigned int lr;
};

struct framer_status {
    bool link_is_on;
};

struct framer_ops;

struct framer {
    struct device dev;
    int id;
    const struct framer_ops *ops;
    struct mutex mutex;
    int init_count;
    int power_count;
    struct regulator *pwr;
    struct work_struct notify_status_work;
    struct blocking_notifier_head notifier_list;
    struct delayed_work polling_work;
    struct framer_status prev_status;
};

struct framer_config {
    enum framer_iface iface;
    enum framer_clock_type clock_type;
    long unsigned int line_clock_rate;
};

struct framer_ops {
    int (*init)(struct framer *);
    void (*exit)(struct framer *);
    int (*power_on)(struct framer *);
    int (*power_off)(struct framer *);
    int (*get_status)(struct framer *, struct framer_status *);
    int (*set_config)(struct framer *, const struct framer_config *);
    int (*get_config)(struct framer *, struct framer_config *);
    u32 flags;
    struct module *owner;
};

struct framer_provider {
    struct device *dev;
    struct module *owner;
    struct list_head list;
    struct framer * (*of_xlate)(struct device *, const struct of_phandle_args *);
};

struct freader {
    void *buf;
    u32 buf_sz;
    int err;
    union {
        struct {
            struct file *file;
            struct folio *folio;
            void *addr;
            loff_t folio_off;
            bool may_fault;
        };
        struct {
            const char *data;
            u64 data_sz;
        };
    };
};

struct free_area {
    struct list_head free_list[6];
    long unsigned int nr_free;
};

struct freezer {
    struct cgroup_subsys_state css;
    unsigned int state;
};

struct fregs_offset {
    const char *name;
    int offset;
};

struct freq_attr {
    struct attribute attr;
    ssize_t (*show)(struct cpufreq_policy *, char *);
    ssize_t (*store)(struct cpufreq_policy *, const char *, size_t);
};

struct p_log {
    const char *prefix;
    struct fc_log *log;
};

struct fs_context_operations;

struct fs_context {
    const struct fs_context_operations *ops;
    struct mutex uapi_mutex;
    struct file_system_type *fs_type;
    void *fs_private;
    void *sget_key;
    struct dentry *root;
    struct user_namespace *user_ns;
    struct net *net_ns;
    const struct cred *cred;
    struct p_log log;
    const char *source;
    void *security;
    void *s_fs_info;
    unsigned int sb_flags;
    unsigned int sb_flags_mask;
    unsigned int s_iflags;
    enum fs_context_purpose purpose: 8;
    enum fs_context_phase phase: 8;
    bool need_free: 1;
    bool global: 1;
    bool oldapi: 1;
    bool exclusive: 1;
};

struct fs_parameter;

struct fs_context_operations {
    void (*free)(struct fs_context *);
    int (*dup)(struct fs_context *, struct fs_context *);
    int (*parse_param)(struct fs_context *, struct fs_parameter *);
    int (*parse_monolithic)(struct fs_context *, void *);
    int (*get_tree)(struct fs_context *);
    int (*reconfigure)(struct fs_context *);
};

struct fs_disk_quota {
    __s8 d_version;
    __s8 d_flags;
    __u16 d_fieldmask;
    __u32 d_id;
    __u64 d_blk_hardlimit;
    __u64 d_blk_softlimit;
    __u64 d_ino_hardlimit;
    __u64 d_ino_softlimit;
    __u64 d_bcount;
    __u64 d_icount;
    __s32 d_itimer;
    __s32 d_btimer;
    __u16 d_iwarns;
    __u16 d_bwarns;
    __s8 d_itimer_hi;
    __s8 d_btimer_hi;
    __s8 d_rtbtimer_hi;
    __s8 d_padding2;
    __u64 d_rtb_hardlimit;
    __u64 d_rtb_softlimit;
    __u64 d_rtbcount;
    __s32 d_rtbtimer;
    __u16 d_rtbwarns;
    __s16 d_padding3;
    char d_padding4[8];
};

struct fs_error_report {
    int error;
    struct inode *inode;
    struct super_block *sb;
};

struct fs_parameter {
    const char *key;
    enum fs_value_type type: 8;
    union {
        char *string;
        void *blob;
        struct filename *name;
        struct file *file;
    };
    size_t size;
    int dirfd;
};

struct fs_parse_result;

typedef int fs_param_type(struct p_log *, const struct fs_parameter_spec *, struct fs_parameter *, struct fs_parse_result *);

struct fs_parameter_spec {
    const char *name;
    fs_param_type *type;
    u8 opt;
    short unsigned int flags;
    const void *data;
};

struct fs_parse_result {
    bool negated;
    union {
        bool boolean;
        int int_32;
        unsigned int uint_32;
        u64 uint_64;
        kuid_t uid;
        kgid_t gid;
    };
};

struct fs_qfilestat {
    __u64 qfs_ino;
    __u64 qfs_nblks;
    __u32 qfs_nextents;
};

typedef struct fs_qfilestat fs_qfilestat_t;

struct fs_qfilestatv {
    __u64 qfs_ino;
    __u64 qfs_nblks;
    __u32 qfs_nextents;
    __u32 qfs_pad;
};

struct fs_quota_stat {
    __s8 qs_version;
    __u16 qs_flags;
    __s8 qs_pad;
    fs_qfilestat_t qs_uquota;
    fs_qfilestat_t qs_gquota;
    __u32 qs_incoredqs;
    __s32 qs_btimelimit;
    __s32 qs_itimelimit;
    __s32 qs_rtbtimelimit;
    __u16 qs_bwarnlimit;
    __u16 qs_iwarnlimit;
};

struct fs_quota_statv {
    __s8 qs_version;
    __u8 qs_pad1;
    __u16 qs_flags;
    __u32 qs_incoredqs;
    struct fs_qfilestatv qs_uquota;
    struct fs_qfilestatv qs_gquota;
    struct fs_qfilestatv qs_pquota;
    __s32 qs_btimelimit;
    __s32 qs_itimelimit;
    __s32 qs_rtbtimelimit;
    __u16 qs_bwarnlimit;
    __u16 qs_iwarnlimit;
    __u16 qs_rtbwarnlimit;
    __u16 qs_pad3;
    __u32 qs_pad4;
    __u64 qs_pad2[7];
};

struct fs_struct {
    int users;
    spinlock_t lock;
    seqcount_spinlock_t seq;
    int umask;
    int in_exec;
    struct path root;
    struct path pwd;
};

struct fs_sysfs_path {
    __u8 len;
    __u8 name[128];
};

struct fscrypt_key_specifier {
    __u32 type;
    __u32 __reserved;
    union {
        __u8 __reserved[32];
        __u8 descriptor[8];
        __u8 identifier[16];
    } u;
};

struct fscrypt_add_key_arg {
    struct fscrypt_key_specifier key_spec;
    __u32 raw_size;
    __u32 key_id;
    __u32 __reserved[8];
    __u8 raw[0];
};

struct fscrypt_context_v1 {
    u8 version;
    u8 contents_encryption_mode;
    u8 filenames_encryption_mode;
    u8 flags;
    u8 master_key_descriptor[8];
    u8 nonce[16];
};

struct fscrypt_context_v2 {
    u8 version;
    u8 contents_encryption_mode;
    u8 filenames_encryption_mode;
    u8 flags;
    u8 log2_data_unit_size;
    u8 __reserved[3];
    u8 master_key_identifier[16];
    u8 nonce[16];
};

union fscrypt_context {
    u8 version;
    struct fscrypt_context_v1 v1;
    struct fscrypt_context_v2 v2;
};

struct fscrypt_prepared_key {
    struct crypto_skcipher *tfm;
    struct blk_crypto_key *blk_key;
};

struct fscrypt_mode;

struct fscrypt_direct_key {
    struct super_block *dk_sb;
    struct hlist_node dk_node;
    refcount_t dk_refcount;
    const struct fscrypt_mode *dk_mode;
    struct fscrypt_prepared_key dk_key;
    u8 dk_descriptor[8];
    u8 dk_raw[64];
};

struct fscrypt_get_key_status_arg {
    struct fscrypt_key_specifier key_spec;
    __u32 __reserved[6];
    __u32 status;
    __u32 status_flags;
    __u32 user_count;
    __u32 __out_reserved[13];
};

struct fscrypt_policy_v1 {
    __u8 version;
    __u8 contents_encryption_mode;
    __u8 filenames_encryption_mode;
    __u8 flags;
    __u8 master_key_descriptor[8];
};

struct fscrypt_policy_v2 {
    __u8 version;
    __u8 contents_encryption_mode;
    __u8 filenames_encryption_mode;
    __u8 flags;
    __u8 log2_data_unit_size;
    __u8 __reserved[3];
    __u8 master_key_identifier[16];
};

struct fscrypt_get_policy_ex_arg {
    __u64 policy_size;
    union {
        __u8 version;
        struct fscrypt_policy_v1 v1;
        struct fscrypt_policy_v2 v2;
    } policy;
};

struct fscrypt_hkdf {
    struct crypto_shash *hmac_tfm;
};

union fscrypt_policy {
    u8 version;
    struct fscrypt_policy_v1 v1;
    struct fscrypt_policy_v2 v2;
};

struct fscrypt_master_key;

struct fscrypt_inode_info {
    struct fscrypt_prepared_key ci_enc_key;
    u8 ci_owns_key: 1;
    u8 ci_inlinecrypt: 1;
    u8 ci_dirhash_key_initialized: 1;
    u8 ci_data_unit_bits;
    u8 ci_data_units_per_block_bits;
    u32 ci_hashed_ino;
    struct fscrypt_mode *ci_mode;
    struct inode *ci_inode;
    struct fscrypt_master_key *ci_master_key;
    struct list_head ci_master_key_link;
    struct fscrypt_direct_key *ci_direct_key;
    siphash_key_t ci_dirhash_key;
    union fscrypt_policy ci_policy;
    u8 ci_nonce[16];
};

union fscrypt_iv {
    struct {
        __le64 index;
        u8 nonce[16];
    };
    u8 raw[32];
    __le64 dun[4];
};

struct fscrypt_key {
    __u32 mode;
    __u8 raw[64];
    __u32 size;
};

struct fscrypt_keyring {
    spinlock_t lock;
    struct hlist_head key_hashtable[128];
};

struct fscrypt_master_key_secret {
    struct fscrypt_hkdf hkdf;
    u32 size;
    u8 raw[64];
};

struct fscrypt_master_key {
    struct hlist_node mk_node;
    struct rw_semaphore mk_sem;
    refcount_t mk_active_refs;
    refcount_t mk_struct_refs;
    struct callback_head mk_rcu_head;
    struct fscrypt_master_key_secret mk_secret;
    struct fscrypt_key_specifier mk_spec;
    struct key *mk_users;
    struct list_head mk_decrypted_inodes;
    spinlock_t mk_decrypted_inodes_lock;
    struct fscrypt_prepared_key mk_direct_keys[11];
    struct fscrypt_prepared_key mk_iv_ino_lblk_64_keys[11];
    struct fscrypt_prepared_key mk_iv_ino_lblk_32_keys[11];
    siphash_key_t mk_ino_hash_key;
    bool mk_ino_hash_key_initialized;
    bool mk_present;
};

struct fscrypt_mode {
    const char *friendly_name;
    const char *cipher_str;
    int keysize;
    int security_strength;
    int ivsize;
    int logged_cryptoapi_impl;
    int logged_blk_crypto_native;
    int logged_blk_crypto_fallback;
    enum blk_crypto_mode_num blk_crypto_mode;
};

struct fscrypt_name {
    const struct qstr *usr_fname;
    struct fscrypt_str disk_name;
    u32 hash;
    u32 minor_hash;
    struct fscrypt_str crypto_buf;
    bool is_nokey_name;
};

struct fscrypt_nokey_name {
    u32 dirhash[2];
    u8 bytes[149];
    u8 sha256[32];
};

struct fscrypt_operations {
    unsigned int needs_bounce_pages: 1;
    unsigned int has_32bit_inodes: 1;
    unsigned int supports_subblock_data_units: 1;
    const char *legacy_key_prefix;
    int (*get_context)(struct inode *, void *, size_t);
    int (*set_context)(struct inode *, const void *, size_t, void *);
    const union fscrypt_policy * (*get_dummy_policy)(struct super_block *);
    bool (*empty_dir)(struct inode *);
    bool (*has_stable_inodes)(struct super_block *);
    struct block_device ** (*get_devices)(struct super_block *, unsigned int *);
};

struct fscrypt_provisioning_key_payload {
    __u32 type;
    __u32 __reserved;
    __u8 raw[0];
};

struct fscrypt_remove_key_arg {
    struct fscrypt_key_specifier key_spec;
    __u32 removal_status_flags;
    __u32 __reserved[5];
};

struct fscrypt_symlink_data {
    __le16 len;
    char encrypted_path[0];
};

struct fsl_mc_obj_desc {
    char type[16];
    int id;
    u16 vendor;
    u16 ver_major;
    u16 ver_minor;
    u8 irq_count;
    u8 region_count;
    u32 state;
    char label[16];
    u16 flags;
};

struct fsl_mc_io;

struct fsl_mc_device_irq;

struct fsl_mc_resource;

struct fsl_mc_device {
    struct device dev;
    u64 dma_mask;
    u16 flags;
    u32 icid;
    u16 mc_handle;
    struct fsl_mc_io *mc_io;
    struct fsl_mc_obj_desc obj_desc;
    struct resource *regions;
    struct fsl_mc_device_irq **irqs;
    struct fsl_mc_resource *resource;
    struct device_link *consumer_link;
    const char *driver_override;
};

struct fsl_mc_resource_pool;

struct fsl_mc_resource {
    enum fsl_mc_pool_type type;
    s32 id;
    void *data;
    struct fsl_mc_resource_pool *parent_pool;
    struct list_head node;
};

struct fsl_mc_device_irq {
    unsigned int virq;
    struct fsl_mc_device *mc_dev;
    u8 dev_irq_index;
    struct fsl_mc_resource resource;
};

struct fsl_mc_io {
    struct device *dev;
    u16 flags;
    u32 portal_size;
    phys_addr_t portal_phys_addr;
    void *portal_virt_addr;
    struct fsl_mc_device *dpmcp_dev;
    union {
        struct mutex mutex;
        raw_spinlock_t spinlock;
    };
};

struct fsmap {
    __u32 fmr_device;
    __u32 fmr_flags;
    __u64 fmr_physical;
    __u64 fmr_owner;
    __u64 fmr_offset;
    __u64 fmr_length;
    __u64 fmr_reserved[3];
};

struct fsmap_head {
    __u32 fmh_iflags;
    __u32 fmh_oflags;
    __u32 fmh_count;
    __u32 fmh_entries;
    __u64 fmh_reserved[6];
    struct fsmap fmh_keys[2];
    struct fsmap fmh_recs[0];
};

struct inotify_group_private_data {
    spinlock_t idr_lock;
    struct idr idr;
    struct ucounts *ucounts;
};

struct fsnotify_ops;

struct fsnotify_group {
    const struct fsnotify_ops *ops;
    refcount_t refcnt;
    spinlock_t notification_lock;
    struct list_head notification_list;
    wait_queue_head_t notification_waitq;
    unsigned int q_len;
    unsigned int max_events;
    enum fsnotify_group_prio priority;
    bool shutdown;
    int flags;
    unsigned int owner_flags;
    struct mutex mark_mutex;
    atomic_t user_waits;
    struct list_head marks_list;
    struct fasync_struct *fsn_fa;
    struct fsnotify_event *overflow_event;
    struct mem_cgroup *memcg;
    union {
        void *private;
        struct inotify_group_private_data inotify_data;
        struct fanotify_group_private_data fanotify_data;
    };
};

struct fsnotify_iter_info {
    struct fsnotify_mark *marks[5];
    struct fsnotify_group *current_group;
    unsigned int report_mask;
    int srcu_idx;
};

typedef struct fsnotify_mark_connector *fsnotify_connp_t;

struct fsnotify_mark_connector {
    spinlock_t lock;
    unsigned char type;
    unsigned char prio;
    short unsigned int flags;
    union {
        void *obj;
        struct fsnotify_mark_connector *destroy_next;
    };
    struct hlist_head list;
};

struct fsnotify_ops {
    int (*handle_event)(struct fsnotify_group *, u32, const void *, int, struct inode *, const struct qstr *, u32, struct fsnotify_iter_info *);
    int (*handle_inode_event)(struct fsnotify_mark *, u32, struct inode *, struct inode *, const struct qstr *, u32);
    void (*free_group_priv)(struct fsnotify_group *);
    void (*freeing_mark)(struct fsnotify_mark *, struct fsnotify_group *);
    void (*free_event)(struct fsnotify_group *, struct fsnotify_event *);
    void (*free_mark)(struct fsnotify_mark *);
};

struct fsnotify_sb_info {
    struct fsnotify_mark_connector *sb_marks;
    atomic_long_t watched_objects[3];
};

struct fstrim_range {
    __u64 start;
    __u64 len;
    __u64 minlen;
};

struct fsuuid {
    __u32 fsu_len;
    __u32 fsu_flags;
    __u8 fsu_uuid[0];
};

struct fsuuid2 {
    __u8 len;
    __u8 uuid[16];
};

struct fsxattr {
    __u32 fsx_xflags;
    __u32 fsx_extsize;
    __u32 fsx_nextents;
    __u32 fsx_projid;
    __u32 fsx_cowextsize;
    unsigned char fsx_pad[8];
};

typedef bool filter_t(u64);

struct ftr_set_desc {
    char name[20];
    union {
        struct arm64_ftr_override *override;
        prel64_t override_prel;
    };
    struct {
        char name[10];
        u8 shift;
        u8 width;
        union {
            filter_t *filter;
            prel64_t filter_prel;
        };
    } fields[0];
};

struct trace_seq {
    char buffer[8156];
    struct seq_buf seq;
    size_t readpos;
    int full;
};

struct tracer;

struct ring_buffer_iter;

struct trace_iterator {
    struct trace_array *tr;
    struct tracer *trace;
    struct array_buffer *array_buffer;
    void *private;
    int cpu_file;
    struct mutex mutex;
    struct ring_buffer_iter **buffer_iter;
    long unsigned int iter_flags;
    void *temp;
    unsigned int temp_size;
    char *fmt;
    unsigned int fmt_size;
    atomic_t wait_index;
    struct trace_seq tmp_seq;
    cpumask_var_t started;
    bool closed;
    bool snapshot;
    struct trace_seq seq;
    struct trace_entry *ent;
    long unsigned int lost_events;
    int leftover;
    int ent_size;
    int cpu;
    u64 ts;
    loff_t pos;
    long int idx;
};

struct ftrace_buffer_info {
    struct trace_iterator iter;
    void *spare;
    unsigned int spare_cpu;
    unsigned int spare_size;
    unsigned int read;
};

struct ftrace_entry {
    struct trace_entry ent;
    long unsigned int ip;
    long unsigned int parent_ip;
};

struct ftrace_event_field {
    struct list_head link;
    const char *name;
    const char *type;
    int filter_type;
    int offset;
    int size;
    unsigned int is_signed: 1;
    unsigned int needs_test: 1;
    int len;
};

struct ftrace_func_command {
    struct list_head list;
    char *name;
    int (*func)(struct trace_array *, struct ftrace_hash *, char *, char *, char *, int);
};

struct ftrace_func_entry {
    struct hlist_node hlist;
    long unsigned int ip;
    long unsigned int direct;
};

struct ftrace_func_map {
    struct ftrace_func_entry entry;
    void *data;
};

struct ftrace_hash {
    long unsigned int size_bits;
    struct hlist_head *buckets;
    long unsigned int count;
    long unsigned int flags;
    struct callback_head rcu;
};

struct ftrace_func_mapper {
    struct ftrace_hash hash;
};

struct ftrace_probe_ops;

struct ftrace_func_probe {
    struct ftrace_probe_ops *probe_ops;
    struct ftrace_ops ops;
    struct trace_array *tr;
    struct list_head list;
    void *data;
    int ref;
};

struct ftrace_glob {
    char *search;
    unsigned int len;
    int type;
};

struct trace_parser {
    bool cont;
    char *buffer;
    unsigned int idx;
    unsigned int size;
};

struct ftrace_graph_data {
    struct ftrace_hash *hash;
    struct ftrace_func_entry *entry;
    int idx;
    enum graph_filter_type type;
    struct ftrace_hash *new_hash;
    const struct seq_operations *seq_ops;
    struct trace_parser parser;
};

struct ftrace_init_func {
    struct list_head list;
    long unsigned int ip;
};

struct ftrace_page;

struct ftrace_iterator {
    loff_t pos;
    loff_t func_pos;
    loff_t mod_pos;
    struct ftrace_page *pg;
    struct dyn_ftrace *func;
    struct ftrace_func_probe *probe;
    struct ftrace_func_entry *probe_entry;
    struct trace_parser parser;
    struct ftrace_hash *hash;
    struct ftrace_ops *ops;
    struct trace_array *tr;
    struct list_head *mod_list;
    int pidx;
    int idx;
    unsigned int flags;
};

struct ftrace_mod_func {
    struct list_head list;
    char *name;
    long unsigned int ip;
    unsigned int size;
};

struct ftrace_mod_load {
    struct list_head list;
    char *func;
    char *module;
    int enable;
};

struct ftrace_mod_map {
    struct callback_head rcu;
    struct list_head list;
    struct module *mod;
    long unsigned int start_addr;
    long unsigned int end_addr;
    struct list_head funcs;
    unsigned int num_funcs;
};

struct ftrace_page {
    struct ftrace_page *next;
    struct dyn_ftrace *records;
    int index;
    int order;
};

struct ftrace_probe_ops {
    void (*func)(long unsigned int, long unsigned int, struct trace_array *, struct ftrace_probe_ops *, void *);
    int (*init)(struct ftrace_probe_ops *, struct trace_array *, long unsigned int, void *, void **);
    void (*free)(struct ftrace_probe_ops *, struct trace_array *, long unsigned int, void *);
    int (*print)(struct seq_file *, long unsigned int, struct ftrace_probe_ops *, void *);
};

struct ftrace_profile {
    struct hlist_node node;
    long unsigned int ip;
    long unsigned int counter;
    long long unsigned int time;
    long long unsigned int time_squared;
};

struct ftrace_profile_page {
    struct ftrace_profile_page *next;
    long unsigned int index;
    struct ftrace_profile records[0];
};

typedef int (*cmp_func_t)(const void *, const void *);

struct tracer_stat {
    const char *name;
    void * (*stat_start)(struct tracer_stat *);
    void * (*stat_next)(void *, int);
    cmp_func_t stat_cmp;
    int (*stat_show)(struct seq_file *, void *);
    void (*stat_release)(void *);
    int (*stat_headers)(struct seq_file *);
};

struct ftrace_profile_stat {
    atomic_t disabled;
    struct hlist_head *hash;
    struct ftrace_profile_page *pages;
    struct ftrace_profile_page *start;
    struct tracer_stat stat;
};

struct ftrace_rec_iter {
    struct ftrace_page *pg;
    int index;
};

struct ftrace_regs {};

struct ftrace_ret_stack {
    long unsigned int ret;
    long unsigned int func;
    long unsigned int fp;
    long unsigned int *retp;
};

struct ftrace_stack {
    long unsigned int calls[1024];
};

struct ftrace_stacks {
    struct ftrace_stack stacks[4];
};

struct func_repeats_entry {
    struct trace_entry ent;
    long unsigned int ip;
    long unsigned int parent_ip;
    u16 count;
    u16 top_delta_ts;
    u32 bottom_delta_ts;
};

struct pinfunction {
    const char *name;
    const char * const *groups;
    size_t ngroups;
};

struct function_desc {
    struct pinfunction func;
    void *data;
};

struct function_filter_data {
    struct ftrace_ops *ops;
    int first_filter;
    int first_notrace;
};

struct futex_hash_bucket {
    atomic_t waiters;
    spinlock_t lock;
    struct plist_head chain;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
};

union futex_key {
    struct {
        u64 i_seq;
        long unsigned int pgoff;
        unsigned int offset;
    } shared;
    struct {
        union {
            struct mm_struct *mm;
            u64 __tmp;
        };
        long unsigned int address;
        unsigned int offset;
    } private;
    struct {
        u64 ptr;
        long unsigned int word;
        unsigned int offset;
    } both;
};

struct rt_mutex_base {
    raw_spinlock_t wait_lock;
    struct rb_root_cached waiters;
    struct task_struct *owner;
};

struct futex_pi_state {
    struct list_head list;
    struct rt_mutex_base pi_mutex;
    struct task_struct *owner;
    refcount_t refcount;
    union futex_key key;
};

struct wake_q_head;

struct futex_q;

typedef void futex_wake_fn(struct wake_q_head *, struct futex_q *);

struct rt_mutex_waiter;

struct futex_q {
    struct plist_node list;
    struct task_struct *task;
    spinlock_t *lock_ptr;
    futex_wake_fn *wake;
    void *wake_data;
    union futex_key key;
    struct futex_pi_state *pi_state;
    struct rt_mutex_waiter *rt_waiter;
    union futex_key *requeue_pi_key;
    u32 bitset;
    atomic_t requeue_state;
};

struct futex_waitv {
    __u64 val;
    __u64 uaddr;
    __u32 flags;
    __u32 __reserved;
};

struct futex_vector {
    struct futex_waitv w;
    struct futex_q q;
};

struct fw_state {
    struct completion completion;
    enum fw_status status;
};

struct fw_priv {
    struct kref ref;
    struct list_head list;
    struct firmware_cache *fwc;
    struct fw_state fw_st;
    void *data;
    size_t size;
    size_t allocated_size;
    size_t offset;
    u32 opt_flags;
    bool is_paged_buf;
    struct page **pages;
    int nr_pages;
    int page_array_size;
    const char *fw_name;
};

struct fw_sysfs {
    bool nowait;
    struct device dev;
    struct fw_priv *fw_priv;
    struct firmware *fw;
    void *fw_upload_priv;
};

struct fw_upload {
    void *dd_handle;
    void *priv;
};

struct fw_upload_ops {
    enum fw_upload_err (*prepare)(struct fw_upload *, const u8 *, u32);
    enum fw_upload_err (*write)(struct fw_upload *, const u8 *, u32, u32, u32 *);
    enum fw_upload_err (*poll_complete)(struct fw_upload *);
    void (*cancel)(struct fw_upload *);
    void (*cleanup)(struct fw_upload *);
};

struct fw_upload_priv {
    struct fw_upload *fw_upload;
    struct module *module;
    const char *name;
    const struct fw_upload_ops *ops;
    struct mutex lock;
    struct work_struct work;
    const u8 *data;
    u32 remaining_size;
    enum fw_upload_prog progress;
    enum fw_upload_prog err_progress;
    enum fw_upload_err err_code;
};

union fwnet_hwaddr {
    u8 u[16];
    struct {
        __be64 uniq_id;
        u8 max_rec;
        u8 sspd;
        u8 fifo[6];
    } uc;
};

struct fwnode_endpoint {
    unsigned int port;
    unsigned int id;
    const struct fwnode_handle *local_fwnode;
};

struct fwnode_link {
    struct fwnode_handle *supplier;
    struct list_head s_hook;
    struct fwnode_handle *consumer;
    struct list_head c_hook;
    u8 flags;
};

struct fwnode_reference_args;

struct fwnode_operations {
    struct fwnode_handle * (*get)(struct fwnode_handle *);
    void (*put)(struct fwnode_handle *);
    bool (*device_is_available)(const struct fwnode_handle *);
    const void * (*device_get_match_data)(const struct fwnode_handle *, const struct device *);
    bool (*device_dma_supported)(const struct fwnode_handle *);
    enum dev_dma_attr (*device_get_dma_attr)(const struct fwnode_handle *);
    bool (*property_present)(const struct fwnode_handle *, const char *);
    bool (*property_read_bool)(const struct fwnode_handle *, const char *);
    int (*property_read_int_array)(const struct fwnode_handle *, const char *, unsigned int, void *, size_t);
    int (*property_read_string_array)(const struct fwnode_handle *, const char *, const char **, size_t);
    const char * (*get_name)(const struct fwnode_handle *);
    const char * (*get_name_prefix)(const struct fwnode_handle *);
    struct fwnode_handle * (*get_parent)(const struct fwnode_handle *);
    struct fwnode_handle * (*get_next_child_node)(const struct fwnode_handle *, struct fwnode_handle *);
    struct fwnode_handle * (*get_named_child_node)(const struct fwnode_handle *, const char *);
    int (*get_reference_args)(const struct fwnode_handle *, const char *, const char *, unsigned int, unsigned int, struct fwnode_reference_args *);
    struct fwnode_handle * (*graph_get_next_endpoint)(const struct fwnode_handle *, struct fwnode_handle *);
    struct fwnode_handle * (*graph_get_remote_endpoint)(const struct fwnode_handle *);
    struct fwnode_handle * (*graph_get_port_parent)(struct fwnode_handle *);
    int (*graph_parse_endpoint)(const struct fwnode_handle *, struct fwnode_endpoint *);
    void * (*iomap)(struct fwnode_handle *, int);
    int (*irq_get)(const struct fwnode_handle *, unsigned int);
    int (*add_links)(struct fwnode_handle *);
};

struct fwnode_reference_args {
    struct fwnode_handle *fwnode;
    unsigned int nargs;
    u64 args[16];
};

struct gcry_mpi {
    int alloced;
    int nlimbs;
    int nbits;
    int sign;
    unsigned int flags;
    mpi_limb_t *d;
};

struct gcs_context {
    struct _aarch64_ctx head;
    __u64 gcspr;
    __u64 features_enabled;
    __u64 reserved;
};

struct pcpu_gen_cookie;

struct gen_cookie {
    struct pcpu_gen_cookie *local;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    atomic64_t forward_last;
    atomic64_t reverse_last;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
};

struct gen_pool;

typedef long unsigned int (*genpool_algo_t)(long unsigned int *, long unsigned int, long unsigned int, unsigned int, void *, struct gen_pool *, long unsigned int);

struct gen_pool {
    spinlock_t lock;
    struct list_head chunks;
    int min_alloc_order;
    genpool_algo_t algo;
    void *data;
    const char *name;
};

struct gen_pool_chunk {
    struct list_head next_chunk;
    atomic_long_t avail;
    phys_addr_t phys_addr;
    void *owner;
    long unsigned int start_addr;
    long unsigned int end_addr;
    long unsigned int bits[0];
};

struct timer_rand_state;

struct gendisk {
    int major;
    int first_minor;
    int minors;
    char disk_name[32];
    short unsigned int events;
    short unsigned int event_flags;
    struct xarray part_tbl;
    struct block_device *part0;
    const struct block_device_operations *fops;
    struct request_queue *queue;
    void *private_data;
    struct bio_set bio_split;
    int flags;
    long unsigned int state;
    struct mutex open_mutex;
    unsigned int open_partitions;
    struct backing_dev_info *bdi;
    struct kobject queue_kobj;
    struct kobject *slave_dir;
    struct list_head slave_bdevs;
    struct timer_rand_state *random;
    atomic_t sync_io;
    struct disk_events *ev;
    unsigned int nr_zones;
    unsigned int zone_capacity;
    unsigned int last_zone_capacity;
    long unsigned int *conv_zones_bitmap;
    unsigned int zone_wplugs_hash_bits;
    atomic_t nr_zone_wplugs;
    spinlock_t zone_wplugs_lock;
    struct mempool_s *zone_wplugs_pool;
    struct hlist_head *zone_wplugs_hash;
    struct workqueue_struct *zone_wplugs_wq;
    struct cdrom_device_info *cdi;
    int node_id;
    struct badblocks *bb;
    struct lockdep_map lockdep_map;
    u64 diskseq;
    blk_mode_t open_mode;
    struct blk_independent_access_ranges *ia_ranges;
};

struct pm_domain_data {
    struct list_head list_node;
    struct device *dev;
};

struct gpd_timing_data;

struct generic_pm_domain_data {
    struct pm_domain_data base;
    struct gpd_timing_data *td;
    struct notifier_block nb;
    struct notifier_block *power_nb;
    int cpu;
    unsigned int performance_state;
    unsigned int default_pstate;
    unsigned int rpm_pstate;
    unsigned int opp_token;
    bool hw_mode;
    void *data;
};

struct geneve_opt {
    __be16 opt_class;
    u8 type;
    u8 length: 5;
    u8 r3: 1;
    u8 r2: 1;
    u8 r1: 1;
    u8 opt_data[0];
};

struct ocontext;

struct genfs {
    char *fstype;
    struct ocontext *head;
    struct genfs *next;
};

struct netlink_callback;

struct nla_policy;

struct genl_split_ops {
    union {
        struct {
            int (*pre_doit)(const struct genl_split_ops *, struct sk_buff *, struct genl_info *);
            int (*doit)(struct sk_buff *, struct genl_info *);
            void (*post_doit)(const struct genl_split_ops *, struct sk_buff *, struct genl_info *);
        };
        struct {
            int (*start)(struct netlink_callback *);
            int (*dumpit)(struct sk_buff *, struct netlink_callback *);
            int (*done)(struct netlink_callback *);
        };
    };
    const struct nla_policy *policy;
    unsigned int maxattr;
    u8 cmd;
    u8 internal_flags;
    u8 flags;
    u8 validate;
};

struct genlmsghdr;

struct genl_info {
    u32 snd_seq;
    u32 snd_portid;
    const struct genl_family *family;
    const struct nlmsghdr *nlhdr;
    struct genlmsghdr *genlhdr;
    struct nlattr **attrs;
    possible_net_t _net;
    union {
        u8 ctx[48];
        void *user_ptr[2];
    };
    struct netlink_ext_ack *extack;
};

struct genl_dumpit_info {
    struct genl_split_ops op;
    struct genl_info info;
};

struct genl_ops;

struct genl_small_ops;

struct genl_multicast_group;

struct genl_family {
    unsigned int hdrsize;
    char name[16];
    unsigned int version;
    unsigned int maxattr;
    u8 netnsok: 1;
    u8 parallel_ops: 1;
    u8 n_ops;
    u8 n_small_ops;
    u8 n_split_ops;
    u8 n_mcgrps;
    u8 resv_start_op;
    const struct nla_policy *policy;
    int (*pre_doit)(const struct genl_split_ops *, struct sk_buff *, struct genl_info *);
    void (*post_doit)(const struct genl_split_ops *, struct sk_buff *, struct genl_info *);
    int (*bind)(int);
    void (*unbind)(int);
    const struct genl_ops *ops;
    const struct genl_small_ops *small_ops;
    const struct genl_split_ops *split_ops;
    const struct genl_multicast_group *mcgrps;
    struct module *module;
    size_t sock_priv_size;
    void (*sock_priv_init)(void *);
    void (*sock_priv_destroy)(void *);
    int id;
    unsigned int mcgrp_offset;
    struct xarray *sock_privs;
};

struct genl_multicast_group {
    char name[16];
    u8 flags;
};

struct genl_op_iter {
    const struct genl_family *family;
    struct genl_split_ops doit;
    struct genl_split_ops dumpit;
    int cmd_idx;
    int entry_idx;
    u32 cmd;
    u8 flags;
};

struct genl_ops {
    int (*doit)(struct sk_buff *, struct genl_info *);
    int (*start)(struct netlink_callback *);
    int (*dumpit)(struct sk_buff *, struct netlink_callback *);
    int (*done)(struct netlink_callback *);
    const struct nla_policy *policy;
    unsigned int maxattr;
    u8 cmd;
    u8 internal_flags;
    u8 flags;
    u8 validate;
};

struct genl_small_ops {
    int (*doit)(struct sk_buff *, struct genl_info *);
    int (*dumpit)(struct sk_buff *, struct netlink_callback *);
    u8 cmd;
    u8 internal_flags;
    u8 flags;
    u8 validate;
};

struct genl_start_context {
    const struct genl_family *family;
    struct nlmsghdr *nlh;
    struct netlink_ext_ack *extack;
    const struct genl_split_ops *ops;
    int hdrlen;
};

struct genlmsghdr {
    __u8 cmd;
    __u8 version;
    __u16 reserved;
};

struct genpd_governor_data {
    s64 max_off_time_ns;
    bool max_off_time_changed;
    ktime_t next_wakeup;
    ktime_t next_hrtimer;
    bool cached_power_down_ok;
    bool cached_power_down_state_idx;
};

struct genpd_lock_ops {
    void (*lock)(struct generic_pm_domain *);
    void (*lock_nested)(struct generic_pm_domain *, int);
    int (*lock_interruptible)(struct generic_pm_domain *);
    void (*unlock)(struct generic_pm_domain *);
};

struct genpd_power_state {
    const char *name;
    s64 power_off_latency_ns;
    s64 power_on_latency_ns;
    s64 residency_ns;
    u64 usage;
    u64 rejected;
    struct fwnode_handle *fwnode;
    u64 idle_time;
    void *data;
};

struct genpool_data_align {
    int align;
};

struct genpool_data_fixed {
    long unsigned int offset;
};

struct genradix_iter {
    size_t offset;
    size_t pos;
};

struct genradix_node {
    union {
        struct genradix_node *children[64];
        u8 data[512];
    };
};

struct getcpu_cache {
    long unsigned int blob[16];
};

struct getdents_callback {
    struct dir_context ctx;
    char *name;
    u64 ino;
    int found;
    int sequence;
};

struct linux_dirent;

struct getdents_callback___2 {
    struct dir_context ctx;
    struct linux_dirent *current_dir;
    int prev_reclen;
    int count;
    int error;
};

struct linux_dirent64;

struct getdents_callback64 {
    struct dir_context ctx;
    struct linux_dirent64 *current_dir;
    int prev_reclen;
    int count;
    int error;
};

struct getfsmap_info {
    struct super_block *gi_sb;
    struct fsmap_head *gi_data;
    unsigned int gi_idx;
    __u32 gi_last_flags;
};

struct input_keymap_entry {
    __u8 flags;
    __u8 len;
    __u16 index;
    __u32 keycode;
    __u8 scancode[32];
};

struct getset_keycode_data {
    struct input_keymap_entry ke;
    int error;
};

struct kvm_memory_slot;

struct gfn_to_hva_cache {
    u64 generation;
    gpa_t gpa;
    long unsigned int hva;
    long unsigned int len;
    struct kvm_memory_slot *memslot;
};

union gic_base {
    void *common_base;
    void **percpu_base;
};

struct gic_chip_data {
    union gic_base dist_base;
    union gic_base cpu_base;
    void *raw_dist_base;
    void *raw_cpu_base;
    u32 percpu_offset;
    u32 saved_spi_enable[32];
    u32 saved_spi_active[32];
    u32 saved_spi_conf[64];
    u32 saved_spi_target[255];
    u32 *saved_ppi_enable;
    u32 *saved_ppi_active;
    u32 *saved_ppi_conf;
    struct irq_domain *domain;
    unsigned int gic_irqs;
};

struct rdists {
    struct {
        raw_spinlock_t rd_lock;
        void *rd_base;
        struct page *pend_page;
        phys_addr_t phys_base;
        u64 flags;
        cpumask_t *vpe_table_mask;
        void *vpe_l1_base;
    } *rdist;
    phys_addr_t prop_table_pa;
    void *prop_table_va;
    u64 flags;
    u32 gicd_typer;
    u32 gicd_typer2;
    int cpuhp_memreserve_state;
    bool has_vlpis;
    bool has_rvpeid;
    bool has_direct_lpi;
    bool has_vpend_valid_dirty;
};

struct redist_region;

struct partition_desc;

struct gic_chip_data___2 {
    struct fwnode_handle *fwnode;
    phys_addr_t dist_phys_base;
    void *dist_base;
    struct redist_region *redist_regions;
    struct rdists rdists;
    struct irq_domain *domain;
    u64 redist_stride;
    u32 nr_redist_regions;
    u64 flags;
    bool has_rss;
    unsigned int ppi_nr;
    struct partition_desc **ppi_descs;
};

struct gic_kvm_info {
    enum gic_type type;
    struct resource vcpu;
    unsigned int maint_irq;
    bool no_maint_irq_mask;
    struct resource vctrl;
    bool has_v4;
    bool has_v4_1;
    bool no_hw_deactivation;
};

struct gic_quirk {
    const char *desc;
    const char *compatible;
    const char *property;
    bool (*init)(void *);
    u32 iidr;
    u32 mask;
};

struct usb_host_endpoint;

struct giveback_urb_bh {
    bool running;
    bool high_prio;
    spinlock_t lock;
    struct list_head head;
    struct work_struct bh;
    struct usb_host_endpoint *completing_ep;
};

struct tc_stats {
    __u64 bytes;
    __u32 packets;
    __u32 drops;
    __u32 overlimits;
    __u32 bps;
    __u32 pps;
    __u32 qlen;
    __u32 backlog;
};

struct gnet_dump {
    spinlock_t *lock;
    struct sk_buff *skb;
    struct nlattr *tail;
    int compat_tc_stats;
    int compat_xstats;
    int padattr;
    void *xstats;
    int xstats_len;
    struct tc_stats tc_stats;
};

struct gnet_estimator {
    signed char interval;
    unsigned char ewma_log;
};

struct gnet_stats_basic {
    __u64 bytes;
    __u32 packets;
};

struct gnet_stats_rate_est {
    __u32 bps;
    __u32 pps;
};

struct gnet_stats_rate_est64 {
    __u64 bps;
    __u64 pps;
};

struct gnu_property {
    u32 pr_type;
    u32 pr_datasz;
};

struct governor_attr {
    struct attribute attr;
    ssize_t (*show)(struct gov_attr_set *, char *);
    ssize_t (*store)(struct gov_attr_set *, const char *, size_t);
};

struct watchdog_governor;

struct governor_priv {
    struct watchdog_governor *gov;
    struct list_head entry;
};

struct gpd_link {
    struct generic_pm_domain *parent;
    struct list_head parent_node;
    struct generic_pm_domain *child;
    struct list_head child_node;
    unsigned int performance_state;
    unsigned int prev_performance_state;
};

struct gpd_timing_data {
    s64 suspend_latency_ns;
    s64 resume_latency_ns;
    s64 effective_constraint_ns;
    ktime_t next_wakeup;
    bool constraint_changed;
    bool cached_suspend_ok;
};

struct gpio_array {
    struct gpio_desc **desc;
    unsigned int size;
    struct gpio_device *gdev;
    long unsigned int *get_mask;
    long unsigned int *set_mask;
    long unsigned int invert_mask[0];
};

struct gpio_v2_line_attribute {
    __u32 id;
    __u32 padding;
    union {
        __u64 flags;
        __u64 values;
        __u32 debounce_period_us;
    };
};

struct gpio_v2_line_info {
    char name[32];
    char consumer[32];
    __u32 offset;
    __u32 num_attrs;
    __u64 flags;
    struct gpio_v2_line_attribute attrs[10];
    __u32 padding[4];
};

struct gpio_v2_line_info_changed {
    struct gpio_v2_line_info info;
    __u64 timestamp_ns;
    __u32 event_type;
    __u32 padding[5];
};

struct gpio_chardev_data {
    struct gpio_device *gdev;
    wait_queue_head_t wait;
    struct {
        union {
            struct __kfifo kfifo;
            struct gpio_v2_line_info_changed *type;
            const struct gpio_v2_line_info_changed *const_type;
            char (*rectype)[0];
            struct gpio_v2_line_info_changed *ptr;
            const struct gpio_v2_line_info_changed *ptr_const;
        };
        struct gpio_v2_line_info_changed buf[32];
    } events;
    struct notifier_block lineinfo_changed_nb;
    struct notifier_block device_unregistered_nb;
    long unsigned int *watched_lines;
    atomic_t watch_abi_version;
    struct file *fp;
};

struct gpio_chip_guard {
    struct gpio_device *gdev;
    struct gpio_chip *gc;
    int idx;
};

typedef struct gpio_chip_guard class_gpio_chip_guard_t;

struct gpio_desc_label;

struct gpio_desc {
    struct gpio_device *gdev;
    long unsigned int flags;
    struct gpio_desc_label *label;
    const char *name;
    struct device_node *hog;
    unsigned int debounce_period_us;
};

struct gpio_desc_label {
    struct callback_head rh;
    char str[0];
};

struct gpio_descs {
    struct gpio_array *info;
    unsigned int ndescs;
    struct gpio_desc *desc[0];
};

struct gpio_device {
    struct device dev;
    struct cdev chrdev;
    int id;
    struct device *mockdev;
    struct module *owner;
    struct gpio_chip *chip;
    struct gpio_desc *descs;
    struct srcu_struct desc_srcu;
    unsigned int base;
    u16 ngpio;
    bool can_sleep;
    const char *label;
    void *data;
    struct list_head list;
    struct raw_notifier_head line_state_notifier;
    rwlock_t line_state_lock;
    struct workqueue_struct *line_state_wq;
    struct blocking_notifier_head device_notifier;
    struct srcu_struct srcu;
    struct list_head pin_ranges;
};

struct gpio_get_config {
    u32 gpio;
    u32 direction;
    u32 polarity;
    u32 term_en;
    u32 term_pull_up;
};

struct gpio_get_set_state {
    u32 gpio;
    u32 state;
};

struct irq_fwspec {
    struct fwnode_handle *fwnode;
    int param_count;
    u32 param[16];
};

struct msi_desc;

struct msi_alloc_info {
    struct msi_desc *desc;
    irq_hw_number_t hwirq;
    long unsigned int flags;
    union {
        long unsigned int ul;
        void *ptr;
    } scratchpad[2];
};

typedef struct msi_alloc_info msi_alloc_info_t;

union gpio_irq_fwspec {
    struct irq_fwspec fwspec;
    msi_alloc_info_t msiinfo;
};

struct gpio_led {
    const char *name;
    const char *default_trigger;
    unsigned int gpio;
    unsigned int active_low: 1;
    unsigned int retain_state_suspended: 1;
    unsigned int panic_indicator: 1;
    unsigned int default_state: 2;
    unsigned int retain_state_shutdown: 1;
    struct gpio_desc *gpiod;
};

struct led_pattern;

struct led_trigger;

struct led_hw_trigger_type;

struct led_classdev {
    const char *name;
    unsigned int brightness;
    unsigned int max_brightness;
    unsigned int color;
    int flags;
    long unsigned int work_flags;
    void (*brightness_set)(struct led_classdev *, enum led_brightness);
    int (*brightness_set_blocking)(struct led_classdev *, enum led_brightness);
    enum led_brightness (*brightness_get)(struct led_classdev *);
    int (*blink_set)(struct led_classdev *, long unsigned int *, long unsigned int *);
    int (*pattern_set)(struct led_classdev *, struct led_pattern *, u32, int);
    int (*pattern_clear)(struct led_classdev *);
    struct device *dev;
    const struct attribute_group **groups;
    struct list_head node;
    const char *default_trigger;
    long unsigned int blink_delay_on;
    long unsigned int blink_delay_off;
    struct timer_list blink_timer;
    int blink_brightness;
    int new_blink_brightness;
    void (*flash_resume)(struct led_classdev *);
    struct workqueue_struct *wq;
    struct work_struct set_brightness_work;
    int delayed_set_value;
    long unsigned int delayed_delay_on;
    long unsigned int delayed_delay_off;
    struct rw_semaphore trigger_lock;
    struct led_trigger *trigger;
    struct list_head trig_list;
    void *trigger_data;
    bool activated;
    struct led_hw_trigger_type *trigger_type;
    const char *hw_control_trigger;
    int (*hw_control_is_supported)(struct led_classdev *, long unsigned int);
    int (*hw_control_set)(struct led_classdev *, long unsigned int);
    int (*hw_control_get)(struct led_classdev *, long unsigned int *);
    struct device * (*hw_control_get_device)(struct led_classdev *);
    int brightness_hw_changed;
    struct kernfs_node *brightness_hw_changed_kn;
    struct mutex led_access;
};

typedef int (*gpio_blink_set_t)(struct gpio_desc *, int, long unsigned int *, long unsigned int *);

struct gpio_led_data {
    struct led_classdev cdev;
    struct gpio_desc *gpiod;
    u8 can_sleep;
    u8 blinking;
    gpio_blink_set_t platform_gpio_blink_set;
};

struct gpio_led_platform_data {
    int num_leds;
    const struct gpio_led *leds;
    gpio_blink_set_t gpio_blink_set;
};

struct gpio_leds_priv {
    int num_leds;
    struct gpio_led_data leds[0];
};

struct gpio_pin_range {
    struct list_head node;
    struct pinctrl_dev *pctldev;
    struct pinctrl_gpio_range range;
};

struct gpio_poweroff {
    struct gpio_desc *reset_gpio;
    u32 timeout_ms;
    u32 active_delay_ms;
    u32 inactive_delay_ms;
};

struct gpio_regulator_state;

struct gpio_regulator_config {
    const char *supply_name;
    const char *input_supply;
    unsigned int enabled_at_boot: 1;
    unsigned int startup_delay;
    enum gpiod_flags *gflags;
    int ngpios;
    struct gpio_regulator_state *states;
    int nr_states;
    enum regulator_type type;
    struct regulator_init_data *init_data;
};

struct gpio_regulator_data {
    struct regulator_desc desc;
    struct gpio_desc **gpiods;
    int nr_gpios;
    struct gpio_regulator_state *states;
    int nr_states;
    int state;
};

struct gpio_regulator_state {
    int value;
    int gpios;
};

struct gpio_set_config {
    u32 gpio;
    u32 direction;
    u32 polarity;
    u32 term_en;
    u32 term_pull_up;
    u32 state;
};

struct gpio_v2_line_config_attribute {
    struct gpio_v2_line_attribute attr;
    __u64 mask;
};

struct gpio_v2_line_config {
    __u64 flags;
    __u32 num_attrs;
    __u32 padding[5];
    struct gpio_v2_line_config_attribute attrs[10];
};

struct gpio_v2_line_event {
    __u64 timestamp_ns;
    __u32 id;
    __u32 offset;
    __u32 seqno;
    __u32 line_seqno;
    __u32 padding[6];
};

struct gpio_v2_line_request {
    __u32 offsets[64];
    char consumer[32];
    struct gpio_v2_line_config config;
    __u32 num_lines;
    __u32 event_buffer_size;
    __u32 padding[5];
    __s32 fd;
};

struct gpio_v2_line_values {
    __u64 bits;
    __u64 mask;
};

struct gpiochip_info {
    char name[32];
    char label[32];
    __u32 lines;
};

struct gpiod_hog {
    struct list_head list;
    const char *chip_label;
    u16 chip_hwnum;
    const char *line_name;
    long unsigned int lflags;
    int dflags;
};

struct gpiod_lookup {
    const char *key;
    u16 chip_hwnum;
    const char *con_id;
    unsigned int idx;
    long unsigned int flags;
};

struct gpiod_lookup_table {
    struct list_head list;
    const char *dev_id;
    struct gpiod_lookup table[0];
};

struct gpioevent_data {
    __u64 timestamp;
    __u32 id;
};

struct gpioevent_request {
    __u32 lineoffset;
    __u32 handleflags;
    __u32 eventflags;
    char consumer_label[32];
    int fd;
};

struct gpiohandle_config {
    __u32 flags;
    __u8 default_values[64];
    __u32 padding[4];
};

struct gpiohandle_data {
    __u8 values[64];
};

struct gpiohandle_request {
    __u32 lineoffsets[64];
    __u32 flags;
    __u8 default_values[64];
    char consumer_label[32];
    __u32 lines;
    int fd;
};

struct gpiolib_seq_priv {
    bool newline;
    int idx;
};

struct gpioline_info {
    __u32 line_offset;
    __u32 flags;
    char name[32];
    char consumer[32];
};

struct gpioline_info_changed {
    struct gpioline_info info;
    __u64 timestamp;
    __u32 event_type;
    __u32 padding[5];
};

struct gre_base_hdr {
    __be16 flags;
    __be16 protocol;
};

struct gre_full_hdr {
    struct gre_base_hdr fixed_header;
    __be16 csum;
    __be16 reserved1;
    __be32 key;
    __be32 seq;
};

struct gro_cell {
    struct sk_buff_head napi_skbs;
    struct napi_struct napi;
};

struct gro_cells {
    struct gro_cell *cells;
};

struct pingroup {
    const char *name;
    const unsigned int *pins;
    size_t npins;
};

struct group_desc {
    struct pingroup grp;
    void *data;
};

struct group_device {
    struct list_head list;
    struct device *dev;
    char *name;
};

struct group_filter {
    union {
        struct {
            __u32 gf_interface_aux;
            struct __kernel_sockaddr_storage gf_group_aux;
            __u32 gf_fmode_aux;
            __u32 gf_numsrc_aux;
            struct __kernel_sockaddr_storage gf_slist[1];
        };
        struct {
            __u32 gf_interface;
            struct __kernel_sockaddr_storage gf_group;
            __u32 gf_fmode;
            __u32 gf_numsrc;
            struct __kernel_sockaddr_storage gf_slist_flex[0];
        };
    };
};

struct group_for_pci_data {
    struct pci_dev *pdev;
    struct iommu_group *group;
};

struct group_info {
    refcount_t usage;
    int ngroups;
    kgid_t gid[0];
};

struct group_req {
    __u32 gr_interface;
    struct __kernel_sockaddr_storage gr_group;
};

struct group_source_req {
    __u32 gsr_interface;
    struct __kernel_sockaddr_storage gsr_group;
    struct __kernel_sockaddr_storage gsr_source;
};

struct rpcsec_gss_oid {
    unsigned int len;
    u8 data[32];
};

struct gss_api_ops;

struct pf_desc;

struct gss_api_mech {
    struct list_head gm_list;
    struct module *gm_owner;
    struct rpcsec_gss_oid gm_oid;
    char *gm_name;
    const struct gss_api_ops *gm_ops;
    int gm_pf_num;
    struct pf_desc *gm_pfs;
    const char *gm_upcall_enctypes;
};

struct gss_ctx;

struct xdr_buf;

struct xdr_netobj;

struct gss_api_ops {
    int (*gss_import_sec_context)(const void *, size_t, struct gss_ctx *, time64_t *, gfp_t);
    u32 (*gss_get_mic)(struct gss_ctx *, struct xdr_buf *, struct xdr_netobj *);
    u32 (*gss_verify_mic)(struct gss_ctx *, struct xdr_buf *, struct xdr_netobj *);
    u32 (*gss_wrap)(struct gss_ctx *, int, struct xdr_buf *, struct page **);
    u32 (*gss_unwrap)(struct gss_ctx *, int, int, struct xdr_buf *);
    void (*gss_delete_sec_context)(void *);
};

struct gss_ctx {
    struct gss_api_mech *mech_type;
    void *internal_ctx_id;
    unsigned int slack;
    unsigned int align;
};

struct h_misc {
    long unsigned int ino;
    __u32 generation;
    uid_t uid;
    gid_t gid;
    umode_t mode;
};

union handle_parts {
    depot_stack_handle_t handle;
    struct {
        u32 pool_index_plus_1: 17;
        u32 offset: 10;
        u32 extra: 5;
    };
};

struct handle_to_path_ctx {
    struct path root;
    enum handle_to_path_flags flags;
    unsigned int fh_flags;
};

struct handshake_net {
    spinlock_t hn_lock;
    int hn_pending;
    int hn_pending_max;
    struct list_head hn_requests;
    long unsigned int hn_flags;
};

struct handshake_req;

struct handshake_proto {
    int hp_handler_class;
    size_t hp_privsize;
    long unsigned int hp_flags;
    int (*hp_accept)(struct handshake_req *, struct genl_info *, int);
    void (*hp_done)(struct handshake_req *, unsigned int, struct genl_info *);
    void (*hp_destroy)(struct handshake_req *);
};

struct handshake_req {
    struct list_head hr_list;
    struct rhash_head hr_rhash;
    long unsigned int hr_flags;
    const struct handshake_proto *hr_proto;
    struct sock *hr_sk;
    void (*hr_odestruct)(struct sock *);
    char hr_priv[0];
};

struct hash {
    int ino;
    int minor;
    int major;
    umode_t mode;
    struct hash *next;
    char name[4098];
};

struct hash_prefix {
    const char *name;
    const u8 *data;
    size_t size;
};

struct hashtab_key_params {
    u32 (*hash)(const void *);
    int (*cmp)(const void *, const void *);
};

struct hashtab_node {
    void *key;
    void *datum;
    struct hashtab_node *next;
};

struct usb_hcd;

struct usb_tt;

struct hc_driver {
    const char *description;
    const char *product_desc;
    size_t hcd_priv_size;
    irqreturn_t (*irq)(struct usb_hcd *);
    int flags;
    int (*reset)(struct usb_hcd *);
    int (*start)(struct usb_hcd *);
    int (*pci_suspend)(struct usb_hcd *, bool);
    int (*pci_resume)(struct usb_hcd *, pm_message_t);
    int (*pci_poweroff_late)(struct usb_hcd *, bool);
    void (*stop)(struct usb_hcd *);
    void (*shutdown)(struct usb_hcd *);
    int (*get_frame_number)(struct usb_hcd *);
    int (*urb_enqueue)(struct usb_hcd *, struct urb *, gfp_t);
    int (*urb_dequeue)(struct usb_hcd *, struct urb *, int);
    int (*map_urb_for_dma)(struct usb_hcd *, struct urb *, gfp_t);
    void (*unmap_urb_for_dma)(struct usb_hcd *, struct urb *);
    void (*endpoint_disable)(struct usb_hcd *, struct usb_host_endpoint *);
    void (*endpoint_reset)(struct usb_hcd *, struct usb_host_endpoint *);
    int (*hub_status_data)(struct usb_hcd *, char *);
    int (*hub_control)(struct usb_hcd *, u16, u16, u16, char *, u16);
    int (*bus_suspend)(struct usb_hcd *);
    int (*bus_resume)(struct usb_hcd *);
    int (*start_port_reset)(struct usb_hcd *, unsigned int);
    long unsigned int (*get_resuming_ports)(struct usb_hcd *);
    void (*relinquish_port)(struct usb_hcd *, int);
    int (*port_handed_over)(struct usb_hcd *, int);
    void (*clear_tt_buffer_complete)(struct usb_hcd *, struct usb_host_endpoint *);
    int (*alloc_dev)(struct usb_hcd *, struct usb_device *);
    void (*free_dev)(struct usb_hcd *, struct usb_device *);
    int (*alloc_streams)(struct usb_hcd *, struct usb_device *, struct usb_host_endpoint **, unsigned int, unsigned int, gfp_t);
    int (*free_streams)(struct usb_hcd *, struct usb_device *, struct usb_host_endpoint **, unsigned int, gfp_t);
    int (*add_endpoint)(struct usb_hcd *, struct usb_device *, struct usb_host_endpoint *);
    int (*drop_endpoint)(struct usb_hcd *, struct usb_device *, struct usb_host_endpoint *);
    int (*check_bandwidth)(struct usb_hcd *, struct usb_device *);
    void (*reset_bandwidth)(struct usb_hcd *, struct usb_device *);
    void (*fixup_endpoint)(struct usb_hcd *, struct usb_device *, struct usb_host_endpoint *, int);
    int (*address_device)(struct usb_hcd *, struct usb_device *, unsigned int);
    int (*enable_device)(struct usb_hcd *, struct usb_device *);
    int (*update_hub_device)(struct usb_hcd *, struct usb_device *, struct usb_tt *, gfp_t);
    int (*reset_device)(struct usb_hcd *, struct usb_device *);
    int (*update_device)(struct usb_hcd *, struct usb_device *);
    int (*set_usb2_hw_lpm)(struct usb_hcd *, struct usb_device *, int);
    int (*enable_usb3_lpm_timeout)(struct usb_hcd *, struct usb_device *, enum usb3_link_state);
    int (*disable_usb3_lpm_timeout)(struct usb_hcd *, struct usb_device *, enum usb3_link_state);
    int (*find_raw_port_number)(struct usb_hcd *, int);
    int (*port_power)(struct usb_hcd *, int, bool);
    int (*submit_single_step_set_feature)(struct usb_hcd *, struct urb *, int);
};

struct hd_geometry {
    unsigned char heads;
    unsigned char sectors;
    short unsigned int cylinders;
    long unsigned int start;
};

struct hh_cache;

struct header_ops {
    int (*create)(struct sk_buff *, struct net_device *, short unsigned int, const void *, const void *, unsigned int);
    int (*parse)(const struct sk_buff *, unsigned char *);
    int (*cache)(const struct neighbour *, struct hh_cache *, __be16);
    void (*cache_update)(struct hh_cache *, const struct net_device *, const unsigned char *);
    bool (*validate)(const char *, unsigned int);
    __be16 (*parse_protocol)(const struct sk_buff *);
};

struct heartbeat_trig_data {
    struct led_classdev *led_cdev;
    unsigned int phase;
    unsigned int period;
    struct timer_list timer;
    unsigned int invert;
};

struct hh_cache {
    unsigned int hh_len;
    seqlock_t hh_lock;
    long unsigned int hh_data[16];
};

struct hid_collection {
    int parent_idx;
    unsigned int type;
    unsigned int usage;
    unsigned int level;
};

struct hid_device;

struct hid_debug_list {
    struct {
        union {
            struct __kfifo kfifo;
            char *type;
            const char *const_type;
            char (*rectype)[0];
            char *ptr;
            const char *ptr_const;
        };
        char buf[0];
    } hid_debug_fifo;
    struct fasync_struct *fasync;
    struct hid_device *hdev;
    struct list_head node;
    struct mutex read_mutex;
};

struct hid_report;

struct hid_report_enum {
    unsigned int numbered;
    struct list_head report_list;
    struct hid_report *report_id_hash[256];
};

struct semaphore {
    raw_spinlock_t lock;
    unsigned int count;
    struct list_head wait_list;
};

struct hid_driver;

struct hid_ll_driver;

struct power_supply;

struct hid_field;

struct hid_usage;

struct hid_device {
    const __u8 *dev_rdesc;
    const __u8 *bpf_rdesc;
    const __u8 *rdesc;
    unsigned int dev_rsize;
    unsigned int bpf_rsize;
    unsigned int rsize;
    unsigned int collection_size;
    struct hid_collection *collection;
    unsigned int maxcollection;
    unsigned int maxapplication;
    __u16 bus;
    __u16 group;
    __u32 vendor;
    __u32 product;
    __u32 version;
    enum hid_type type;
    unsigned int country;
    struct hid_report_enum report_enum[3];
    struct work_struct led_work;
    struct semaphore driver_input_lock;
    struct device dev;
    struct hid_driver *driver;
    void *devres_group_id;
    const struct hid_ll_driver *ll_driver;
    struct mutex ll_open_lock;
    unsigned int ll_open_count;
    struct power_supply *battery;
    __s32 battery_capacity;
    __s32 battery_min;
    __s32 battery_max;
    __s32 battery_report_type;
    __s32 battery_report_id;
    __s32 battery_charge_status;
    enum hid_battery_status battery_status;
    bool battery_avoid_query;
    ktime_t battery_ratelimit_time;
    long unsigned int status;
    unsigned int claimed;
    unsigned int quirks;
    unsigned int initial_quirks;
    bool io_started;
    struct list_head inputs;
    void *hiddev;
    void *hidraw;
    char name[128];
    char phys[64];
    char uniq[64];
    void *driver_data;
    int (*ff_init)(struct hid_device *);
    int (*hiddev_connect)(struct hid_device *, unsigned int);
    void (*hiddev_disconnect)(struct hid_device *);
    void (*hiddev_hid_event)(struct hid_device *, struct hid_field *, struct hid_usage *, __s32);
    void (*hiddev_report_event)(struct hid_device *, struct hid_report *);
    short unsigned int debug;
    struct dentry *debug_dir;
    struct dentry *debug_rdesc;
    struct dentry *debug_events;
    struct list_head debug_list;
    spinlock_t debug_list_lock;
    wait_queue_head_t debug_wait;
    struct kref ref;
    unsigned int id;
};

struct hid_device_id {
    __u16 bus;
    __u16 group;
    __u32 vendor;
    __u32 product;
    kernel_ulong_t driver_data;
};

struct hid_report_id;

struct hid_usage_id;

struct hid_input;

struct hid_driver {
    char *name;
    const struct hid_device_id *id_table;
    struct list_head dyn_list;
    spinlock_t dyn_lock;
    bool (*match)(struct hid_device *, bool);
    int (*probe)(struct hid_device *, const struct hid_device_id *);
    void (*remove)(struct hid_device *);
    const struct hid_report_id *report_table;
    int (*raw_event)(struct hid_device *, struct hid_report *, u8 *, int);
    const struct hid_usage_id *usage_table;
    int (*event)(struct hid_device *, struct hid_field *, struct hid_usage *, __s32);
    void (*report)(struct hid_device *, struct hid_report *);
    const __u8 * (*report_fixup)(struct hid_device *, __u8 *, unsigned int *);
    int (*input_mapping)(struct hid_device *, struct hid_input *, struct hid_field *, struct hid_usage *, long unsigned int **, int *);
    int (*input_mapped)(struct hid_device *, struct hid_input *, struct hid_field *, struct hid_usage *, long unsigned int **, int *);
    int (*input_configured)(struct hid_device *, struct hid_input *);
    void (*feature_mapping)(struct hid_device *, struct hid_field *, struct hid_usage *);
    int (*suspend)(struct hid_device *, pm_message_t);
    int (*resume)(struct hid_device *);
    int (*reset_resume)(struct hid_device *);
    struct device_driver driver;
};

struct hid_dynid {
    struct list_head list;
    struct hid_device_id id;
};

struct hid_field {
    unsigned int physical;
    unsigned int logical;
    unsigned int application;
    struct hid_usage *usage;
    unsigned int maxusage;
    unsigned int flags;
    unsigned int report_offset;
    unsigned int report_size;
    unsigned int report_count;
    unsigned int report_type;
    __s32 *value;
    __s32 *new_value;
    __s32 *usages_priorities;
    __s32 logical_minimum;
    __s32 logical_maximum;
    __s32 physical_minimum;
    __s32 physical_maximum;
    __s32 unit_exponent;
    unsigned int unit;
    bool ignored;
    struct hid_report *report;
    unsigned int index;
    struct hid_input *hidinput;
    __u16 dpad;
    unsigned int slot_idx;
};

struct hid_field_entry {
    struct list_head list;
    struct hid_field *field;
    unsigned int index;
    __s32 priority;
};

struct hid_global {
    unsigned int usage_page;
    __s32 logical_minimum;
    __s32 logical_maximum;
    __s32 physical_minimum;
    __s32 physical_maximum;
    __s32 unit_exponent;
    unsigned int unit;
    unsigned int report_id;
    unsigned int report_size;
    unsigned int report_count;
};

struct hid_input {
    struct list_head list;
    struct hid_report *report;
    struct input_dev *input;
    const char *name;
    struct list_head reports;
    unsigned int application;
    bool registered;
};

struct hid_item {
    unsigned int format;
    __u8 size;
    __u8 type;
    __u8 tag;
    union {
        __u8 u8;
        __s8 s8;
        __u16 u16;
        __s16 s16;
        __u32 u32;
        __s32 s32;
        const __u8 *longdata;
    } data;
};

struct hid_ll_driver {
    int (*start)(struct hid_device *);
    void (*stop)(struct hid_device *);
    int (*open)(struct hid_device *);
    void (*close)(struct hid_device *);
    int (*power)(struct hid_device *, int);
    int (*parse)(struct hid_device *);
    void (*request)(struct hid_device *, struct hid_report *, int);
    int (*wait)(struct hid_device *);
    int (*raw_request)(struct hid_device *, unsigned char, __u8 *, size_t, unsigned char, int);
    int (*output_report)(struct hid_device *, __u8 *, size_t);
    int (*idle)(struct hid_device *, int, int, int);
    bool (*may_wakeup)(struct hid_device *);
    unsigned int max_buffer_size;
};

struct hid_local {
    unsigned int usage[12288];
    u8 usage_size[12288];
    unsigned int collection_index[12288];
    unsigned int usage_index;
    unsigned int usage_minimum;
    unsigned int delimiter_depth;
    unsigned int delimiter_branch;
};

struct hid_parser {
    struct hid_global global;
    struct hid_global global_stack[4];
    unsigned int global_stack_ptr;
    struct hid_local local;
    unsigned int *collection_stack;
    unsigned int collection_stack_ptr;
    unsigned int collection_stack_size;
    struct hid_device *device;
    unsigned int scan_flags;
};

struct hid_report {
    struct list_head list;
    struct list_head hidinput_list;
    struct list_head field_entry_list;
    unsigned int id;
    enum hid_report_type type;
    unsigned int application;
    struct hid_field *field[256];
    struct hid_field_entry *field_entries;
    unsigned int maxfield;
    unsigned int size;
    struct hid_device *device;
    bool tool_active;
    unsigned int tool;
};

struct hid_report_id {
    __u32 report_type;
};

struct hid_usage {
    unsigned int hid;
    unsigned int collection_index;
    unsigned int usage_index;
    __s8 resolution_multiplier;
    __s8 wheel_factor;
    __u16 code;
    __u8 type;
    __s16 hat_min;
    __s16 hat_max;
    __s16 hat_dir;
    __s16 wheel_accumulated;
};

struct hid_usage_entry {
    unsigned int page;
    unsigned int usage;
    const char *description;
};

struct hid_usage_id {
    __u32 usage_hid;
    __u32 usage_type;
    __u32 usage_code;
};

struct hiddev {
    int minor;
    int exist;
    int open;
    struct mutex existancelock;
    wait_queue_head_t wait;
    struct hid_device *hid;
    struct list_head list;
    spinlock_t list_lock;
    bool initialized;
};

struct hidraw {
    unsigned int minor;
    int exist;
    int open;
    wait_queue_head_t wait;
    struct hid_device *hid;
    struct device *dev;
    spinlock_t list_lock;
    struct list_head list;
};

struct hidraw_devinfo {
    __u32 bustype;
    __s16 vendor;
    __s16 product;
};

struct hidraw_report {
    __u8 *value;
    int len;
};

struct hidraw_list {
    struct hidraw_report buffer[64];
    int head;
    int tail;
    struct fasync_struct *fasync;
    struct hidraw *hidraw;
    struct list_head node;
    struct mutex read_mutex;
    bool revoked;
};

struct hist_elt_data {
    char *comm;
    u64 *var_ref_vals;
    char **field_var_str;
    int n_field_var_str;
};

struct hist_var {
    char *name;
    struct hist_trigger_data *hist_data;
    unsigned int idx;
};

struct hist_field {
    struct ftrace_event_field *field;
    long unsigned int flags;
    long unsigned int buckets;
    const char *type;
    struct hist_field *operands[2];
    struct hist_trigger_data *hist_data;
    enum hist_field_fn fn_num;
    unsigned int ref;
    unsigned int size;
    unsigned int offset;
    unsigned int is_signed;
    struct hist_var var;
    enum field_op_id operator;
    char *system;
    char *event_name;
    char *name;
    unsigned int var_ref_idx;
    bool read_once;
    unsigned int var_str_idx;
    u64 constant;
    u64 div_multiplier;
};

struct hist_file_data {
    struct file *file;
    u64 last_read;
    u64 last_act;
};

struct var_defs {
    unsigned int n_vars;
    char *name[16];
    char *expr[16];
};

struct hist_trigger_attrs {
    char *keys_str;
    char *vals_str;
    char *sort_key_str;
    char *name;
    char *clock;
    bool pause;
    bool cont;
    bool clear;
    bool ts_in_usecs;
    bool no_hitcount;
    unsigned int map_bits;
    char *assignment_str[16];
    unsigned int n_assignments;
    char *action_str[8];
    unsigned int n_actions;
    struct var_defs var_defs;
};

struct tracing_map_sort_key {
    unsigned int field_idx;
    bool descending;
};

struct tracing_map;

struct hist_trigger_data {
    struct hist_field *fields[22];
    unsigned int n_vals;
    unsigned int n_keys;
    unsigned int n_fields;
    unsigned int n_vars;
    unsigned int n_var_str;
    unsigned int key_size;
    struct tracing_map_sort_key sort_keys[2];
    unsigned int n_sort_keys;
    struct trace_event_file *event_file;
    struct hist_trigger_attrs *attrs;
    struct tracing_map *map;
    bool enable_timestamps;
    bool remove;
    struct hist_field *var_refs[16];
    unsigned int n_var_refs;
    struct action_data *actions[8];
    unsigned int n_actions;
    struct field_var *field_vars[64];
    unsigned int n_field_vars;
    unsigned int n_field_var_str;
    struct field_var_hist *field_var_hists[64];
    unsigned int n_field_var_hists;
    struct field_var *save_vars[64];
    unsigned int n_save_vars;
    unsigned int n_save_var_str;
};

struct hist_val_stat {
    u64 max;
    u64 total;
};

struct hist_var_data {
    struct list_head list;
    struct hist_trigger_data *hist_data;
};

struct hlist_bl_head {
    struct hlist_bl_node *first;
};

struct hmac_ctx {
    struct crypto_shash *hash;
    u8 pads[0];
};

struct mmu_interval_notifier;

struct hmm_range {
    struct mmu_interval_notifier *notifier;
    long unsigned int notifier_seq;
    long unsigned int start;
    long unsigned int end;
    long unsigned int *hmm_pfns;
    long unsigned int default_flags;
    long unsigned int pfn_flags_mask;
    void *dev_private_owner;
};

struct hmm_vma_walk {
    struct hmm_range *range;
    long unsigned int last;
};

struct hop_jumbo_hdr {
    u8 nexthdr;
    u8 hdrlen;
    u8 tlv_type;
    u8 tlv_len;
    __be32 jumbo_payload_len;
};

struct kvm_vmid {
    atomic64_t id;
};

struct kvm_mmu_memory_cache {
    gfp_t gfp_zero;
    gfp_t gfp_custom;
    u64 init_value;
    struct kmem_cache *kmem_cache;
    int capacity;
    int nobjs;
    void **objects;
};

struct kvm_pgtable;

struct kvm_arch;

struct kvm_s2_mmu {
    struct kvm_vmid vmid;
    phys_addr_t pgd_phys;
    struct kvm_pgtable *pgt;
    u64 vtcr;
    int *last_vcpu_ran;
    struct kvm_mmu_memory_cache split_page_cache;
    uint64_t split_page_chunk_size;
    struct kvm_arch *arch;
    u64 tlb_vttbr;
    u64 tlb_vtcr;
    bool nested_stage2_enabled;
    bool pending_unmap;
    atomic_t refcnt;
};

struct vgic_its;

struct vgic_register_region;

struct vgic_io_device {
    gpa_t base_addr;
    union {
        struct kvm_vcpu *redist_vcpu;
        struct vgic_its *its;
    };
    const struct vgic_register_region *regions;
    enum iodev_type iodev_type;
    int nr_regions;
    struct kvm_io_device dev;
};

struct its_vpe;

struct its_vm {
    struct fwnode_handle *fwnode;
    struct irq_domain *domain;
    struct page *vprop_page;
    struct its_vpe **vpes;
    int nr_vpes;
    irq_hw_number_t db_lpi_base;
    long unsigned int *db_bitmap;
    int nr_db_lpis;
    raw_spinlock_t vmapp_lock;
    u32 vlpi_count[16];
};

struct vgic_irq;

struct vgic_state_iter;

struct vgic_dist {
    bool in_kernel;
    bool ready;
    bool initialized;
    u32 vgic_model;
    u32 implementation_rev;
    bool v2_groups_user_writable;
    bool msis_require_devid;
    int nr_spis;
    gpa_t vgic_dist_base;
    union {
        gpa_t vgic_cpu_base;
        struct list_head rd_regions;
    };
    bool enabled;
    bool nassgireq;
    struct vgic_irq *spis;
    struct vgic_io_device dist_iodev;
    bool has_its;
    bool table_write_in_progress;
    u64 propbaser;
    struct xarray lpi_xa;
    struct vgic_state_iter *iter;
    struct its_vm its_vm;
};

struct kvm_smccc_features {
    long unsigned int std_bmap;
    long unsigned int std_hyp_bmap;
    long unsigned int vendor_hyp_bmap;
};

struct maple_tree {
    union {
        spinlock_t ma_lock;
        lockdep_map_p ma_external_lock;
    };
    unsigned int ma_flags;
    void *ma_root;
};

struct pkvm_mapping;

struct kvm_hyp_memcache {
    phys_addr_t head;
    long unsigned int nr_pages;
    struct pkvm_mapping *mapping;
};

struct kvm_protected_vm {
    pkvm_handle_t handle;
    struct kvm_hyp_memcache teardown_mc;
    bool enabled;
};

struct kvm_mpidr_data;

struct kvm_sysreg_masks;

struct kvm_arch {
    struct kvm_s2_mmu mmu;
    u64 fgu[5];
    struct kvm_s2_mmu *nested_mmus;
    size_t nested_mmus_size;
    int nested_mmus_next;
    struct vgic_dist vgic;
    struct arch_timer_vm_data timer_data;
    u32 psci_version;
    struct mutex config_lock;
    long unsigned int flags;
    long unsigned int vcpu_features[1];
    struct kvm_mpidr_data *mpidr_data;
    long unsigned int *pmu_filter;
    struct arm_pmu *arm_pmu;
    cpumask_var_t supported_cpus;
    u8 pmcr_n;
    u8 idreg_debugfs_iter;
    struct kvm_smccc_features smccc_feat;
    struct maple_tree smccc_filter;
    u64 id_regs[56];
    u64 ctr_el0;
    struct kvm_sysreg_masks *sysreg_masks;
    struct kvm_protected_vm pkvm;
};

typedef bool (*kvm_pgtable_force_pte_cb_t)(u64, u64, enum kvm_pgtable_prot);

struct kvm_pgtable_mm_ops;

struct kvm_pgtable {
    union {
        struct rb_root pkvm_mappings;
        struct {
            u32 ia_bits;
            s8 start_level;
            kvm_pteref_t pgd;
            struct kvm_pgtable_mm_ops *mm_ops;
            enum kvm_pgtable_stage2_flags flags;
            kvm_pgtable_force_pte_cb_t force_pte_cb;
        };
    };
    struct kvm_s2_mmu *mmu;
};

struct kvm_pgtable_mm_ops {
    void * (*zalloc_page)(void *);
    void * (*zalloc_pages_exact)(size_t);
    void (*free_pages_exact)(void *, size_t);
    void (*free_unlinked_table)(void *, s8);
    void (*get_page)(void *);
    void (*put_page)(void *);
    int (*page_count)(void *);
    void * (*phys_to_virt)(phys_addr_t);
    phys_addr_t (*virt_to_phys)(void *);
    void (*dcache_clean_inval_poc)(void *, size_t);
    void (*icache_inval_pou)(void *, size_t);
};

union hyp_spinlock {
    u32 __val;
    struct {
        u16 owner;
        u16 next;
    };
};

typedef union hyp_spinlock hyp_spinlock_t;

struct host_mmu {
    struct kvm_arch arch;
    struct kvm_pgtable pgt;
    struct kvm_pgtable_mm_ops mm_ops;
    hyp_spinlock_t lock;
};

struct hotplug_slot_ops;

struct pci_slot;

struct hotplug_slot {
    const struct hotplug_slot_ops *ops;
    struct list_head slot_list;
    struct pci_slot *pci_slot;
    struct module *owner;
    const char *mod_name;
};

struct hotplug_slot_ops {
    int (*enable_slot)(struct hotplug_slot *);
    int (*disable_slot)(struct hotplug_slot *);
    int (*set_attention_status)(struct hotplug_slot *, u8);
    int (*hardware_test)(struct hotplug_slot *, u32);
    int (*get_power_status)(struct hotplug_slot *, u8 *);
    int (*get_attention_status)(struct hotplug_slot *, u8 *);
    int (*get_latch_status)(struct hotplug_slot *, u8 *);
    int (*get_adapter_status)(struct hotplug_slot *, u8 *);
    int (*reset_slot)(struct hotplug_slot *, bool);
};

struct housekeeping {
    struct cpumask cpumasks[3];
    long unsigned int flags;
};

struct hprobe {
    enum hprobe_state state;
    int srcu_idx;
    struct uprobe *uprobe;
};

struct seqcount_raw_spinlock {
    seqcount_t seqcount;
};

typedef struct seqcount_raw_spinlock seqcount_raw_spinlock_t;

struct hrtimer_cpu_base;

struct hrtimer_clock_base {
    struct hrtimer_cpu_base *cpu_base;
    unsigned int index;
    clockid_t clockid;
    seqcount_raw_spinlock_t seq;
    struct hrtimer *running;
    struct timerqueue_head active;
    ktime_t (*get_time)(void);
    ktime_t offset;
};

struct hrtimer_cpu_base {
    raw_spinlock_t lock;
    unsigned int cpu;
    unsigned int active_bases;
    unsigned int clock_was_set_seq;
    unsigned int hres_active: 1;
    unsigned int in_hrtirq: 1;
    unsigned int hang_detected: 1;
    unsigned int softirq_activated: 1;
    unsigned int online: 1;
    unsigned int nr_events;
    short unsigned int nr_retries;
    short unsigned int nr_hangs;
    unsigned int max_hang_time;
    ktime_t expires_next;
    struct hrtimer *next_timer;
    ktime_t softirq_expires_next;
    struct hrtimer *softirq_next_timer;
    struct hrtimer_clock_base clock_base[8];
    call_single_data_t csd;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
};

struct hrtimer_sleeper {
    struct hrtimer timer;
    struct task_struct *task;
};

struct hsq_slot {
    struct mmc_request *mrq;
};

struct hsr_tag {
    __be16 path_and_LSDU_size;
    __be16 sequence_nr;
    __be16 encap_proto;
};

struct hstate {
    struct mutex resize_lock;
    struct lock_class_key resize_key;
    int next_nid_to_alloc;
    int next_nid_to_free;
    unsigned int order;
    unsigned int demote_order;
    long unsigned int mask;
    long unsigned int max_huge_pages;
    long unsigned int nr_huge_pages;
    long unsigned int free_huge_pages;
    long unsigned int resv_huge_pages;
    long unsigned int surplus_huge_pages;
    long unsigned int nr_overcommit_huge_pages;
    struct list_head hugepage_activelist;
    struct list_head hugepage_freelists[1];
    unsigned int max_huge_pages_node[1];
    unsigned int nr_huge_pages_node[1];
    unsigned int free_huge_pages_node[1];
    unsigned int surplus_huge_pages_node[1];
    char name[32];
};

struct pcpu_freelist_node {
    struct pcpu_freelist_node *next;
};

struct htab_elem {
    union {
        struct hlist_nulls_node hash_node;
        struct {
            void *padding;
            union {
                struct pcpu_freelist_node fnode;
                struct htab_elem *batch_flink;
            };
        };
    };
    union {
        void *ptr_to_pptr;
        struct bpf_lru_node lru_node;
    };
    u32 hash;
    long: 0;
    char key[0];
};

struct huge_bootmem_page {
    struct list_head list;
    struct hstate *hstate;
};

struct hugepage_subpool {
    spinlock_t lock;
    long int count;
    long int max_hpages;
    long int used_hpages;
    struct hstate *hstate;
    long int min_hpages;
    long int rsv_hpages;
};

struct hugetlb_cgroup_per_node;

struct hugetlb_cgroup {
    struct cgroup_subsys_state css;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    struct page_counter hugepage[4];
    struct page_counter rsvd_hugepage[4];
    atomic_long_t events[4];
    atomic_long_t events_local[4];
    struct cgroup_file events_file[4];
    struct cgroup_file events_local_file[4];
    struct hugetlb_cgroup_per_node *nodeinfo[0];
};

struct hugetlb_cgroup_per_node {
    long unsigned int usage[4];
};

struct hugetlb_vma_lock {
    struct kref refs;
    struct rw_semaphore rw_sema;
    struct vm_area_struct *vma;
};

struct hugetlbfs_fs_context {
    struct hstate *hstate;
    long long unsigned int max_size_opt;
    long long unsigned int min_size_opt;
    long int max_hpages;
    long int nr_inodes;
    long int min_hpages;
    enum hugetlbfs_size_type max_val_type;
    enum hugetlbfs_size_type min_val_type;
    kuid_t uid;
    kgid_t gid;
    umode_t mode;
};

struct hugetlbfs_inode_info {
    struct inode vfs_inode;
    unsigned int seals;
};

struct hugetlbfs_sb_info {
    long int max_inodes;
    long int free_inodes;
    spinlock_t stat_lock;
    struct hstate *hstate;
    struct hugepage_subpool *spool;
    kuid_t uid;
    kgid_t gid;
    umode_t mode;
};

struct hvc_struct;

struct hv_ops {
    ssize_t (*get_chars)(uint32_t, u8 *, size_t);
    ssize_t (*put_chars)(uint32_t, const u8 *, size_t);
    int (*flush)(uint32_t, bool);
    int (*notifier_add)(struct hvc_struct *, int);
    void (*notifier_del)(struct hvc_struct *, int);
    void (*notifier_hangup)(struct hvc_struct *, int);
    int (*tiocmget)(struct hvc_struct *);
    int (*tiocmset)(struct hvc_struct *, unsigned int, unsigned int);
    void (*dtr_rts)(struct hvc_struct *, bool);
};

struct tty_buffer {
    union {
        struct tty_buffer *next;
        struct llist_node free;
    };
    unsigned int used;
    unsigned int size;
    unsigned int commit;
    unsigned int lookahead;
    unsigned int read;
    bool flags;
    long: 0;
    u8 data[0];
};

struct tty_bufhead {
    struct tty_buffer *head;
    struct work_struct work;
    struct mutex lock;
    atomic_t priority;
    struct tty_buffer sentinel;
    struct llist_head free;
    atomic_t mem_used;
    int mem_limit;
    struct tty_buffer *tail;
};

struct tty_struct;

struct tty_port_operations;

struct tty_port_client_operations;

struct tty_port {
    struct tty_bufhead buf;
    struct tty_struct *tty;
    struct tty_struct *itty;
    const struct tty_port_operations *ops;
    const struct tty_port_client_operations *client_ops;
    spinlock_t lock;
    int blocked_open;
    int count;
    wait_queue_head_t open_wait;
    wait_queue_head_t delta_msr_wait;
    long unsigned int flags;
    long unsigned int iflags;
    unsigned char console: 1;
    struct mutex mutex;
    struct mutex buf_mutex;
    u8 *xmit_buf;
    struct {
        union {
            struct __kfifo kfifo;
            u8 *type;
            const u8 *const_type;
            char (*rectype)[0];
            u8 *ptr;
            const u8 *ptr_const;
        };
        u8 buf[0];
    } xmit_fifo;
    unsigned int close_delay;
    unsigned int closing_wait;
    int drain_delay;
    struct kref kref;
    void *client_data;
};

struct winsize {
    short unsigned int ws_row;
    short unsigned int ws_col;
    short unsigned int ws_xpixel;
    short unsigned int ws_ypixel;
};

struct hvc_struct {
    struct tty_port port;
    spinlock_t lock;
    int index;
    int do_wakeup;
    int outbuf_size;
    int n_outbuf;
    uint32_t vtermno;
    const struct hv_ops *ops;
    int irq_requested;
    int data;
    struct winsize ws;
    struct work_struct tty_resize;
    struct list_head next;
    long unsigned int flags;
    u8 outbuf[0];
};

struct hw_perf_event_extra {
    u64 config;
    unsigned int reg;
    int alloc;
    int idx;
};

struct rhlist_head {
    struct rhash_head rhead;
    struct rhlist_head *next;
};

struct hw_perf_event {
    union {
        struct {
            u64 config;
            u64 last_tag;
            long unsigned int config_base;
            long unsigned int event_base;
            int event_base_rdpmc;
            int idx;
            int last_cpu;
            int flags;
            struct hw_perf_event_extra extra_reg;
            struct hw_perf_event_extra branch_reg;
        };
        struct {
            u64 aux_config;
            unsigned int aux_paused;
        };
        struct {
            struct hrtimer hrtimer;
        };
        struct {
            struct list_head tp_list;
        };
        struct {
            u64 pwr_acc;
            u64 ptsc;
        };
        struct {
            struct arch_hw_breakpoint info;
            struct rhlist_head bp_list;
        };
        struct {
            u8 iommu_bank;
            u8 iommu_cntr;
            u16 padding;
            u64 conf;
            u64 conf1;
        };
    };
    struct task_struct *target;
    void *addr_filters;
    long unsigned int addr_filters_gen;
    int state;
    local64_t prev_count;
    u64 sample_period;
    union {
        struct {
            u64 last_period;
            local64_t period_left;
        };
        struct {
            u64 saved_metric;
            u64 saved_slots;
        };
    };
    u64 interrupts_seq;
    u64 interrupts;
    u64 freq_time_stamp;
    u64 freq_count_stamp;
};

struct hw_port_info {
    struct net_device *lower_dev;
    u32 port_id;
};

struct hwlat_data {
    struct mutex lock;
    u64 count;
    u64 sample_window;
    u64 sample_width;
    int thread_mode;
};

struct hwlat_entry {
    struct trace_entry ent;
    u64 duration;
    u64 outer_duration;
    u64 nmi_total_ts;
    struct timespec64 timestamp;
    unsigned int nmi_count;
    unsigned int seqnum;
    unsigned int count;
};

struct hwlat_kthread_data {
    struct task_struct *kthread;
    u64 nmi_ts_start;
    u64 nmi_total_ts;
    int nmi_count;
    int nmi_cpu;
};

struct hwlat_sample {
    u64 seqnum;
    u64 duration;
    u64 outer_duration;
    u64 nmi_total_ts;
    struct timespec64 timestamp;
    int nmi_count;
    int count;
};

struct hwmon_channel_info {
    enum hwmon_sensor_types type;
    const u32 *config;
};

struct hwmon_ops;

struct hwmon_chip_info {
    const struct hwmon_ops *ops;
    const struct hwmon_channel_info * const *info;
};

struct hwmon_device {
    const char *name;
    const char *label;
    struct device dev;
    const struct hwmon_chip_info *chip;
    struct list_head tzdata;
    struct attribute_group group;
    const struct attribute_group **groups;
};

struct hwmon_device_attribute {
    struct device_attribute dev_attr;
    const struct hwmon_ops *ops;
    enum hwmon_sensor_types type;
    u32 attr;
    int index;
    char name[32];
};

struct hwmon_ops {
    umode_t visible;
    umode_t (*is_visible)(const void *, enum hwmon_sensor_types, u32, int);
    int (*read)(struct device *, enum hwmon_sensor_types, u32, int, long int *);
    int (*read_string)(struct device *, enum hwmon_sensor_types, u32, int, const char **);
    int (*write)(struct device *, enum hwmon_sensor_types, u32, int, long int);
};

struct hwmon_thermal_data {
    struct list_head node;
    struct device *dev;
    int index;
    struct thermal_zone_device *tzd;
};

struct hwmon_type_attr_list {
    const u32 *attrs;
    size_t n_attrs;
};

struct hwtstamp_config {
    int flags;
    int tx_type;
    int rx_filter;
};

struct hwtstamp_provider_desc {
    int index;
    enum hwtstamp_provider_qualifier qualifier;
};

struct hwtstamp_provider {
    struct callback_head callback_head;
    enum hwtstamp_source source;
    struct phy_device *phydev;
    struct hwtstamp_provider_desc desc;
};

struct hyp_fixmap_slot {
    u64 addr;
    kvm_pte_t *ptep;
};

struct hyp_map_data {
    const u64 phys;
    kvm_pte_t attr;
};

struct hyp_page {
    u16 refcount;
    u8 order;
    enum pkvm_page_state host_state: 8;
    u32 host_share_guest_count;
};

struct hyp_pool {
    hyp_spinlock_t lock;
    struct list_head free_area[11];
    phys_addr_t range_start;
    phys_addr_t range_end;
    u8 max_order;
};

struct hyp_shared_pfn {
    u64 pfn;
    int count;
    struct rb_node node;
};

struct rt_mutex {
    struct rt_mutex_base rtmutex;
};

struct i2c_algorithm;

struct i2c_lock_operations;

struct i2c_bus_recovery_info;

struct i2c_adapter_quirks;

struct i2c_adapter {
    struct module *owner;
    unsigned int class;
    const struct i2c_algorithm *algo;
    void *algo_data;
    const struct i2c_lock_operations *lock_ops;
    struct rt_mutex bus_lock;
    struct rt_mutex mux_lock;
    int timeout;
    int retries;
    struct device dev;
    long unsigned int locked_flags;
    int nr;
    char name[48];
    struct completion dev_released;
    struct mutex userspace_clients_lock;
    struct list_head userspace_clients;
    struct i2c_bus_recovery_info *bus_recovery_info;
    const struct i2c_adapter_quirks *quirks;
    struct irq_domain *host_notify_domain;
    struct regulator *bus_regulator;
    struct dentry *debugfs;
    long unsigned int addrs_in_instantiation[2];
};

struct i2c_adapter_quirks {
    u64 flags;
    int max_num_msgs;
    u16 max_write_len;
    u16 max_read_len;
    u16 max_comb_1st_msg_len;
    u16 max_comb_2nd_msg_len;
};

struct i2c_msg;

union i2c_smbus_data;

struct i2c_client;

struct i2c_algorithm {
    union {
        int (*xfer)(struct i2c_adapter *, struct i2c_msg *, int);
        int (*master_xfer)(struct i2c_adapter *, struct i2c_msg *, int);
    };
    union {
        int (*xfer_atomic)(struct i2c_adapter *, struct i2c_msg *, int);
        int (*master_xfer_atomic)(struct i2c_adapter *, struct i2c_msg *, int);
    };
    int (*smbus_xfer)(struct i2c_adapter *, u16, short unsigned int, char, u8, int, union i2c_smbus_data *);
    int (*smbus_xfer_atomic)(struct i2c_adapter *, u16, short unsigned int, char, u8, int, union i2c_smbus_data *);
    u32 (*functionality)(struct i2c_adapter *);
    union {
        int (*reg_target)(struct i2c_client *);
        int (*reg_slave)(struct i2c_client *);
    };
    union {
        int (*unreg_target)(struct i2c_client *);
        int (*unreg_slave)(struct i2c_client *);
    };
};

struct i2c_board_info {
    char type[20];
    short unsigned int flags;
    short unsigned int addr;
    const char *dev_name;
    void *platform_data;
    struct device_node *of_node;
    struct fwnode_handle *fwnode;
    const struct software_node *swnode;
    const struct resource *resources;
    unsigned int num_resources;
    int irq;
};

struct i2c_bus_recovery_info {
    int (*recover_bus)(struct i2c_adapter *);
    int (*get_scl)(struct i2c_adapter *);
    void (*set_scl)(struct i2c_adapter *, int);
    int (*get_sda)(struct i2c_adapter *);
    void (*set_sda)(struct i2c_adapter *, int);
    int (*get_bus_free)(struct i2c_adapter *);
    void (*prepare_recovery)(struct i2c_adapter *);
    void (*unprepare_recovery)(struct i2c_adapter *);
    struct gpio_desc *scl_gpiod;
    struct gpio_desc *sda_gpiod;
    struct pinctrl *pinctrl;
    struct pinctrl_state *pins_default;
    struct pinctrl_state *pins_gpio;
};

typedef int (*i2c_slave_cb_t)(struct i2c_client *, enum i2c_slave_event, u8 *);

struct i2c_client {
    short unsigned int flags;
    short unsigned int addr;
    char name[20];
    struct i2c_adapter *adapter;
    struct device dev;
    int init_irq;
    int irq;
    struct list_head detected;
    i2c_slave_cb_t slave_cb;
    void *devres_group_id;
    struct dentry *debugfs;
};

struct i2c_cmd_arg {
    unsigned int cmd;
    void *arg;
};

struct i2c_dev {
    struct list_head list;
    struct i2c_adapter *adap;
    struct device dev;
    struct cdev cdev;
};

struct i2c_device_id {
    char name[20];
    kernel_ulong_t driver_data;
};

struct i2c_device_identity {
    u16 manufacturer_id;
    u16 part_id;
    u8 die_revision;
};

struct i2c_devinfo {
    struct list_head list;
    int busnum;
    struct i2c_board_info board_info;
};

struct i2c_driver {
    unsigned int class;
    int (*probe)(struct i2c_client *);
    void (*remove)(struct i2c_client *);
    void (*shutdown)(struct i2c_client *);
    void (*alert)(struct i2c_client *, enum i2c_alert_protocol, unsigned int);
    int (*command)(struct i2c_client *, unsigned int, void *);
    struct device_driver driver;
    const struct i2c_device_id *id_table;
    int (*detect)(struct i2c_client *, struct i2c_board_info *);
    const short unsigned int *address_list;
    struct list_head clients;
    u32 flags;
};

struct i2c_lock_operations {
    void (*lock_bus)(struct i2c_adapter *, unsigned int);
    int (*trylock_bus)(struct i2c_adapter *, unsigned int);
    void (*unlock_bus)(struct i2c_adapter *, unsigned int);
};

struct i2c_msg {
    __u16 addr;
    __u16 flags;
    __u16 len;
    __u8 *buf;
};

struct i2c_msg32 {
    u16 addr;
    u16 flags;
    u16 len;
    compat_caddr_t buf;
};

struct i2c_of_probe_ops;

struct i2c_of_probe_cfg {
    const struct i2c_of_probe_ops *ops;
    const char *type;
};

struct i2c_of_probe_ops {
    int (*enable)(struct device *, struct device_node *, void *);
    void (*cleanup_early)(struct device *, void *);
    void (*cleanup)(struct device *, void *);
};

struct i2c_of_probe_simple_opts;

struct i2c_of_probe_simple_ctx {
    const struct i2c_of_probe_simple_opts *opts;
    struct regulator *supply;
    struct gpio_desc *gpiod;
};

struct i2c_of_probe_simple_opts {
    const char *res_node_compatible;
    const char *supply_name;
    const char *gpio_name;
    unsigned int post_power_on_delay_ms;
    unsigned int post_gpio_config_delay_ms;
    bool gpio_assert_to_enable;
};

struct i2c_rdwr_ioctl_data {
    struct i2c_msg *msgs;
    __u32 nmsgs;
};

struct i2c_rdwr_ioctl_data32 {
    compat_caddr_t msgs;
    u32 nmsgs;
};

struct i2c_smbus_alert_setup {
    int irq;
};

union i2c_smbus_data {
    __u8 byte;
    __u16 word;
    __u8 block[34];
};

struct i2c_smbus_ioctl_data {
    __u8 read_write;
    __u8 command;
    __u32 size;
    union i2c_smbus_data *data;
};

struct i2c_smbus_ioctl_data32 {
    u8 read_write;
    u8 command;
    u32 size;
    compat_caddr_t data;
};

struct i2c_timings {
    u32 bus_freq_hz;
    u32 scl_rise_ns;
    u32 scl_fall_ns;
    u32 scl_int_delay_ns;
    u32 sda_fall_ns;
    u32 sda_hold_ns;
    u32 digital_filter_width_ns;
    u32 analog_filter_cutoff_freq_hz;
};

struct iattr {
    unsigned int ia_valid;
    umode_t ia_mode;
    union {
        kuid_t ia_uid;
        vfsuid_t ia_vfsuid;
    };
    union {
        kgid_t ia_gid;
        vfsgid_t ia_vfsgid;
    };
    loff_t ia_size;
    struct timespec64 ia_atime;
    struct timespec64 ia_mtime;
    struct timespec64 ia_ctime;
    struct file *ia_file;
};

struct ib_pd;

struct ib_uobject;

struct ib_gid_attr;

struct ib_ah {
    struct ib_device *device;
    struct ib_pd *pd;
    struct ib_uobject *uobject;
    const struct ib_gid_attr *sgid_attr;
    enum rdma_ah_attr_type type;
};

struct ib_ah_attr {
    u16 dlid;
    u8 src_path_bits;
};

struct ib_core_device {
    struct device dev;
    possible_net_t rdma_net;
    struct kobject *ports_kobj;
    struct list_head port_list;
    struct ib_device *owner;
};

struct ib_counters {
    struct ib_device *device;
    struct ib_uobject *uobject;
    atomic_t usecnt;
};

struct ib_counters_read_attr {
    u64 *counters_buff;
    u32 ncounters;
    u32 flags;
};

struct ib_ucq_object;

struct ib_cq;

typedef void (*ib_comp_handler)(struct ib_cq *, void *);

struct irq_poll;

typedef int irq_poll_fn(struct irq_poll *, int);

struct irq_poll {
    struct list_head list;
    long unsigned int state;
    int weight;
    irq_poll_fn *poll;
};

struct rdma_restrack_entry {
    bool valid;
    u8 no_track: 1;
    struct kref kref;
    struct completion comp;
    struct task_struct *task;
    const char *kern_name;
    enum rdma_restrack_type type;
    bool user;
    u32 id;
};

struct ib_event;

struct ib_wc;

struct ib_cq {
    struct ib_device *device;
    struct ib_ucq_object *uobject;
    ib_comp_handler comp_handler;
    void (*event_handler)(struct ib_event *, void *);
    void *cq_context;
    int cqe;
    unsigned int cqe_used;
    atomic_t usecnt;
    enum ib_poll_context poll_ctx;
    struct ib_wc *wc;
    struct list_head pool_entry;
    union {
        struct irq_poll iop;
        struct work_struct work;
    };
    struct workqueue_struct *comp_wq;
    struct dim *dim;
    ktime_t timestamp;
    u8 interrupt: 1;
    u8 shared: 1;
    unsigned int comp_vector;
    struct rdma_restrack_entry res;
};

struct ib_cq_caps {
    u16 max_cq_moderation_count;
    u16 max_cq_moderation_period;
};

struct ib_cq_init_attr {
    unsigned int cqe;
    u32 comp_vector;
    u32 flags;
};

struct ib_cqe {
    void (*done)(struct ib_cq *, struct ib_wc *);
};

struct ib_mad;

struct uverbs_attr_bundle;

struct rdma_cm_id;

struct iw_cm_id;

struct iw_cm_conn_param;

struct ib_uverbs_file;

struct ib_qp;

struct ib_send_wr;

struct ib_recv_wr;

struct ib_srq;

struct ib_grh;

struct ib_device_attr;

struct ib_udata;

struct ib_device_modify;

struct ib_port_attr;

struct ib_port_modify;

struct ib_port_immutable;

struct rdma_netdev_alloc_params;

union ib_gid;

struct ib_ucontext;

struct rdma_user_mmap_entry;

struct rdma_ah_init_attr;

struct rdma_ah_attr;

struct ib_srq_init_attr;

struct ib_srq_attr;

struct ib_qp_init_attr;

struct ib_qp_attr;

struct ib_mr;

struct ib_sge;

struct ib_mr_status;

struct ib_mw;

struct ib_xrcd;

struct ib_flow;

struct ib_flow_attr;

struct ib_flow_action;

struct ifla_vf_info;

struct ifla_vf_stats;

struct ifla_vf_guid;

struct ib_wq;

struct ib_wq_init_attr;

struct ib_wq_attr;

struct ib_rwq_ind_table;

struct ib_rwq_ind_table_init_attr;

struct ib_dm;

struct ib_dm_alloc_attr;

struct ib_dm_mr_attr;

struct rdma_hw_stats;

struct rdma_counter;

struct ib_device_ops {
    struct module *owner;
    enum rdma_driver_id driver_id;
    u32 uverbs_abi_ver;
    unsigned int uverbs_no_driver_id_binding: 1;
    const struct attribute_group *device_group;
    const struct attribute_group **port_groups;
    int (*post_send)(struct ib_qp *, const struct ib_send_wr *, const struct ib_send_wr **);
    int (*post_recv)(struct ib_qp *, const struct ib_recv_wr *, const struct ib_recv_wr **);
    void (*drain_rq)(struct ib_qp *);
    void (*drain_sq)(struct ib_qp *);
    int (*poll_cq)(struct ib_cq *, int, struct ib_wc *);
    int (*peek_cq)(struct ib_cq *, int);
    int (*req_notify_cq)(struct ib_cq *, enum ib_cq_notify_flags);
    int (*post_srq_recv)(struct ib_srq *, const struct ib_recv_wr *, const struct ib_recv_wr **);
    int (*process_mad)(struct ib_device *, int, u32, const struct ib_wc *, const struct ib_grh *, const struct ib_mad *, struct ib_mad *, size_t *, u16 *);
    int (*query_device)(struct ib_device *, struct ib_device_attr *, struct ib_udata *);
    int (*modify_device)(struct ib_device *, int, struct ib_device_modify *);
    void (*get_dev_fw_str)(struct ib_device *, char *);
    const struct cpumask * (*get_vector_affinity)(struct ib_device *, int);
    int (*query_port)(struct ib_device *, u32, struct ib_port_attr *);
    int (*modify_port)(struct ib_device *, u32, int, struct ib_port_modify *);
    int (*get_port_immutable)(struct ib_device *, u32, struct ib_port_immutable *);
    enum rdma_link_layer (*get_link_layer)(struct ib_device *, u32);
    struct net_device * (*get_netdev)(struct ib_device *, u32);
    struct net_device * (*alloc_rdma_netdev)(struct ib_device *, u32, enum rdma_netdev_t, const char *, unsigned char, void (*)(struct net_device *));
    int (*rdma_netdev_get_params)(struct ib_device *, u32, enum rdma_netdev_t, struct rdma_netdev_alloc_params *);
    int (*query_gid)(struct ib_device *, u32, int, union ib_gid *);
    int (*add_gid)(const struct ib_gid_attr *, void **);
    int (*del_gid)(const struct ib_gid_attr *, void **);
    int (*query_pkey)(struct ib_device *, u32, u16, u16 *);
    int (*alloc_ucontext)(struct ib_ucontext *, struct ib_udata *);
    void (*dealloc_ucontext)(struct ib_ucontext *);
    int (*mmap)(struct ib_ucontext *, struct vm_area_struct *);
    void (*mmap_free)(struct rdma_user_mmap_entry *);
    void (*disassociate_ucontext)(struct ib_ucontext *);
    int (*alloc_pd)(struct ib_pd *, struct ib_udata *);
    int (*dealloc_pd)(struct ib_pd *, struct ib_udata *);
    int (*create_ah)(struct ib_ah *, struct rdma_ah_init_attr *, struct ib_udata *);
    int (*create_user_ah)(struct ib_ah *, struct rdma_ah_init_attr *, struct ib_udata *);
    int (*modify_ah)(struct ib_ah *, struct rdma_ah_attr *);
    int (*query_ah)(struct ib_ah *, struct rdma_ah_attr *);
    int (*destroy_ah)(struct ib_ah *, u32);
    int (*create_srq)(struct ib_srq *, struct ib_srq_init_attr *, struct ib_udata *);
    int (*modify_srq)(struct ib_srq *, struct ib_srq_attr *, enum ib_srq_attr_mask, struct ib_udata *);
    int (*query_srq)(struct ib_srq *, struct ib_srq_attr *);
    int (*destroy_srq)(struct ib_srq *, struct ib_udata *);
    int (*create_qp)(struct ib_qp *, struct ib_qp_init_attr *, struct ib_udata *);
    int (*modify_qp)(struct ib_qp *, struct ib_qp_attr *, int, struct ib_udata *);
    int (*query_qp)(struct ib_qp *, struct ib_qp_attr *, int, struct ib_qp_init_attr *);
    int (*destroy_qp)(struct ib_qp *, struct ib_udata *);
    int (*create_cq)(struct ib_cq *, const struct ib_cq_init_attr *, struct uverbs_attr_bundle *);
    int (*modify_cq)(struct ib_cq *, u16, u16);
    int (*destroy_cq)(struct ib_cq *, struct ib_udata *);
    int (*resize_cq)(struct ib_cq *, int, struct ib_udata *);
    struct ib_mr * (*get_dma_mr)(struct ib_pd *, int);
    struct ib_mr * (*reg_user_mr)(struct ib_pd *, u64, u64, u64, int, struct ib_udata *);
    struct ib_mr * (*reg_user_mr_dmabuf)(struct ib_pd *, u64, u64, u64, int, int, struct uverbs_attr_bundle *);
    struct ib_mr * (*rereg_user_mr)(struct ib_mr *, int, u64, u64, u64, int, struct ib_pd *, struct ib_udata *);
    int (*dereg_mr)(struct ib_mr *, struct ib_udata *);
    struct ib_mr * (*alloc_mr)(struct ib_pd *, enum ib_mr_type, u32);
    struct ib_mr * (*alloc_mr_integrity)(struct ib_pd *, u32, u32);
    int (*advise_mr)(struct ib_pd *, enum ib_uverbs_advise_mr_advice, u32, struct ib_sge *, u32, struct uverbs_attr_bundle *);
    int (*map_mr_sg)(struct ib_mr *, struct scatterlist *, int, unsigned int *);
    int (*check_mr_status)(struct ib_mr *, u32, struct ib_mr_status *);
    int (*alloc_mw)(struct ib_mw *, struct ib_udata *);
    int (*dealloc_mw)(struct ib_mw *);
    int (*attach_mcast)(struct ib_qp *, union ib_gid *, u16);
    int (*detach_mcast)(struct ib_qp *, union ib_gid *, u16);
    int (*alloc_xrcd)(struct ib_xrcd *, struct ib_udata *);
    int (*dealloc_xrcd)(struct ib_xrcd *, struct ib_udata *);
    struct ib_flow * (*create_flow)(struct ib_qp *, struct ib_flow_attr *, struct ib_udata *);
    int (*destroy_flow)(struct ib_flow *);
    int (*destroy_flow_action)(struct ib_flow_action *);
    int (*set_vf_link_state)(struct ib_device *, int, u32, int);
    int (*get_vf_config)(struct ib_device *, int, u32, struct ifla_vf_info *);
    int (*get_vf_stats)(struct ib_device *, int, u32, struct ifla_vf_stats *);
    int (*get_vf_guid)(struct ib_device *, int, u32, struct ifla_vf_guid *, struct ifla_vf_guid *);
    int (*set_vf_guid)(struct ib_device *, int, u32, u64, int);
    struct ib_wq * (*create_wq)(struct ib_pd *, struct ib_wq_init_attr *, struct ib_udata *);
    int (*destroy_wq)(struct ib_wq *, struct ib_udata *);
    int (*modify_wq)(struct ib_wq *, struct ib_wq_attr *, u32, struct ib_udata *);
    int (*create_rwq_ind_table)(struct ib_rwq_ind_table *, struct ib_rwq_ind_table_init_attr *, struct ib_udata *);
    int (*destroy_rwq_ind_table)(struct ib_rwq_ind_table *);
    struct ib_dm * (*alloc_dm)(struct ib_device *, struct ib_ucontext *, struct ib_dm_alloc_attr *, struct uverbs_attr_bundle *);
    int (*dealloc_dm)(struct ib_dm *, struct uverbs_attr_bundle *);
    struct ib_mr * (*reg_dm_mr)(struct ib_pd *, struct ib_dm *, struct ib_dm_mr_attr *, struct uverbs_attr_bundle *);
    int (*create_counters)(struct ib_counters *, struct uverbs_attr_bundle *);
    int (*destroy_counters)(struct ib_counters *);
    int (*read_counters)(struct ib_counters *, struct ib_counters_read_attr *, struct uverbs_attr_bundle *);
    int (*map_mr_sg_pi)(struct ib_mr *, struct scatterlist *, int, unsigned int *, struct scatterlist *, int, unsigned int *);
    struct rdma_hw_stats * (*alloc_hw_device_stats)(struct ib_device *);
    struct rdma_hw_stats * (*alloc_hw_port_stats)(struct ib_device *, u32);
    int (*get_hw_stats)(struct ib_device *, struct rdma_hw_stats *, u32, int);
    int (*modify_hw_stat)(struct ib_device *, u32, unsigned int, bool);
    int (*fill_res_mr_entry)(struct sk_buff *, struct ib_mr *);
    int (*fill_res_mr_entry_raw)(struct sk_buff *, struct ib_mr *);
    int (*fill_res_cq_entry)(struct sk_buff *, struct ib_cq *);
    int (*fill_res_cq_entry_raw)(struct sk_buff *, struct ib_cq *);
    int (*fill_res_qp_entry)(struct sk_buff *, struct ib_qp *);
    int (*fill_res_qp_entry_raw)(struct sk_buff *, struct ib_qp *);
    int (*fill_res_cm_id_entry)(struct sk_buff *, struct rdma_cm_id *);
    int (*fill_res_srq_entry)(struct sk_buff *, struct ib_srq *);
    int (*fill_res_srq_entry_raw)(struct sk_buff *, struct ib_srq *);
    int (*enable_driver)(struct ib_device *);
    void (*dealloc_driver)(struct ib_device *);
    void (*iw_add_ref)(struct ib_qp *);
    void (*iw_rem_ref)(struct ib_qp *);
    struct ib_qp * (*iw_get_qp)(struct ib_device *, int);
    int (*iw_connect)(struct iw_cm_id *, struct iw_cm_conn_param *);
    int (*iw_accept)(struct iw_cm_id *, struct iw_cm_conn_param *);
    int (*iw_reject)(struct iw_cm_id *, const void *, u8);
    int (*iw_create_listen)(struct iw_cm_id *, int);
    int (*iw_destroy_listen)(struct iw_cm_id *);
    int (*counter_bind_qp)(struct rdma_counter *, struct ib_qp *);
    int (*counter_unbind_qp)(struct ib_qp *);
    int (*counter_dealloc)(struct rdma_counter *);
    struct rdma_hw_stats * (*counter_alloc_stats)(struct rdma_counter *);
    int (*counter_update_stats)(struct rdma_counter *);
    int (*fill_stat_mr_entry)(struct sk_buff *, struct ib_mr *);
    int (*query_ucontext)(struct ib_ucontext *, struct uverbs_attr_bundle *);
    int (*get_numa_node)(struct ib_device *);
    struct ib_device * (*add_sub_dev)(struct ib_device *, enum rdma_nl_dev_type, const char *);
    void (*del_sub_dev)(struct ib_device *);
    void (*ufile_hw_cleanup)(struct ib_uverbs_file *);
    void (*report_port_event)(struct ib_device *, struct net_device *, long unsigned int);
    size_t size_ib_ah;
    size_t size_ib_counters;
    size_t size_ib_cq;
    size_t size_ib_mw;
    size_t size_ib_pd;
    size_t size_ib_qp;
    size_t size_ib_rwq_ind_table;
    size_t size_ib_srq;
    size_t size_ib_ucontext;
    size_t size_ib_xrcd;
};

struct ib_odp_caps {
    uint64_t general_caps;
    struct {
        uint32_t rc_odp_caps;
        uint32_t uc_odp_caps;
        uint32_t ud_odp_caps;
        uint32_t xrc_odp_caps;
    } per_transport_caps;
};

struct ib_rss_caps {
    u32 supported_qpts;
    u32 max_rwq_indirection_tables;
    u32 max_rwq_indirection_table_size;
};

struct ib_tm_caps {
    u32 max_rndv_hdr_size;
    u32 max_num_tags;
    u32 flags;
    u32 max_ops;
    u32 max_sge;
};

struct ib_device_attr {
    u64 fw_ver;
    __be64 sys_image_guid;
    u64 max_mr_size;
    u64 page_size_cap;
    u32 vendor_id;
    u32 vendor_part_id;
    u32 hw_ver;
    int max_qp;
    int max_qp_wr;
    u64 device_cap_flags;
    u64 kernel_cap_flags;
    int max_send_sge;
    int max_recv_sge;
    int max_sge_rd;
    int max_cq;
    int max_cqe;
    int max_mr;
    int max_pd;
    int max_qp_rd_atom;
    int max_ee_rd_atom;
    int max_res_rd_atom;
    int max_qp_init_rd_atom;
    int max_ee_init_rd_atom;
    enum ib_atomic_cap atomic_cap;
    enum ib_atomic_cap masked_atomic_cap;
    int max_ee;
    int max_rdd;
    int max_mw;
    int max_raw_ipv6_qp;
    int max_raw_ethy_qp;
    int max_mcast_grp;
    int max_mcast_qp_attach;
    int max_total_mcast_qp_attach;
    int max_ah;
    int max_srq;
    int max_srq_wr;
    int max_srq_sge;
    unsigned int max_fast_reg_page_list_len;
    unsigned int max_pi_fast_reg_page_list_len;
    u16 max_pkeys;
    u8 local_ca_ack_delay;
    int sig_prot_cap;
    int sig_guard_cap;
    struct ib_odp_caps odp_caps;
    uint64_t timestamp_mask;
    uint64_t hca_core_clock;
    struct ib_rss_caps rss_caps;
    u32 max_wq_type_rq;
    u32 raw_packet_caps;
    struct ib_tm_caps tm_caps;
    struct ib_cq_caps cq_caps;
    u64 max_dm_size;
    u32 max_sgl_rd;
};

struct hw_stats_device_data;

struct rdmacg_device {
    struct list_head dev_node;
    struct list_head rpools;
    char *name;
};

struct rdma_restrack_root;

struct uapi_definition;

struct ib_port_data;

struct rdma_link_ops;

struct ib_device {
    struct device *dma_device;
    struct ib_device_ops ops;
    char name[64];
    struct callback_head callback_head;
    struct list_head event_handler_list;
    struct rw_semaphore event_handler_rwsem;
    spinlock_t qp_open_list_lock;
    struct rw_semaphore client_data_rwsem;
    struct xarray client_data;
    struct mutex unregistration_lock;
    rwlock_t cache_lock;
    struct ib_port_data *port_data;
    int num_comp_vectors;
    union {
        struct device dev;
        struct ib_core_device coredev;
    };
    const struct attribute_group *groups[4];
    u8 hw_stats_attr_index;
    u64 uverbs_cmd_mask;
    char node_desc[64];
    __be64 node_guid;
    u32 local_dma_lkey;
    u16 is_switch: 1;
    u16 kverbs_provider: 1;
    u16 use_cq_dim: 1;
    u8 node_type;
    u32 phys_port_cnt;
    struct ib_device_attr attrs;
    struct hw_stats_device_data *hw_stats_data;
    struct rdmacg_device cg_device;
    u32 index;
    spinlock_t cq_pools_lock;
    struct list_head cq_pools[3];
    struct rdma_restrack_root *res;
    const struct uapi_definition *driver_def;
    refcount_t refcount;
    struct completion unreg_completion;
    struct work_struct unregistration_work;
    const struct rdma_link_ops *link_ops;
    struct mutex compat_devs_mutex;
    struct xarray compat_devs;
    char iw_ifname[16];
    u32 iw_driver_flags;
    u32 lag_flags;
    struct mutex subdev_lock;
    struct list_head subdev_list_head;
    enum rdma_nl_dev_type type;
    struct ib_device *parent;
    struct list_head subdev_list;
    enum rdma_nl_name_assign_type name_assign_type;
};

struct ib_device_modify {
    u64 sys_image_guid;
    char node_desc[64];
};

struct ib_dm {
    struct ib_device *device;
    u32 length;
    u32 flags;
    struct ib_uobject *uobject;
    atomic_t usecnt;
};

struct ib_dm_alloc_attr {
    u64 length;
    u32 alignment;
    u32 flags;
};

struct ib_dm_mr_attr {
    u64 length;
    u64 offset;
    u32 access_flags;
};

struct ib_event {
    struct ib_device *device;
    union {
        struct ib_cq *cq;
        struct ib_qp *qp;
        struct ib_srq *srq;
        struct ib_wq *wq;
        u32 port_num;
    } element;
    enum ib_event_type event;
};

struct ib_flow {
    struct ib_qp *qp;
    struct ib_device *device;
    struct ib_uobject *uobject;
};

struct ib_flow_action {
    struct ib_device *device;
    struct ib_uobject *uobject;
    enum ib_flow_action_type type;
    atomic_t usecnt;
};

struct ib_flow_eth_filter {
    u8 dst_mac[6];
    u8 src_mac[6];
    __be16 ether_type;
    __be16 vlan_tag;
};

struct ib_flow_spec_eth {
    u32 type;
    u16 size;
    struct ib_flow_eth_filter val;
    struct ib_flow_eth_filter mask;
};

struct ib_flow_ib_filter {
    __be16 dlid;
    __u8 sl;
};

struct ib_flow_spec_ib {
    u32 type;
    u16 size;
    struct ib_flow_ib_filter val;
    struct ib_flow_ib_filter mask;
};

struct ib_flow_ipv4_filter {
    __be32 src_ip;
    __be32 dst_ip;
    u8 proto;
    u8 tos;
    u8 ttl;
    u8 flags;
};

struct ib_flow_spec_ipv4 {
    u32 type;
    u16 size;
    struct ib_flow_ipv4_filter val;
    struct ib_flow_ipv4_filter mask;
};

struct ib_flow_tcp_udp_filter {
    __be16 dst_port;
    __be16 src_port;
};

struct ib_flow_spec_tcp_udp {
    u32 type;
    u16 size;
    struct ib_flow_tcp_udp_filter val;
    struct ib_flow_tcp_udp_filter mask;
};

struct ib_flow_ipv6_filter {
    u8 src_ip[16];
    u8 dst_ip[16];
    __be32 flow_label;
    u8 next_hdr;
    u8 traffic_class;
    u8 hop_limit;
} __attribute__((packed));

struct ib_flow_spec_ipv6 {
    u32 type;
    u16 size;
    struct ib_flow_ipv6_filter val;
    struct ib_flow_ipv6_filter mask;
};

struct ib_flow_tunnel_filter {
    __be32 tunnel_id;
};

struct ib_flow_spec_tunnel {
    u32 type;
    u16 size;
    struct ib_flow_tunnel_filter val;
    struct ib_flow_tunnel_filter mask;
};

struct ib_flow_esp_filter {
    __be32 spi;
    __be32 seq;
};

struct ib_flow_spec_esp {
    u32 type;
    u16 size;
    struct ib_flow_esp_filter val;
    struct ib_flow_esp_filter mask;
};

struct ib_flow_gre_filter {
    __be16 c_ks_res0_ver;
    __be16 protocol;
    __be32 key;
};

struct ib_flow_spec_gre {
    u32 type;
    u16 size;
    struct ib_flow_gre_filter val;
    struct ib_flow_gre_filter mask;
};

struct ib_flow_mpls_filter {
    __be32 tag;
};

struct ib_flow_spec_mpls {
    u32 type;
    u16 size;
    struct ib_flow_mpls_filter val;
    struct ib_flow_mpls_filter mask;
};

struct ib_flow_spec_action_tag {
    enum ib_flow_spec_type type;
    u16 size;
    u32 tag_id;
};

struct ib_flow_spec_action_drop {
    enum ib_flow_spec_type type;
    u16 size;
};

struct ib_flow_spec_action_handle {
    enum ib_flow_spec_type type;
    u16 size;
    struct ib_flow_action *act;
};

struct ib_flow_spec_action_count {
    enum ib_flow_spec_type type;
    u16 size;
    struct ib_counters *counters;
};

union ib_flow_spec {
    struct {
        u32 type;
        u16 size;
    };
    struct ib_flow_spec_eth eth;
    struct ib_flow_spec_ib ib;
    struct ib_flow_spec_ipv4 ipv4;
    struct ib_flow_spec_tcp_udp tcp_udp;
    struct ib_flow_spec_ipv6 ipv6;
    struct ib_flow_spec_tunnel tunnel;
    struct ib_flow_spec_esp esp;
    struct ib_flow_spec_gre gre;
    struct ib_flow_spec_mpls mpls;
    struct ib_flow_spec_action_tag flow_tag;
    struct ib_flow_spec_action_drop drop;
    struct ib_flow_spec_action_handle action;
    struct ib_flow_spec_action_count flow_count;
};

struct ib_flow_attr {
    enum ib_flow_attr_type type;
    u16 size;
    u16 priority;
    u32 flags;
    u8 num_of_specs;
    u32 port;
    union ib_flow_spec flows[0];
};

union ib_gid {
    u8 raw[16];
    struct {
        __be64 subnet_prefix;
        __be64 interface_id;
    } global;
};

struct ib_gid_attr {
    struct net_device *ndev;
    struct ib_device *device;
    union ib_gid gid;
    enum ib_gid_type gid_type;
    u16 index;
    u32 port_num;
};

struct ib_global_route {
    const struct ib_gid_attr *sgid_attr;
    union ib_gid dgid;
    u32 flow_label;
    u8 sgid_index;
    u8 hop_limit;
    u8 traffic_class;
};

struct ib_grh {
    __be32 version_tclass_flow;
    __be16 paylen;
    u8 next_hdr;
    u8 hop_limit;
    union ib_gid sgid;
    union ib_gid dgid;
};

struct ib_sig_attrs;

struct ib_mr {
    struct ib_device *device;
    struct ib_pd *pd;
    u32 lkey;
    u32 rkey;
    u64 iova;
    u64 length;
    unsigned int page_size;
    enum ib_mr_type type;
    bool need_inval;
    union {
        struct ib_uobject *uobject;
        struct list_head qp_entry;
    };
    struct ib_dm *dm;
    struct ib_sig_attrs *sig_attrs;
    struct rdma_restrack_entry res;
};

struct ib_sig_err {
    enum ib_sig_err_type err_type;
    u32 expected;
    u32 actual;
    u64 sig_err_offset;
    u32 key;
};

struct ib_mr_status {
    u32 fail_status;
    struct ib_sig_err sig_err;
};

struct ib_mw {
    struct ib_device *device;
    struct ib_pd *pd;
    struct ib_uobject *uobject;
    u32 rkey;
    enum ib_mw_type type;
};

struct ib_pd {
    u32 local_dma_lkey;
    u32 flags;
    struct ib_device *device;
    struct ib_uobject *uobject;
    atomic_t usecnt;
    u32 unsafe_global_rkey;
    struct ib_mr *__internal_mr;
    struct rdma_restrack_entry res;
};

struct ib_port_attr {
    u64 subnet_prefix;
    enum ib_port_state state;
    enum ib_mtu max_mtu;
    enum ib_mtu active_mtu;
    u32 phys_mtu;
    int gid_tbl_len;
    unsigned int ip_gids: 1;
    u32 port_cap_flags;
    u32 max_msg_sz;
    u32 bad_pkey_cntr;
    u32 qkey_viol_cntr;
    u16 pkey_tbl_len;
    u32 sm_lid;
    u32 lid;
    u8 lmc;
    u8 max_vl_num;
    u8 sm_sl;
    u8 subnet_timeout;
    u8 init_type_reply;
    u8 active_width;
    u16 active_speed;
    u8 phys_state;
    u16 port_cap_flags2;
};

struct ib_pkey_cache;

struct ib_gid_table;

struct ib_port_cache {
    u64 subnet_prefix;
    struct ib_pkey_cache *pkey;
    struct ib_gid_table *gid;
    u8 lmc;
    enum ib_port_state port_state;
    enum ib_port_state last_port_state;
};

struct ib_port_immutable {
    int pkey_tbl_len;
    int gid_tbl_len;
    u32 core_cap_flags;
    u32 max_mad_size;
};

struct rdma_counter_mode {
    enum rdma_nl_counter_mode mode;
    enum rdma_nl_counter_mask mask;
    struct auto_mode_param param;
};

struct rdma_port_counter {
    struct rdma_counter_mode mode;
    struct rdma_hw_stats *hstats;
    unsigned int num_counters;
    struct mutex lock;
};

struct ib_port;

struct ib_port_data {
    struct ib_device *ib_dev;
    struct ib_port_immutable immutable;
    spinlock_t pkey_list_lock;
    spinlock_t netdev_lock;
    struct list_head pkey_list;
    struct ib_port_cache cache;
    struct net_device *netdev;
    netdevice_tracker netdev_tracker;
    struct hlist_node ndev_hash_link;
    struct rdma_port_counter port_counter;
    struct ib_port *sysfs;
};

struct ib_port_modify {
    u32 set_port_cap_mask;
    u32 clr_port_cap_mask;
    u8 init_type;
};

struct ib_qp_security;

struct ib_port_pkey {
    enum port_pkey_state state;
    u16 pkey_index;
    u32 port_num;
    struct list_head qp_list;
    struct list_head to_error_list;
    struct ib_qp_security *sec;
};

struct ib_ports_pkeys {
    struct ib_port_pkey main;
    struct ib_port_pkey alt;
};

struct ib_uqp_object;

struct ib_qp {
    struct ib_device *device;
    struct ib_pd *pd;
    struct ib_cq *send_cq;
    struct ib_cq *recv_cq;
    spinlock_t mr_lock;
    int mrs_used;
    struct list_head rdma_mrs;
    struct list_head sig_mrs;
    struct ib_srq *srq;
    struct completion srq_completion;
    struct ib_xrcd *xrcd;
    struct list_head xrcd_list;
    atomic_t usecnt;
    struct list_head open_list;
    struct ib_qp *real_qp;
    struct ib_uqp_object *uobject;
    void (*event_handler)(struct ib_event *, void *);
    void (*registered_event_handler)(struct ib_event *, void *);
    void *qp_context;
    const struct ib_gid_attr *av_sgid_attr;
    const struct ib_gid_attr *alt_path_sgid_attr;
    u32 qp_num;
    u32 max_write_sge;
    u32 max_read_sge;
    enum ib_qp_type qp_type;
    struct ib_rwq_ind_table *rwq_ind_tbl;
    struct ib_qp_security *qp_sec;
    u32 port;
    bool integrity_en;
    struct rdma_restrack_entry res;
    struct rdma_counter *counter;
};

struct ib_qp_cap {
    u32 max_send_wr;
    u32 max_recv_wr;
    u32 max_send_sge;
    u32 max_recv_sge;
    u32 max_inline_data;
    u32 max_rdma_ctxs;
};

struct roce_ah_attr {
    u8 dmac[6];
};

struct opa_ah_attr {
    u32 dlid;
    u8 src_path_bits;
    bool make_grd;
};

struct rdma_ah_attr {
    struct ib_global_route grh;
    u8 sl;
    u8 static_rate;
    u32 port_num;
    u8 ah_flags;
    enum rdma_ah_attr_type type;
    union {
        struct ib_ah_attr ib;
        struct roce_ah_attr roce;
        struct opa_ah_attr opa;
    };
};

struct ib_qp_attr {
    enum ib_qp_state qp_state;
    enum ib_qp_state cur_qp_state;
    enum ib_mtu path_mtu;
    enum ib_mig_state path_mig_state;
    u32 qkey;
    u32 rq_psn;
    u32 sq_psn;
    u32 dest_qp_num;
    int qp_access_flags;
    struct ib_qp_cap cap;
    struct rdma_ah_attr ah_attr;
    struct rdma_ah_attr alt_ah_attr;
    u16 pkey_index;
    u16 alt_pkey_index;
    u8 en_sqd_async_notify;
    u8 sq_draining;
    u8 max_rd_atomic;
    u8 max_dest_rd_atomic;
    u8 min_rnr_timer;
    u32 port_num;
    u8 timeout;
    u8 retry_cnt;
    u8 rnr_retry;
    u32 alt_port_num;
    u8 alt_timeout;
    u32 rate_limit;
    struct net_device *xmit_slave;
};

struct ib_qp_init_attr {
    void (*event_handler)(struct ib_event *, void *);
    void *qp_context;
    struct ib_cq *send_cq;
    struct ib_cq *recv_cq;
    struct ib_srq *srq;
    struct ib_xrcd *xrcd;
    struct ib_qp_cap cap;
    enum ib_sig_type sq_sig_type;
    enum ib_qp_type qp_type;
    u32 create_flags;
    u32 port_num;
    struct ib_rwq_ind_table *rwq_ind_tbl;
    u32 source_qpn;
};

struct ib_qp_security {
    struct ib_qp *qp;
    struct ib_device *dev;
    struct mutex mutex;
    struct ib_ports_pkeys *ports_pkeys;
    struct list_head shared_qp_list;
    void *security;
    bool destroying;
    atomic_t error_list_count;
    struct completion error_complete;
    int error_comps_pending;
};

struct rdma_cgroup;

struct ib_rdmacg_object {
    struct rdma_cgroup *cg;
};

struct ib_recv_wr {
    struct ib_recv_wr *next;
    union {
        u64 wr_id;
        struct ib_cqe *wr_cqe;
    };
    struct ib_sge *sg_list;
    int num_sge;
};

struct ib_rwq_ind_table {
    struct ib_device *device;
    struct ib_uobject *uobject;
    atomic_t usecnt;
    u32 ind_tbl_num;
    u32 log_ind_tbl_size;
    struct ib_wq **ind_tbl;
};

struct ib_rwq_ind_table_init_attr {
    u32 log_ind_tbl_size;
    struct ib_wq **ind_tbl;
};

struct ib_send_wr {
    struct ib_send_wr *next;
    union {
        u64 wr_id;
        struct ib_cqe *wr_cqe;
    };
    struct ib_sge *sg_list;
    int num_sge;
    enum ib_wr_opcode opcode;
    int send_flags;
    union {
        __be32 imm_data;
        u32 invalidate_rkey;
    } ex;
};

struct ib_sge {
    u64 addr;
    u32 length;
    u32 lkey;
};

struct ib_t10_dif_domain {
    enum ib_t10_dif_bg_type bg_type;
    u16 pi_interval;
    u16 bg;
    u16 app_tag;
    u32 ref_tag;
    bool ref_remap;
    bool app_escape;
    bool ref_escape;
    u16 apptag_check_mask;
};

struct ib_sig_domain {
    enum ib_signature_type sig_type;
    union {
        struct ib_t10_dif_domain dif;
    } sig;
};

struct ib_sig_attrs {
    u8 check_mask;
    struct ib_sig_domain mem;
    struct ib_sig_domain wire;
    int meta_length;
};

struct ib_usrq_object;

struct ib_srq {
    struct ib_device *device;
    struct ib_pd *pd;
    struct ib_usrq_object *uobject;
    void (*event_handler)(struct ib_event *, void *);
    void *srq_context;
    enum ib_srq_type srq_type;
    atomic_t usecnt;
    struct {
        struct ib_cq *cq;
        union {
            struct {
                struct ib_xrcd *xrcd;
                u32 srq_num;
            } xrc;
        };
    } ext;
    struct rdma_restrack_entry res;
};

struct ib_srq_attr {
    u32 max_wr;
    u32 max_sge;
    u32 srq_limit;
};

struct ib_srq_init_attr {
    void (*event_handler)(struct ib_event *, void *);
    void *srq_context;
    struct ib_srq_attr attr;
    enum ib_srq_type srq_type;
    struct {
        struct ib_cq *cq;
        union {
            struct {
                struct ib_xrcd *xrcd;
            } xrc;
            struct {
                u32 max_num_tags;
            } tag_matching;
        };
    } ext;
};

struct ib_ucontext {
    struct ib_device *device;
    struct ib_uverbs_file *ufile;
    struct ib_rdmacg_object cg_obj;
    struct rdma_restrack_entry res;
    struct xarray mmap_xa;
};

struct ib_udata {
    const void *inbuf;
    void *outbuf;
    size_t inlen;
    size_t outlen;
};

struct uverbs_api_object;

struct ib_uobject {
    u64 user_handle;
    struct ib_uverbs_file *ufile;
    struct ib_ucontext *context;
    void *object;
    struct list_head list;
    struct ib_rdmacg_object cg_obj;
    int id;
    struct kref ref;
    atomic_t usecnt;
    struct callback_head rcu;
    const struct uverbs_api_object *uapi_object;
};

struct ib_wc {
    union {
        u64 wr_id;
        struct ib_cqe *wr_cqe;
    };
    enum ib_wc_status status;
    enum ib_wc_opcode opcode;
    u32 vendor_err;
    u32 byte_len;
    struct ib_qp *qp;
    union {
        __be32 imm_data;
        u32 invalidate_rkey;
    } ex;
    u32 src_qp;
    u32 slid;
    int wc_flags;
    u16 pkey_index;
    u8 sl;
    u8 dlid_path_bits;
    u32 port_num;
    u8 smac[6];
    u16 vlan_id;
    u8 network_hdr_type;
};

struct ib_uwq_object;

struct ib_wq {
    struct ib_device *device;
    struct ib_uwq_object *uobject;
    void *wq_context;
    void (*event_handler)(struct ib_event *, void *);
    struct ib_pd *pd;
    struct ib_cq *cq;
    u32 wq_num;
    enum ib_wq_state state;
    enum ib_wq_type wq_type;
    atomic_t usecnt;
};

struct ib_wq_attr {
    enum ib_wq_state wq_state;
    enum ib_wq_state curr_wq_state;
    u32 flags;
    u32 flags_mask;
};

struct ib_wq_init_attr {
    void *wq_context;
    enum ib_wq_type wq_type;
    u32 max_wr;
    u32 max_sge;
    struct ib_cq *cq;
    void (*event_handler)(struct ib_event *, void *);
    u32 create_flags;
};

struct ib_xrcd {
    struct ib_device *device;
    atomic_t usecnt;
    struct inode *inode;
    struct rw_semaphore tgt_qps_rwsem;
    struct xarray tgt_qps;
};

struct ic_device {
    struct ic_device *next;
    struct net_device *dev;
    short unsigned int flags;
    short int able;
    __be32 xid;
};

struct icmp6_err {
    int err;
    int fatal;
};

struct icmp6_filter {
    __u32 data[8];
};

struct icmpv6_echo {
    __be16 identifier;
    __be16 sequence;
};

struct icmpv6_nd_advt {
    __u32 reserved: 5;
    __u32 override: 1;
    __u32 solicited: 1;
    __u32 router: 1;
    __u32 reserved2: 24;
};

struct icmpv6_nd_ra {
    __u8 hop_limit;
    __u8 reserved: 3;
    __u8 router_pref: 2;
    __u8 home_agent: 1;
    __u8 other: 1;
    __u8 managed: 1;
    __be16 rt_lifetime;
};

struct icmp6hdr {
    __u8 icmp6_type;
    __u8 icmp6_code;
    __sum16 icmp6_cksum;
    union {
        __be32 un_data32[1];
        __be16 un_data16[2];
        __u8 un_data8[4];
        struct icmpv6_echo u_echo;
        struct icmpv6_nd_advt u_nd_advt;
        struct icmpv6_nd_ra u_nd_ra;
    } icmp6_dataun;
};

struct icmphdr {
    __u8 type;
    __u8 code;
    __sum16 checksum;
    union {
        struct {
            __be16 id;
            __be16 sequence;
        } echo;
        __be32 gateway;
        struct {
            __be16 __unused;
            __be16 mtu;
        } frag;
        __u8 reserved[4];
    } un;
};

struct ip_options {
    __be32 faddr;
    __be32 nexthop;
    unsigned char optlen;
    unsigned char srr;
    unsigned char rr;
    unsigned char ts;
    unsigned char is_strictroute: 1;
    unsigned char srr_is_hit: 1;
    unsigned char is_changed: 1;
    unsigned char rr_needaddr: 1;
    unsigned char ts_needtime: 1;
    unsigned char ts_needaddr: 1;
    unsigned char router_alert;
    unsigned char cipso;
    unsigned char __pad2;
    unsigned char __data[0];
};

struct ip_options_rcu {
    struct callback_head rcu;
    struct ip_options opt;
};

struct ip_options_data {
    struct ip_options_rcu opt;
    char data[40];
};

struct icmp_bxm {
    struct sk_buff *skb;
    int offset;
    int data_len;
    struct {
        struct icmphdr icmph;
        __be32 times[3];
    } data;
    int head_len;
    struct ip_options_data replyopts;
};

struct icmp_control {
    enum skb_drop_reason (*handler)(struct sk_buff *);
    short int error;
};

struct icmp_err {
    int errno;
    unsigned int fatal: 1;
};

struct icmp_ext_echo_ctype3_hdr {
    __be16 afi;
    __u8 addrlen;
    __u8 reserved;
};

struct icmp_extobj_hdr {
    __be16 length;
    __u8 class_num;
    __u8 class_type;
};

struct icmp_ext_echo_iio {
    struct icmp_extobj_hdr extobj_hdr;
    union {
        char name[16];
        __be32 ifindex;
        struct {
            struct icmp_ext_echo_ctype3_hdr ctype3_hdr;
            union {
                __be32 ipv4_addr;
                struct in6_addr ipv6_addr;
            } ip_addr;
        } addr;
    } ident;
};

struct icmp_ext_hdr {
    __u8 reserved1: 4;
    __u8 version: 4;
    __u8 reserved2;
    __sum16 checksum;
};

struct icmp_filter {
    __u32 data;
};

struct icmp_mib {
    long unsigned int mibs[30];
};

struct icmpmsg_mib {
    atomic_long_t mibs[512];
};

struct icmpv6_mib {
    long unsigned int mibs[7];
};

struct icmpv6_mib_device {
    atomic_long_t mibs[7];
};

struct icmpv6_msg {
    struct sk_buff *skb;
    int offset;
    uint8_t type;
};

struct icmpv6msg_mib {
    atomic_long_t mibs[512];
};

struct icmpv6msg_mib_device {
    atomic_long_t mibs[512];
};

struct id_bitmap {
    long unsigned int map[4];
};

struct ida_bitmap {
    long unsigned int bitmap[16];
};

struct idempotent {
    const void *cookie;
    struct hlist_node entry;
    struct completion complete;
    int ret;
};

struct idle_timer {
    struct hrtimer timer;
    int done;
};

struct idmap_key {
    bool map_up;
    u32 id;
    u32 count;
};

struct ieee80211_channel {
    enum nl80211_band band;
    u32 center_freq;
    u16 freq_offset;
    u16 hw_value;
    u32 flags;
    int max_antenna_gain;
    int max_power;
    int max_reg_power;
    bool beacon_found;
    u32 orig_flags;
    int orig_mag;
    int orig_mpwr;
    enum nl80211_dfs_state dfs_state;
    long unsigned int dfs_state_entered;
    unsigned int dfs_cac_ms;
    s8 psd;
};

struct ieee80211_eht_cap_elem_fixed {
    u8 mac_cap_info[2];
    u8 phy_cap_info[9];
};

struct ieee80211_eht_mcs_nss_supp_20mhz_only {
    union {
        struct {
            u8 rx_tx_mcs7_max_nss;
            u8 rx_tx_mcs9_max_nss;
            u8 rx_tx_mcs11_max_nss;
            u8 rx_tx_mcs13_max_nss;
        };
        u8 rx_tx_max_nss[4];
    };
};

struct ieee80211_eht_mcs_nss_supp_bw {
    union {
        struct {
            u8 rx_tx_mcs9_max_nss;
            u8 rx_tx_mcs11_max_nss;
            u8 rx_tx_mcs13_max_nss;
        };
        u8 rx_tx_max_nss[3];
    };
};

struct ieee80211_eht_mcs_nss_supp {
    union {
        struct ieee80211_eht_mcs_nss_supp_20mhz_only only_20mhz;
        struct {
            struct ieee80211_eht_mcs_nss_supp_bw _80;
            struct ieee80211_eht_mcs_nss_supp_bw _160;
            struct ieee80211_eht_mcs_nss_supp_bw _320;
        } bw;
    };
};

struct ieee80211_freq_range {
    u32 start_freq_khz;
    u32 end_freq_khz;
    u32 max_bandwidth_khz;
};

struct ieee80211_he_6ghz_capa {
    __le16 capa;
};

struct ieee80211_he_cap_elem {
    u8 mac_cap_info[6];
    u8 phy_cap_info[11];
};

struct ieee80211_he_mcs_nss_supp {
    __le16 rx_mcs_80;
    __le16 tx_mcs_80;
    __le16 rx_mcs_160;
    __le16 tx_mcs_160;
    __le16 rx_mcs_80p80;
    __le16 tx_mcs_80p80;
};

struct ieee80211_iface_limit;

struct ieee80211_iface_combination {
    const struct ieee80211_iface_limit *limits;
    u32 num_different_channels;
    u16 max_interfaces;
    u8 n_limits;
    bool beacon_int_infra_match;
    u8 radar_detect_widths;
    u8 radar_detect_regions;
    u32 beacon_int_min_gcd;
};

struct ieee80211_iface_limit {
    u16 max;
    u16 types;
};

struct ieee80211_power_rule {
    u32 max_antenna_gain;
    u32 max_eirp;
};

struct ieee80211_rate {
    u32 flags;
    u16 bitrate;
    u16 hw_value;
    u16 hw_value_short;
};

struct ieee80211_wmm_ac {
    u16 cw_min;
    u16 cw_max;
    u16 cot;
    u8 aifsn;
};

struct ieee80211_wmm_rule {
    struct ieee80211_wmm_ac client[4];
    struct ieee80211_wmm_ac ap[4];
};

struct ieee80211_reg_rule {
    struct ieee80211_freq_range freq_range;
    struct ieee80211_power_rule power_rule;
    struct ieee80211_wmm_rule wmm_rule;
    u32 flags;
    u32 dfs_cac_ms;
    bool has_wmm;
    s8 psd;
};

struct ieee80211_regdomain {
    struct callback_head callback_head;
    u32 n_reg_rules;
    char alpha2[3];
    enum nl80211_dfs_regions dfs_region;
    struct ieee80211_reg_rule reg_rules[0];
};

struct ieee80211_sta_he_cap {
    bool has_he;
    struct ieee80211_he_cap_elem he_cap_elem;
    struct ieee80211_he_mcs_nss_supp he_mcs_nss_supp;
    u8 ppe_thres[25];
} __attribute__((packed));

struct ieee80211_sta_eht_cap {
    bool has_eht;
    struct ieee80211_eht_cap_elem_fixed eht_cap_elem;
    struct ieee80211_eht_mcs_nss_supp eht_mcs_nss_supp;
    u8 eht_ppe_thres[32];
};

struct ieee80211_sband_iftype_data {
    u16 types_mask;
    struct ieee80211_sta_he_cap he_cap;
    struct ieee80211_he_6ghz_capa he_6ghz_capa;
    struct ieee80211_sta_eht_cap eht_cap;
    struct {
        const u8 *data;
        unsigned int len;
    } vendor_elems;
} __attribute__((packed));

struct ieee80211_sta_ht_cap {
    u16 cap;
    bool ht_supported;
    u8 ampdu_factor;
    u8 ampdu_density;
    struct ieee80211_mcs_info mcs;
    short: 0;
} __attribute__((packed));

struct ieee80211_sta_s1g_cap {
    bool s1g;
    u8 cap[10];
    u8 nss_mcs[5];
};

struct ieee80211_sta_vht_cap {
    bool vht_supported;
    u32 cap;
    struct ieee80211_vht_mcs_info vht_mcs;
};

struct ieee80211_supported_band {
    struct ieee80211_channel *channels;
    struct ieee80211_rate *bitrates;
    enum nl80211_band band;
    int n_channels;
    int n_bitrates;
    struct ieee80211_sta_ht_cap ht_cap;
    struct ieee80211_sta_vht_cap vht_cap;
    struct ieee80211_sta_s1g_cap s1g_cap;
    struct ieee80211_edmg edmg_cap;
    u16 n_iftype_data;
    const struct ieee80211_sband_iftype_data *iftype_data;
};

struct ieee80211_txrx_stypes {
    u16 tx;
    u16 rx;
};

struct ieee802154_addr {
    u8 mode;
    __le16 pan_id;
    union {
        __le16 short_addr;
        __le64 extended_addr;
    };
};

struct ieee802154_pan_device {
    __le16 pan_id;
    u8 mode;
    __le16 short_addr;
    __le64 extended_addr;
    struct list_head node;
};

struct ieee_ets {
    __u8 willing;
    __u8 ets_cap;
    __u8 cbs;
    __u8 tc_tx_bw[8];
    __u8 tc_rx_bw[8];
    __u8 tc_tsa[8];
    __u8 prio_tc[8];
    __u8 tc_reco_bw[8];
    __u8 tc_reco_tsa[8];
    __u8 reco_prio_tc[8];
};

struct ieee_maxrate {
    __u64 tc_maxrate[8];
};

struct ieee_pfc {
    __u8 pfc_cap;
    __u8 pfc_en;
    __u8 mbc;
    __u16 delay;
    __u64 requests[8];
    __u64 indications[8];
};

struct ieee_qcn {
    __u8 rpg_enable[8];
    __u32 rppp_max_rps[8];
    __u32 rpg_time_reset[8];
    __u32 rpg_byte_reset[8];
    __u32 rpg_threshold[8];
    __u32 rpg_max_rate[8];
    __u32 rpg_ai_rate[8];
    __u32 rpg_hai_rate[8];
    __u32 rpg_gd[8];
    __u32 rpg_min_dec_fac[8];
    __u32 rpg_min_rate[8];
    __u32 cndd_state_machine[8];
};

struct ieee_qcn_stats {
    __u64 rppp_rp_centiseconds[8];
    __u32 rppp_created_rps[8];
};

struct if6_iter_state {
    struct seq_net_private p;
    int bucket;
    int offset;
};

struct if_dqblk {
    __u64 dqb_bhardlimit;
    __u64 dqb_bsoftlimit;
    __u64 dqb_curspace;
    __u64 dqb_ihardlimit;
    __u64 dqb_isoftlimit;
    __u64 dqb_curinodes;
    __u64 dqb_btime;
    __u64 dqb_itime;
    __u32 dqb_valid;
};

struct if_dqinfo {
    __u64 dqi_bgrace;
    __u64 dqi_igrace;
    __u32 dqi_flags;
    __u32 dqi_valid;
};

struct if_nextdqblk {
    __u64 dqb_bhardlimit;
    __u64 dqb_bsoftlimit;
    __u64 dqb_curspace;
    __u64 dqb_ihardlimit;
    __u64 dqb_isoftlimit;
    __u64 dqb_curinodes;
    __u64 dqb_btime;
    __u64 dqb_itime;
    __u32 dqb_valid;
    __u32 dqb_id;
};

struct if_set {
    if_mask ifs_bits[8];
};

struct if_settings {
    unsigned int type;
    unsigned int size;
    union {
        raw_hdlc_proto *raw_hdlc;
        cisco_proto *cisco;
        fr_proto *fr;
        fr_proto_pvc *fr_pvc;
        fr_proto_pvc_info *fr_pvc_info;
        x25_hdlc_proto *x25;
        sync_serial_settings *sync;
        te1_settings *te1;
    } ifs_ifsu;
};

struct if_stats_msg {
    __u8 family;
    __u8 pad1;
    __u16 pad2;
    __u32 ifindex;
    __u32 filter_mask;
};

struct ifa6_config {
    const struct in6_addr *pfx;
    unsigned int plen;
    u8 ifa_proto;
    const struct in6_addr *peer_pfx;
    u32 rt_priority;
    u32 ifa_flags;
    u32 preferred_lft;
    u32 valid_lft;
    u16 scope;
};

struct ifa_cacheinfo {
    __u32 ifa_prefered;
    __u32 ifa_valid;
    __u32 cstamp;
    __u32 tstamp;
};

struct ifacaddr6 {
    struct in6_addr aca_addr;
    struct fib6_info *aca_rt;
    struct ifacaddr6 *aca_next;
    struct hlist_node aca_addr_lst;
    int aca_users;
    refcount_t aca_refcnt;
    long unsigned int aca_cstamp;
    long unsigned int aca_tstamp;
    struct callback_head rcu;
};

struct ifaddrlblmsg {
    __u8 ifal_family;
    __u8 __ifal_reserved;
    __u8 ifal_prefixlen;
    __u8 ifal_flags;
    __u32 ifal_index;
    __u32 ifal_seq;
};

struct ifaddrmsg {
    __u8 ifa_family;
    __u8 ifa_prefixlen;
    __u8 ifa_flags;
    __u8 ifa_scope;
    __u32 ifa_index;
};

struct ifbond {
    __s32 bond_mode;
    __s32 num_slaves;
    __s32 miimon;
};

typedef struct ifbond ifbond;

struct ifconf {
    int ifc_len;
    union {
        char *ifcu_buf;
        struct ifreq *ifcu_req;
    } ifc_ifcu;
};

struct ifinfomsg {
    unsigned char ifi_family;
    unsigned char __ifi_pad;
    short unsigned int ifi_type;
    int ifi_index;
    unsigned int ifi_flags;
    unsigned int ifi_change;
};

struct ifla_cacheinfo {
    __u32 max_reasm_len;
    __u32 tstamp;
    __u32 reachable_time;
    __u32 retrans_time;
};

struct ifla_vf_broadcast {
    __u8 broadcast[32];
};

struct ifla_vf_guid {
    __u32 vf;
    __u64 guid;
};

struct ifla_vf_info {
    __u32 vf;
    __u8 mac[32];
    __u32 vlan;
    __u32 qos;
    __u32 spoofchk;
    __u32 linkstate;
    __u32 min_tx_rate;
    __u32 max_tx_rate;
    __u32 rss_query_en;
    __u32 trusted;
    __be16 vlan_proto;
};

struct ifla_vf_link_state {
    __u32 vf;
    __u32 link_state;
};

struct ifla_vf_mac {
    __u32 vf;
    __u8 mac[32];
};

struct ifla_vf_rate {
    __u32 vf;
    __u32 min_tx_rate;
    __u32 max_tx_rate;
};

struct ifla_vf_rss_query_en {
    __u32 vf;
    __u32 setting;
};

struct ifla_vf_spoofchk {
    __u32 vf;
    __u32 setting;
};

struct ifla_vf_stats {
    __u64 rx_packets;
    __u64 tx_packets;
    __u64 rx_bytes;
    __u64 tx_bytes;
    __u64 broadcast;
    __u64 multicast;
    __u64 rx_dropped;
    __u64 tx_dropped;
};

struct ifla_vf_trust {
    __u32 vf;
    __u32 setting;
};

struct ifla_vf_tx_rate {
    __u32 vf;
    __u32 rate;
};

struct ifla_vf_vlan {
    __u32 vf;
    __u32 vlan;
    __u32 qos;
};

struct ifla_vf_vlan_info {
    __u32 vf;
    __u32 vlan;
    __u32 qos;
    __be16 vlan_proto;
};

struct ifmap {
    long unsigned int mem_start;
    long unsigned int mem_end;
    short unsigned int base_addr;
    unsigned char irq;
    unsigned char dma;
    unsigned char port;
};

struct inet6_dev;

struct ip6_sf_list;

struct ifmcaddr6 {
    struct in6_addr mca_addr;
    struct inet6_dev *idev;
    struct ifmcaddr6 *next;
    struct ip6_sf_list *mca_sources;
    struct ip6_sf_list *mca_tomb;
    unsigned int mca_sfmode;
    unsigned char mca_crcount;
    long unsigned int mca_sfcount[2];
    struct delayed_work mca_work;
    unsigned int mca_flags;
    int mca_users;
    refcount_t mca_refcnt;
    long unsigned int mca_cstamp;
    long unsigned int mca_tstamp;
    struct callback_head rcu;
};

struct ifreq {
    union {
        char ifrn_name[16];
    } ifr_ifrn;
    union {
        struct sockaddr ifru_addr;
        struct sockaddr ifru_dstaddr;
        struct sockaddr ifru_broadaddr;
        struct sockaddr ifru_netmask;
        struct sockaddr ifru_hwaddr;
        short int ifru_flags;
        int ifru_ivalue;
        int ifru_mtu;
        struct ifmap ifru_map;
        char ifru_slave[16];
        char ifru_newname[16];
        void *ifru_data;
        struct if_settings ifru_settings;
    } ifr_ifru;
};

struct ifslave {
    __s32 slave_id;
    char slave_name[16];
    __s8 link;
    __s8 state;
    __u32 link_failure_count;
};

typedef struct ifslave ifslave;

struct igmp6_mc_iter_state {
    struct seq_net_private p;
    struct net_device *dev;
    struct inet6_dev *idev;
};

struct igmp6_mcf_iter_state {
    struct seq_net_private p;
    struct net_device *dev;
    struct inet6_dev *idev;
    struct ifmcaddr6 *im;
};

struct in_device;

struct igmp_mc_iter_state {
    struct seq_net_private p;
    struct net_device *dev;
    struct in_device *in_dev;
};

struct ip_mc_list;

struct igmp_mcf_iter_state {
    struct seq_net_private p;
    struct net_device *dev;
    struct in_device *idev;
    struct ip_mc_list *im;
};

struct igmphdr {
    __u8 type;
    __u8 code;
    __sum16 csum;
    __be32 group;
};

struct igmpmsg {
    __u32 unused1;
    __u32 unused2;
    unsigned char im_msgtype;
    unsigned char im_mbz;
    unsigned char im_vif;
    unsigned char im_vif_hi;
    struct in_addr im_src;
    struct in_addr im_dst;
};

struct igmpv3_grec {
    __u8 grec_type;
    __u8 grec_auxwords;
    __be16 grec_nsrcs;
    __be32 grec_mca;
    __be32 grec_src[0];
};

struct igmpv3_query {
    __u8 type;
    __u8 code;
    __sum16 csum;
    __be32 group;
    __u8 qrv: 3;
    __u8 suppress: 1;
    __u8 resv: 4;
    __u8 qqic;
    __be16 nsrcs;
    __be32 srcs[0];
};

struct igmpv3_report {
    __u8 type;
    __u8 resv1;
    __sum16 csum;
    __be16 resv2;
    __be16 ngrec;
    struct igmpv3_grec grec[0];
};

struct ima_algo_desc {
    struct crypto_shash *tfm;
    enum hash_algo algo;
};

struct ima_digest_data {
    union {
        struct {
            u8 algo;
            u8 length;
            union {
                struct {
                    u8 unused;
                    u8 type;
                } sha1;
                struct {
                    u8 type;
                    u8 algo;
                } ng;
                u8 data[2];
            } xattr;
        };
        struct ima_digest_data_hdr hdr;
    };
    u8 digest[0];
};

struct modsig;

struct ima_iint_cache;

struct ima_event_data {
    struct ima_iint_cache *iint;
    struct file *file;
    const unsigned char *filename;
    struct evm_ima_xattr_data *xattr_value;
    int xattr_len;
    const struct modsig *modsig;
    const char *violation;
    const void *buf;
    int buf_len;
};

struct ima_field_data {
    u8 *data;
    u32 len;
};

struct ima_file_id {
    __u8 hash_type;
    __u8 hash_algorithm;
    __u8 hash[64];
};

struct ima_h_table {
    atomic_long_t len;
    atomic_long_t violations;
    struct hlist_head queue[1024];
};

struct ima_iint_cache {
    struct mutex mutex;
    struct integrity_inode_attributes real_inode;
    long unsigned int flags;
    long unsigned int measured_pcrs;
    long unsigned int atomic_flags;
    enum integrity_status ima_file_status: 4;
    enum integrity_status ima_mmap_status: 4;
    enum integrity_status ima_bprm_status: 4;
    enum integrity_status ima_read_status: 4;
    enum integrity_status ima_creds_status: 4;
    struct ima_digest_data *ima_hash;
};

struct ima_kexec_hdr {
    u16 version;
    u16 _reserved0;
    u32 _reserved1;
    u64 buffer_size;
    u64 count;
};

struct ima_key_entry {
    struct list_head list;
    void *payload;
    size_t payload_len;
    char *keyring_name;
};

struct ima_max_digest_data {
    struct ima_digest_data_hdr hdr;
    u8 digest[64];
};

struct ima_template_entry;

struct ima_queue_entry {
    struct hlist_node hnext;
    struct list_head later;
    struct ima_template_entry *entry;
};

struct ima_rule_opt_list;

struct ima_template_desc;

struct ima_rule_entry {
    struct list_head list;
    int action;
    unsigned int flags;
    enum ima_hooks func;
    int mask;
    long unsigned int fsmagic;
    uuid_t fsuuid;
    kuid_t uid;
    kgid_t gid;
    kuid_t fowner;
    kgid_t fgroup;
    bool (*uid_op)(kuid_t, kuid_t);
    bool (*gid_op)(kgid_t, kgid_t);
    bool (*fowner_op)(vfsuid_t, kuid_t);
    bool (*fgroup_op)(vfsgid_t, kgid_t);
    int pcr;
    unsigned int allowed_algos;
    struct {
        void *rule;
        char *args_p;
        int type;
    } lsm[6];
    char *fsname;
    struct ima_rule_opt_list *keyrings;
    struct ima_rule_opt_list *label;
    struct ima_template_desc *template;
};

struct ima_rule_opt_list {
    size_t count;
    char *items[0];
};

struct ima_template_field;

struct ima_template_desc {
    struct list_head list;
    char *name;
    char *fmt;
    int num_fields;
    const struct ima_template_field **fields;
};

struct tpm_digest;

struct ima_template_entry {
    int pcr;
    struct tpm_digest *digests;
    struct ima_template_desc *template_desc;
    u32 template_data_len;
    struct ima_field_data template_data[0];
};

struct ima_template_field {
    const char field_id[16];
    int (*field_init)(struct ima_event_data *, struct ima_field_data *);
    void (*field_show)(struct seq_file *, enum ima_show_type, struct ima_field_data *);
};

struct imon_dec {
    int state;
    int count;
    int last_chk;
    unsigned int bits;
    bool stick_keyboard;
};

struct in6_flowlabel_req {
    struct in6_addr flr_dst;
    __be32 flr_label;
    __u8 flr_action;
    __u8 flr_share;
    __u16 flr_flags;
    __u16 flr_expires;
    __u16 flr_linger;
    __u32 __flr_pad;
};

struct in6_ifreq {
    struct in6_addr ifr6_addr;
    __u32 ifr6_prefixlen;
    int ifr6_ifindex;
};

struct in6_pktinfo {
    struct in6_addr ipi6_addr;
    int ipi6_ifindex;
};

struct in6_rtmsg {
    struct in6_addr rtmsg_dst;
    struct in6_addr rtmsg_src;
    struct in6_addr rtmsg_gateway;
    __u32 rtmsg_type;
    __u16 rtmsg_dst_len;
    __u16 rtmsg_src_len;
    __u32 rtmsg_metric;
    long unsigned int rtmsg_info;
    __u32 rtmsg_flags;
    int rtmsg_ifindex;
};

struct in6_validator_info {
    struct in6_addr i6vi_addr;
    struct inet6_dev *i6vi_dev;
    struct netlink_ext_ack *extack;
};

struct ipv4_devconf {
    void *sysctl;
    int data[33];
    long unsigned int state[1];
};

struct in_ifaddr;

struct neigh_parms;

struct in_device {
    struct net_device *dev;
    netdevice_tracker dev_tracker;
    refcount_t refcnt;
    int dead;
    struct in_ifaddr *ifa_list;
    struct ip_mc_list *mc_list;
    struct ip_mc_list **mc_hash;
    int mc_count;
    spinlock_t mc_tomb_lock;
    struct ip_mc_list *mc_tomb;
    long unsigned int mr_v1_seen;
    long unsigned int mr_v2_seen;
    long unsigned int mr_maxdelay;
    long unsigned int mr_qi;
    long unsigned int mr_qri;
    unsigned char mr_qrv;
    unsigned char mr_gq_running;
    u32 mr_ifc_count;
    struct timer_list mr_gq_timer;
    struct timer_list mr_ifc_timer;
    struct neigh_parms *arp_parms;
    struct ipv4_devconf cnf;
    struct callback_head callback_head;
};

struct in_ifaddr {
    struct hlist_node addr_lst;
    struct in_ifaddr *ifa_next;
    struct in_device *ifa_dev;
    struct callback_head callback_head;
    __be32 ifa_local;
    __be32 ifa_address;
    __be32 ifa_mask;
    __u32 ifa_rt_priority;
    __be32 ifa_broadcast;
    unsigned char ifa_scope;
    unsigned char ifa_prefixlen;
    unsigned char ifa_proto;
    __u32 ifa_flags;
    char ifa_label[16];
    __u32 ifa_valid_lft;
    __u32 ifa_preferred_lft;
    long unsigned int ifa_cstamp;
    long unsigned int ifa_tstamp;
};

struct in_pktinfo {
    int ipi_ifindex;
    struct in_addr ipi_spec_dst;
    struct in_addr ipi_addr;
};

struct in_validator_info {
    __be32 ivi_addr;
    struct in_device *ivi_dev;
    struct netlink_ext_ack *extack;
};

struct inbound_win {
    u64 size;
    u64 pci_offset;
    u64 cpu_addr;
};

struct indication {
    u32 bit;
    const char *name;
};

struct ipv6_txoptions;

struct inet6_cork {
    struct ipv6_txoptions *opt;
    u8 hop_limit;
    u8 tclass;
};

struct ipv6_stable_secret {
    bool initialized;
    struct in6_addr secret;
};

struct ipv6_devconf {
    __u8 __cacheline_group_begin__ipv6_devconf_read_txrx[0];
    __s32 disable_ipv6;
    __s32 hop_limit;
    __s32 mtu6;
    __s32 forwarding;
    __s32 disable_policy;
    __s32 proxy_ndp;
    __u8 __cacheline_group_end__ipv6_devconf_read_txrx[0];
    __s32 accept_ra;
    __s32 accept_redirects;
    __s32 autoconf;
    __s32 dad_transmits;
    __s32 rtr_solicits;
    __s32 rtr_solicit_interval;
    __s32 rtr_solicit_max_interval;
    __s32 rtr_solicit_delay;
    __s32 force_mld_version;
    __s32 mldv1_unsolicited_report_interval;
    __s32 mldv2_unsolicited_report_interval;
    __s32 use_tempaddr;
    __s32 temp_valid_lft;
    __s32 temp_prefered_lft;
    __s32 regen_min_advance;
    __s32 regen_max_retry;
    __s32 max_desync_factor;
    __s32 max_addresses;
    __s32 accept_ra_defrtr;
    __u32 ra_defrtr_metric;
    __s32 accept_ra_min_hop_limit;
    __s32 accept_ra_min_lft;
    __s32 accept_ra_pinfo;
    __s32 ignore_routes_with_linkdown;
    __s32 accept_ra_rtr_pref;
    __s32 rtr_probe_interval;
    __s32 accept_ra_rt_info_min_plen;
    __s32 accept_ra_rt_info_max_plen;
    __s32 accept_source_route;
    __s32 accept_ra_from_local;
    atomic_t mc_forwarding;
    __s32 drop_unicast_in_l2_multicast;
    __s32 accept_dad;
    __s32 force_tllao;
    __s32 ndisc_notify;
    __s32 suppress_frag_ndisc;
    __s32 accept_ra_mtu;
    __s32 drop_unsolicited_na;
    __s32 accept_untracked_na;
    struct ipv6_stable_secret stable_secret;
    __s32 use_oif_addrs_only;
    __s32 keep_addr_on_down;
    __s32 seg6_enabled;
    __s32 seg6_require_hmac;
    __u32 enhanced_dad;
    __u32 addr_gen_mode;
    __s32 ndisc_tclass;
    __s32 rpl_seg_enabled;
    __u32 ioam6_id;
    __u32 ioam6_id_wide;
    __u8 ioam6_enabled;
    __u8 ndisc_evict_nocarrier;
    __u8 ra_honor_pio_life;
    __u8 ra_honor_pio_pflag;
    struct ctl_table_header *sysctl_header;
};

struct ipstats_mib;

struct ipv6_devstat {
    struct proc_dir_entry *proc_dir_entry;
    struct ipstats_mib *ipv6;
    struct icmpv6_mib_device *icmpv6dev;
    struct icmpv6msg_mib_device *icmpv6msgdev;
};

struct inet6_dev {
    struct net_device *dev;
    netdevice_tracker dev_tracker;
    struct list_head addr_list;
    struct ifmcaddr6 *mc_list;
    struct ifmcaddr6 *mc_tomb;
    unsigned char mc_qrv;
    unsigned char mc_gq_running;
    unsigned char mc_ifc_count;
    unsigned char mc_dad_count;
    long unsigned int mc_v1_seen;
    long unsigned int mc_qi;
    long unsigned int mc_qri;
    long unsigned int mc_maxdelay;
    struct delayed_work mc_gq_work;
    struct delayed_work mc_ifc_work;
    struct delayed_work mc_dad_work;
    struct delayed_work mc_query_work;
    struct delayed_work mc_report_work;
    struct sk_buff_head mc_query_queue;
    struct sk_buff_head mc_report_queue;
    spinlock_t mc_query_lock;
    spinlock_t mc_report_lock;
    struct mutex mc_lock;
    struct ifacaddr6 *ac_list;
    rwlock_t lock;
    refcount_t refcnt;
    __u32 if_flags;
    int dead;
    u32 desync_factor;
    struct list_head tempaddr_list;
    struct in6_addr token;
    struct neigh_parms *nd_parms;
    struct ipv6_devconf cnf;
    struct ipv6_devstat stats;
    struct timer_list rs_timer;
    __s32 rs_interval;
    __u8 rs_probes;
    long unsigned int tstamp;
    struct callback_head rcu;
    unsigned int ra_mtu;
};

struct inet6_fill_args {
    u32 portid;
    u32 seq;
    int event;
    unsigned int flags;
    int netnsid;
    int ifindex;
    enum addr_type_t type;
    bool force_rt_scope_universe;
};

struct inet6_ifaddr {
    struct in6_addr addr;
    __u32 prefix_len;
    __u32 rt_priority;
    __u32 valid_lft;
    __u32 prefered_lft;
    refcount_t refcnt;
    spinlock_t lock;
    int state;
    __u32 flags;
    __u8 dad_probes;
    __u8 stable_privacy_retry;
    __u16 scope;
    __u64 dad_nonce;
    long unsigned int cstamp;
    long unsigned int tstamp;
    struct delayed_work dad_work;
    struct inet6_dev *idev;
    struct fib6_info *rt;
    struct hlist_node addr_lst;
    struct list_head if_list;
    struct list_head if_list_aux;
    struct list_head tmp_list;
    struct inet6_ifaddr *ifpub;
    int regen_count;
    bool tokenized;
    u8 ifa_proto;
    struct callback_head rcu;
    struct in6_addr peer_addr;
};

struct inet6_skb_parm;

struct inet6_protocol {
    int (*handler)(struct sk_buff *);
    int (*err_handler)(struct sk_buff *, struct inet6_skb_parm *, u8, u8, int, __be32);
    unsigned int flags;
    u32 secret;
};

struct inet6_skb_parm {
    int iif;
    __be16 ra;
    __u16 dst0;
    __u16 srcrt;
    __u16 dst1;
    __u16 lastopt;
    __u16 nhoff;
    __u16 flags;
    __u16 dsthao;
    __u16 frag_max_size;
    __u16 srhoff;
};

union inet_addr {
    __u32 all[4];
    __be32 ip;
    __be32 ip6[4];
    struct in_addr in;
    struct in6_addr in6;
};

struct inet_bind2_bucket {
    possible_net_t ib_net;
    int l3mdev;
    short unsigned int port;
    short unsigned int addr_type;
    struct in6_addr v6_rcv_saddr;
    struct hlist_node node;
    struct hlist_node bhash_node;
    struct hlist_head owners;
};

struct inet_bind_bucket {
    possible_net_t ib_net;
    int l3mdev;
    short unsigned int port;
    signed char fastreuse;
    signed char fastreuseport;
    kuid_t fastuid;
    struct in6_addr fast_v6_rcv_saddr;
    __be32 fast_rcv_saddr;
    short unsigned int fast_sk_family;
    bool fast_ipv6_only;
    struct hlist_node node;
    struct hlist_head bhash2;
};

struct inet_bind_hashbucket {
    spinlock_t lock;
    struct hlist_head chain;
};

struct inet_cork {
    unsigned int flags;
    __be32 addr;
    struct ip_options *opt;
    unsigned int fragsize;
    int length;
    struct dst_entry *dst;
    u8 tx_flags;
    __u8 ttl;
    __s16 tos;
    u32 priority;
    __u16 gso_size;
    u32 ts_opt_id;
    u64 transmit_time;
    u32 mark;
};

struct inet_cork_full {
    struct inet_cork base;
    struct flowi fl;
};

struct ipv6_pinfo;

struct ip_mc_socklist;

struct inet_sock {
    struct sock sk;
    struct ipv6_pinfo *pinet6;
    long unsigned int inet_flags;
    __be32 inet_saddr;
    __s16 uc_ttl;
    __be16 inet_sport;
    struct ip_options_rcu *inet_opt;
    atomic_t inet_id;
    __u8 tos;
    __u8 min_ttl;
    __u8 mc_ttl;
    __u8 pmtudisc;
    __u8 rcv_tos;
    __u8 convert_csum;
    int uc_index;
    int mc_index;
    __be32 mc_addr;
    u32 local_port_range;
    struct ip_mc_socklist *mc_list;
    struct inet_cork_full cork;
};

struct request_sock_queue {
    spinlock_t rskq_lock;
    u8 rskq_defer_accept;
    u32 synflood_warned;
    atomic_t qlen;
    atomic_t young;
    struct request_sock *rskq_accept_head;
    struct request_sock *rskq_accept_tail;
    struct fastopen_queue fastopenq;
};

struct inet_connection_sock_af_ops;

struct tcp_ulp_ops;

struct inet_connection_sock {
    struct inet_sock icsk_inet;
    struct request_sock_queue icsk_accept_queue;
    struct inet_bind_bucket *icsk_bind_hash;
    struct inet_bind2_bucket *icsk_bind2_hash;
    long unsigned int icsk_timeout;
    struct timer_list icsk_retransmit_timer;
    struct timer_list icsk_delack_timer;
    __u32 icsk_rto;
    __u32 icsk_rto_min;
    __u32 icsk_delack_max;
    __u32 icsk_pmtu_cookie;
    const struct tcp_congestion_ops *icsk_ca_ops;
    const struct inet_connection_sock_af_ops *icsk_af_ops;
    const struct tcp_ulp_ops *icsk_ulp_ops;
    void *icsk_ulp_data;
    void (*icsk_clean_acked)(struct sock *, u32);
    unsigned int (*icsk_sync_mss)(struct sock *, u32);
    __u8 icsk_ca_state: 5;
    __u8 icsk_ca_initialized: 1;
    __u8 icsk_ca_setsockopt: 1;
    __u8 icsk_ca_dst_locked: 1;
    __u8 icsk_retransmits;
    __u8 icsk_pending;
    __u8 icsk_backoff;
    __u8 icsk_syn_retries;
    __u8 icsk_probes_out;
    __u16 icsk_ext_hdr_len;
    struct {
        __u8 pending;
        __u8 quick;
        __u8 pingpong;
        __u8 retry;
        __u32 ato: 8;
        __u32 lrcv_flowlabel: 20;
        __u32 unused: 4;
        long unsigned int timeout;
        __u32 lrcvtime;
        __u16 last_seg_size;
        __u16 rcv_mss;
    } icsk_ack;
    struct {
        int search_high;
        int search_low;
        u32 probe_size: 31;
        u32 enabled: 1;
        u32 probe_timestamp;
    } icsk_mtup;
    u32 icsk_probes_tstamp;
    u32 icsk_user_timeout;
    u64 icsk_ca_priv[13];
};

struct inet_connection_sock_af_ops {
    int (*queue_xmit)(struct sock *, struct sk_buff *, struct flowi *);
    void (*send_check)(struct sock *, struct sk_buff *);
    int (*rebuild_header)(struct sock *);
    void (*sk_rx_dst_set)(struct sock *, const struct sk_buff *);
    int (*conn_request)(struct sock *, struct sk_buff *);
    struct sock * (*syn_recv_sock)(const struct sock *, struct sk_buff *, struct request_sock *, struct dst_entry *, struct request_sock *, bool *);
    u16 net_header_len;
    u16 sockaddr_len;
    int (*setsockopt)(struct sock *, int, int, sockptr_t, unsigned int);
    int (*getsockopt)(struct sock *, int, int, char *, int *);
    void (*addr2sockaddr)(struct sock *, struct sockaddr *);
    void (*mtu_reduced)(struct sock *);
};

struct inet_ehash_bucket {
    struct hlist_nulls_head chain;
};

struct inet_fill_args {
    u32 portid;
    u32 seq;
    int event;
    unsigned int flags;
    int netnsid;
    int ifindex;
};

struct inet_frags {
    unsigned int qsize;
    void (*constructor)(struct inet_frag_queue *, const void *);
    void (*destructor)(struct inet_frag_queue *);
    void (*frag_expire)(struct timer_list *);
    struct kmem_cache *frags_cachep;
    const char *frags_cache_name;
    struct rhashtable_params rhash_params;
    refcount_t refcnt;
    struct completion completion;
};

struct inet_listen_hashbucket;

struct inet_hashinfo {
    struct inet_ehash_bucket *ehash;
    spinlock_t *ehash_locks;
    unsigned int ehash_mask;
    unsigned int ehash_locks_mask;
    struct kmem_cache *bind_bucket_cachep;
    struct inet_bind_hashbucket *bhash;
    struct kmem_cache *bind2_bucket_cachep;
    struct inet_bind_hashbucket *bhash2;
    unsigned int bhash_size;
    unsigned int lhash2_mask;
    struct inet_listen_hashbucket *lhash2;
    bool pernet;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
};

struct inet_listen_hashbucket {
    spinlock_t lock;
    struct hlist_nulls_head nulls_head;
};

struct ipv4_addr_key {
    __be32 addr;
    int vif;
};

struct inetpeer_addr {
    union {
        struct ipv4_addr_key a4;
        struct in6_addr a6;
        u32 key[4];
    };
    __u16 family;
};

struct inet_peer {
    struct rb_node rb_node;
    struct inetpeer_addr daddr;
    u32 metrics[17];
    u32 rate_tokens;
    u32 n_redirects;
    long unsigned int rate_last;
    union {
        struct {
            atomic_t rid;
        };
        struct callback_head rcu;
    };
    __u32 dtime;
    refcount_t refcnt;
};

struct proto_ops;

struct inet_protosw {
    struct list_head list;
    short unsigned int type;
    short unsigned int protocol;
    struct proto *prot;
    const struct proto_ops *ops;
    unsigned char flags;
};

struct request_sock_ops;

struct saved_syn;

struct request_sock {
    struct sock_common __req_common;
    struct request_sock *dl_next;
    u16 mss;
    u8 num_retrans;
    u8 syncookie: 1;
    u8 num_timeout: 7;
    u32 ts_recent;
    struct timer_list rsk_timer;
    const struct request_sock_ops *rsk_ops;
    struct sock *sk;
    struct saved_syn *saved_syn;
    u32 secid;
    u32 peer_secid;
    u32 timeout;
};

struct inet_request_sock {
    struct request_sock req;
    u16 snd_wscale: 4;
    u16 rcv_wscale: 4;
    u16 tstamp_ok: 1;
    u16 sack_ok: 1;
    u16 wscale_ok: 1;
    u16 ecn_ok: 1;
    u16 acked: 1;
    u16 no_srccheck: 1;
    u16 smc_ok: 1;
    u32 ir_mark;
    union {
        struct ip_options_rcu *ireq_opt;
        struct {
            struct ipv6_txoptions *ipv6_opt;
            struct sk_buff *pktopts;
        };
    };
};

struct inet_skb_parm {
    int iif;
    struct ip_options opt;
    u16 flags;
    u16 frag_max_size;
};

struct inet_timewait_death_row {
    refcount_t tw_refcount;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    struct inet_hashinfo *hashinfo;
    int sysctl_max_tw_buckets;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
};

struct inet_timewait_sock {
    struct sock_common __tw_common;
    __u32 tw_mark;
    unsigned char tw_substate;
    unsigned char tw_rcv_wscale;
    __be16 tw_sport;
    unsigned int tw_transparent: 1;
    unsigned int tw_flowlabel: 20;
    unsigned int tw_usec_ts: 1;
    unsigned int tw_pad: 2;
    unsigned int tw_tos: 8;
    u32 tw_txhash;
    u32 tw_priority;
    u32 tw_entry_stamp;
    struct timer_list tw_timer;
    struct inet_bind_bucket *tw_tb;
    struct inet_bind2_bucket *tw_tb2;
};

struct inflate_state {
    inflate_mode mode;
    int last;
    int wrap;
    int havedict;
    int flags;
    unsigned int dmax;
    long unsigned int check;
    long unsigned int total;
    unsigned int wbits;
    unsigned int wsize;
    unsigned int whave;
    unsigned int write;
    unsigned char *window;
    long unsigned int hold;
    unsigned int bits;
    unsigned int length;
    unsigned int offset;
    unsigned int extra;
    const code *lencode;
    const code *distcode;
    unsigned int lenbits;
    unsigned int distbits;
    unsigned int ncode;
    unsigned int nlen;
    unsigned int ndist;
    unsigned int have;
    code *next;
    short unsigned int lens[320];
    short unsigned int work[288];
    code codes[2048];
};

struct inflate_workspace {
    struct inflate_state inflate_state;
    unsigned char working_window[32768];
};

struct mnt_idmap;

struct kstat;

struct offset_ctx;

struct inode_operations {
    struct dentry * (*lookup)(struct inode *, struct dentry *, unsigned int);
    const char * (*get_link)(struct dentry *, struct inode *, struct delayed_call *);
    int (*permission)(struct mnt_idmap *, struct inode *, int);
    struct posix_acl * (*get_inode_acl)(struct inode *, int, bool);
    int (*readlink)(struct dentry *, char *, int);
    int (*create)(struct mnt_idmap *, struct inode *, struct dentry *, umode_t, bool);
    int (*link)(struct dentry *, struct inode *, struct dentry *);
    int (*unlink)(struct inode *, struct dentry *);
    int (*symlink)(struct mnt_idmap *, struct inode *, struct dentry *, const char *);
    int (*mkdir)(struct mnt_idmap *, struct inode *, struct dentry *, umode_t);
    int (*rmdir)(struct inode *, struct dentry *);
    int (*mknod)(struct mnt_idmap *, struct inode *, struct dentry *, umode_t, dev_t);
    int (*rename)(struct mnt_idmap *, struct inode *, struct dentry *, struct inode *, struct dentry *, unsigned int);
    int (*setattr)(struct mnt_idmap *, struct dentry *, struct iattr *);
    int (*getattr)(struct mnt_idmap *, const struct path *, struct kstat *, u32, unsigned int);
    ssize_t (*listxattr)(struct dentry *, char *, size_t);
    int (*fiemap)(struct inode *, struct fiemap_extent_info *, u64, u64);
    int (*update_time)(struct inode *, int);
    int (*atomic_open)(struct inode *, struct dentry *, struct file *, unsigned int, umode_t);
    int (*tmpfile)(struct mnt_idmap *, struct inode *, struct file *, umode_t);
    struct posix_acl * (*get_acl)(struct mnt_idmap *, struct dentry *, int);
    int (*set_acl)(struct mnt_idmap *, struct dentry *, struct posix_acl *, int);
    int (*fileattr_set)(struct mnt_idmap *, struct dentry *, struct fileattr *);
    int (*fileattr_get)(struct dentry *, struct fileattr *);
    struct offset_ctx * (*get_offset_ctx)(struct inode *);
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
};

struct inode_security_struct {
    struct inode *inode;
    struct list_head list;
    u32 task_sid;
    u32 sid;
    u16 sclass;
    unsigned char initialized;
    spinlock_t lock;
};

struct inode_smack {
    struct smack_known *smk_inode;
    struct smack_known *smk_task;
    struct smack_known *smk_mmap;
    int smk_flags;
};

struct inode_switch_wbs_context {
    struct rcu_work work;
    struct bdi_writeback *new_wb;
    struct inode *inodes[0];
};

struct inodes_stat_t {
    long int nr_inodes;
    long int nr_unused;
    long int dummy[5];
};

struct inotify_event {
    __s32 wd;
    __u32 mask;
    __u32 cookie;
    __u32 len;
    char name[0];
};

struct inotify_event_info {
    struct fsnotify_event fse;
    u32 mask;
    int wd;
    u32 sync_cookie;
    int name_len;
    char name[0];
};

struct inotify_inode_mark {
    struct fsnotify_mark fsn_mark;
    int wd;
};

struct input_absinfo {
    __s32 value;
    __s32 minimum;
    __s32 maximum;
    __s32 fuzz;
    __s32 flat;
    __s32 resolution;
};

struct input_id {
    __u16 bustype;
    __u16 vendor;
    __u16 product;
    __u16 version;
};

struct input_dev_poller;

struct input_mt;

struct input_dev {
    const char *name;
    const char *phys;
    const char *uniq;
    struct input_id id;
    long unsigned int propbit[1];
    long unsigned int evbit[1];
    long unsigned int keybit[12];
    long unsigned int relbit[1];
    long unsigned int absbit[1];
    long unsigned int mscbit[1];
    long unsigned int ledbit[1];
    long unsigned int sndbit[1];
    long unsigned int ffbit[2];
    long unsigned int swbit[1];
    unsigned int hint_events_per_packet;
    unsigned int keycodemax;
    unsigned int keycodesize;
    void *keycode;
    int (*setkeycode)(struct input_dev *, const struct input_keymap_entry *, unsigned int *);
    int (*getkeycode)(struct input_dev *, struct input_keymap_entry *);
    struct ff_device *ff;
    struct input_dev_poller *poller;
    unsigned int repeat_key;
    struct timer_list timer;
    int rep[2];
    struct input_mt *mt;
    struct input_absinfo *absinfo;
    long unsigned int key[12];
    long unsigned int led[1];
    long unsigned int snd[1];
    long unsigned int sw[1];
    int (*open)(struct input_dev *);
    void (*close)(struct input_dev *);
    int (*flush)(struct input_dev *, struct file *);
    int (*event)(struct input_dev *, unsigned int, unsigned int, int);
    struct input_handle *grab;
    spinlock_t event_lock;
    struct mutex mutex;
    unsigned int users;
    bool going_away;
    struct device dev;
    struct list_head h_list;
    struct list_head node;
    unsigned int num_vals;
    unsigned int max_vals;
    struct input_value *vals;
    bool devres_managed;
    ktime_t timestamp[3];
    bool inhibited;
};

struct input_dev_poller {
    void (*poll)(struct input_dev *);
    unsigned int poll_interval;
    unsigned int poll_interval_max;
    unsigned int poll_interval_min;
    struct input_dev *input;
    struct delayed_work work;
};

struct input_device_id {
    kernel_ulong_t flags;
    __u16 bustype;
    __u16 vendor;
    __u16 product;
    __u16 version;
    kernel_ulong_t evbit[1];
    kernel_ulong_t keybit[12];
    kernel_ulong_t relbit[1];
    kernel_ulong_t absbit[1];
    kernel_ulong_t mscbit[1];
    kernel_ulong_t ledbit[1];
    kernel_ulong_t sndbit[1];
    kernel_ulong_t ffbit[2];
    kernel_ulong_t swbit[1];
    kernel_ulong_t propbit[1];
    kernel_ulong_t driver_info;
};

struct input_devres {
    struct input_dev *input;
};

struct input_event_compat {
    compat_ulong_t sec;
    compat_ulong_t usec;
    __u16 type;
    __u16 code;
    __s32 value;
};

struct input_handler {
    void *private;
    void (*event)(struct input_handle *, unsigned int, unsigned int, int);
    unsigned int (*events)(struct input_handle *, struct input_value *, unsigned int);
    bool (*filter)(struct input_handle *, unsigned int, unsigned int, int);
    bool (*match)(struct input_handler *, struct input_dev *);
    int (*connect)(struct input_handler *, struct input_dev *, const struct input_device_id *);
    void (*disconnect)(struct input_handle *);
    void (*start)(struct input_handle *);
    bool passive_observer;
    bool legacy_minors;
    int minor;
    const char *name;
    const struct input_device_id *id_table;
    struct list_head h_list;
    struct list_head node;
};

struct input_mask {
    __u32 type;
    __u32 codes_size;
    __u64 codes_ptr;
};

struct input_mt_slot {
    int abs[14];
    unsigned int frame;
    unsigned int key;
};

struct input_mt {
    int trkid;
    int num_slots;
    int slot;
    unsigned int flags;
    unsigned int frame;
    int *red;
    struct input_mt_slot slots[0];
};

struct input_mt_pos {
    s16 x;
    s16 y;
};

struct input_seq_state {
    short unsigned int pos;
    bool mutex_acquired;
    int input_devices_state;
};

struct input_value {
    __u16 type;
    __u16 code;
    __s32 value;
};

struct insn_emulation {
    const char *name;
    enum legacy_insn_status status;
    bool (*try_emulate)(struct pt_regs *, u32);
    int (*set_hw_mode)(bool);
    int current_mode;
    int min;
    int max;
    struct ctl_table sysctl;
};

struct instance_attribute {
    struct attribute attr;
    ssize_t (*show)(struct edac_device_instance *, char *);
    ssize_t (*store)(struct edac_device_instance *, const char *, size_t);
};

struct instance_attribute___2 {
    struct attribute attr;
    ssize_t (*show)(struct edac_pci_ctl_info *, char *);
    ssize_t (*store)(struct edac_pci_ctl_info *, const char *, size_t);
};

struct internal_container {
    struct klist_node node;
    struct attribute_container *cont;
    struct device classdev;
};

struct internal_state {
    int dummy;
};

struct interval {
    uint32_t first;
    uint32_t last;
};

struct interval_tree_node {
    struct rb_node rb;
    long unsigned int start;
    long unsigned int last;
    long unsigned int __subtree_last;
};

struct interval_tree_span_iter {
    struct interval_tree_node *nodes[2];
    long unsigned int first_index;
    long unsigned int last_index;
    union {
        long unsigned int start_hole;
        long unsigned int start_used;
    };
    union {
        long unsigned int last_hole;
        long unsigned int last_used;
    };
    int is_hole;
};

struct invalid_value_data {
    struct source_location location;
    struct type_descriptor *type;
};

struct io_accept {
    struct file *file;
    struct sockaddr *addr;
    int *addr_len;
    int flags;
    int iou_flags;
    u32 file_slot;
    long unsigned int nofile;
};

struct io_alloc_cache {
    void **entries;
    unsigned int nr_cached;
    unsigned int max_cached;
    unsigned int elem_size;
    unsigned int init_clear;
};

struct ubuf_info;

struct msghdr {
    void *msg_name;
    int msg_namelen;
    int msg_inq;
    struct iov_iter msg_iter;
    union {
        void *msg_control;
        void *msg_control_user;
    };
    bool msg_control_is_user: 1;
    bool msg_get_inq: 1;
    unsigned int msg_flags;
    __kernel_size_t msg_controllen;
    struct kiocb *msg_iocb;
    struct ubuf_info *msg_ubuf;
    int (*sg_from_iter)(struct sk_buff *, struct iov_iter *, size_t);
};

struct io_async_msghdr {
    struct iovec *free_iov;
    int free_iov_nr;
    union {
        struct {
            int namelen;
            struct iovec fast_iov;
            __kernel_size_t controllen;
            __kernel_size_t payloadlen;
            struct sockaddr *uaddr;
            struct msghdr msg;
            struct __kernel_sockaddr_storage addr;
        };
        struct {
            int namelen;
            struct iovec fast_iov;
            __kernel_size_t controllen;
            __kernel_size_t payloadlen;
            struct sockaddr *uaddr;
            struct msghdr msg;
            struct __kernel_sockaddr_storage addr;
        } clear;
    };
};

struct iov_iter_state {
    size_t iov_offset;
    size_t count;
    long unsigned int nr_segs;
};

struct wait_page_queue {
    struct folio *folio;
    int bit_nr;
    wait_queue_entry_t wait;
};

struct uio_meta {
    uio_meta_flags_t flags;
    u16 app_tag;
    u64 seed;
    struct iov_iter iter;
};

struct io_meta_state {
    u32 seed;
    struct iov_iter_state iter_meta;
};

struct io_async_rw {
    size_t bytes_done;
    struct iovec *free_iovec;
    union {
        struct {
            struct iov_iter iter;
            struct iov_iter_state iter_state;
            struct iovec fast_iov;
            int free_iov_nr;
            union {
                struct wait_page_queue wpq;
                struct {
                    struct uio_meta meta;
                    struct io_meta_state meta_state;
                };
            };
        };
        struct {
            struct iov_iter iter;
            struct iov_iter_state iter_state;
            struct iovec fast_iov;
            int free_iov_nr;
            union {
                struct wait_page_queue wpq;
                struct {
                    struct uio_meta meta;
                    struct io_meta_state meta_state;
                };
            };
        } clear;
    };
};

struct io_bind {
    struct file *file;
    int addr_len;
};

struct io_buffer {
    struct list_head list;
    __u64 addr;
    __u32 len;
    __u16 bid;
    __u16 bgid;
};

struct io_mapped_region {
    struct page **pages;
    void *ptr;
    unsigned int nr_pages;
    unsigned int flags;
};

struct io_uring_buf_ring;

struct io_buffer_list {
    union {
        struct list_head buf_list;
        struct io_uring_buf_ring *buf_ring;
    };
    __u16 bgid;
    __u16 buf_nr_pages;
    __u16 nr_entries;
    __u16 head;
    __u16 mask;
    __u16 flags;
    struct io_mapped_region region;
};

struct io_cancel {
    struct file *file;
    u64 addr;
    u32 flags;
    s32 fd;
    u8 opcode;
};

struct io_ring_ctx;

struct io_cancel_data {
    struct io_ring_ctx *ctx;
    union {
        u64 data;
        struct file *file;
    };
    u8 opcode;
    u32 flags;
    int seq;
};

struct io_wq_work;

typedef bool work_cancel_fn(struct io_wq_work *, void *);

struct io_cb_cancel_data {
    work_cancel_fn *fn;
    void *data;
    int nr_running;
    int nr_pending;
    bool cancel_all;
};

struct io_close {
    struct file *file;
    int fd;
    u32 file_slot;
};

struct io_cmd_data {
    struct file *file;
    __u8 data[56];
};

struct io_kiocb;

struct io_cold_def {
    const char *name;
    void (*cleanup)(struct io_kiocb *);
    void (*fail)(struct io_kiocb *);
};

struct io_comp_batch {
    struct rq_list req_list;
    bool need_ts;
    void (*complete)(struct io_comp_batch *);
};

struct io_connect {
    struct file *file;
    struct sockaddr *addr;
    int addr_len;
    bool in_progress;
    bool seen_econnaborted;
};

struct io_context {
    atomic_long_t refcount;
    atomic_t active_ref;
    short unsigned int ioprio;
    spinlock_t lock;
    struct xarray icq_tree;
    struct io_cq *icq_hint;
    struct hlist_head icq_list;
    struct work_struct release_work;
};

struct io_cq {
    struct request_queue *q;
    struct io_context *ioc;
    union {
        struct list_head q_node;
        struct kmem_cache *__rcu_icq_cache;
    };
    union {
        struct hlist_node ioc_node;
        struct callback_head __rcu_head;
    };
    unsigned int flags;
};

struct io_cqe {
    __u64 user_data;
    __s32 res;
    union {
        __u32 flags;
        int fd;
    };
};

struct io_cqring_offsets {
    __u32 head;
    __u32 tail;
    __u32 ring_mask;
    __u32 ring_entries;
    __u32 overflow;
    __u32 cqes;
    __u32 flags;
    __u32 resv1;
    __u64 user_addr;
};

struct io_defer_entry {
    struct list_head list;
    struct io_kiocb *req;
    u32 seq;
};

struct io_epoll {
    struct file *file;
    int epfd;
    int op;
    int fd;
    struct epoll_event event;
};

struct io_ev_fd {
    struct eventfd_ctx *cq_ev_fd;
    unsigned int eventfd_async;
    unsigned int last_cq_tail;
    refcount_t refs;
    atomic_t ops;
    struct callback_head rcu;
};

struct io_fadvise {
    struct file *file;
    u64 offset;
    u64 len;
    u32 advice;
};

struct io_rsrc_node;

struct io_rsrc_data {
    unsigned int nr;
    struct io_rsrc_node **nodes;
};

struct io_file_table {
    struct io_rsrc_data data;
    long unsigned int *bitmap;
    unsigned int alloc_hint;
};

struct io_fixed_install {
    struct file *file;
    unsigned int o_flags;
};

struct io_ftrunc {
    struct file *file;
    loff_t len;
};

struct io_futex {
    struct file *file;
    union {
        u32 *uaddr;
        struct futex_waitv *uwaitv;
    };
    long unsigned int futex_val;
    long unsigned int futex_mask;
    long unsigned int futexv_owned;
    u32 futex_flags;
    unsigned int futex_nr;
    bool futexv_unqueued;
};

struct io_futex_data {
    struct futex_q q;
    struct io_kiocb *req;
};

struct io_hash_bucket {
    struct hlist_head list;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
};

struct io_hash_table {
    struct io_hash_bucket *hbs;
    unsigned int hash_bits;
};

struct io_imu_folio_data {
    unsigned int nr_pages_head;
    unsigned int nr_pages_mid;
    unsigned int folio_shift;
    unsigned int nr_folios;
};

struct io_uring_sqe;

struct io_issue_def {
    unsigned int needs_file: 1;
    unsigned int plug: 1;
    unsigned int hash_reg_file: 1;
    unsigned int unbound_nonreg_file: 1;
    unsigned int pollin: 1;
    unsigned int pollout: 1;
    unsigned int poll_exclusive: 1;
    unsigned int buffer_select: 1;
    unsigned int audit_skip: 1;
    unsigned int ioprio: 1;
    unsigned int iopoll: 1;
    unsigned int iopoll_queue: 1;
    unsigned int vectored: 1;
    short unsigned int async_size;
    int (*issue)(struct io_kiocb *, unsigned int);
    int (*prep)(struct io_kiocb *, const struct io_uring_sqe *);
};

struct io_wq_work_node {
    struct io_wq_work_node *next;
};

struct io_tw_state;

typedef void (*io_req_tw_func_t)(struct io_kiocb *, struct io_tw_state *);

struct io_task_work {
    struct llist_node node;
    io_req_tw_func_t func;
};

struct io_wq_work {
    struct io_wq_work_node list;
    atomic_t flags;
    int cancel_seq;
};

struct io_uring_task;

struct io_kiocb {
    union {
        struct file *file;
        struct io_cmd_data cmd;
    };
    u8 opcode;
    u8 iopoll_completed;
    u16 buf_index;
    unsigned int nr_tw;
    io_req_flags_t flags;
    struct io_cqe cqe;
    struct io_ring_ctx *ctx;
    struct io_uring_task *tctx;
    union {
        struct io_buffer *kbuf;
        struct io_buffer_list *buf_list;
        struct io_rsrc_node *buf_node;
    };
    union {
        struct io_wq_work_node comp_list;
        __poll_t apoll_events;
    };
    struct io_rsrc_node *file_node;
    atomic_t refs;
    bool cancel_seq_set;
    struct io_task_work io_task_work;
    union {
        struct hlist_node hash_node;
        u64 iopoll_start;
    };
    struct async_poll *apoll;
    void *async_data;
    atomic_t poll_refs;
    struct io_kiocb *link;
    const struct cred *creds;
    struct io_wq_work work;
    struct {
        u64 extra1;
        u64 extra2;
    } big_cqe;
};

struct io_link {
    struct file *file;
    int old_dfd;
    int new_dfd;
    struct filename *oldpath;
    struct filename *newpath;
    int flags;
};

struct io_listen {
    struct file *file;
    int backlog;
};

struct io_madvise {
    struct file *file;
    u64 addr;
    u64 len;
    u32 advice;
};

struct io_mapped_ubuf {
    u64 ubuf;
    unsigned int len;
    unsigned int nr_bvecs;
    unsigned int folio_shift;
    refcount_t refs;
    long unsigned int acct_pages;
    struct bio_vec bvec[0];
};

struct io_mkdir {
    struct file *file;
    int dfd;
    umode_t mode;
    struct filename *filename;
};

struct io_msg {
    struct file *file;
    struct file *src_file;
    struct callback_head tw;
    u64 user_data;
    u32 len;
    u32 cmd;
    u32 src_fd;
    union {
        u32 dst_fd;
        u32 cqe_flags;
    };
    u32 flags;
};

struct io_napi_entry {
    unsigned int napi_id;
    struct list_head list;
    long unsigned int timeout;
    struct hlist_node node;
    struct callback_head rcu;
};

struct io_nop {
    struct file *file;
    int result;
    int fd;
    int buffer;
    unsigned int flags;
};

struct ubuf_info_ops;

struct ubuf_info {
    const struct ubuf_info_ops *ops;
    refcount_t refcnt;
    u8 flags;
};

struct io_notif_data {
    struct file *file;
    struct ubuf_info uarg;
    struct io_notif_data *next;
    struct io_notif_data *head;
    unsigned int account_pages;
    bool zc_report;
    bool zc_used;
    bool zc_copied;
};

struct io_open {
    struct file *file;
    int dfd;
    u32 file_slot;
    struct filename *filename;
    struct open_how how;
    long unsigned int nofile;
};

struct io_uring_cqe {
    __u64 user_data;
    __s32 res;
    __u32 flags;
    __u64 big_cqe[0];
};

struct io_overflow_cqe {
    struct list_head list;
    struct io_uring_cqe cqe;
};

struct io_pagetable {
    struct rw_semaphore domains_rwsem;
    struct xarray domains;
    struct xarray access_list;
    unsigned int next_domain_id;
    struct rw_semaphore iova_rwsem;
    struct rb_root_cached area_itree;
    struct rb_root_cached allowed_itree;
    struct rb_root_cached reserved_itree;
    u8 disable_large_pages;
    long unsigned int iova_alignment;
};

struct io_pgtable_init_fns {
    struct io_pgtable * (*alloc)(struct io_pgtable_cfg *, void *);
    void (*free)(struct io_pgtable *);
    u32 caps;
};

struct io_pgtable_walk_data {
    struct io_pgtable *iop;
    void *data;
    int (*visit)(struct io_pgtable_walk_data *, int, arm_lpae_iopte *, size_t);
    long unsigned int flags;
    u64 addr;
    const u64 end;
};

struct io_poll_table {
    struct poll_table_struct pt;
    struct io_kiocb *req;
    int nr_entries;
    int error;
    bool owning;
    __poll_t result_mask;
};

struct io_poll_update {
    struct file *file;
    u64 old_user_data;
    u64 new_user_data;
    __poll_t events;
    bool update_events;
    bool update_user_data;
};

struct io_provide_buf {
    struct file *file;
    __u64 addr;
    __u32 len;
    __u32 bgid;
    __u32 nbufs;
    __u16 bid;
};

struct io_uring_recvmsg_out {
    __u32 namelen;
    __u32 controllen;
    __u32 payloadlen;
    __u32 flags;
};

struct io_recvmsg_multishot_hdr {
    struct io_uring_recvmsg_out msg;
    struct __kernel_sockaddr_storage addr;
};

struct io_rename {
    struct file *file;
    int old_dfd;
    int new_dfd;
    struct filename *oldpath;
    struct filename *newpath;
    int flags;
};

struct io_restriction {
    long unsigned int register_op[1];
    long unsigned int sqe_op[1];
    u8 sqe_flags_allowed;
    u8 sqe_flags_required;
    bool registered;
};

struct io_wq_work_list {
    struct io_wq_work_node *first;
    struct io_wq_work_node *last;
};

struct io_submit_link {
    struct io_kiocb *head;
    struct io_kiocb *last;
};

struct io_submit_state {
    struct io_wq_work_node free_list;
    struct io_wq_work_list compl_reqs;
    struct io_submit_link link;
    bool plug_started;
    bool need_plug;
    bool cq_flush;
    short unsigned int submit_nr;
    struct blk_plug plug;
};

struct io_rings;

struct io_sq_data;

struct io_wq_hash;

struct io_ring_ctx {
    struct {
        unsigned int flags;
        unsigned int drain_next: 1;
        unsigned int restricted: 1;
        unsigned int off_timeout_used: 1;
        unsigned int drain_active: 1;
        unsigned int has_evfd: 1;
        unsigned int task_complete: 1;
        unsigned int lockless_cq: 1;
        unsigned int syscall_iopoll: 1;
        unsigned int poll_activated: 1;
        unsigned int drain_disabled: 1;
        unsigned int compat: 1;
        unsigned int iowq_limits_set: 1;
        struct task_struct *submitter_task;
        struct io_rings *rings;
        struct percpu_ref refs;
        clockid_t clockid;
        enum tk_offsets clock_offset;
        enum task_work_notify_mode notify_method;
        unsigned int sq_thread_idle;
        long: 64;
    };
    struct {
        struct mutex uring_lock;
        u32 *sq_array;
        struct io_uring_sqe *sq_sqes;
        unsigned int cached_sq_head;
        unsigned int sq_entries;
        atomic_t cancel_seq;
        bool poll_multi_queue;
        struct io_wq_work_list iopoll_list;
        struct io_file_table file_table;
        struct io_rsrc_data buf_table;
        struct io_submit_state submit_state;
        struct xarray io_bl_xa;
        struct io_hash_table cancel_table;
        struct io_alloc_cache apoll_cache;
        struct io_alloc_cache netmsg_cache;
        struct io_alloc_cache rw_cache;
        struct io_alloc_cache uring_cache;
        struct hlist_head cancelable_uring_cmd;
        u64 hybrid_poll_time;
    };
    struct {
        struct io_uring_cqe *cqe_cached;
        struct io_uring_cqe *cqe_sentinel;
        unsigned int cached_cq_tail;
        unsigned int cq_entries;
        struct io_ev_fd *io_ev_fd;
        unsigned int cq_extra;
        void *cq_wait_arg;
        size_t cq_wait_size;
        long: 64;
    };
    struct {
        struct llist_head work_llist;
        struct llist_head retry_llist;
        long unsigned int check_cq;
        atomic_t cq_wait_nr;
        atomic_t cq_timeouts;
        struct wait_queue_head cq_wait;
        long: 64;
    };
    struct {
        raw_spinlock_t timeout_lock;
        struct list_head timeout_list;
        struct list_head ltimeout_list;
        unsigned int cq_last_tm_flush;
        long: 64;
        long: 64;
    };
    spinlock_t completion_lock;
    struct list_head io_buffers_comp;
    struct list_head cq_overflow_list;
    struct hlist_head waitid_list;
    struct hlist_head futex_list;
    struct io_alloc_cache futex_cache;
    const struct cred *sq_creds;
    struct io_sq_data *sq_data;
    struct wait_queue_head sqo_sq_wait;
    struct list_head sqd_list;
    unsigned int file_alloc_start;
    unsigned int file_alloc_end;
    struct list_head io_buffers_cache;
    struct wait_queue_head poll_wq;
    struct io_restriction restrictions;
    u32 pers_next;
    struct xarray personalities;
    struct io_wq_hash *hash_map;
    struct user_struct *user;
    struct mm_struct *mm_account;
    struct llist_head fallback_llist;
    struct delayed_work fallback_work;
    struct work_struct exit_work;
    struct list_head tctx_list;
    struct completion ref_comp;
    u32 iowq_limits[2];
    struct callback_head poll_wq_task_work;
    struct list_head defer_list;
    struct io_alloc_cache msg_cache;
    spinlock_t msg_lock;
    struct list_head napi_list;
    spinlock_t napi_lock;
    ktime_t napi_busy_poll_dt;
    bool napi_prefer_busy_poll;
    u8 napi_track_mode;
    struct hlist_head napi_ht[16];
    unsigned int evfd_last_cq_tail;
    struct mutex mmap_lock;
    struct io_mapped_region sq_region;
    struct io_mapped_region ring_region;
    struct io_mapped_region param_region;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
};

struct io_ring_ctx_rings {
    struct io_rings *rings;
    struct io_uring_sqe *sq_sqes;
    struct io_mapped_region sq_region;
    struct io_mapped_region ring_region;
};

struct io_uring {
    u32 head;
    u32 tail;
};

struct io_rings {
    struct io_uring sq;
    struct io_uring cq;
    u32 sq_ring_mask;
    u32 cq_ring_mask;
    u32 sq_ring_entries;
    u32 cq_ring_entries;
    u32 sq_dropped;
    atomic_t sq_flags;
    u32 cq_flags;
    u32 cq_overflow;
    long: 64;
    long: 64;
    struct io_uring_cqe cqes[0];
};

struct io_rsrc_node {
    unsigned char type;
    int refs;
    u64 tag;
    union {
        long unsigned int file_ptr;
        struct io_mapped_ubuf *buf;
    };
};

struct io_rsrc_update {
    struct file *file;
    u64 arg;
    u32 nr_args;
    u32 offset;
};

struct io_rw {
    struct kiocb kiocb;
    u64 addr;
    u32 len;
    rwf_t flags;
};

struct io_shutdown {
    struct file *file;
    int how;
};

struct io_socket {
    struct file *file;
    int domain;
    int type;
    int protocol;
    int flags;
    u32 file_slot;
    long unsigned int nofile;
};

struct io_splice {
    struct file *file_out;
    loff_t off_out;
    loff_t off_in;
    u64 len;
    int splice_fd_in;
    unsigned int flags;
    struct io_rsrc_node *rsrc_node;
};

struct io_sq_data {
    refcount_t refs;
    atomic_t park_pending;
    struct mutex lock;
    struct list_head ctx_list;
    struct task_struct *thread;
    struct wait_queue_head wait;
    unsigned int sq_thread_idle;
    int sq_cpu;
    pid_t task_pid;
    pid_t task_tgid;
    u64 work_time;
    long unsigned int state;
    struct completion exited;
};

struct io_sqring_offsets {
    __u32 head;
    __u32 tail;
    __u32 ring_mask;
    __u32 ring_entries;
    __u32 flags;
    __u32 dropped;
    __u32 array;
    __u32 resv1;
    __u64 user_addr;
};

struct user_msghdr;

struct io_sr_msg {
    struct file *file;
    union {
        struct compat_msghdr *umsg_compat;
        struct user_msghdr *umsg;
        void *buf;
    };
    int len;
    unsigned int done_io;
    unsigned int msg_flags;
    unsigned int nr_multishot_loops;
    u16 flags;
    u16 buf_group;
    u16 buf_index;
    bool retry;
    bool imported;
    void *msg_control;
    struct io_kiocb *notif;
};

struct statx;

struct io_statx {
    struct file *file;
    int dfd;
    unsigned int mask;
    unsigned int flags;
    struct filename *filename;
    struct statx *buffer;
};

struct io_sync {
    struct file *file;
    loff_t len;
    loff_t off;
    int flags;
    int mode;
};

struct io_task_cancel {
    struct io_uring_task *tctx;
    bool all;
};

struct io_tctx_exit {
    struct callback_head task_work;
    struct completion completion;
    struct io_ring_ctx *ctx;
};

struct io_tctx_node {
    struct list_head ctx_node;
    struct task_struct *task;
    struct io_ring_ctx *ctx;
};

struct io_timeout {
    struct file *file;
    u32 off;
    u32 target_seq;
    u32 repeats;
    struct list_head list;
    struct io_kiocb *head;
    struct io_kiocb *prev;
};

struct io_timeout_data {
    struct io_kiocb *req;
    struct hrtimer timer;
    struct timespec64 ts;
    enum hrtimer_mode mode;
    u32 flags;
};

struct io_timeout_rem {
    struct file *file;
    u64 addr;
    struct timespec64 ts;
    u32 flags;
    bool ltimeout;
};

struct io_tlb_area {
    long unsigned int used;
    unsigned int index;
    spinlock_t lock;
};

struct io_tlb_slot;

struct io_tlb_pool {
    phys_addr_t start;
    phys_addr_t end;
    void *vaddr;
    long unsigned int nslabs;
    bool late_alloc;
    unsigned int nareas;
    unsigned int area_nslabs;
    struct io_tlb_area *areas;
    struct io_tlb_slot *slots;
};

struct io_tlb_mem {
    struct io_tlb_pool defpool;
    long unsigned int nslabs;
    struct dentry *debugfs;
    bool force_bounce;
    bool for_alloc;
    atomic_long_t total_used;
    atomic_long_t used_hiwater;
    atomic_long_t transient_nslabs;
};

struct io_tlb_slot {
    phys_addr_t orig_addr;
    size_t alloc_size;
    short unsigned int list;
    short unsigned int pad_slots;
};

struct io_tw_state {};

struct io_unlink {
    struct file *file;
    int dfd;
    int flags;
    struct filename *filename;
};

struct io_uring_attr_pi {
    __u16 flags;
    __u16 app_tag;
    __u32 len;
    __u64 addr;
    __u64 seed;
    __u64 rsvd;
};

struct io_uring_buf {
    __u64 addr;
    __u32 len;
    __u16 bid;
    __u16 resv;
};

struct io_uring_buf_reg {
    __u64 ring_addr;
    __u32 ring_entries;
    __u16 bgid;
    __u16 flags;
    __u64 resv[3];
};

struct io_uring_buf_ring {
    union {
        struct {
            __u64 resv1;
            __u32 resv2;
            __u16 resv3;
            __u16 tail;
        };
        struct {
            struct {} __empty_bufs;
            struct io_uring_buf bufs[0];
        };
    };
};

struct io_uring_buf_status {
    __u32 buf_group;
    __u32 head;
    __u32 resv[8];
};

struct io_uring_clock_register {
    __u32 clockid;
    __u32 __resv[3];
};

struct io_uring_clone_buffers {
    __u32 src_fd;
    __u32 flags;
    __u32 src_off;
    __u32 dst_off;
    __u32 nr;
    __u32 pad[3];
};

struct io_uring_cmd {
    struct file *file;
    const struct io_uring_sqe *sqe;
    void (*task_work_cb)(struct io_uring_cmd *, unsigned int);
    u32 cmd_op;
    u32 flags;
    u8 pdu[32];
};

struct io_uring_sqe {
    __u8 opcode;
    __u8 flags;
    __u16 ioprio;
    __s32 fd;
    union {
        __u64 off;
        __u64 addr2;
        struct {
            __u32 cmd_op;
            __u32 __pad1;
        };
    };
    union {
        __u64 addr;
        __u64 splice_off_in;
        struct {
            __u32 level;
            __u32 optname;
        };
    };
    __u32 len;
    union {
        __kernel_rwf_t rw_flags;
        __u32 fsync_flags;
        __u16 poll_events;
        __u32 poll32_events;
        __u32 sync_range_flags;
        __u32 msg_flags;
        __u32 timeout_flags;
        __u32 accept_flags;
        __u32 cancel_flags;
        __u32 open_flags;
        __u32 statx_flags;
        __u32 fadvise_advice;
        __u32 splice_flags;
        __u32 rename_flags;
        __u32 unlink_flags;
        __u32 hardlink_flags;
        __u32 xattr_flags;
        __u32 msg_ring_flags;
        __u32 uring_cmd_flags;
        __u32 waitid_flags;
        __u32 futex_flags;
        __u32 install_fd_flags;
        __u32 nop_flags;
    };
    __u64 user_data;
    union {
        __u16 buf_index;
        __u16 buf_group;
    };
    __u16 personality;
    union {
        __s32 splice_fd_in;
        __u32 file_index;
        __u32 optlen;
        struct {
            __u16 addr_len;
            __u16 __pad3[1];
        };
    };
    union {
        struct {
            __u64 addr3;
            __u64 __pad2[1];
        };
        struct {
            __u64 attr_ptr;
            __u64 attr_type_mask;
        };
        __u64 optval;
        __u8 cmd[0];
    };
};

struct io_uring_cmd_data {
    void *op_data;
    struct io_uring_sqe sqes[2];
};

struct io_uring_file_index_range {
    __u32 off;
    __u32 len;
    __u64 resv;
};

struct io_uring_getevents_arg {
    __u64 sigmask;
    __u32 sigmask_sz;
    __u32 min_wait_usec;
    __u64 ts;
};

struct io_uring_mem_region_reg {
    __u64 region_uptr;
    __u64 flags;
    __u64 __resv[2];
};

struct io_uring_napi {
    __u32 busy_poll_to;
    __u8 prefer_busy_poll;
    __u8 opcode;
    __u8 pad[2];
    __u32 op_param;
    __u32 resv;
};

struct io_uring_params {
    __u32 sq_entries;
    __u32 cq_entries;
    __u32 flags;
    __u32 sq_thread_cpu;
    __u32 sq_thread_idle;
    __u32 features;
    __u32 wq_fd;
    __u32 resv[3];
    struct io_sqring_offsets sq_off;
    struct io_cqring_offsets cq_off;
};

struct io_uring_probe_op {
    __u8 op;
    __u8 resv;
    __u16 flags;
    __u32 resv2;
};

struct io_uring_probe {
    __u8 last_op;
    __u8 ops_len;
    __u16 resv;
    __u32 resv2[3];
    struct io_uring_probe_op ops[0];
};

struct io_uring_reg_wait {
    struct __kernel_timespec ts;
    __u32 min_wait_usec;
    __u32 flags;
    __u64 sigmask;
    __u32 sigmask_sz;
    __u32 pad[3];
    __u64 pad2[2];
};

struct io_uring_region_desc {
    __u64 user_addr;
    __u64 size;
    __u32 flags;
    __u32 id;
    __u64 mmap_offset;
    __u64 __resv[4];
};

struct io_uring_restriction {
    __u16 opcode;
    union {
        __u8 register_op;
        __u8 sqe_op;
        __u8 sqe_flags;
    };
    __u8 resv;
    __u32 resv2[3];
};

struct io_uring_rsrc_register {
    __u32 nr;
    __u32 flags;
    __u64 resv2;
    __u64 data;
    __u64 tags;
};

struct io_uring_rsrc_update {
    __u32 offset;
    __u32 resv;
    __u64 data;
};

struct io_uring_rsrc_update2 {
    __u32 offset;
    __u32 resv;
    __u64 data;
    __u64 tags;
    __u32 nr;
    __u32 resv2;
};

struct io_uring_sync_cancel_reg {
    __u64 addr;
    __s32 fd;
    __u32 flags;
    struct __kernel_timespec timeout;
    __u8 opcode;
    __u8 pad[7];
    __u64 pad2[3];
};

struct io_wq;

struct io_uring_task {
    int cached_refs;
    const struct io_ring_ctx *last;
    struct task_struct *task;
    struct io_wq *io_wq;
    struct file *registered_rings[16];
    struct xarray xa;
    struct wait_queue_head wait;
    atomic_t in_cancel;
    atomic_t inflight_tracked;
    struct percpu_counter inflight;
    long: 64;
    long: 64;
    long: 64;
    struct {
        struct llist_head task_list;
        struct callback_head task_work;
        long: 64;
        long: 64;
        long: 64;
        long: 64;
        long: 64;
    };
};

struct io_wait_queue {
    struct wait_queue_entry wq;
    struct io_ring_ctx *ctx;
    unsigned int cq_tail;
    unsigned int cq_min_tail;
    unsigned int nr_timeouts;
    int hit_timeout;
    ktime_t min_timeout;
    ktime_t timeout;
    struct hrtimer t;
    ktime_t napi_busy_poll_dt;
    bool napi_prefer_busy_poll;
};

struct waitid_info {
    pid_t pid;
    uid_t uid;
    int status;
    int cause;
};

struct io_waitid {
    struct file *file;
    int which;
    pid_t upid;
    int options;
    atomic_t refs;
    struct wait_queue_head *head;
    struct siginfo *infop;
    struct waitid_info info;
};

struct rusage;

struct wait_opts {
    enum pid_type wo_type;
    int wo_flags;
    struct pid *wo_pid;
    struct waitid_info *wo_info;
    int wo_stat;
    struct rusage *wo_rusage;
    wait_queue_entry_t child_wait;
    int notask_error;
};

struct io_waitid_async {
    struct io_kiocb *req;
    struct wait_opts wo;
};

struct io_worker {
    refcount_t ref;
    int create_index;
    long unsigned int flags;
    struct hlist_nulls_node nulls_node;
    struct list_head all_list;
    struct task_struct *task;
    struct io_wq *wq;
    struct io_wq_work *cur_work;
    raw_spinlock_t lock;
    struct completion ref_done;
    long unsigned int create_state;
    struct callback_head create_work;
    int init_retries;
    union {
        struct callback_head rcu;
        struct delayed_work work;
    };
};

typedef struct io_wq_work *free_work_fn(struct io_wq_work *);

typedef void io_wq_work_fn(struct io_wq_work *);

struct io_wq_acct {
    unsigned int nr_workers;
    unsigned int max_workers;
    int index;
    atomic_t nr_running;
    raw_spinlock_t lock;
    struct io_wq_work_list work_list;
    long unsigned int flags;
};

struct io_wq {
    long unsigned int state;
    free_work_fn *free_work;
    io_wq_work_fn *do_work;
    struct io_wq_hash *hash;
    atomic_t worker_refs;
    struct completion worker_done;
    struct hlist_node cpuhp_node;
    struct task_struct *task;
    struct io_wq_acct acct[2];
    raw_spinlock_t lock;
    struct hlist_nulls_head free_list;
    struct list_head all_list;
    struct wait_queue_entry wait;
    struct io_wq_work *hash_tail[64];
    cpumask_var_t cpu_mask;
};

struct io_wq_data {
    struct io_wq_hash *hash;
    struct task_struct *task;
    io_wq_work_fn *do_work;
    free_work_fn *free_work;
};

struct io_wq_hash {
    refcount_t refs;
    long unsigned int map;
    struct wait_queue_head wait;
};

struct xattr_name;

struct kernel_xattr_ctx {
    union {
        const void *cvalue;
        void *value;
    };
    void *kvalue;
    size_t size;
    struct xattr_name *kname;
    unsigned int flags;
};

struct io_xattr {
    struct file *file;
    struct kernel_xattr_ctx ctx;
    struct filename *filename;
};

struct ioam6_hdr {
    __u8 opt_type;
    __u8 opt_len;
    char: 8;
    __u8 type;
};

struct ioam6_lwt_freq {
    u32 k;
    u32 n;
};

struct ipv6_opt_hdr {
    __u8 nexthdr;
    __u8 hdrlen;
};

struct ioam6_trace_hdr {
    __be16 namespace_id;
    char: 2;
    __u8 overflow: 1;
    __u8 nodelen: 5;
    __u8 remlen: 7;
    union {
        __be32 type_be32;
        struct {
            __u32 bit7: 1;
            __u32 bit6: 1;
            __u32 bit5: 1;
            __u32 bit4: 1;
            __u32 bit3: 1;
            __u32 bit2: 1;
            __u32 bit1: 1;
            __u32 bit0: 1;
            __u32 bit15: 1;
            __u32 bit14: 1;
            __u32 bit13: 1;
            __u32 bit12: 1;
            __u32 bit11: 1;
            __u32 bit10: 1;
            __u32 bit9: 1;
            __u32 bit8: 1;
            __u32 bit23: 1;
            __u32 bit22: 1;
            __u32 bit21: 1;
            __u32 bit20: 1;
            __u32 bit19: 1;
            __u32 bit18: 1;
            __u32 bit17: 1;
            __u32 bit16: 1;
        } type;
    };
    __u8 data[0];
};

struct ioam6_lwt_encap {
    struct ipv6_opt_hdr eh;
    u8 pad[2];
    struct ioam6_hdr ioamh;
    struct ioam6_trace_hdr traceh;
};

struct ioam6_lwt {
    struct dst_cache cache;
    struct ioam6_lwt_freq freq;
    atomic_t pkt_cnt;
    u8 mode;
    bool has_tunsrc;
    struct in6_addr tunsrc;
    struct in6_addr tundst;
    struct ioam6_lwt_encap tuninfo;
};

struct ioam6_schema;

struct ioam6_namespace {
    struct rhash_head head;
    struct callback_head rcu;
    struct ioam6_schema *schema;
    __be16 id;
    __be32 data;
    __be64 data_wide;
};

struct ioam6_pernet_data {
    struct mutex lock;
    struct rhashtable namespaces;
    struct rhashtable schemas;
};

struct ioam6_schema {
    struct rhash_head head;
    struct callback_head rcu;
    struct ioam6_namespace *ns;
    u32 id;
    int len;
    __be32 hdr;
    u8 data[0];
};

struct iocb {
    __u64 aio_data;
    __u32 aio_key;
    __kernel_rwf_t aio_rw_flags;
    __u16 aio_lio_opcode;
    __s16 aio_reqprio;
    __u32 aio_fildes;
    __u64 aio_buf;
    __u64 aio_nbytes;
    __s64 aio_offset;
    __u64 aio_reserved2;
    __u32 aio_flags;
    __u32 aio_resfd;
};

struct iomap_folio_ops;

struct iomap {
    u64 addr;
    loff_t offset;
    u64 length;
    u16 type;
    u16 flags;
    struct block_device *bdev;
    struct dax_device *dax_dev;
    void *inline_data;
    void *private;
    const struct iomap_folio_ops *folio_ops;
    u64 validity_cookie;
};

struct iomap_dio_ops;

struct iomap_dio {
    struct kiocb *iocb;
    const struct iomap_dio_ops *dops;
    loff_t i_size;
    loff_t size;
    atomic_t ref;
    unsigned int flags;
    int error;
    size_t done_before;
    bool wait_for_completion;
    union {
        struct {
            struct iov_iter *iter;
            struct task_struct *waiter;
        } submit;
        struct {
            struct work_struct work;
        } aio;
    };
};

struct iomap_iter;

struct iomap_dio_ops {
    int (*end_io)(struct kiocb *, ssize_t, int, unsigned int);
    void (*submit_io)(const struct iomap_iter *, struct bio *, loff_t);
    struct bio_set *bio_set;
};

struct iomap_folio_ops {
    struct folio * (*get_folio)(struct iomap_iter *, loff_t, unsigned int);
    void (*put_folio)(struct inode *, loff_t, unsigned int, struct folio *);
    bool (*iomap_valid)(struct inode *, const struct iomap *);
};

struct iomap_folio_state {
    spinlock_t state_lock;
    unsigned int read_bytes_pending;
    atomic_t write_bytes_pending;
    long unsigned int state[0];
};

struct iomap_ioend {
    struct list_head io_list;
    u16 io_type;
    u16 io_flags;
    struct inode *io_inode;
    size_t io_size;
    loff_t io_offset;
    sector_t io_sector;
    struct bio io_bio;
};

struct iomap_iter {
    struct inode *inode;
    loff_t pos;
    u64 len;
    s64 processed;
    unsigned int flags;
    struct iomap iomap;
    struct iomap srcmap;
    void *private;
};

struct iomap_ops {
    int (*iomap_begin)(struct inode *, loff_t, loff_t, unsigned int, struct iomap *, struct iomap *);
    int (*iomap_end)(struct inode *, loff_t, loff_t, ssize_t, unsigned int, struct iomap *);
};

struct iomap_readpage_ctx {
    struct folio *cur_folio;
    bool cur_folio_in_bio;
    struct bio *bio;
    struct readahead_control *rac;
};

struct iomap_swapfile_info {
    struct iomap iomap;
    struct swap_info_struct *sis;
    uint64_t lowest_ppage;
    uint64_t highest_ppage;
    long unsigned int nr_pages;
    int nr_extents;
    struct file *file;
};

struct iomap_writepage_ctx;

struct iomap_writeback_ops {
    int (*map_blocks)(struct iomap_writepage_ctx *, struct inode *, loff_t, unsigned int);
    int (*prepare_ioend)(struct iomap_ioend *, int);
    void (*discard_folio)(struct folio *, loff_t);
};

struct iomap_writepage_ctx {
    struct iomap iomap;
    struct iomap_ioend *ioend;
    const struct iomap_writeback_ops *ops;
    u32 nr_folios;
};

struct iommu_attach_handle {
    struct iommu_domain *domain;
};

struct iova_bitmap;

struct iommu_dirty_bitmap {
    struct iova_bitmap *bitmap;
    struct iommu_iotlb_gather *gather;
};

struct iommu_dirty_ops {
    int (*set_dirty_tracking)(struct iommu_domain *, bool);
    int (*read_and_clear_dirty)(struct iommu_domain *, long unsigned int, size_t, long unsigned int, struct iommu_dirty_bitmap *);
};

struct iova {
    struct rb_node node;
    long unsigned int pfn_hi;
    long unsigned int pfn_lo;
};

struct iova_rcache;

struct iova_domain {
    spinlock_t iova_rbtree_lock;
    struct rb_root rbroot;
    struct rb_node *cached_node;
    struct rb_node *cached32_node;
    long unsigned int granule;
    long unsigned int start_pfn;
    long unsigned int dma_32bit_pfn;
    long unsigned int max32_alloc_size;
    struct iova anchor;
    struct iova_rcache *rcaches;
    struct hlist_node cpuhp_dead;
};

struct iommu_dma_options {
    enum iommu_dma_queue_type qt;
    size_t fq_size;
    unsigned int fq_timeout;
};

struct iova_fq;

struct iommu_dma_cookie {
    enum iommu_dma_cookie_type type;
    union {
        struct {
            struct iova_domain iovad;
            union {
                struct iova_fq *single_fq;
                struct iova_fq *percpu_fq;
            };
            atomic64_t fq_flush_start_cnt;
            atomic64_t fq_flush_finish_cnt;
            struct timer_list fq_timer;
            atomic_t fq_timer_on;
        };
        dma_addr_t msi_iova;
    };
    struct list_head msi_page_list;
    struct iommu_domain *fq_domain;
    struct iommu_dma_options options;
    struct mutex mutex;
};

struct iommu_dma_msi_page {
    struct list_head list;
    dma_addr_t iova;
    phys_addr_t phys;
};

struct iommu_user_data_array;

struct iommu_domain_ops {
    int (*attach_dev)(struct iommu_domain *, struct device *);
    int (*set_dev_pasid)(struct iommu_domain *, struct device *, ioasid_t, struct iommu_domain *);
    int (*map_pages)(struct iommu_domain *, long unsigned int, phys_addr_t, size_t, size_t, int, gfp_t, size_t *);
    size_t (*unmap_pages)(struct iommu_domain *, long unsigned int, size_t, size_t, struct iommu_iotlb_gather *);
    void (*flush_iotlb_all)(struct iommu_domain *);
    int (*iotlb_sync_map)(struct iommu_domain *, long unsigned int, size_t);
    void (*iotlb_sync)(struct iommu_domain *, struct iommu_iotlb_gather *);
    int (*cache_invalidate_user)(struct iommu_domain *, struct iommu_user_data_array *);
    phys_addr_t (*iova_to_phys)(struct iommu_domain *, dma_addr_t);
    bool (*enforce_cache_coherency)(struct iommu_domain *);
    int (*set_pgtable_quirks)(struct iommu_domain *, long unsigned int);
    void (*free)(struct iommu_domain *);
};

struct iommu_fault_page_request {
    u32 flags;
    u32 pasid;
    u32 grpid;
    u32 perm;
    u64 addr;
    u64 private_data[2];
};

struct iommu_fault {
    u32 type;
    struct iommu_fault_page_request prm;
};

struct iopf_queue;

struct iommu_fault_param {
    struct mutex lock;
    refcount_t users;
    struct callback_head rcu;
    struct device *dev;
    struct iopf_queue *queue;
    struct list_head queue_list;
    struct list_head partial;
    struct list_head faults;
};

struct iommu_flush_ops {
    void (*tlb_flush_all)(void *);
    void (*tlb_flush_walk)(long unsigned int, size_t, size_t, void *);
    void (*tlb_add_page)(struct iommu_iotlb_gather *, long unsigned int, size_t, void *);
};

struct iommu_fwspec {
    struct fwnode_handle *iommu_fwnode;
    u32 flags;
    unsigned int num_ids;
    u32 ids[0];
};

struct iommu_group {
    struct kobject kobj;
    struct kobject *devices_kobj;
    struct list_head devices;
    struct xarray pasid_array;
    struct mutex mutex;
    void *iommu_data;
    void (*iommu_data_release)(void *);
    char *name;
    int id;
    struct iommu_domain *default_domain;
    struct iommu_domain *blocking_domain;
    struct iommu_domain *domain;
    struct list_head entry;
    unsigned int owner_cnt;
    void *owner;
};

struct iommu_group_attribute {
    struct attribute attr;
    ssize_t (*show)(struct iommu_group *, char *);
    ssize_t (*store)(struct iommu_group *, const char *, size_t);
};

struct iommu_iotlb_gather {
    long unsigned int start;
    long unsigned int end;
    size_t pgsize;
    struct list_head freelist;
    bool queued;
};

struct iommu_mm_data {
    u32 pasid;
    struct list_head sva_domains;
};

struct iommu_user_data;

struct iopf_fault;

struct iommu_page_response;

struct iommufd_viommu;

struct iommufd_ctx;

struct iommu_ops {
    bool (*capable)(struct device *, enum iommu_cap);
    void * (*hw_info)(struct device *, u32 *, u32 *);
    struct iommu_domain * (*domain_alloc)(unsigned int);
    struct iommu_domain * (*domain_alloc_paging_flags)(struct device *, u32, const struct iommu_user_data *);
    struct iommu_domain * (*domain_alloc_paging)(struct device *);
    struct iommu_domain * (*domain_alloc_sva)(struct device *, struct mm_struct *);
    struct iommu_domain * (*domain_alloc_nested)(struct device *, struct iommu_domain *, u32, const struct iommu_user_data *);
    struct iommu_device * (*probe_device)(struct device *);
    void (*release_device)(struct device *);
    void (*probe_finalize)(struct device *);
    struct iommu_group * (*device_group)(struct device *);
    void (*get_resv_regions)(struct device *, struct list_head *);
    int (*of_xlate)(struct device *, const struct of_phandle_args *);
    bool (*is_attach_deferred)(struct device *);
    int (*dev_enable_feat)(struct device *, enum iommu_dev_features);
    int (*dev_disable_feat)(struct device *, enum iommu_dev_features);
    void (*page_response)(struct device *, struct iopf_fault *, struct iommu_page_response *);
    int (*def_domain_type)(struct device *);
    struct iommufd_viommu * (*viommu_alloc)(struct device *, struct iommu_domain *, struct iommufd_ctx *, unsigned int);
    const struct iommu_domain_ops *default_domain_ops;
    long unsigned int pgsize_bitmap;
    struct module *owner;
    struct iommu_domain *identity_domain;
    struct iommu_domain *blocked_domain;
    struct iommu_domain *release_domain;
    struct iommu_domain *default_domain;
    u8 user_pasid_table: 1;
};

struct iommu_page_response {
    u32 pasid;
    u32 grpid;
    u32 code;
};

struct iommu_resv_region {
    struct list_head list;
    phys_addr_t start;
    size_t length;
    int prot;
    enum iommu_resv_type type;
    void (*free)(struct device *, struct iommu_resv_region *);
};

struct iommu_sva {
    struct iommu_attach_handle handle;
    struct device *dev;
    refcount_t users;
};

struct iommu_user_data {
    unsigned int type;
    void *uptr;
    size_t len;
};

struct iommu_user_data_array {
    unsigned int type;
    void *uptr;
    size_t entry_len;
    u32 entry_num;
};

struct iommufd_ioas;

struct iommufd_ctx {
    struct file *file;
    struct xarray objects;
    struct xarray groups;
    wait_queue_head_t destroy_wait;
    struct rw_semaphore ioas_creation_lock;
    u8 account_mode;
    u8 no_iommu_mode;
    struct iommufd_ioas *vfio_ioas;
};

struct iommufd_object {
    refcount_t shortterm_users;
    refcount_t users;
    enum iommufd_object_type type;
    unsigned int id;
};

struct iommufd_fault {
    struct iommufd_object obj;
    struct iommufd_ctx *ictx;
    struct file *filep;
    spinlock_t lock;
    struct list_head deliver;
    struct mutex mutex;
    struct xarray response;
    struct wait_queue_head wait_queue;
};

struct iommufd_hw_pagetable {
    struct iommufd_object obj;
    struct iommu_domain *domain;
    struct iommufd_fault *fault;
};

struct iommufd_hwpt_paging {
    struct iommufd_hw_pagetable common;
    struct iommufd_ioas *ioas;
    bool auto_domain: 1;
    bool enforce_cache_coherency: 1;
    bool msi_cookie: 1;
    bool nest_parent: 1;
    struct list_head hwpt_item;
};

struct iommufd_ioas {
    struct iommufd_object obj;
    struct io_pagetable iopt;
    struct mutex mutex;
    struct list_head hwpt_list;
};

struct iommufd_vdevice {
    struct iommufd_object obj;
    struct iommufd_ctx *ictx;
    struct iommufd_viommu *viommu;
    struct device *dev;
    u64 id;
};

struct iommufd_viommu_ops;

struct iommufd_viommu {
    struct iommufd_object obj;
    struct iommufd_ctx *ictx;
    struct iommu_device *iommu_dev;
    struct iommufd_hwpt_paging *hwpt;
    const struct iommufd_viommu_ops *ops;
    struct xarray vdevs;
    unsigned int type;
};

struct iommufd_viommu_ops {
    void (*destroy)(struct iommufd_viommu *);
    struct iommu_domain * (*alloc_domain_nested)(struct iommufd_viommu *, u32, const struct iommu_user_data *);
    int (*cache_invalidate)(struct iommufd_viommu *, struct iommu_user_data_array *);
};

struct iopf_fault {
    struct iommu_fault fault;
    struct list_head list;
};

struct iopf_group {
    struct iopf_fault last_fault;
    struct list_head faults;
    size_t fault_count;
    struct list_head pending_node;
    struct work_struct work;
    struct iommu_attach_handle *attach_handle;
    struct iommu_fault_param *fault_param;
    struct list_head node;
    u32 cookie;
};

struct iopf_queue {
    struct workqueue_struct *wq;
    struct list_head devices;
    struct mutex lock;
};

struct ioprio_blkcg {
    struct blkcg_policy_data cpd;
    enum prio_policy prio_policy;
};

struct iova_bitmap_map {
    long unsigned int iova;
    long unsigned int length;
    long unsigned int pgshift;
    long unsigned int pgoff;
    long unsigned int npages;
    struct page **pages;
};

struct iova_bitmap {
    struct iova_bitmap_map mapped;
    u8 *bitmap;
    long unsigned int mapped_base_index;
    long unsigned int mapped_total_index;
    long unsigned int iova;
    size_t length;
};

struct iova_magazine;

struct iova_cpu_rcache {
    spinlock_t lock;
    struct iova_magazine *loaded;
    struct iova_magazine *prev;
};

struct iova_fq_entry {
    long unsigned int iova_pfn;
    long unsigned int pages;
    struct list_head freelist;
    u64 counter;
};

struct iova_fq {
    spinlock_t lock;
    unsigned int head;
    unsigned int tail;
    unsigned int mod_mask;
    struct iova_fq_entry entries[0];
};

struct iova_magazine {
    union {
        long unsigned int size;
        struct iova_magazine *next;
    };
    long unsigned int pfns[127];
};

struct iova_rcache {
    spinlock_t lock;
    unsigned int depot_size;
    struct iova_magazine *depot;
    struct iova_cpu_rcache *cpu_rcaches;
    struct iova_domain *iovad;
    struct delayed_work work;
};

struct iova_to_phys_data {
    arm_lpae_iopte pte;
    int lvl;
};

struct ip6_flowlabel {
    struct ip6_flowlabel *next;
    __be32 label;
    atomic_t users;
    struct in6_addr dst;
    struct ipv6_txoptions *opt;
    long unsigned int linger;
    struct callback_head rcu;
    u8 share;
    union {
        struct pid *pid;
        kuid_t uid;
    } owner;
    long unsigned int lastuse;
    long unsigned int expires;
    struct net *fl_net;
};

struct ip6_frag_state {
    u8 *prevhdr;
    unsigned int hlen;
    unsigned int mtu;
    unsigned int left;
    int offset;
    int ptr;
    int hroom;
    int troom;
    __be32 frag_id;
    u8 nexthdr;
};

struct ipv6hdr;

struct ip6_fraglist_iter {
    struct ipv6hdr *tmp_hdr;
    struct sk_buff *frag;
    int offset;
    unsigned int hlen;
    __be32 frag_id;
    u8 nexthdr;
};

struct ip6_mtuinfo {
    struct sockaddr_in6 ip6m_addr;
    __u32 ip6m_mtu;
};

struct ip6_ra_chain {
    struct ip6_ra_chain *next;
    struct sock *sk;
    int sel;
    void (*destructor)(struct sock *);
};

struct ip6_rt_info {
    struct in6_addr daddr;
    struct in6_addr saddr;
    u_int32_t mark;
};

struct ip6_sf_list {
    struct ip6_sf_list *sf_next;
    struct in6_addr sf_addr;
    long unsigned int sf_count[2];
    unsigned char sf_gsresp;
    unsigned char sf_oldin;
    unsigned char sf_crcount;
    struct callback_head rcu;
};

struct ip6_sf_socklist {
    unsigned int sl_max;
    unsigned int sl_count;
    struct callback_head rcu;
    struct in6_addr sl_addr[0];
};

struct ip_tunnel_encap {
    u16 type;
    u16 flags;
    __be16 sport;
    __be16 dport;
};

struct ip6_tnl {
    struct ip6_tnl *next;
    struct net_device *dev;
    netdevice_tracker dev_tracker;
    struct net *net;
    struct __ip6_tnl_parm parms;
    struct flowi fl;
    struct dst_cache dst_cache;
    struct gro_cells gro_cells;
    int err_count;
    long unsigned int err_time;
    __u32 i_seqno;
    atomic_t o_seqno;
    int hlen;
    int tun_hlen;
    int encap_hlen;
    struct ip_tunnel_encap encap;
    int mlink;
};

struct ip6_tnl_encap_ops {
    size_t (*encap_hlen)(struct ip_tunnel_encap *);
    int (*build_header)(struct sk_buff *, struct ip_tunnel_encap *, u8 *, struct flowi6 *);
    int (*err_handler)(struct sk_buff *, struct inet6_skb_parm *, u8, u8, int, __be32);
};

struct ip6addrlbl_entry {
    struct in6_addr prefix;
    int prefixlen;
    int ifindex;
    int addrtype;
    u32 label;
    struct hlist_node list;
    struct callback_head rcu;
};

struct ip6addrlbl_init_table {
    const struct in6_addr *prefix;
    int prefixlen;
    u32 label;
};

struct ip6fl_iter_state {
    struct seq_net_private p;
    struct pid_namespace *pid_ns;
    int bucket;
};

struct mr_table;

struct ip6mr_result {
    struct mr_table *mrt;
};

struct ip6rd_flowi {
    struct flowi6 fl6;
    struct in6_addr gateway;
};

struct ip_auth_hdr {
    __u8 nexthdr;
    __u8 hdrlen;
    __be16 reserved;
    __be32 spi;
    __be32 seq_no;
    __u8 auth_data[0];
};

struct ip_beet_phdr {
    __u8 nexthdr;
    __u8 hdrlen;
    __u8 padlen;
    __u8 reserved;
};

struct ip_conntrack_stat {
    unsigned int found;
    unsigned int invalid;
    unsigned int insert;
    unsigned int insert_failed;
    unsigned int clash_resolve;
    unsigned int drop;
    unsigned int early_drop;
    unsigned int error;
    unsigned int expect_new;
    unsigned int expect_create;
    unsigned int expect_delete;
    unsigned int search_restart;
    unsigned int chaintoolong;
};

struct ip_ct_sctp {
    enum sctp_conntrack state;
    __be32 vtag[2];
    u8 init[2];
    u8 last_dir;
    u8 flags;
};

struct ip_ct_tcp_state {
    u_int32_t td_end;
    u_int32_t td_maxend;
    u_int32_t td_maxwin;
    u_int32_t td_maxack;
    u_int8_t td_scale;
    u_int8_t flags;
};

struct ip_ct_tcp {
    struct ip_ct_tcp_state seen[2];
    u_int8_t state;
    u_int8_t last_dir;
    u_int8_t retrans;
    u_int8_t last_index;
    u_int32_t last_seq;
    u_int32_t last_ack;
    u_int32_t last_end;
    u_int16_t last_win;
    u_int8_t last_wscale;
    u_int8_t last_flags;
};

struct ip_esp_hdr {
    __be32 spi;
    __be32 seq_no;
    __u8 enc_data[0];
};

struct ip_frag_state {
    bool DF;
    unsigned int hlen;
    unsigned int ll_rs;
    unsigned int mtu;
    unsigned int left;
    int offset;
    int ptr;
    __be16 not_last_frag;
};

struct ip_fraglist_iter {
    struct sk_buff *frag;
    struct iphdr *iph;
    int offset;
    unsigned int hlen;
};

struct ip_sf_list;

struct ip_mc_list {
    struct in_device *interface;
    __be32 multiaddr;
    unsigned int sfmode;
    struct ip_sf_list *sources;
    struct ip_sf_list *tomb;
    long unsigned int sfcount[2];
    union {
        struct ip_mc_list *next;
        struct ip_mc_list *next_rcu;
    };
    struct ip_mc_list *next_hash;
    struct timer_list timer;
    int users;
    refcount_t refcnt;
    spinlock_t lock;
    char tm_running;
    char reporter;
    char unsolicit_count;
    char loaded;
    unsigned char gsquery;
    unsigned char crcount;
    long unsigned int mca_cstamp;
    long unsigned int mca_tstamp;
    struct callback_head rcu;
};

struct ip_mreqn {
    struct in_addr imr_multiaddr;
    struct in_addr imr_address;
    int imr_ifindex;
};

struct ip_sf_socklist;

struct ip_mc_socklist {
    struct ip_mc_socklist *next_rcu;
    struct ip_mreqn multi;
    unsigned int sfmode;
    struct ip_sf_socklist *sflist;
    struct callback_head rcu;
};

struct ip_mreq_source {
    __be32 imr_multiaddr;
    __be32 imr_interface;
    __be32 imr_sourceaddr;
};

struct ip_msfilter {
    __be32 imsf_multiaddr;
    __be32 imsf_interface;
    __u32 imsf_fmode;
    __u32 imsf_numsrc;
    union {
        __be32 imsf_slist[1];
        struct {
            struct {} __empty_imsf_slist_flex;
            __be32 imsf_slist_flex[0];
        };
    };
};

struct ip_ra_chain {
    struct ip_ra_chain *next;
    struct sock *sk;
    union {
        void (*destructor)(struct sock *);
        struct sock *saved_sk;
    };
    struct callback_head rcu;
};

struct kvec {
    void *iov_base;
    size_t iov_len;
};

struct ip_reply_arg {
    struct kvec iov[1];
    int flags;
    __wsum csum;
    int csumoffset;
    int bound_dev_if;
    u8 tos;
    kuid_t uid;
};

struct ip_rt_acct {
    __u32 o_bytes;
    __u32 o_packets;
    __u32 i_bytes;
    __u32 i_packets;
};

struct ip_rt_info {
    __be32 daddr;
    __be32 saddr;
    u_int8_t tos;
    u_int32_t mark;
};

struct ip_sf_list {
    struct ip_sf_list *sf_next;
    long unsigned int sf_count[2];
    __be32 sf_inaddr;
    unsigned char sf_gsresp;
    unsigned char sf_oldin;
    unsigned char sf_crcount;
};

struct ip_sf_socklist {
    unsigned int sl_max;
    unsigned int sl_count;
    struct callback_head rcu;
    __be32 sl_addr[0];
};

struct ip_tunnel_parm_kern {
    char name[16];
    long unsigned int i_flags[1];
    long unsigned int o_flags[1];
    __be32 i_key;
    __be32 o_key;
    int link;
    struct iphdr iph;
};

struct ip_tunnel_6rd_parm {
    struct in6_addr prefix;
    __be32 relay_prefix;
    u16 prefixlen;
    u16 relay_prefixlen;
};

struct ip_tunnel_fan {
    struct list_head fan_maps;
};

struct ip_tunnel_prl_entry;

struct ip_tunnel {
    struct ip_tunnel *next;
    struct hlist_node hash_node;
    struct net_device *dev;
    netdevice_tracker dev_tracker;
    struct net *net;
    long unsigned int err_time;
    int err_count;
    u32 i_seqno;
    atomic_t o_seqno;
    int tun_hlen;
    u32 index;
    u8 erspan_ver;
    u8 dir;
    u16 hwid;
    struct dst_cache dst_cache;
    struct ip_tunnel_parm_kern parms;
    int mlink;
    int encap_hlen;
    int hlen;
    struct ip_tunnel_encap encap;
    struct ip_tunnel_6rd_parm ip6rd;
    struct ip_tunnel_prl_entry *prl;
    unsigned int prl_count;
    struct ip_tunnel_fan fan;
    unsigned int ip_tnl_net_id;
    struct gro_cells gro_cells;
    __u32 fwmark;
    bool collect_md;
    bool ignore_df;
};

struct ip_tunnel_encap_ops {
    size_t (*encap_hlen)(struct ip_tunnel_encap *);
    int (*build_header)(struct sk_buff *, struct ip_tunnel_encap *, u8 *, struct flowi4 *);
    int (*err_handler)(struct sk_buff *, u32);
};

struct ip_tunnel_key {
    __be64 tun_id;
    union {
        struct {
            __be32 src;
            __be32 dst;
        } ipv4;
        struct {
            struct in6_addr src;
            struct in6_addr dst;
        } ipv6;
    } u;
    long unsigned int tun_flags[1];
    __be32 label;
    u32 nhid;
    u8 tos;
    u8 ttl;
    __be16 tp_src;
    __be16 tp_dst;
    __u8 flow_flags;
};

struct ip_tunnel_info {
    struct ip_tunnel_key key;
    struct ip_tunnel_encap encap;
    struct dst_cache dst_cache;
    u8 options_len;
    u8 mode;
};

struct ip_tunnel_prl_entry {
    struct ip_tunnel_prl_entry *next;
    __be32 addr;
    u16 flags;
    struct callback_head callback_head;
};

struct ipc64_perm {
    __kernel_key_t key;
    __kernel_uid32_t uid;
    __kernel_gid32_t gid;
    __kernel_uid32_t cuid;
    __kernel_gid32_t cgid;
    __kernel_mode_t mode;
    unsigned char __pad1[0];
    short unsigned int seq;
    short unsigned int __pad2;
    __kernel_ulong_t __unused1;
    __kernel_ulong_t __unused2;
};

struct ipc_ids {
    int in_use;
    short unsigned int seq;
    struct rw_semaphore rwsem;
    struct idr ipcs_idr;
    int max_idx;
    int last_idx;
    int next_id;
    struct rhashtable key_ht;
};

struct ipc_namespace {
    struct ipc_ids ids[3];
    int sem_ctls[4];
    int used_sems;
    unsigned int msg_ctlmax;
    unsigned int msg_ctlmnb;
    unsigned int msg_ctlmni;
    struct percpu_counter percpu_msg_bytes;
    struct percpu_counter percpu_msg_hdrs;
    size_t shm_ctlmax;
    size_t shm_ctlall;
    long unsigned int shm_tot;
    int shm_ctlmni;
    int shm_rmid_forced;
    struct notifier_block ipcns_nb;
    struct vfsmount *mq_mnt;
    unsigned int mq_queues_count;
    unsigned int mq_queues_max;
    unsigned int mq_msg_max;
    unsigned int mq_msgsize_max;
    unsigned int mq_msg_default;
    unsigned int mq_msgsize_default;
    struct ctl_table_set mq_set;
    struct ctl_table_header *mq_sysctls;
    struct ctl_table_set ipc_set;
    struct ctl_table_header *ipc_sysctls;
    struct user_namespace *user_ns;
    struct ucounts *ucounts;
    struct llist_node mnt_llist;
    struct ns_common ns;
};

struct ipc_params;

struct kern_ipc_perm;

struct ipc_ops {
    int (*getnew)(struct ipc_namespace *, struct ipc_params *);
    int (*associate)(struct kern_ipc_perm *, int);
    int (*more_checks)(struct kern_ipc_perm *, struct ipc_params *);
};

struct ipc_params {
    key_t key;
    int flg;
    union {
        size_t size;
        int nsems;
    } u;
};

struct ipc_perm {
    __kernel_key_t key;
    __kernel_uid_t uid;
    __kernel_gid_t gid;
    __kernel_uid_t cuid;
    __kernel_gid_t cgid;
    __kernel_mode_t mode;
    short unsigned int seq;
};

struct ipc_proc_iface {
    const char *path;
    const char *header;
    int ids;
    int (*show)(struct seq_file *, void *);
};

struct ipc_proc_iter {
    struct ipc_namespace *ns;
    struct pid_namespace *pid_ns;
    struct ipc_proc_iface *iface;
};

struct ipc_security_struct {
    u16 sclass;
    u32 sid;
};

struct sockcm_cookie {
    u64 transmit_time;
    u32 mark;
    u32 tsflags;
    u32 ts_opt_id;
    u32 priority;
};

struct ipcm6_cookie {
    struct sockcm_cookie sockc;
    __s16 hlimit;
    __s16 tclass;
    __u16 gso_size;
    __s8 dontfrag;
    struct ipv6_txoptions *opt;
};

struct ipcm_cookie {
    struct sockcm_cookie sockc;
    __be32 addr;
    int oif;
    struct ip_options_rcu *opt;
    __u8 protocol;
    __u8 ttl;
    __s16 tos;
    __u16 gso_size;
};

struct ipe_bdev {
    struct digest_info *root_hash;
};

struct ipe_eval_ctx {
    enum ipe_op_type op;
    enum ipe_hook_type hook;
    const struct file *file;
    bool initramfs;
    const struct ipe_bdev *ipe_bdev;
};

struct ipe_op_table {
    struct list_head rules;
    enum ipe_action_type default_action;
};

struct ipe_parsed_policy {
    const char *name;
    struct {
        u16 major;
        u16 minor;
        u16 rev;
    } version;
    enum ipe_action_type global_default_action;
    struct ipe_op_table rules[7];
};

struct ipe_policy {
    const char *pkcs7;
    size_t pkcs7len;
    const char *text;
    size_t textlen;
    struct ipe_parsed_policy *parsed;
    struct dentry *policyfs;
};

struct ipe_prop {
    struct list_head next;
    enum ipe_prop_type type;
    void *value;
};

struct ipe_rule {
    enum ipe_op_type op;
    enum ipe_action_type action;
    struct list_head props;
    struct list_head next;
};

struct ipe_superblock {
    bool initramfs;
};

struct ipefs_file {
    const char *name;
    umode_t access;
    const struct file_operations *fops;
};

struct ipfrag_skb_cb {
    union {
        struct inet_skb_parm h4;
        struct inet6_skb_parm h6;
    };
    struct sk_buff *next_frag;
    int frag_run_len;
    int ip_defrag_offset;
};

struct ipmr_result {
    struct mr_table *mrt;
};

struct ipq {
    struct inet_frag_queue q;
    u8 ecn;
    u16 max_df_size;
    int iif;
    unsigned int rid;
    struct inet_peer *peer;
};

struct iproc_rng200_dev {
    struct hwrng rng;
    void *base;
};

struct ipstats_mib {
    u64 mibs[38];
    struct u64_stats_sync syncp;
};

struct ipv6_ac_socklist {
    struct in6_addr acl_addr;
    int acl_ifindex;
    struct ipv6_ac_socklist *acl_next;
};

struct udp_table;

struct ipv6_bpf_stub {
    int (*inet6_bind)(struct sock *, struct sockaddr *, int, u32);
    struct sock * (*udp6_lib_lookup)(const struct net *, const struct in6_addr *, __be16, const struct in6_addr *, __be16, int, int, struct udp_table *, struct sk_buff *);
    int (*ipv6_setsockopt)(struct sock *, int, int, sockptr_t, unsigned int);
    int (*ipv6_getsockopt)(struct sock *, int, int, sockptr_t, sockptr_t);
    int (*ipv6_dev_get_saddr)(struct net *, const struct net_device *, const struct in6_addr *, unsigned int, struct in6_addr *);
};

struct ipv6_destopt_hao {
    __u8 type;
    __u8 length;
    struct in6_addr addr;
} __attribute__((packed));

struct ipv6_fl_socklist {
    struct ipv6_fl_socklist *next;
    struct ip6_flowlabel *fl;
    struct callback_head rcu;
};

struct ipv6_mc_socklist {
    struct in6_addr addr;
    int ifindex;
    unsigned int sfmode;
    struct ipv6_mc_socklist *next;
    struct ip6_sf_socklist *sflist;
    struct callback_head rcu;
};

struct ipv6_mreq {
    struct in6_addr ipv6mr_multiaddr;
    int ipv6mr_ifindex;
};

struct ipv6_params {
    __s32 disable_ipv6;
    __s32 autoconf;
};

struct ipv6_pinfo {
    struct in6_addr saddr;
    struct in6_pktinfo sticky_pktinfo;
    const struct in6_addr *daddr_cache;
    const struct in6_addr *saddr_cache;
    __be32 flow_label;
    __u32 frag_size;
    s16 hop_limit;
    u8 mcast_hops;
    int ucast_oif;
    int mcast_oif;
    union {
        struct {
            __u16 srcrt: 1;
            __u16 osrcrt: 1;
            __u16 rxinfo: 1;
            __u16 rxoinfo: 1;
            __u16 rxhlim: 1;
            __u16 rxohlim: 1;
            __u16 hopopts: 1;
            __u16 ohopopts: 1;
            __u16 dstopts: 1;
            __u16 odstopts: 1;
            __u16 rxflow: 1;
            __u16 rxtclass: 1;
            __u16 rxpmtu: 1;
            __u16 rxorigdstaddr: 1;
            __u16 recvfragsize: 1;
        } bits;
        __u16 all;
    } rxopt;
    __u8 srcprefs;
    __u8 pmtudisc;
    __u8 min_hopcount;
    __u8 tclass;
    __be32 rcv_flowinfo;
    __u32 dst_cookie;
    struct ipv6_mc_socklist *ipv6_mc_list;
    struct ipv6_ac_socklist *ipv6_ac_list;
    struct ipv6_fl_socklist *ipv6_fl_list;
    struct ipv6_txoptions *opt;
    struct sk_buff *pktoptions;
    struct sk_buff *rxpmtu;
    struct inet6_cork cork;
};

struct ipv6_route_iter {
    struct seq_net_private p;
    struct fib6_walker w;
    loff_t skip;
    struct fib6_table *tbl;
    int sernum;
};

struct ipv6_rpl_sr_hdr {
    __u8 nexthdr;
    __u8 hdrlen;
    __u8 type;
    __u8 segments_left;
    __u32 cmpre: 4;
    __u32 cmpri: 4;
    __u32 reserved: 4;
    __u32 pad: 4;
    __u32 reserved1: 16;
    union {
        struct {
            struct {} __empty_addr;
            struct in6_addr addr[0];
        };
        struct {
            struct {} __empty_data;
            __u8 data[0];
        };
    } segments;
};

struct ipv6_rt_hdr {
    __u8 nexthdr;
    __u8 hdrlen;
    __u8 type;
    __u8 segments_left;
};

struct ipv6_saddr_dst {
    const struct in6_addr *addr;
    int ifindex;
    int scope;
    int label;
    unsigned int prefs;
};

struct ipv6_saddr_score {
    int rule;
    int addr_type;
    struct inet6_ifaddr *ifa;
    long unsigned int scorebits[1];
    int scopedist;
    int matchlen;
};

struct ipv6_sr_hdr {
    __u8 nexthdr;
    __u8 hdrlen;
    __u8 type;
    __u8 segments_left;
    __u8 first_segment;
    __u8 flags;
    __u16 tag;
    struct in6_addr segments[0];
};

struct neigh_table;

struct ipv6_stub {
    int (*ipv6_sock_mc_join)(struct sock *, int, const struct in6_addr *);
    int (*ipv6_sock_mc_drop)(struct sock *, int, const struct in6_addr *);
    struct dst_entry * (*ipv6_dst_lookup_flow)(struct net *, const struct sock *, struct flowi6 *, const struct in6_addr *);
    int (*ipv6_route_input)(struct sk_buff *);
    struct fib6_table * (*fib6_get_table)(struct net *, u32);
    int (*fib6_lookup)(struct net *, int, struct flowi6 *, struct fib6_result *, int);
    int (*fib6_table_lookup)(struct net *, struct fib6_table *, int, struct flowi6 *, struct fib6_result *, int);
    void (*fib6_select_path)(const struct net *, struct fib6_result *, struct flowi6 *, int, bool, const struct sk_buff *, int);
    u32 (*ip6_mtu_from_fib6)(const struct fib6_result *, const struct in6_addr *, const struct in6_addr *);
    int (*fib6_nh_init)(struct net *, struct fib6_nh *, struct fib6_config *, gfp_t, struct netlink_ext_ack *);
    void (*fib6_nh_release)(struct fib6_nh *);
    void (*fib6_nh_release_dsts)(struct fib6_nh *);
    void (*fib6_update_sernum)(struct net *, struct fib6_info *);
    int (*ip6_del_rt)(struct net *, struct fib6_info *, bool);
    void (*fib6_rt_update)(struct net *, struct fib6_info *, struct nl_info *);
    void (*udpv6_encap_enable)(void);
    void (*ndisc_send_na)(struct net_device *, const struct in6_addr *, const struct in6_addr *, bool, bool, bool, bool);
    void (*xfrm6_local_rxpmtu)(struct sk_buff *, u32);
    int (*xfrm6_udp_encap_rcv)(struct sock *, struct sk_buff *);
    struct sk_buff * (*xfrm6_gro_udp_encap_rcv)(struct sock *, struct list_head *, struct sk_buff *);
    int (*xfrm6_rcv_encap)(struct sk_buff *, int, __be32, int);
    struct neigh_table *nd_tbl;
    int (*ipv6_fragment)(struct net *, struct sock *, struct sk_buff *, int (*)(struct net *, struct sock *, struct sk_buff *));
    struct net_device * (*ipv6_dev_find)(struct net *, const struct in6_addr *, struct net_device *);
    int (*ip6_xmit)(const struct sock *, struct sk_buff *, struct flowi6 *, __u32, struct ipv6_txoptions *, int, u32);
};

struct ipv6_txoptions {
    refcount_t refcnt;
    int tot_len;
    __u16 opt_flen;
    __u16 opt_nflen;
    struct ipv6_opt_hdr *hopopt;
    struct ipv6_opt_hdr *dst0opt;
    struct ipv6_rt_hdr *srcrt;
    struct ipv6_opt_hdr *dst1opt;
    struct callback_head rcu;
};

struct ipv6hdr {
    __u8 priority: 4;
    __u8 version: 4;
    __u8 flow_lbl[3];
    __be16 payload_len;
    __u8 nexthdr;
    __u8 hop_limit;
    union {
        struct {
            struct in6_addr saddr;
            struct in6_addr daddr;
        };
        struct {
            struct in6_addr saddr;
            struct in6_addr daddr;
        } addrs;
    };
};

struct ir_raw_event {
    union {
        u32 duration;
        u32 carrier;
    };
    u8 duty_cycle;
    unsigned int pulse: 1;
    unsigned int overflow: 1;
    unsigned int timeout: 1;
    unsigned int carrier_report: 1;
};

struct nec_dec {
    int state;
    unsigned int count;
    u32 bits;
    bool is_nec_x;
    bool necx_repeat;
};

struct rc5_dec {
    int state;
    u32 bits;
    unsigned int count;
    bool is_rc5x;
};

struct rc6_dec {
    int state;
    u8 header;
    u32 body;
    bool toggle;
    unsigned int count;
    unsigned int wanted_bits;
};

struct sony_dec {
    int state;
    u32 bits;
    unsigned int count;
};

struct jvc_dec {
    int state;
    u16 bits;
    u16 old_bits;
    unsigned int count;
    bool first;
    bool toggle;
};

struct sanyo_dec {
    int state;
    unsigned int count;
    u64 bits;
};

struct sharp_dec {
    int state;
    unsigned int count;
    u32 bits;
    unsigned int pulse_len;
};

struct mce_kbd_dec {
    spinlock_t keylock;
    struct timer_list rx_timeout;
    int state;
    u8 header;
    u32 body;
    unsigned int count;
    unsigned int wanted_bits;
};

struct xmp_dec {
    int state;
    unsigned int count;
    u32 durations[16];
};

struct rc_dev;

struct ir_raw_event_ctrl {
    struct list_head list;
    struct task_struct *thread;
    struct {
        union {
            struct __kfifo kfifo;
            struct ir_raw_event *type;
            const struct ir_raw_event *const_type;
            char (*rectype)[0];
            struct ir_raw_event *ptr;
            const struct ir_raw_event *ptr_const;
        };
        struct ir_raw_event buf[512];
    } kfifo;
    ktime_t last_event;
    struct rc_dev *dev;
    spinlock_t edge_spinlock;
    struct timer_list edge_handle;
    struct ir_raw_event prev_ev;
    struct ir_raw_event this_ev;
    struct nec_dec nec;
    struct rc5_dec rc5;
    struct rc6_dec rc6;
    struct sony_dec sony;
    struct jvc_dec jvc;
    struct sanyo_dec sanyo;
    struct sharp_dec sharp;
    struct mce_kbd_dec mce_kbd;
    struct xmp_dec xmp;
    struct imon_dec imon;
};

struct ir_raw_handler {
    struct list_head list;
    u64 protocols;
    int (*decode)(struct rc_dev *, struct ir_raw_event);
    int (*encode)(enum rc_proto, u32, struct ir_raw_event *, unsigned int);
    u32 carrier;
    u32 min_timeout;
    int (*raw_register)(struct rc_dev *);
    int (*raw_unregister)(struct rc_dev *);
};

struct ir_raw_timings_manchester {
    unsigned int leader_pulse;
    unsigned int leader_space;
    unsigned int clock;
    unsigned int invert: 1;
    unsigned int trailer_space;
};

struct ir_raw_timings_pd {
    unsigned int header_pulse;
    unsigned int header_space;
    unsigned int bit_pulse;
    unsigned int bit_space[2];
    unsigned int trailer_pulse;
    unsigned int trailer_space;
    unsigned int msb_first: 1;
};

struct ir_raw_timings_pl {
    unsigned int header_pulse;
    unsigned int bit_space;
    unsigned int bit_pulse[2];
    unsigned int trailer_space;
    unsigned int msb_first: 1;
};

struct irq_affinity {
    unsigned int pre_vectors;
    unsigned int post_vectors;
    unsigned int nr_sets;
    unsigned int set_size[4];
    void (*calc_sets)(struct irq_affinity *, unsigned int);
    void *priv;
};

struct irq_affinity_desc {
    struct cpumask mask;
    unsigned int is_managed: 1;
};

struct irq_affinity_devres {
    unsigned int count;
    unsigned int irq[0];
};

struct irq_affinity_notify {
    unsigned int irq;
    struct kref kref;
    struct work_struct work;
    void (*notify)(struct irq_affinity_notify *, const cpumask_t *);
    void (*release)(struct kref *);
};

struct irq_bypass_producer;

struct irq_bypass_consumer {
    struct list_head node;
    void *token;
    int (*add_producer)(struct irq_bypass_consumer *, struct irq_bypass_producer *);
    void (*del_producer)(struct irq_bypass_consumer *, struct irq_bypass_producer *);
    void (*stop)(struct irq_bypass_consumer *);
    void (*start)(struct irq_bypass_consumer *);
};

struct irq_bypass_producer {
    struct list_head node;
    void *token;
    int irq;
    int (*add_consumer)(struct irq_bypass_producer *, struct irq_bypass_consumer *);
    void (*del_consumer)(struct irq_bypass_producer *, struct irq_bypass_consumer *);
    void (*stop)(struct irq_bypass_producer *);
    void (*start)(struct irq_bypass_producer *);
};

struct msi_msg;

struct irq_chip {
    const char *name;
    unsigned int (*irq_startup)(struct irq_data *);
    void (*irq_shutdown)(struct irq_data *);
    void (*irq_enable)(struct irq_data *);
    void (*irq_disable)(struct irq_data *);
    void (*irq_ack)(struct irq_data *);
    void (*irq_mask)(struct irq_data *);
    void (*irq_mask_ack)(struct irq_data *);
    void (*irq_unmask)(struct irq_data *);
    void (*irq_eoi)(struct irq_data *);
    int (*irq_set_affinity)(struct irq_data *, const struct cpumask *, bool);
    int (*irq_retrigger)(struct irq_data *);
    int (*irq_set_type)(struct irq_data *, unsigned int);
    int (*irq_set_wake)(struct irq_data *, unsigned int);
    void (*irq_bus_lock)(struct irq_data *);
    void (*irq_bus_sync_unlock)(struct irq_data *);
    void (*irq_suspend)(struct irq_data *);
    void (*irq_resume)(struct irq_data *);
    void (*irq_pm_shutdown)(struct irq_data *);
    void (*irq_calc_mask)(struct irq_data *);
    void (*irq_print_chip)(struct irq_data *, struct seq_file *);
    int (*irq_request_resources)(struct irq_data *);
    void (*irq_release_resources)(struct irq_data *);
    void (*irq_compose_msi_msg)(struct irq_data *, struct msi_msg *);
    void (*irq_write_msi_msg)(struct irq_data *, struct msi_msg *);
    int (*irq_get_irqchip_state)(struct irq_data *, enum irqchip_irq_state, bool *);
    int (*irq_set_irqchip_state)(struct irq_data *, enum irqchip_irq_state, bool);
    int (*irq_set_vcpu_affinity)(struct irq_data *, void *);
    void (*ipi_send_single)(struct irq_data *, unsigned int);
    void (*ipi_send_mask)(struct irq_data *, const struct cpumask *);
    int (*irq_nmi_setup)(struct irq_data *);
    void (*irq_nmi_teardown)(struct irq_data *);
    long unsigned int flags;
};

struct irq_chip_regs {
    long unsigned int enable;
    long unsigned int disable;
    long unsigned int mask;
    long unsigned int ack;
    long unsigned int eoi;
    long unsigned int type;
};

struct irq_chip_type {
    struct irq_chip chip;
    struct irq_chip_regs regs;
    irq_flow_handler_t handler;
    u32 type;
    u32 mask_cache_priv;
    u32 *mask_cache;
};

struct irq_chip_generic {
    raw_spinlock_t lock;
    void *reg_base;
    u32 (*reg_readl)(void *);
    void (*reg_writel)(u32, void *);
    void (*suspend)(struct irq_chip_generic *);
    void (*resume)(struct irq_chip_generic *);
    unsigned int irq_base;
    unsigned int irq_cnt;
    u32 mask_cache;
    u32 wake_enabled;
    u32 wake_active;
    unsigned int num_ct;
    void *private;
    long unsigned int installed;
    long unsigned int unused;
    struct irq_domain *domain;
    struct list_head list;
    struct irq_chip_type chip_types[0];
};

struct irq_common_data {
    unsigned int state_use_accessors;
    void *handler_data;
    struct msi_desc *msi_desc;
    cpumask_var_t affinity;
    cpumask_var_t effective_affinity;
    unsigned int ipi_offset;
};

struct irq_data {
    u32 mask;
    unsigned int irq;
    irq_hw_number_t hwirq;
    struct irq_common_data *common;
    struct irq_chip *chip;
    struct irq_domain *domain;
    struct irq_data *parent_data;
    void *chip_data;
};

struct irqstat;

struct irqaction;

struct irq_desc {
    struct irq_common_data irq_common_data;
    struct irq_data irq_data;
    struct irqstat *kstat_irqs;
    irq_flow_handler_t handle_irq;
    struct irqaction *action;
    unsigned int status_use_accessors;
    unsigned int core_internal_state__do_not_mess_with_it;
    unsigned int depth;
    unsigned int wake_depth;
    unsigned int tot_count;
    unsigned int irq_count;
    long unsigned int last_unhandled;
    unsigned int irqs_unhandled;
    atomic_t threads_handled;
    int threads_handled_last;
    raw_spinlock_t lock;
    struct cpumask *percpu_enabled;
    const struct cpumask *percpu_affinity;
    const struct cpumask *affinity_hint;
    struct irq_affinity_notify *affinity_notify;
    long unsigned int threads_oneshot;
    atomic_t threads_active;
    wait_queue_head_t wait_for_threads;
    struct proc_dir_entry *dir;
    struct callback_head rcu;
    struct kobject kobj;
    struct mutex request_mutex;
    int parent_irq;
    struct module *owner;
    const char *name;
    struct hlist_node resend_node;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
};

struct irq_desc_devres {
    unsigned int from;
    unsigned int cnt;
};

struct irq_devres {
    unsigned int irq;
    void *dev_id;
};

struct irq_domain_chip_generic;

struct msi_parent_ops;

struct irq_domain {
    struct list_head link;
    const char *name;
    const struct irq_domain_ops *ops;
    void *host_data;
    unsigned int flags;
    unsigned int mapcount;
    struct mutex mutex;
    struct irq_domain *root;
    struct fwnode_handle *fwnode;
    enum irq_domain_bus_token bus_token;
    struct irq_domain_chip_generic *gc;
    struct device *dev;
    struct device *pm_dev;
    struct irq_domain *parent;
    const struct msi_parent_ops *msi_parent_ops;
    void (*exit)(struct irq_domain *);
    irq_hw_number_t hwirq_max;
    unsigned int revmap_size;
    struct xarray revmap_tree;
    struct irq_data *revmap[0];
};

struct irq_domain_chip_generic {
    unsigned int irqs_per_chip;
    unsigned int num_chips;
    unsigned int irq_flags_to_clear;
    unsigned int irq_flags_to_set;
    enum irq_gc_flags gc_flags;
    void (*exit)(struct irq_chip_generic *);
    struct irq_chip_generic *gc[0];
};

struct irq_domain_chip_generic_info {
    const char *name;
    irq_flow_handler_t handler;
    unsigned int irqs_per_chip;
    unsigned int num_ct;
    unsigned int irq_flags_to_clear;
    unsigned int irq_flags_to_set;
    enum irq_gc_flags gc_flags;
    int (*init)(struct irq_chip_generic *);
    void (*exit)(struct irq_chip_generic *);
};

struct irq_domain_data {
    struct irq_domain *irqdomain;
    unsigned int phyirq;
    struct irq_chip *irqchip;
    irq_flow_handler_t irq_handler;
    u32 irqenable;
    struct mutex irq_lock;
};

struct irq_domain_info {
    struct fwnode_handle *fwnode;
    unsigned int domain_flags;
    unsigned int size;
    irq_hw_number_t hwirq_max;
    int direct_max;
    unsigned int hwirq_base;
    unsigned int virq_base;
    enum irq_domain_bus_token bus_token;
    const char *name_suffix;
    const struct irq_domain_ops *ops;
    void *host_data;
    struct irq_domain *parent;
    struct irq_domain_chip_generic_info *dgc_info;
    int (*init)(struct irq_domain *);
    void (*exit)(struct irq_domain *);
};

struct irq_generic_chip_devres {
    struct irq_chip_generic *gc;
    u32 msk;
    unsigned int clr;
    unsigned int set;
};

struct irq_glue {
    struct irq_affinity_notify notify;
    struct cpu_rmap *rmap;
    u16 index;
};

struct irq_info {
    struct hlist_node node;
    int irq;
    spinlock_t lock;
    struct list_head *head;
};

struct irq_ops {
    long unsigned int flags;
    bool (*get_input_level)(int);
};

struct irq_sim_work_ctx;

struct irq_sim_irq_ctx {
    bool enabled;
    struct irq_sim_work_ctx *work_ctx;
};

struct irq_sim_ops {
    int (*irq_sim_irq_requested)(struct irq_domain *, irq_hw_number_t, void *);
    void (*irq_sim_irq_released)(struct irq_domain *, irq_hw_number_t, void *);
};

struct irq_sim_work_ctx {
    struct irq_work work;
    unsigned int irq_count;
    long unsigned int *pending;
    struct irq_domain *domain;
    struct irq_sim_ops ops;
    void *user_data;
};

typedef irqreturn_t (*irq_handler_t)(int, void *);

struct irqaction {
    irq_handler_t handler;
    void *dev_id;
    void *percpu_dev_id;
    struct irqaction *next;
    irq_handler_t thread_fn;
    struct task_struct *thread;
    struct irqaction *secondary;
    unsigned int irq;
    unsigned int flags;
    long unsigned int thread_flags;
    long unsigned int thread_mask;
    const char *name;
    struct proc_dir_entry *dir;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
};

struct irqchip_fwid {
    struct fwnode_handle fwnode;
    unsigned int type;
    char *name;
    phys_addr_t *pa;
};

struct irqstat {
    unsigned int cnt;
};

struct irqtrace_events {
    unsigned int irq_events;
    long unsigned int hardirq_enable_ip;
    long unsigned int hardirq_disable_ip;
    unsigned int hardirq_enable_event;
    unsigned int hardirq_disable_event;
    long unsigned int softirq_disable_ip;
    long unsigned int softirq_enable_ip;
    unsigned int softirq_disable_event;
    unsigned int softirq_enable_event;
};

struct itimerspec64 {
    struct timespec64 it_interval;
    struct timespec64 it_value;
};

struct its_baser {
    void *base;
    u64 val;
    u32 order;
    u32 psz;
};

struct its_cmd_block {
    union {
        u64 raw_cmd[4];
        __le64 raw_cmd_le[4];
    };
};

struct its_device;

struct its_collection;

struct its_cmd_desc {
    union {
        struct {
            struct its_device *dev;
            u32 event_id;
        } its_inv_cmd;
        struct {
            struct its_device *dev;
            u32 event_id;
        } its_clear_cmd;
        struct {
            struct its_device *dev;
            u32 event_id;
        } its_int_cmd;
        struct {
            struct its_device *dev;
            int valid;
        } its_mapd_cmd;
        struct {
            struct its_collection *col;
            int valid;
        } its_mapc_cmd;
        struct {
            struct its_device *dev;
            u32 phys_id;
            u32 event_id;
        } its_mapti_cmd;
        struct {
            struct its_device *dev;
            struct its_collection *col;
            u32 event_id;
        } its_movi_cmd;
        struct {
            struct its_device *dev;
            u32 event_id;
        } its_discard_cmd;
        struct {
            struct its_collection *col;
        } its_invall_cmd;
        struct {
            struct its_vpe *vpe;
        } its_vinvall_cmd;
        struct {
            struct its_vpe *vpe;
            struct its_collection *col;
            bool valid;
        } its_vmapp_cmd;
        struct {
            struct its_vpe *vpe;
            struct its_device *dev;
            u32 virt_id;
            u32 event_id;
            bool db_enabled;
        } its_vmapti_cmd;
        struct {
            struct its_vpe *vpe;
            struct its_device *dev;
            u32 event_id;
            bool db_enabled;
        } its_vmovi_cmd;
        struct {
            struct its_vpe *vpe;
            struct its_collection *col;
            u16 seq_num;
            u16 its_list;
        } its_vmovp_cmd;
        struct {
            struct its_vpe *vpe;
        } its_invdb_cmd;
        struct {
            struct its_vpe *vpe;
            u8 sgi;
            u8 priority;
            bool enable;
            bool group;
            bool clear;
        } its_vsgi_cmd;
    };
};

struct its_cmd_info {
    enum its_vcpu_info_cmd_type cmd_type;
    union {
        struct its_vlpi_map *map;
        u8 config;
        bool req_db;
        struct {
            bool g0en;
            bool g1en;
        };
        struct {
            u8 priority;
            bool group;
        };
    };
};

struct its_collection___2 {
    struct list_head coll_list;
    u32 collection_id;
    u32 target_addr;
};

struct its_collection {
    u64 target_address;
    u16 col_id;
};

struct its_device___2 {
    struct list_head dev_list;
    struct list_head itt_head;
    u32 num_eventid_bits;
    gpa_t itt_addr;
    u32 device_id;
};

struct its_node;

struct its_device {
    struct list_head entry;
    struct its_node *its;
    struct event_lpi_map event_map;
    void *itt;
    u32 itt_sz;
    u32 nr_ites;
    u32 device_id;
    bool shared;
};

struct its_ite {
    struct list_head ite_list;
    struct vgic_irq *irq;
    struct its_collection___2 *collection;
    u32 event_id;
};

struct its_node {
    raw_spinlock_t lock;
    struct mutex dev_alloc_lock;
    struct list_head entry;
    void *base;
    void *sgir_base;
    phys_addr_t phys_base;
    struct its_cmd_block *cmd_base;
    struct its_cmd_block *cmd_write;
    struct its_baser tables[8];
    struct its_collection *collections;
    struct fwnode_handle *fwnode_handle;
    u64 (*get_msi_base)(struct its_device *);
    u64 typer;
    u64 cbaser_save;
    u32 ctlr_save;
    u32 mpidr;
    struct list_head its_device_list;
    u64 flags;
    long unsigned int list_nr;
    int numa_node;
    unsigned int msi_domain_flags;
    u32 pre_its_base;
    int vlpi_redist_offset;
};

struct its_vlpi_map {
    struct its_vm *vm;
    struct its_vpe *vpe;
    u32 vintid;
    u8 properties;
    bool db_enabled;
};

struct its_vpe {
    struct page *vpt_page;
    struct its_vm *its_vm;
    atomic_t vlpi_count;
    int irq;
    irq_hw_number_t vpe_db_lpi;
    bool resident;
    bool ready;
    union {
        struct {
            int vpe_proxy_event;
            bool idai;
        };
        struct {
            struct fwnode_handle *fwnode;
            struct irq_domain *sgi_domain;
            struct {
                u8 priority;
                bool enabled;
                bool group;
            } sgi_config[16];
        };
    };
    atomic_t vmapp_count;
    raw_spinlock_t vpe_lock;
    u16 col_idx;
    u16 vpe_id;
    bool pending_last;
};

struct iw_discarded {
    __u32 nwid;
    __u32 code;
    __u32 fragment;
    __u32 retries;
    __u32 misc;
};

struct iw_encode_ext {
    __u32 ext_flags;
    __u8 tx_seq[8];
    __u8 rx_seq[8];
    struct sockaddr addr;
    __u16 alg;
    __u16 key_len;
    __u8 key[0];
};

struct iw_point {
    void *pointer;
    __u16 length;
    __u16 flags;
};

struct iw_param {
    __s32 value;
    __u8 fixed;
    __u8 disabled;
    __u16 flags;
};

struct iw_freq {
    __s32 m;
    __s16 e;
    __u8 i;
    __u8 flags;
};

struct iw_quality {
    __u8 qual;
    __u8 level;
    __u8 noise;
    __u8 updated;
};

union iwreq_data {
    char name[16];
    struct iw_point essid;
    struct iw_param nwid;
    struct iw_freq freq;
    struct iw_param sens;
    struct iw_param bitrate;
    struct iw_param txpower;
    struct iw_param rts;
    struct iw_param frag;
    __u32 mode;
    struct iw_param retry;
    struct iw_point encoding;
    struct iw_param power;
    struct iw_quality qual;
    struct sockaddr ap_addr;
    struct sockaddr addr;
    struct iw_param param;
    struct iw_point data;
};

struct iw_event {
    __u16 len;
    __u16 cmd;
    union iwreq_data u;
};

struct iw_request_info;

typedef int (*iw_handler)(struct net_device *, struct iw_request_info *, union iwreq_data *, char *);

struct iw_priv_args;

struct iw_statistics;

struct iw_handler_def {
    const iw_handler *standard;
    __u16 num_standard;
    __u16 num_private;
    __u16 num_private_args;
    const iw_handler *private;
    const struct iw_priv_args *private_args;
    struct iw_statistics * (*get_wireless_stats)(struct net_device *);
};

struct iw_ioctl_description {
    __u8 header_type;
    __u8 flags;
    __u16 token_size;
    __u16 min_tokens;
    __u16 max_tokens;
};

struct iw_missed {
    __u32 beacon;
};

struct iw_priv_args {
    __u32 cmd;
    __u16 set_args;
    __u16 get_args;
    char name[16];
};

struct iw_request_info {
    __u16 cmd;
    __u16 flags;
};

struct iw_statistics {
    __u16 status;
    struct iw_quality qual;
    struct iw_discarded discard;
    struct iw_missed miss;
};

struct iwreq {
    union {
        char ifrn_name[16];
    } ifr_ifrn;
    union iwreq_data u;
};

struct transaction_s;

typedef struct transaction_s transaction_t;

struct jbd2_inode {
    transaction_t *i_transaction;
    transaction_t *i_next_transaction;
    struct list_head i_list;
    struct inode *i_vfs_inode;
    long unsigned int i_flags;
    loff_t i_dirty_start;
    loff_t i_dirty_end;
};

struct jbd2_journal_block_tail {
    __be32 t_checksum;
};

typedef struct journal_s journal_t;

struct jbd2_journal_handle {
    union {
        transaction_t *h_transaction;
        journal_t *h_journal;
    };
    handle_t *h_rsv_handle;
    int h_total_credits;
    int h_revoke_credits;
    int h_revoke_credits_requested;
    int h_ref;
    int h_err;
    unsigned int h_sync: 1;
    unsigned int h_jdata: 1;
    unsigned int h_reserved: 1;
    unsigned int h_aborted: 1;
    unsigned int h_type: 8;
    unsigned int h_line_no: 16;
    long unsigned int h_start_jiffies;
    unsigned int h_requested_credits;
    unsigned int saved_alloc_context;
};

struct journal_header_s {
    __be32 h_magic;
    __be32 h_blocktype;
    __be32 h_sequence;
};

typedef struct journal_header_s journal_header_t;

struct jbd2_journal_revoke_header_s {
    journal_header_t r_header;
    __be32 r_count;
};

typedef struct jbd2_journal_revoke_header_s jbd2_journal_revoke_header_t;

struct jbd2_revoke_record_s {
    struct list_head hash;
    tid_t sequence;
    long long unsigned int blocknr;
};

struct jbd2_revoke_table_s {
    int hash_size;
    int hash_shift;
    struct list_head *hash_table;
};

struct transaction_stats_s;

struct jbd2_stats_proc_session {
    journal_t *journal;
    struct transaction_stats_s *stats;
    int start;
    int max;
};

struct rand_data;

struct shash_desc;

struct jitterentropy {
    spinlock_t jent_lock;
    struct rand_data *entropy_collector;
    struct crypto_shash *tfm;
    struct shash_desc *sdesc;
};

struct join_entry {
    u32 token;
    u32 remote_nonce;
    u32 local_nonce;
    u8 join_id;
    u8 local_id;
    u8 backup;
    u8 valid;
};

struct journal_block_tag3_s {
    __be32 t_blocknr;
    __be32 t_flags;
    __be32 t_blocknr_high;
    __be32 t_checksum;
};

typedef struct journal_block_tag3_s journal_block_tag3_t;

struct journal_block_tag_s {
    __be32 t_blocknr;
    __be16 t_checksum;
    __be16 t_flags;
    __be32 t_blocknr_high;
};

typedef struct journal_block_tag_s journal_block_tag_t;

struct journal_head {
    struct buffer_head *b_bh;
    spinlock_t b_state_lock;
    int b_jcount;
    unsigned int b_jlist;
    unsigned int b_modified;
    char *b_frozen_data;
    char *b_committed_data;
    transaction_t *b_transaction;
    transaction_t *b_next_transaction;
    struct journal_head *b_tnext;
    struct journal_head *b_tprev;
    transaction_t *b_cp_transaction;
    struct journal_head *b_cpnext;
    struct journal_head *b_cpprev;
    struct jbd2_buffer_trigger_type *b_triggers;
    struct jbd2_buffer_trigger_type *b_frozen_triggers;
};

struct transaction_run_stats_s {
    long unsigned int rs_wait;
    long unsigned int rs_request_delay;
    long unsigned int rs_running;
    long unsigned int rs_locked;
    long unsigned int rs_flushing;
    long unsigned int rs_logging;
    __u32 rs_handle_count;
    __u32 rs_blocks;
    __u32 rs_blocks_logged;
};

struct transaction_stats_s {
    long unsigned int ts_tid;
    long unsigned int ts_requested;
    struct transaction_run_stats_s run;
};

struct journal_superblock_s;

typedef struct journal_superblock_s journal_superblock_t;

struct journal_s {
    long unsigned int j_flags;
    int j_errno;
    struct mutex j_abort_mutex;
    struct buffer_head *j_sb_buffer;
    journal_superblock_t *j_superblock;
    rwlock_t j_state_lock;
    int j_barrier_count;
    struct mutex j_barrier;
    transaction_t *j_running_transaction;
    transaction_t *j_committing_transaction;
    transaction_t *j_checkpoint_transactions;
    wait_queue_head_t j_wait_transaction_locked;
    wait_queue_head_t j_wait_done_commit;
    wait_queue_head_t j_wait_commit;
    wait_queue_head_t j_wait_updates;
    wait_queue_head_t j_wait_reserved;
    wait_queue_head_t j_fc_wait;
    struct mutex j_checkpoint_mutex;
    struct buffer_head *j_chkpt_bhs[64];
    struct shrinker *j_shrinker;
    struct percpu_counter j_checkpoint_jh_count;
    transaction_t *j_shrink_transaction;
    long unsigned int j_head;
    long unsigned int j_tail;
    long unsigned int j_free;
    long unsigned int j_first;
    long unsigned int j_last;
    long unsigned int j_fc_first;
    long unsigned int j_fc_off;
    long unsigned int j_fc_last;
    struct block_device *j_dev;
    int j_blocksize;
    long long unsigned int j_blk_offset;
    char j_devname[56];
    struct block_device *j_fs_dev;
    errseq_t j_fs_dev_wb_err;
    unsigned int j_total_len;
    atomic_t j_reserved_credits;
    spinlock_t j_list_lock;
    struct inode *j_inode;
    tid_t j_tail_sequence;
    tid_t j_transaction_sequence;
    tid_t j_commit_sequence;
    tid_t j_commit_request;
    __u8 j_uuid[16];
    struct task_struct *j_task;
    int j_max_transaction_buffers;
    int j_revoke_records_per_block;
    int j_transaction_overhead_buffers;
    long unsigned int j_commit_interval;
    struct timer_list j_commit_timer;
    spinlock_t j_revoke_lock;
    struct jbd2_revoke_table_s *j_revoke;
    struct jbd2_revoke_table_s *j_revoke_table[2];
    struct buffer_head **j_wbuf;
    struct buffer_head **j_fc_wbuf;
    int j_wbufsize;
    int j_fc_wbufsize;
    pid_t j_last_sync_writer;
    u64 j_average_commit_time;
    u32 j_min_batch_time;
    u32 j_max_batch_time;
    void (*j_commit_callback)(journal_t *, transaction_t *);
    int (*j_submit_inode_data_buffers)(struct jbd2_inode *);
    int (*j_finish_inode_data_buffers)(struct jbd2_inode *);
    spinlock_t j_history_lock;
    struct proc_dir_entry *j_proc_entry;
    struct transaction_stats_s j_stats;
    unsigned int j_failed_commit;
    void *j_private;
    __u32 j_csum_seed;
    void (*j_fc_cleanup_callback)(struct journal_s *, int, tid_t);
    int (*j_fc_replay_callback)(struct journal_s *, struct buffer_head *, enum passtype, int, tid_t);
    int (*j_bmap)(struct journal_s *, sector_t *);
};

struct journal_superblock_s {
    journal_header_t s_header;
    __be32 s_blocksize;
    __be32 s_maxlen;
    __be32 s_first;
    __be32 s_sequence;
    __be32 s_start;
    __be32 s_errno;
    __be32 s_feature_compat;
    __be32 s_feature_incompat;
    __be32 s_feature_ro_compat;
    __u8 s_uuid[16];
    __be32 s_nr_users;
    __be32 s_dynsuper;
    __be32 s_max_transaction;
    __be32 s_max_trans_data;
    __u8 s_checksum_type;
    __u8 s_padding2[3];
    __be32 s_num_fc_blks;
    __be32 s_head;
    __u32 s_padding[40];
    __be32 s_checksum;
    __u8 s_users[768];
};

struct jump_entry {
    s32 code;
    s32 target;
    long int key;
};

struct k_itimer;

struct k_clock {
    int (*clock_getres)(const clockid_t, struct timespec64 *);
    int (*clock_set)(const clockid_t, const struct timespec64 *);
    int (*clock_get_timespec)(const clockid_t, struct timespec64 *);
    ktime_t (*clock_get_ktime)(const clockid_t);
    int (*clock_adj)(const clockid_t, struct __kernel_timex *);
    int (*timer_create)(struct k_itimer *);
    int (*nsleep)(const clockid_t, int, const struct timespec64 *);
    int (*timer_set)(struct k_itimer *, int, struct itimerspec64 *, struct itimerspec64 *);
    int (*timer_del)(struct k_itimer *);
    void (*timer_get)(struct k_itimer *, struct itimerspec64 *);
    void (*timer_rearm)(struct k_itimer *);
    s64 (*timer_forward)(struct k_itimer *, ktime_t);
    ktime_t (*timer_remaining)(struct k_itimer *, ktime_t);
    int (*timer_try_to_cancel)(struct k_itimer *);
    void (*timer_arm)(struct k_itimer *, ktime_t, bool, bool);
    void (*timer_wait_running)(struct k_itimer *);
};

struct kernel_siginfo {
    struct {
        int si_signo;
        int si_errno;
        int si_code;
        union __sifields _sifields;
    };
};

struct sigqueue {
    struct list_head list;
    int flags;
    kernel_siginfo_t info;
    struct ucounts *ucounts;
};

struct signal_struct;

struct k_itimer {
    struct hlist_node list;
    struct hlist_node ignored_list;
    struct hlist_node t_hash;
    spinlock_t it_lock;
    const struct k_clock *kclock;
    clockid_t it_clock;
    timer_t it_id;
    int it_status;
    bool it_sig_periodic;
    s64 it_overrun;
    s64 it_overrun_last;
    unsigned int it_signal_seq;
    unsigned int it_sigqueue_seq;
    int it_sigev_notify;
    enum pid_type it_pid_type;
    ktime_t it_interval;
    struct signal_struct *it_signal;
    union {
        struct pid *it_pid;
        struct task_struct *it_process;
    };
    struct sigqueue sigq;
    rcuref_t rcuref;
    union {
        struct {
            struct hrtimer timer;
        } real;
        struct cpu_timer cpu;
        struct {
            struct alarm alarmtimer;
        } alarm;
    } it;
    struct callback_head rcu;
};

typedef void __signalfn_t(int);

typedef __signalfn_t *__sighandler_t;

typedef void __restorefn_t(void);

typedef __restorefn_t *__sigrestore_t;

struct sigaction {
    __sighandler_t sa_handler;
    long unsigned int sa_flags;
    __sigrestore_t sa_restorer;
    sigset_t sa_mask;
};

struct k_sigaction {
    struct sigaction sa;
};

struct kallsym_iter {
    loff_t pos;
    loff_t pos_mod_end;
    loff_t pos_ftrace_mod_end;
    loff_t pos_bpf_end;
    long unsigned int value;
    unsigned int nameoff;
    char type;
    char name[512];
    char module_name[56];
    int exported;
    int show_value;
};

struct kallsyms_data {
    long unsigned int *addrs;
    const char **syms;
    size_t cnt;
    size_t found;
};

struct karatsuba_ctx {
    struct karatsuba_ctx *next;
    mpi_ptr_t tspace;
    mpi_size_t tspace_size;
    mpi_ptr_t tp;
    mpi_size_t tp_size;
};

struct led_trigger {
    const char *name;
    int (*activate)(struct led_classdev *);
    void (*deactivate)(struct led_classdev *);
    enum led_brightness brightness;
    struct led_hw_trigger_type *trigger_type;
    spinlock_t leddev_list_lock;
    struct list_head led_cdevs;
    struct list_head next_trig;
    const struct attribute_group **groups;
};

struct kbd_led_trigger {
    struct led_trigger trigger;
    unsigned int mask;
};

struct kbd_repeat {
    int delay;
    int period;
};

struct kbd_struct {
    unsigned char lockstate;
    unsigned char slockstate;
    unsigned char ledmode: 1;
    unsigned char ledflagstate: 4;
    char: 3;
    unsigned char default_ledflagstate: 4;
    unsigned char kbdmode: 3;
    int: 1;
    unsigned char modeflags: 5;
};

struct kbdiacr {
    unsigned char diacr;
    unsigned char base;
    unsigned char result;
};

struct kbdiacrs {
    unsigned int kb_cnt;
    struct kbdiacr kbdiacr[256];
};

struct kbdiacruc {
    unsigned int diacr;
    unsigned int base;
    unsigned int result;
};

struct kbdiacrsuc {
    unsigned int kb_cnt;
    struct kbdiacruc kbdiacruc[256];
};

struct kbentry {
    unsigned char kb_table;
    unsigned char kb_index;
    short unsigned int kb_value;
};

struct kbkeycode {
    unsigned int scancode;
    unsigned int keycode;
};

struct kbsentry {
    unsigned char kb_func;
    unsigned char kb_string[512];
};

struct kcmp_epoll_slot {
    __u32 efd;
    __u32 tfd;
    __u32 toff;
};

struct kcore_list {
    struct list_head list;
    long unsigned int addr;
    size_t size;
    int type;
};

struct kcsan_scoped_access {};

struct kdb_macro {
    kdbtab_t cmd;
    struct list_head statements;
};

struct kdb_macro_statement {
    char *statement;
    struct list_head list_node;
};

struct tcp6_ao_context {
    struct in6_addr saddr;
    struct in6_addr daddr;
    __be16 sport;
    __be16 dport;
    __be32 sisn;
    __be32 disn;
};

struct kdf_input_block {
    u8 counter;
    u8 label[6];
    struct tcp6_ao_context ctx;
    __be16 outlen;
} __attribute__((packed));

struct tcp4_ao_context {
    __be32 saddr;
    __be32 daddr;
    __be16 sport;
    __be16 dport;
    __be32 sisn;
    __be32 disn;
};

struct kdf_input_block___2 {
    u8 counter;
    u8 label[6];
    struct tcp4_ao_context ctx;
    __be16 outlen;
} __attribute__((packed));

struct kdf_testvec {
    unsigned char *key;
    size_t keylen;
    unsigned char *ikm;
    size_t ikmlen;
    struct kvec info;
    unsigned char *expected;
    size_t expectedlen;
};

struct kern_ipc_perm {
    spinlock_t lock;
    bool deleted;
    int id;
    key_t key;
    kuid_t uid;
    kgid_t gid;
    kuid_t cuid;
    kgid_t cgid;
    umode_t mode;
    long unsigned int seq;
    void *security;
    struct rhash_head khtnode;
    struct callback_head rcu;
    refcount_t refcount;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
};

struct kernel_clone_args {
    u64 flags;
    int *pidfd;
    int *child_tid;
    int *parent_tid;
    const char *name;
    int exit_signal;
    u32 kthread: 1;
    u32 io_thread: 1;
    u32 user_worker: 1;
    u32 no_files: 1;
    long unsigned int stack;
    long unsigned int stack_size;
    long unsigned int tls;
    pid_t *set_tid;
    size_t set_tid_size;
    int cgroup;
    int idle;
    int (*fn)(void *);
    void *fn_arg;
    struct cgroup *cgrp;
    struct css_set *cset;
    unsigned int kill_seq;
};

struct kernel_cpustat {
    u64 cpustat[10];
};

struct kernel_ethtool_ringparam {
    u32 rx_buf_len;
    u8 tcp_data_split;
    u8 tx_push;
    u8 rx_push;
    u32 cqe_size;
    u32 tx_push_buf_len;
    u32 tx_push_buf_max_len;
    u32 hds_thresh;
    u32 hds_thresh_max;
};

struct kernel_ethtool_ts_info {
    u32 cmd;
    u32 so_timestamping;
    int phc_index;
    enum hwtstamp_provider_qualifier phc_qualifier;
    enum hwtstamp_tx_types tx_types;
    enum hwtstamp_rx_filters rx_filters;
};

struct kernel_hwtstamp_config {
    int flags;
    int tx_type;
    int rx_filter;
    struct ifreq *ifr;
    bool copied_to_user;
    enum hwtstamp_source source;
    enum hwtstamp_provider_qualifier qualifier;
};

struct kernel_param_ops;

struct kparam_string;

struct kparam_array;

struct kernel_param {
    const char *name;
    struct module *mod;
    const struct kernel_param_ops *ops;
    const u16 perm;
    s8 level;
    u8 flags;
    union {
        void *arg;
        const struct kparam_string *str;
        const struct kparam_array *arr;
    };
};

struct kernel_param_ops {
    unsigned int flags;
    int (*set)(const char *, const struct kernel_param *);
    int (*get)(char *, const struct kernel_param *);
    void (*free)(void *);
};

struct kernel_pkey_params {
    struct key *key;
    const char *encoding;
    const char *hash_algo;
    char *info;
    __u32 in_len;
    union {
        __u32 out_len;
        __u32 in2_len;
    };
    enum kernel_pkey_operation op: 8;
};

struct kernel_pkey_query {
    __u32 supported_ops;
    __u32 key_size;
    __u16 max_data_size;
    __u16 max_sig_size;
    __u16 max_enc_size;
    __u16 max_dec_size;
};

struct kernel_stat {
    long unsigned int irqs_sum;
    unsigned int softirqs[10];
};

struct kernel_symbol {
    int value_offset;
    int name_offset;
    int namespace_offset;
};

struct kernfs_open_node;

struct kernfs_elem_attr {
    const struct kernfs_ops *ops;
    struct kernfs_open_node *open;
    loff_t size;
    struct kernfs_node *notify_next;
};

struct kernfs_elem_dir {
    long unsigned int subdirs;
    struct rb_root children;
    struct kernfs_root *root;
    long unsigned int rev;
};

struct kernfs_elem_symlink {
    struct kernfs_node *target_kn;
};

struct kernfs_global_locks {
    struct mutex open_file_mutex[1024];
};

struct simple_xattrs {
    struct rb_root rb_root;
    rwlock_t lock;
};

struct kernfs_iattrs {
    kuid_t ia_uid;
    kgid_t ia_gid;
    struct timespec64 ia_atime;
    struct timespec64 ia_mtime;
    struct timespec64 ia_ctime;
    struct simple_xattrs xattrs;
    atomic_t nr_user_xattrs;
    atomic_t user_xattr_size;
};

struct kernfs_node {
    atomic_t count;
    atomic_t active;
    struct kernfs_node *parent;
    const char *name;
    struct rb_node rb;
    const void *ns;
    unsigned int hash;
    short unsigned int flags;
    umode_t mode;
    union {
        struct kernfs_elem_dir dir;
        struct kernfs_elem_symlink symlink;
        struct kernfs_elem_attr attr;
    };
    u64 id;
    void *priv;
    struct kernfs_iattrs *iattr;
    struct callback_head rcu;
};

struct kernfs_open_file {
    struct kernfs_node *kn;
    struct file *file;
    struct seq_file *seq_file;
    void *priv;
    struct mutex mutex;
    struct mutex prealloc_mutex;
    int event;
    struct list_head list;
    char *prealloc_buf;
    size_t atomic_write_len;
    bool mmapped: 1;
    bool released: 1;
    const struct vm_operations_struct *vm_ops;
};

struct kernfs_open_node {
    struct callback_head callback_head;
    atomic_t event;
    wait_queue_head_t poll;
    struct list_head files;
    unsigned int nr_mmapped;
    unsigned int nr_to_release;
};

struct kernfs_ops {
    int (*open)(struct kernfs_open_file *);
    void (*release)(struct kernfs_open_file *);
    int (*seq_show)(struct seq_file *, void *);
    void * (*seq_start)(struct seq_file *, loff_t *);
    void * (*seq_next)(struct seq_file *, void *, loff_t *);
    void (*seq_stop)(struct seq_file *, void *);
    ssize_t (*read)(struct kernfs_open_file *, char *, size_t, loff_t);
    size_t atomic_write_len;
    bool prealloc;
    ssize_t (*write)(struct kernfs_open_file *, char *, size_t, loff_t);
    __poll_t (*poll)(struct kernfs_open_file *, struct poll_table_struct *);
    int (*mmap)(struct kernfs_open_file *, struct vm_area_struct *);
    loff_t (*llseek)(struct kernfs_open_file *, loff_t, int);
};

struct kernfs_syscall_ops;

struct kernfs_root {
    struct kernfs_node *kn;
    unsigned int flags;
    struct idr ino_idr;
    u32 last_id_lowbits;
    u32 id_highbits;
    struct kernfs_syscall_ops *syscall_ops;
    struct list_head supers;
    wait_queue_head_t deactivate_waitq;
    struct rw_semaphore kernfs_rwsem;
    struct rw_semaphore kernfs_iattr_rwsem;
    struct rw_semaphore kernfs_supers_rwsem;
    struct callback_head rcu;
};

struct kernfs_super_info {
    struct super_block *sb;
    struct kernfs_root *root;
    const void *ns;
    struct list_head node;
};

struct kernfs_syscall_ops {
    int (*show_options)(struct seq_file *, struct kernfs_root *);
    int (*mkdir)(struct kernfs_node *, const char *, umode_t);
    int (*rmdir)(struct kernfs_node *);
    int (*rename)(struct kernfs_node *, struct kernfs_node *, const char *);
    int (*show_path)(struct seq_file *, struct kernfs_node *, struct kernfs_root *);
};

struct kimage;

struct kexec_buf {
    struct kimage *image;
    void *buffer;
    long unsigned int bufsz;
    long unsigned int mem;
    long unsigned int memsz;
    long unsigned int buf_align;
    long unsigned int buf_min;
    long unsigned int buf_max;
    bool top_down;
};

typedef int kexec_probe_t(const char *, long unsigned int);

typedef void *kexec_load_t(struct kimage *, char *, long unsigned int, char *, long unsigned int, char *, long unsigned int);

typedef int kexec_cleanup_t(void *);

typedef int kexec_verify_sig_t(const char *, long unsigned int);

struct kexec_file_ops {
    kexec_probe_t *probe;
    kexec_load_t *load;
    kexec_cleanup_t *cleanup;
    kexec_verify_sig_t *verify_sig;
};

struct kexec_load_limit {
    struct mutex mutex;
    int limit;
};

struct kexec_segment {
    union {
        void *buf;
        void *kbuf;
    };
    size_t bufsz;
    long unsigned int mem;
    size_t memsz;
};

struct kexec_sha_region {
    long unsigned int start;
    long unsigned int len;
};

struct key_type;

struct key_tag;

struct keyring_index_key {
    long unsigned int hash;
    union {
        struct {
            u16 desc_len;
            char desc[6];
        };
        long unsigned int x;
    };
    struct key_type *type;
    struct key_tag *domain_tag;
    const char *description;
};

union key_payload {
    void *rcu_data0;
    void *data[4];
};

struct watch_list;

struct key_user;

struct key_restriction;

struct key {
    refcount_t usage;
    key_serial_t serial;
    union {
        struct list_head graveyard_link;
        struct rb_node serial_node;
    };
    struct watch_list *watchers;
    struct rw_semaphore sem;
    struct key_user *user;
    void *security;
    union {
        time64_t expiry;
        time64_t revoked_at;
    };
    time64_t last_used_at;
    kuid_t uid;
    kgid_t gid;
    key_perm_t perm;
    short unsigned int quotalen;
    short unsigned int datalen;
    short int state;
    long unsigned int flags;
    union {
        struct keyring_index_key index_key;
        struct {
            long unsigned int hash;
            long unsigned int len_desc;
            struct key_type *type;
            struct key_tag *domain_tag;
            char *description;
        };
    };
    union {
        union key_payload payload;
        struct {
            struct list_head name_link;
            struct assoc_array keys;
        };
    };
    struct key_restriction *restrict_link;
};

struct key_match_data {
    bool (*cmp)(const struct key *, const struct key_match_data *);
    const void *raw_data;
    void *preparsed;
    unsigned int lookup_type;
};

struct watch_notification {
    __u32 type: 24;
    __u32 subtype: 8;
    __u32 info;
};

struct key_notification {
    struct watch_notification watch;
    __u32 key_id;
    __u32 aux;
};

struct key_params {
    const u8 *key;
    const u8 *seq;
    int key_len;
    int seq_len;
    u16 vlan_id;
    u32 cipher;
    enum nl80211_key_mode mode;
};

struct key_preparsed_payload {
    const char *orig_description;
    char *description;
    union key_payload payload;
    const void *data;
    size_t datalen;
    size_t quotalen;
    time64_t expiry;
};

typedef int (*key_restrict_link_func_t)(struct key *, const struct key_type *, const union key_payload *, struct key *);

struct key_restriction {
    key_restrict_link_func_t check;
    struct key *key;
    struct key_type *keytype;
};

struct key_security_struct {
    u32 sid;
};

struct key_tag {
    struct callback_head rcu;
    refcount_t usage;
    bool removed;
};

typedef int (*request_key_actor_t)(struct key *, void *);

struct key_type {
    const char *name;
    size_t def_datalen;
    unsigned int flags;
    int (*vet_description)(const char *);
    int (*preparse)(struct key_preparsed_payload *);
    void (*free_preparse)(struct key_preparsed_payload *);
    int (*instantiate)(struct key *, struct key_preparsed_payload *);
    int (*update)(struct key *, struct key_preparsed_payload *);
    int (*match_preparse)(struct key_match_data *);
    void (*match_free)(struct key_match_data *);
    void (*revoke)(struct key *);
    void (*destroy)(struct key *);
    void (*describe)(const struct key *, struct seq_file *);
    long int (*read)(const struct key *, char *, size_t);
    request_key_actor_t request_key;
    struct key_restriction * (*lookup_restriction)(const char *);
    int (*asym_query)(const struct kernel_pkey_params *, struct kernel_pkey_query *);
    int (*asym_eds_op)(struct kernel_pkey_params *, const void *, void *);
    int (*asym_verify_signature)(struct kernel_pkey_params *, const void *, const void *);
    struct list_head link;
    struct lock_class_key lock_class;
};

struct key_user {
    struct rb_node node;
    struct mutex cons_lock;
    spinlock_t lock;
    refcount_t usage;
    atomic_t nkeys;
    atomic_t nikeys;
    kuid_t uid;
    int qnkeys;
    int qnbytes;
};

struct key_vector {
    t_key key;
    unsigned char pos;
    unsigned char bits;
    unsigned char slen;
    union {
        struct hlist_head leaf;
        struct {
            struct {} __empty_tnode;
            struct key_vector *tnode[0];
        };
    };
};

struct keyboard_notifier_param {
    struct vc_data *vc;
    int down;
    int shift;
    int ledstate;
    unsigned int value;
};

struct keyctl_dh_params {
    union {
        __s32 private;
        __s32 priv;
    };
    __s32 prime;
    __s32 base;
};

struct keyctl_kdf_params {
    char *hashname;
    char *otherinfo;
    __u32 otherinfolen;
    __u32 __spare[8];
};

struct keyctl_pkey_params {
    __s32 key_id;
    __u32 in_len;
    union {
        __u32 out_len;
        __u32 in2_len;
    };
    __u32 __spare[7];
};

struct keyctl_pkey_query {
    __u32 supported_ops;
    __u32 key_size;
    __u16 max_data_size;
    __u16 max_sig_size;
    __u16 max_enc_size;
    __u16 max_dec_size;
    __u32 __spare[10];
};

struct keyring_read_iterator_context {
    size_t buflen;
    size_t count;
    key_serial_t *buffer;
};

struct __key_reference_with_attributes;

typedef struct __key_reference_with_attributes *key_ref_t;

struct keyring_search_context {
    struct keyring_index_key index_key;
    const struct cred *cred;
    struct key_match_data match_data;
    unsigned int flags;
    int (*iterator)(const void *, void *);
    int skipped_ret;
    bool possessed;
    key_ref_t result;
    time64_t now;
};

struct rcu_gp_oldstate {
    long unsigned int rgos_norm;
    long unsigned int rgos_exp;
};

struct kfree_rcu_cpu;

struct kfree_rcu_cpu_work {
    struct rcu_work rcu_work;
    struct callback_head *head_free;
    struct rcu_gp_oldstate head_free_gp_snap;
    struct list_head bulk_head_free[2];
    struct kfree_rcu_cpu *krcp;
};

struct kfree_rcu_cpu {
    struct callback_head *head;
    long unsigned int head_gp_snap;
    atomic_t head_count;
    struct list_head bulk_head[2];
    atomic_t bulk_count[2];
    struct kfree_rcu_cpu_work krw_arr[2];
    raw_spinlock_t lock;
    struct delayed_work monitor_work;
    bool initialized;
    struct delayed_work page_cache_work;
    atomic_t backoff_page_cache_fill;
    atomic_t work_in_progress;
    struct hrtimer hrtimer;
    struct llist_head bkvcache;
    int nr_bkv_objs;
};

struct kgdb_arch {
    unsigned char gdb_bpt_instr[4];
    long unsigned int flags;
    int (*set_breakpoint)(long unsigned int, char *);
    int (*remove_breakpoint)(long unsigned int, char *);
    int (*set_hw_breakpoint)(long unsigned int, int, enum kgdb_bptype);
    int (*remove_hw_breakpoint)(long unsigned int, int, enum kgdb_bptype);
    void (*disable_hw_break)(struct pt_regs *);
    void (*remove_all_hw_break)(void);
    void (*correct_hw_break)(void);
    void (*enable_nmi)(bool);
};

struct kgdb_bkpt {
    long unsigned int bpt_addr;
    unsigned char saved_instr[4];
    enum kgdb_bptype type;
    enum kgdb_bpstate state;
};

struct kgdb_io {
    const char *name;
    int (*read_char)(void);
    void (*write_char)(u8);
    void (*flush)(void);
    int (*init)(void);
    void (*deinit)(void);
    void (*pre_exception)(void);
    void (*post_exception)(void);
    struct console *cons;
};

struct kgdb_nmi_tty_priv {
    struct tty_port port;
    struct timer_list timer;
    struct {
        union {
            struct __kfifo kfifo;
            char *type;
            const char *const_type;
            char (*rectype)[0];
            char *ptr;
            const char *ptr_const;
        };
        char buf[16];
    } fifo;
};

struct kgdb_state {
    int ex_vector;
    int signo;
    int err_code;
    int cpu;
    int pass_exception;
    long unsigned int thr_query;
    long unsigned int threadid;
    long int kgdb_usethreadid;
    struct pt_regs *linux_regs;
    atomic_t *send_ready;
};

struct mm_slot {
    struct hlist_node hash;
    struct list_head mm_node;
    struct mm_struct *mm;
};

struct khugepaged_mm_slot {
    struct mm_slot slot;
};

struct khugepaged_scan {
    struct list_head mm_head;
    struct khugepaged_mm_slot *mm_slot;
    long unsigned int address;
};

struct kimage_arch {
    void *dtb;
    phys_addr_t dtb_mem;
    phys_addr_t kern_reloc;
    phys_addr_t el2_vectors;
    phys_addr_t ttbr0;
    phys_addr_t ttbr1;
    phys_addr_t zero_page;
    long unsigned int phys_offset;
    long unsigned int t0sz;
};

struct purgatory_info {
    const Elf64_Ehdr *ehdr;
    Elf64_Shdr *sechdrs;
    void *purgatory_buf;
};

struct kimage {
    kimage_entry_t head;
    kimage_entry_t *entry;
    kimage_entry_t *last_entry;
    long unsigned int start;
    struct page *control_code_page;
    struct page *swap_page;
    void *vmcoreinfo_data_copy;
    long unsigned int nr_segments;
    struct kexec_segment segment[16];
    struct list_head control_pages;
    struct list_head dest_pages;
    struct list_head unusable_pages;
    long unsigned int control_page;
    unsigned int type: 1;
    unsigned int preserve_context: 1;
    unsigned int file_mode: 1;
    struct kimage_arch arch;
    void *kernel_buf;
    long unsigned int kernel_buf_len;
    void *initrd_buf;
    long unsigned int initrd_buf_len;
    char *cmdline_buf;
    long unsigned int cmdline_buf_len;
    const struct kexec_file_ops *fops;
    void *image_loader_data;
    struct purgatory_info purgatory_info;
    void *ima_buffer;
    phys_addr_t ima_buffer_addr;
    size_t ima_buffer_size;
    void *elf_headers;
    long unsigned int elf_headers_sz;
    long unsigned int elf_load_addr;
};

struct kioctx_cpu;

struct kioctx {
    struct percpu_ref users;
    atomic_t dead;
    struct percpu_ref reqs;
    long unsigned int user_id;
    struct kioctx_cpu *cpu;
    unsigned int req_batch;
    unsigned int max_reqs;
    unsigned int nr_events;
    long unsigned int mmap_base;
    long unsigned int mmap_size;
    struct folio **ring_folios;
    long int nr_pages;
    struct rcu_work free_rwork;
    struct ctx_rq_wait *rq_wait;
    long: 64;
    long: 64;
    long: 64;
    struct {
        atomic_t reqs_available;
        long: 64;
        long: 64;
        long: 64;
        long: 64;
        long: 64;
        long: 64;
        long: 64;
    };
    struct {
        spinlock_t ctx_lock;
        struct list_head active_reqs;
        long: 64;
        long: 64;
        long: 64;
        long: 64;
        long: 64;
    };
    struct {
        struct mutex ring_lock;
        wait_queue_head_t wait;
        long: 64;
    };
    struct {
        unsigned int tail;
        unsigned int completed_events;
        spinlock_t completion_lock;
        long: 64;
        long: 64;
        long: 64;
        long: 64;
        long: 64;
        long: 64;
    };
    struct folio *internal_folios[8];
    struct file *aio_ring_file;
    unsigned int id;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
};

struct kioctx_cpu {
    unsigned int reqs_available;
};

struct kioctx_table {
    struct callback_head rcu;
    unsigned int nr;
    struct kioctx *table[0];
};

struct klist_waiter {
    struct list_head list;
    struct klist_node *node;
    struct task_struct *process;
    int woken;
};

struct km_event {
    union {
        u32 hard;
        u32 proto;
        u32 byid;
        u32 aevent;
        u32 type;
    } data;
    u32 seq;
    u32 portid;
    u32 event;
    struct net *net;
};

struct kmalloc_info_struct {
    const char *name[19];
    unsigned int size;
};

struct kmalloced_param {
    struct list_head list;
    char val[0];
};

struct kmap_ctrl {};

typedef struct kmem_cache *kmem_buckets[14];

struct reciprocal_value {
    u32 m;
    u8 sh1;
    u8 sh2;
};

struct kmem_cache_order_objects {
    unsigned int x;
};

struct kmem_cache_cpu;

struct kmem_cache_node;

struct kmem_cache {
    struct kmem_cache_cpu *cpu_slab;
    slab_flags_t flags;
    long unsigned int min_partial;
    unsigned int size;
    unsigned int object_size;
    struct reciprocal_value reciprocal_size;
    unsigned int offset;
    unsigned int cpu_partial;
    unsigned int cpu_partial_slabs;
    struct kmem_cache_order_objects oo;
    struct kmem_cache_order_objects min;
    gfp_t allocflags;
    int refcount;
    void (*ctor)(void *);
    unsigned int inuse;
    unsigned int align;
    unsigned int red_left_pad;
    const char *name;
    struct list_head list;
    struct kobject kobj;
    long unsigned int random;
    unsigned int *random_seq;
    unsigned int useroffset;
    unsigned int usersize;
    struct kmem_cache_node *node[1];
};

struct kmem_cache_args {
    unsigned int align;
    unsigned int useroffset;
    unsigned int usersize;
    unsigned int freeptr_offset;
    bool use_freeptr_offset;
    void (*ctor)(void *);
};

struct kmem_cache_cpu {
    union {
        struct {
            void **freelist;
            long unsigned int tid;
        };
        freelist_aba_t freelist_tid;
    };
    struct slab *slab;
    struct slab *partial;
    local_lock_t lock;
};

union kmem_cache_iter_priv {
    struct bpf_iter_kmem_cache it;
    struct bpf_iter_kmem_cache_kern kit;
};

struct kmem_cache_node {
    spinlock_t list_lock;
    long unsigned int nr_partial;
    struct list_head partial;
    atomic_long_t nr_slabs;
    atomic_long_t total_objects;
    struct list_head full;
};

struct kmem_obj_info {
    void *kp_ptr;
    struct slab *kp_slab;
    void *kp_objp;
    long unsigned int kp_data_offset;
    struct kmem_cache *kp_slab_cache;
    void *kp_ret;
    void *kp_stack[16];
    void *kp_free_stack[16];
};

struct kmsg_dump_detail {
    enum kmsg_dump_reason reason;
    const char *description;
};

struct kmsg_dump_iter {
    u64 cur_seq;
    u64 next_seq;
};

struct kobj_attribute {
    struct attribute attr;
    ssize_t (*show)(struct kobject *, struct kobj_attribute *, char *);
    ssize_t (*store)(struct kobject *, struct kobj_attribute *, const char *, size_t);
};

struct probe;

struct kobj_map {
    struct probe *probes[255];
    struct mutex *lock;
};

struct kobj_ns_type_operations {
    enum kobj_ns_type type;
    bool (*current_may_mount)(void);
    void * (*grab_current_ns)(void);
    const void * (*netlink_ns)(struct sock *);
    const void * (*initial_ns)(void);
    void (*drop_ns)(void *);
};

struct kobj_uevent_env {
    char *argv[3];
    char *envp[64];
    int envp_idx;
    char buf[2048];
    int buflen;
};

struct kparam_array {
    unsigned int max;
    unsigned int elemsize;
    unsigned int *num;
    const struct kernel_param_ops *ops;
    void *elem;
};

struct kparam_string {
    unsigned int maxlen;
    char *string;
};

struct kpp_request;

struct kpp_alg {
    int (*set_secret)(struct crypto_kpp *, const void *, unsigned int);
    int (*generate_public_key)(struct kpp_request *);
    int (*compute_shared_secret)(struct kpp_request *);
    unsigned int (*max_size)(struct crypto_kpp *);
    int (*init)(struct crypto_kpp *);
    void (*exit)(struct crypto_kpp *);
    struct crypto_alg base;
};

struct kpp_instance {
    void (*free)(struct kpp_instance *);
    union {
        struct {
            char head[48];
            struct crypto_instance base;
        } s;
        struct kpp_alg alg;
    };
};

struct kpp_request {
    struct crypto_async_request base;
    struct scatterlist *src;
    struct scatterlist *dst;
    unsigned int src_len;
    unsigned int dst_len;
    void *__ctx[0];
};

struct kpp_secret {
    short unsigned int type;
    short unsigned int len;
};

struct kprobe;

typedef int (*kprobe_pre_handler_t)(struct kprobe *, struct pt_regs *);

typedef void (*kprobe_post_handler_t)(struct kprobe *, struct pt_regs *, long unsigned int);

struct kprobe {
    struct hlist_node hlist;
    struct list_head list;
    long unsigned int nmissed;
    kprobe_opcode_t *addr;
    const char *symbol_name;
    unsigned int offset;
    kprobe_pre_handler_t pre_handler;
    kprobe_post_handler_t post_handler;
    kprobe_opcode_t opcode;
    struct arch_specific_insn ainsn;
    u32 flags;
};

struct kprobe_blacklist_entry {
    struct list_head list;
    long unsigned int start_addr;
    long unsigned int end_addr;
};

struct prev_kprobe {
    struct kprobe *kp;
    unsigned int status;
};

struct kprobe_ctlblk {
    unsigned int kprobe_status;
    long unsigned int saved_irqflag;
    struct prev_kprobe prev_kprobe;
};

struct kprobe_insn_cache {
    struct mutex mutex;
    void * (*alloc)(void);
    void (*free)(void *);
    const char *sym;
    struct list_head pages;
    size_t insn_size;
    int nr_garbage;
};

struct kprobe_insn_page {
    struct list_head list;
    kprobe_opcode_t *insns;
    struct kprobe_insn_cache *cache;
    int nused;
    int ngarbage;
    char slot_used[0];
};

struct kprobe_trace_entry_head {
    struct trace_entry ent;
    long unsigned int ip;
};

struct kretprobe_instance;

typedef int (*kretprobe_handler_t)(struct kretprobe_instance *, struct pt_regs *);

struct kretprobe_holder;

struct kretprobe {
    struct kprobe kp;
    kretprobe_handler_t handler;
    kretprobe_handler_t entry_handler;
    int maxactive;
    int nmissed;
    size_t data_size;
    struct kretprobe_holder *rph;
};

struct objpool_head;

typedef int (*objpool_fini_cb)(struct objpool_head *, void *);

struct objpool_slot;

struct objpool_head {
    int obj_size;
    int nr_objs;
    int nr_possible_cpus;
    int capacity;
    gfp_t gfp;
    refcount_t ref;
    long unsigned int flags;
    struct objpool_slot **cpu_slots;
    objpool_fini_cb release;
    void *context;
};

struct kretprobe_holder {
    struct kretprobe *rp;
    struct objpool_head pool;
};

struct kretprobe_instance {
    struct callback_head rcu;
    struct llist_node llist;
    struct kretprobe_holder *rph;
    kprobe_opcode_t *ret_addr;
    void *fp;
    char data[0];
};

struct kretprobe_trace_entry_head {
    struct trace_entry ent;
    long unsigned int func;
    long unsigned int ret_ip;
};

struct kset_uevent_ops;

struct kset {
    struct list_head list;
    spinlock_t list_lock;
    struct kobject kobj;
    const struct kset_uevent_ops *uevent_ops;
};

struct kset_uevent_ops {
    int (* const filter)(const struct kobject *);
    const char * (* const name)(const struct kobject *);
    int (* const uevent)(const struct kobject *, struct kobj_uevent_env *);
};

struct ksignal {
    struct k_sigaction ka;
    kernel_siginfo_t info;
    int sig;
};

struct kstat {
    u32 result_mask;
    umode_t mode;
    unsigned int nlink;
    uint32_t blksize;
    u64 attributes;
    u64 attributes_mask;
    u64 ino;
    dev_t dev;
    dev_t rdev;
    kuid_t uid;
    kgid_t gid;
    loff_t size;
    struct timespec64 atime;
    struct timespec64 mtime;
    struct timespec64 ctime;
    struct timespec64 btime;
    u64 blocks;
    u64 mnt_id;
    u64 change_cookie;
    u64 subvol;
    u32 dio_mem_align;
    u32 dio_offset_align;
    u32 dio_read_offset_align;
    u32 atomic_write_unit_min;
    u32 atomic_write_unit_max;
    u32 atomic_write_segments_max;
};

struct kstatfs {
    long int f_type;
    long int f_bsize;
    u64 f_blocks;
    u64 f_bfree;
    u64 f_bavail;
    u64 f_files;
    u64 f_ffree;
    __kernel_fsid_t f_fsid;
    long int f_namelen;
    long int f_frsize;
    long int f_flags;
    long int f_spare[4];
};

struct statmount {
    __u32 size;
    __u32 mnt_opts;
    __u64 mask;
    __u32 sb_dev_major;
    __u32 sb_dev_minor;
    __u64 sb_magic;
    __u32 sb_flags;
    __u32 fs_type;
    __u64 mnt_id;
    __u64 mnt_parent_id;
    __u32 mnt_id_old;
    __u32 mnt_parent_id_old;
    __u64 mnt_attr;
    __u64 mnt_propagation;
    __u64 mnt_peer_group;
    __u64 mnt_master;
    __u64 propagate_from;
    __u32 mnt_root;
    __u32 mnt_point;
    __u64 mnt_ns_id;
    __u32 fs_subtype;
    __u32 sb_source;
    __u32 opt_num;
    __u32 opt_array;
    __u32 opt_sec_num;
    __u32 opt_sec_array;
    __u64 __spare2[46];
    char str[0];
};

struct seq_file {
    char *buf;
    size_t size;
    size_t from;
    size_t count;
    size_t pad_until;
    loff_t index;
    loff_t read_pos;
    struct mutex lock;
    const struct seq_operations *op;
    int poll_event;
    const struct file *file;
    void *private;
};

struct kstatmount {
    struct statmount *buf;
    size_t bufsize;
    struct vfsmount *mnt;
    u64 mask;
    struct path root;
    struct statmount sm;
    struct seq_file seq;
};

struct ktermios {
    tcflag_t c_iflag;
    tcflag_t c_oflag;
    tcflag_t c_cflag;
    tcflag_t c_lflag;
    cc_t c_line;
    cc_t c_cc[19];
    speed_t c_ispeed;
    speed_t c_ospeed;
};

struct kthread {
    long unsigned int flags;
    unsigned int cpu;
    unsigned int node;
    int started;
    int result;
    int (*threadfn)(void *);
    void *data;
    struct completion parked;
    struct completion exited;
    struct cgroup_subsys_state *blkcg_css;
    char *full_name;
    struct task_struct *task;
    struct list_head hotplug_node;
    struct cpumask *preferred_affinity;
};

struct kthread_create_info {
    char *full_name;
    int (*threadfn)(void *);
    void *data;
    int node;
    struct task_struct *result;
    struct completion *done;
    struct list_head list;
};

struct kthread_delayed_work {
    struct kthread_work work;
    struct timer_list timer;
};

struct kthread_flush_work {
    struct kthread_work work;
    struct completion done;
};

struct kthread_worker {
    unsigned int flags;
    raw_spinlock_t lock;
    struct list_head work_list;
    struct list_head delayed_work_list;
    struct task_struct *task;
    struct kthread_work *current_work;
};

typedef bool (*stack_trace_consume_fn)(void *, long unsigned int);

struct kunwind_consume_entry_data {
    stack_trace_consume_fn consume_entry;
    void *cookie;
};

struct stack_info {
    long unsigned int low;
    long unsigned int high;
};

struct unwind_state {
    long unsigned int fp;
    long unsigned int pc;
    struct stack_info stack;
    struct stack_info *stacks;
    int nr_stacks;
};

union unwind_flags {
    long unsigned int all;
    struct {
        long unsigned int fgraph: 1;
        long unsigned int kretprobe: 1;
    };
};

struct kunwind_state {
    struct unwind_state common;
    struct task_struct *task;
    int graph_idx;
    struct llist_node *kr_cur;
    enum kunwind_source source;
    union unwind_flags flags;
    struct pt_regs *regs;
};

struct kvfree_rcu_bulk_data {
    struct list_head list;
    struct rcu_gp_oldstate gp_snap;
    long unsigned int nr_records;
    void *records[0];
};

struct kvm_memslots {
    u64 generation;
    atomic_long_t last_used_slot;
    struct rb_root_cached hva_tree;
    struct rb_root gfn_tree;
    struct hlist_head id_hash[128];
    int node_idx;
};

struct kvm_vm_stat_generic {
    u64 remote_tlb_flush;
    u64 remote_tlb_flush_requests;
};

struct kvm_vm_stat {
    struct kvm_vm_stat_generic generic;
};

struct mmu_notifier_ops;

struct mmu_notifier {
    struct hlist_node hlist;
    const struct mmu_notifier_ops *ops;
    struct mm_struct *mm;
    struct callback_head rcu;
    unsigned int users;
};

struct kvm_io_bus;

struct kvm_coalesced_mmio_ring;

struct kvm_irq_routing_table;

struct kvm_stat_data;

struct kvm {
    rwlock_t mmu_lock;
    struct mutex slots_lock;
    struct mutex slots_arch_lock;
    struct mm_struct *mm;
    long unsigned int nr_memslot_pages;
    struct kvm_memslots __memslots[2];
    struct kvm_memslots *memslots[1];
    struct xarray vcpu_array;
    atomic_t nr_memslots_dirty_logging;
    spinlock_t mn_invalidate_lock;
    long unsigned int mn_active_invalidate_count;
    struct rcuwait mn_memslots_update_rcuwait;
    spinlock_t gpc_lock;
    struct list_head gpc_list;
    atomic_t online_vcpus;
    int max_vcpus;
    int created_vcpus;
    int last_boosted_vcpu;
    struct list_head vm_list;
    struct mutex lock;
    struct kvm_io_bus *buses[5];
    struct {
        spinlock_t lock;
        struct list_head items;
        struct list_head resampler_list;
        struct mutex resampler_lock;
    } irqfds;
    struct list_head ioeventfds;
    struct kvm_vm_stat stat;
    struct kvm_arch arch;
    refcount_t users_count;
    struct kvm_coalesced_mmio_ring *coalesced_mmio_ring;
    spinlock_t ring_lock;
    struct list_head coalesced_zones;
    struct mutex irq_lock;
    struct kvm_irq_routing_table *irq_routing;
    struct hlist_head irq_ack_notifier_list;
    struct mmu_notifier mmu_notifier;
    long unsigned int mmu_invalidate_seq;
    long int mmu_invalidate_in_progress;
    gfn_t mmu_invalidate_range_start;
    gfn_t mmu_invalidate_range_end;
    struct list_head devices;
    u64 manual_dirty_log_protect;
    struct dentry *debugfs_dentry;
    struct kvm_stat_data **debugfs_stat_data;
    struct srcu_struct srcu;
    struct srcu_struct irq_srcu;
    pid_t userspace_pid;
    bool override_halt_poll_ns;
    unsigned int max_halt_poll_ns;
    u32 dirty_ring_size;
    bool dirty_ring_with_bitmap;
    bool vm_bugged;
    bool vm_dead;
    char stats_id[48];
};

struct kvm_arch_memory_slot {};

struct kvm_arm_copy_mte_tags {
    __u64 guest_ipa;
    __u64 length;
    void *addr;
    __u64 flags;
    __u64 reserved[2];
};

struct kvm_arm_counter_offset {
    __u64 counter_offset;
    __u64 reserved;
};

struct kvm_arm_device_addr {
    __u64 id;
    __u64 addr;
};

struct kvm_clear_dirty_log {
    __u32 slot;
    __u32 num_pages;
    __u64 first_page;
    union {
        void *dirty_bitmap;
        __u64 padding2;
    };
};

struct kvm_coalesced_mmio {
    __u64 phys_addr;
    __u32 len;
    union {
        __u32 pad;
        __u32 pio;
    };
    __u8 data[8];
};

struct kvm_coalesced_mmio_zone {
    __u64 addr;
    __u32 size;
    union {
        __u32 pad;
        __u32 pio;
    };
};

struct kvm_coalesced_mmio_dev {
    struct list_head list;
    struct kvm_io_device dev;
    struct kvm *kvm;
    struct kvm_coalesced_mmio_zone zone;
};

struct kvm_coalesced_mmio_ring {
    __u32 first;
    __u32 last;
    struct kvm_coalesced_mmio coalesced_mmio[0];
};

struct user_fpsimd_state {
    __int128 unsigned vregs[32];
    __u32 fpsr;
    __u32 fpcr;
    __u32 __reserved[2];
};

struct kvm_cpu_context {
    struct user_pt_regs regs;
    u64 spsr_abt;
    u64 spsr_und;
    u64 spsr_irq;
    u64 spsr_fiq;
    struct user_fpsimd_state fp_regs;
    u64 sys_regs[286];
    struct kvm_vcpu *__hyp_running_vcpu;
    u64 *vncr_array;
};

struct kvm_create_device {
    __u32 type;
    __u32 fd;
    __u32 flags;
};

struct kvm_debug_exit_arch {
    __u32 hsr;
    __u32 hsr_high;
    __u64 far;
};

struct kvm_device_ops;

struct kvm_device {
    const struct kvm_device_ops *ops;
    struct kvm *kvm;
    void *private;
    struct list_head vm_node;
};

struct kvm_device_attr {
    __u32 flags;
    __u32 group;
    __u64 attr;
    __u64 addr;
};

struct kvm_device_ops {
    const char *name;
    int (*create)(struct kvm_device *, u32);
    void (*init)(struct kvm_device *);
    void (*destroy)(struct kvm_device *);
    void (*release)(struct kvm_device *);
    int (*set_attr)(struct kvm_device *, struct kvm_device_attr *);
    int (*get_attr)(struct kvm_device *, struct kvm_device_attr *);
    int (*has_attr)(struct kvm_device *, struct kvm_device_attr *);
    long int (*ioctl)(struct kvm_device *, unsigned int, long unsigned int);
    int (*mmap)(struct kvm_device *, struct vm_area_struct *);
};

struct kvm_dirty_gfn {
    __u32 flags;
    __u32 slot;
    __u64 offset;
};

struct kvm_dirty_log {
    __u32 slot;
    __u32 padding1;
    union {
        void *dirty_bitmap;
        __u64 padding2;
    };
};

struct kvm_dirty_ring {
    u32 dirty_index;
    u32 reset_index;
    u32 size;
    u32 soft_limit;
    struct kvm_dirty_gfn *dirty_gfns;
    int index;
};

struct kvm_enable_cap {
    __u32 cap;
    __u32 flags;
    __u64 args[4];
    __u8 pad[64];
};

struct kvm_exception_table_entry {
    int insn;
    int fixup;
};

struct kvm_ffa_buffers {
    hyp_spinlock_t lock;
    void *tx;
    void *rx;
};

struct kvm_ffa_descriptor_buffer {
    void *buf;
    size_t len;
};

struct kvm_follow_pfn {
    const struct kvm_memory_slot *slot;
    const gfn_t gfn;
    long unsigned int hva;
    unsigned int flags;
    bool pin;
    bool *map_writable;
    struct page **refcounted_page;
};

struct kvm_fpu {};

union kvm_mmu_notifier_arg {
    long unsigned int attributes;
};

struct kvm_gfn_range {
    struct kvm_memory_slot *slot;
    gfn_t start;
    gfn_t end;
    union kvm_mmu_notifier_arg arg;
    enum kvm_gfn_range_filter attr_filter;
    bool may_block;
};

struct kvm_guest_debug_arch {
    __u64 dbg_bcr[16];
    __u64 dbg_bvr[16];
    __u64 dbg_wcr[16];
    __u64 dbg_wvr[16];
};

struct kvm_guest_debug {
    __u32 control;
    __u32 pad;
    struct kvm_guest_debug_arch arch;
};

struct kvm_host_data {
    long unsigned int flags;
    long: 64;
    struct kvm_cpu_context host_ctxt;
    struct cpu_sve_state *sve_state;
    u64 fpmr;
    enum {
        FP_STATE_FREE = 0,
        FP_STATE_HOST_OWNED = 1,
        FP_STATE_GUEST_OWNED = 2,
    } fp_owner;
    struct {
        struct kvm_guest_debug_arch regs;
        u64 pmscr_el1;
        u64 trfcr_el1;
        u64 mdcr_el2;
    } host_debug_state;
    u64 trfcr_while_in_guest;
    unsigned int nr_event_counters;
    unsigned int debug_brps;
    unsigned int debug_wrps;
    long: 64;
};

struct kvm_host_map {
    struct page *pinned_page;
    struct page *page;
    void *hva;
    kvm_pfn_t pfn;
    kvm_pfn_t gfn;
    bool writable;
};

struct psci_0_1_function_ids {
    u32 cpu_suspend;
    u32 cpu_on;
    u32 cpu_off;
    u32 migrate;
};

struct kvm_host_psci_config {
    u32 version;
    u32 smccc_version;
    struct psci_0_1_function_ids function_ids_0_1;
    bool psci_0_1_cpu_suspend_implemented;
    bool psci_0_1_cpu_on_implemented;
    bool psci_0_1_cpu_off_implemented;
    bool psci_0_1_migrate_implemented;
};

struct kvm_hv_sint {
    u32 vcpu;
    u32 sint;
};

struct kvm_hyperv_exit {
    __u32 type;
    __u32 pad1;
    union {
        struct {
            __u32 msr;
            __u32 pad2;
            __u64 control;
            __u64 evt_page;
            __u64 msg_page;
        } synic;
        struct {
            __u64 input;
            __u64 result;
            __u64 params[2];
        } hcall;
        struct {
            __u32 msr;
            __u32 pad2;
            __u64 control;
            __u64 status;
            __u64 send_page;
            __u64 recv_page;
            __u64 pending_page;
        } syndbg;
    } u;
};

struct kvm_io_range {
    gpa_t addr;
    int len;
    struct kvm_io_device *dev;
};

struct kvm_io_bus {
    int dev_count;
    int ioeventfd_count;
    struct kvm_io_range range[0];
};

struct kvm_io_device_ops {
    int (*read)(struct kvm_vcpu *, struct kvm_io_device *, gpa_t, int, void *);
    int (*write)(struct kvm_vcpu *, struct kvm_io_device *, gpa_t, int, const void *);
    void (*destructor)(struct kvm_io_device *);
};

struct kvm_ioeventfd {
    __u64 datamatch;
    __u64 addr;
    __u32 len;
    __s32 fd;
    __u32 flags;
    __u8 pad[36];
};

struct kvm_irq_ack_notifier {
    struct hlist_node link;
    unsigned int gsi;
    void (*irq_acked)(struct kvm_irq_ack_notifier *);
};

struct kvm_irq_level {
    union {
        __u32 irq;
        __s32 status;
    };
    __u32 level;
};

struct kvm_irq_routing_irqchip {
    __u32 irqchip;
    __u32 pin;
};

struct kvm_irq_routing_msi {
    __u32 address_lo;
    __u32 address_hi;
    __u32 data;
    union {
        __u32 pad;
        __u32 devid;
    };
};

struct kvm_irq_routing_s390_adapter {
    __u64 ind_addr;
    __u64 summary_addr;
    __u64 ind_offset;
    __u32 summary_offset;
    __u32 adapter_id;
};

struct kvm_irq_routing_hv_sint {
    __u32 vcpu;
    __u32 sint;
};

struct kvm_irq_routing_xen_evtchn {
    __u32 port;
    __u32 vcpu;
    __u32 priority;
};

struct kvm_irq_routing_entry {
    __u32 gsi;
    __u32 type;
    __u32 flags;
    __u32 pad;
    union {
        struct kvm_irq_routing_irqchip irqchip;
        struct kvm_irq_routing_msi msi;
        struct kvm_irq_routing_s390_adapter adapter;
        struct kvm_irq_routing_hv_sint hv_sint;
        struct kvm_irq_routing_xen_evtchn xen_evtchn;
        __u32 pad[8];
    } u;
};

struct kvm_irq_routing {
    __u32 nr;
    __u32 flags;
    struct kvm_irq_routing_entry entries[0];
};

struct kvm_irq_routing_table {
    int chip[988];
    u32 nr_rt_entries;
    struct hlist_head map[0];
};

struct kvm_irqfd {
    __u32 fd;
    __u32 gsi;
    __u32 flags;
    __u32 resamplefd;
    __u8 pad[16];
};

struct kvm_s390_adapter_int {
    u64 ind_addr;
    u64 summary_addr;
    u64 ind_offset;
    u32 summary_offset;
    u32 adapter_id;
};

struct kvm_xen_evtchn {
    u32 port;
    u32 vcpu_id;
    int vcpu_idx;
    u32 priority;
};

struct kvm_kernel_irq_routing_entry {
    u32 gsi;
    u32 type;
    int (*set)(struct kvm_kernel_irq_routing_entry *, struct kvm *, int, int, bool);
    union {
        struct {
            unsigned int irqchip;
            unsigned int pin;
        } irqchip;
        struct {
            u32 address_lo;
            u32 address_hi;
            u32 data;
            u32 flags;
            u32 devid;
        } msi;
        struct kvm_s390_adapter_int adapter;
        struct kvm_hv_sint hv_sint;
        struct kvm_xen_evtchn xen_evtchn;
    };
    struct hlist_node link;
};

struct kvm_kernel_irqfd_resampler;

struct kvm_kernel_irqfd {
    struct kvm *kvm;
    wait_queue_entry_t wait;
    struct kvm_kernel_irq_routing_entry irq_entry;
    seqcount_spinlock_t irq_entry_sc;
    int gsi;
    struct work_struct inject;
    struct kvm_kernel_irqfd_resampler *resampler;
    struct eventfd_ctx *resamplefd;
    struct list_head resampler_link;
    struct eventfd_ctx *eventfd;
    struct list_head list;
    poll_table pt;
    struct work_struct shutdown;
    struct irq_bypass_consumer consumer;
    struct irq_bypass_producer *producer;
};

struct kvm_kernel_irqfd_resampler {
    struct kvm *kvm;
    struct list_head list;
    struct kvm_irq_ack_notifier notifier;
    struct list_head link;
};

struct kvm_mem_range {
    u64 start;
    u64 end;
};

struct kvm_memory_slot {
    struct hlist_node id_node[2];
    struct interval_tree_node hva_node[2];
    struct rb_node gfn_node[2];
    gfn_t base_gfn;
    long unsigned int npages;
    long unsigned int *dirty_bitmap;
    struct kvm_arch_memory_slot arch;
    long unsigned int userspace_addr;
    u32 flags;
    short int id;
    u16 as_id;
};

struct kvm_memslot_iter {
    struct kvm_memslots *slots;
    struct rb_node *node;
    struct kvm_memory_slot *slot;
};

struct kvm_mmio_fragment {
    gpa_t gpa;
    void *data;
    unsigned int len;
};

typedef bool (*gfn_handler_t)(struct kvm *, struct kvm_gfn_range *);

typedef void (*on_lock_fn_t)(struct kvm *);

struct kvm_mmu_notifier_range {
    u64 start;
    u64 end;
    union kvm_mmu_notifier_arg arg;
    gfn_handler_t handler;
    on_lock_fn_t on_lock;
    bool flush_on_ret;
    bool may_block;
};

struct kvm_mmu_notifier_return {
    bool ret;
    bool found_memslot;
};

typedef struct kvm_mmu_notifier_return kvm_mn_ret_t;

struct kvm_mp_state {
    __u32 mp_state;
};

struct kvm_mpidr_data {
    u64 mpidr_mask;
    struct {
        struct {} __empty_cmpidr_to_idx;
        u16 cmpidr_to_idx[0];
    };
};

struct kvm_msi {
    __u32 address_lo;
    __u32 address_hi;
    __u32 data;
    __u32 flags;
    __u32 devid;
    __u8 pad[12];
};

struct kvm_nvhe_init_params {
    long unsigned int mair_el2;
    long unsigned int tcr_el2;
    long unsigned int tpidr_el2;
    long unsigned int stack_hyp_va;
    long unsigned int stack_pa;
    phys_addr_t pgd_pa;
    long unsigned int hcr_el2;
    long unsigned int vttbr;
    long unsigned int vtcr;
    long unsigned int tmp;
};

struct kvm_nvhe_stacktrace_info {
    long unsigned int stack_base;
    long unsigned int overflow_stack_base;
    long unsigned int fp;
    long unsigned int pc;
};

struct kvm_one_reg {
    __u64 id;
    __u64 addr;
};

struct kvm_pgtable_visit_ctx {
    kvm_pte_t *ptep;
    kvm_pte_t old;
    void *arg;
    struct kvm_pgtable_mm_ops *mm_ops;
    u64 start;
    u64 addr;
    u64 end;
    s8 level;
    enum kvm_pgtable_walk_flags flags;
};

struct kvm_pgtable_walker;

struct kvm_pgtable_walk_data {
    struct kvm_pgtable_walker *walker;
    const u64 start;
    u64 addr;
    const u64 end;
};

typedef int (*kvm_pgtable_visitor_fn_t)(const struct kvm_pgtable_visit_ctx *, enum kvm_pgtable_walk_flags);

struct kvm_pgtable_walker {
    const kvm_pgtable_visitor_fn_t cb;
    void * const arg;
    const enum kvm_pgtable_walk_flags flags;
};

struct kvm_pmc {
    u8 idx;
    struct perf_event *perf_event;
};

struct kvm_pmu_events {
    u64 events_host;
    u64 events_guest;
};

struct kvm_pmu {
    struct irq_work overflow_work;
    struct kvm_pmu_events events;
    struct kvm_pmc pmc[32];
    int irq_num;
    bool created;
    bool irq_level;
};

struct kvm_pmu_event_filter {
    __u16 base_event;
    __u16 nevents;
    __u8 action;
    __u8 pad[3];
};

struct kvm_reg_list {
    __u64 n;
    __u64 reg[0];
};

struct kvm_regs {
    struct user_pt_regs regs;
    __u64 sp_el1;
    __u64 elr_el1;
    __u64 spsr[5];
    long: 64;
    struct user_fpsimd_state fp_regs;
};

struct kvm_xen_exit {
    __u32 type;
    union {
        struct {
            __u32 longmode;
            __u32 cpl;
            __u64 input;
            __u64 result;
            __u64 params[6];
        } hcall;
    } u;
};

struct kvm_sync_regs {
    __u64 device_irq_level;
};

struct kvm_run {
    __u8 request_interrupt_window;
    __u8 immediate_exit__unsafe;
    __u8 padding1[6];
    __u32 exit_reason;
    __u8 ready_for_interrupt_injection;
    __u8 if_flag;
    __u16 flags;
    __u64 cr8;
    __u64 apic_base;
    union {
        struct {
            __u64 hardware_exit_reason;
        } hw;
        struct {
            __u64 hardware_entry_failure_reason;
            __u32 cpu;
        } fail_entry;
        struct {
            __u32 exception;
            __u32 error_code;
        } ex;
        struct {
            __u8 direction;
            __u8 size;
            __u16 port;
            __u32 count;
            __u64 data_offset;
        } io;
        struct {
            struct kvm_debug_exit_arch arch;
        } debug;
        struct {
            __u64 phys_addr;
            __u8 data[8];
            __u32 len;
            __u8 is_write;
        } mmio;
        struct {
            __u64 phys_addr;
            __u8 data[8];
            __u32 len;
            __u8 is_write;
        } iocsr_io;
        struct {
            __u64 nr;
            __u64 args[6];
            __u64 ret;
            union {
                __u64 flags;
            };
        } hypercall;
        struct {
            __u64 rip;
            __u32 is_write;
            __u32 pad;
        } tpr_access;
        struct {
            __u8 icptcode;
            __u16 ipa;
            __u32 ipb;
        } s390_sieic;
        __u64 s390_reset_flags;
        struct {
            __u64 trans_exc_code;
            __u32 pgm_code;
        } s390_ucontrol;
        struct {
            __u32 dcrn;
            __u32 data;
            __u8 is_write;
        } dcr;
        struct {
            __u32 suberror;
            __u32 ndata;
            __u64 data[16];
        } internal;
        struct {
            __u32 suberror;
            __u32 ndata;
            __u64 flags;
            union {
                struct {
                    __u8 insn_size;
                    __u8 insn_bytes[15];
                };
            };
        } emulation_failure;
        struct {
            __u64 gprs[32];
        } osi;
        struct {
            __u64 nr;
            __u64 ret;
            __u64 args[9];
        } papr_hcall;
        struct {
            __u16 subchannel_id;
            __u16 subchannel_nr;
            __u32 io_int_parm;
            __u32 io_int_word;
            __u32 ipb;
            __u8 dequeued;
        } s390_tsch;
        struct {
            __u32 epr;
        } epr;
        struct {
            __u32 type;
            __u32 ndata;
            union {
                __u64 data[16];
            };
        } system_event;
        struct {
            __u64 addr;
            __u8 ar;
            __u8 reserved;
            __u8 fc;
            __u8 sel1;
            __u16 sel2;
        } s390_stsi;
        struct {
            __u8 vector;
        } eoi;
        struct kvm_hyperv_exit hyperv;
        struct {
            __u64 esr_iss;
            __u64 fault_ipa;
        } arm_nisv;
        struct {
            __u8 error;
            __u8 pad[7];
            __u32 reason;
            __u32 index;
            __u64 data;
        } msr;
        struct kvm_xen_exit xen;
        struct {
            long unsigned int extension_id;
            long unsigned int function_id;
            long unsigned int args[6];
            long unsigned int ret[2];
        } riscv_sbi;
        struct {
            long unsigned int csr_num;
            long unsigned int new_value;
            long unsigned int write_mask;
            long unsigned int ret_value;
        } riscv_csr;
        struct {
            __u32 flags;
        } notify;
        struct {
            __u64 flags;
            __u64 gpa;
            __u64 size;
        } memory_fault;
        char padding[256];
    };
    __u64 kvm_valid_regs;
    __u64 kvm_dirty_regs;
    union {
        struct kvm_sync_regs regs;
        char padding[2048];
    } s;
};

struct kvm_s2_trans {
    phys_addr_t output;
    long unsigned int block_size;
    bool writable;
    bool readable;
    int level;
    u32 esr;
    u64 desc;
};

struct kvm_signal_mask {
    __u32 len;
    __u8 sigset[0];
};

struct kvm_smccc_filter {
    __u32 base;
    __u32 nr_functions;
    __u8 action;
    __u8 pad[15];
};

struct kvm_sregs {};

struct kvm_stat_data {
    struct kvm *kvm;
    const struct _kvm_stats_desc *desc;
    enum kvm_stat_kind kind;
};

struct kvm_stats_header {
    __u32 flags;
    __u32 name_size;
    __u32 num_desc;
    __u32 id_offset;
    __u32 desc_offset;
    __u32 data_offset;
};

struct kvm_sysreg_masks {
    struct {
        u64 res0;
        u64 res1;
    } mask[156];
};

struct kvm_translation {
    __u64 linear_address;
    __u64 physical_address;
    __u8 valid;
    __u8 writeable;
    __u8 usermode;
    __u8 pad[5];
};

struct kvm_userspace_memory_region {
    __u32 slot;
    __u32 flags;
    __u64 guest_phys_addr;
    __u64 memory_size;
    __u64 userspace_addr;
};

struct kvm_userspace_memory_region2 {
    __u32 slot;
    __u32 flags;
    __u64 guest_phys_addr;
    __u64 memory_size;
    __u64 userspace_addr;
    __u64 guest_memfd_offset;
    __u32 guest_memfd;
    __u32 pad1;
    __u64 pad2[14];
};

struct preempt_ops;

struct preempt_notifier {
    struct hlist_node link;
    struct preempt_ops *ops;
};

struct kvm_vcpu_fault_info {
    u64 esr_el2;
    u64 far_el2;
    u64 hpfar_el2;
    u64 disr_el1;
};

struct vgic_v2_cpu_if {
    u32 vgic_hcr;
    u32 vgic_vmcr;
    u32 vgic_apr;
    u32 vgic_lr[64];
    unsigned int used_lrs;
};

struct vgic_v3_cpu_if {
    u32 vgic_hcr;
    u32 vgic_vmcr;
    u32 vgic_sre;
    u32 vgic_ap0r[4];
    u32 vgic_ap1r[4];
    u64 vgic_lr[16];
    struct its_vpe its_vpe;
    unsigned int used_lrs;
};

struct vgic_redist_region;

struct vgic_cpu {
    union {
        struct vgic_v2_cpu_if vgic_v2;
        struct vgic_v3_cpu_if vgic_v3;
    };
    struct vgic_irq *private_irqs;
    raw_spinlock_t ap_list_lock;
    struct list_head ap_list_head;
    struct vgic_io_device rd_iodev;
    struct vgic_redist_region *rdreg;
    u32 rdreg_index;
    atomic_t syncr_busy;
    u64 pendbaser;
    atomic_t ctlr;
    u32 num_pri_bits;
    u32 num_id_bits;
};

struct vcpu_reset_state {
    long unsigned int pc;
    long unsigned int r0;
    bool be;
    bool reset;
};

struct kvm_vcpu_arch {
    struct kvm_cpu_context ctxt;
    void *sve_state;
    enum fp_type fp_type;
    unsigned int sve_max_vl;
    struct kvm_s2_mmu *hw_mmu;
    u64 hcr_el2;
    u64 hcrx_el2;
    u64 mdcr_el2;
    struct kvm_vcpu_fault_info fault;
    u8 cflags;
    u8 iflags;
    u8 sflags;
    bool pause;
    struct kvm_guest_debug_arch vcpu_debug_state;
    struct kvm_guest_debug_arch external_debug_state;
    u64 external_mdscr_el1;
    enum {
        VCPU_DEBUG_FREE = 0,
        VCPU_DEBUG_HOST_OWNED = 1,
        VCPU_DEBUG_GUEST_OWNED = 2,
    } debug_owner;
    struct vgic_cpu vgic_cpu;
    struct arch_timer_cpu timer_cpu;
    struct kvm_pmu pmu;
    struct kvm_mp_state mp_state;
    spinlock_t mp_state_lock;
    struct kvm_mmu_memory_cache mmu_page_cache;
    struct kvm_hyp_memcache pkvm_memcache;
    u64 vsesr_el2;
    struct vcpu_reset_state reset_state;
    struct {
        u64 last_steal;
        gpa_t base;
    } steal;
    u32 *ccsidr;
    long: 64;
};

struct kvm_vcpu_stat_generic {
    u64 halt_successful_poll;
    u64 halt_attempted_poll;
    u64 halt_poll_invalid;
    u64 halt_wakeup;
    u64 halt_poll_success_ns;
    u64 halt_poll_fail_ns;
    u64 halt_wait_ns;
    u64 halt_poll_success_hist[32];
    u64 halt_poll_fail_hist[32];
    u64 halt_wait_hist[32];
    u64 blocking;
};

struct kvm_vcpu_stat {
    struct kvm_vcpu_stat_generic generic;
    u64 hvc_exit_stat;
    u64 wfe_exit_stat;
    u64 wfi_exit_stat;
    u64 mmio_exit_user;
    u64 mmio_exit_kernel;
    u64 signal_exits;
    u64 exits;
};

struct kvm_vcpu {
    struct kvm *kvm;
    struct preempt_notifier preempt_notifier;
    int cpu;
    int vcpu_id;
    int vcpu_idx;
    int ____srcu_idx;
    int mode;
    u64 requests;
    long unsigned int guest_debug;
    struct mutex mutex;
    struct kvm_run *run;
    struct rcuwait wait;
    struct pid *pid;
    rwlock_t pid_lock;
    int sigset_active;
    sigset_t sigset;
    unsigned int halt_poll_ns;
    bool valid_wakeup;
    int mmio_needed;
    int mmio_read_completed;
    int mmio_is_write;
    int mmio_cur_fragment;
    int mmio_nr_fragments;
    struct kvm_mmio_fragment mmio_fragments[2];
    struct {
        bool in_spin_loop;
        bool dy_eligible;
    } spin_loop;
    bool wants_to_run;
    bool preempted;
    bool ready;
    bool scheduled_out;
    struct kvm_vcpu_arch arch;
    struct kvm_vcpu_stat stat;
    char stats_id[48];
    struct kvm_dirty_ring dirty_ring;
    struct kvm_memory_slot *last_used_slot;
    u64 last_used_slot_gen;
    long: 64;
};

struct kvm_vcpu_events {
    struct {
        __u8 serror_pending;
        __u8 serror_has_esr;
        __u8 ext_dabt_pending;
        __u8 pad[5];
        __u64 serror_esr;
    } exception;
    __u32 reserved[12];
};

struct kvm_vcpu_init {
    __u32 target;
    __u32 features[7];
};

struct kvm_vfio {
    struct list_head file_list;
    struct mutex lock;
    bool noncoherent;
};

struct kvm_vfio_file {
    struct list_head node;
    struct file *file;
};

typedef int (*lookup_by_table_id_t)(struct net *, u32);

struct l3mdev_handler {
    lookup_by_table_id_t dev_lookup;
};

struct l3mdev_ops {
    u32 (*l3mdev_fib_table)(const struct net_device *);
    struct sk_buff * (*l3mdev_l3_rcv)(struct net_device *, struct sk_buff *, u16);
    struct sk_buff * (*l3mdev_l3_out)(struct net_device *, struct sock *, struct sk_buff *, u16);
    struct dst_entry * (*l3mdev_link_scope_lookup)(const struct net_device *, struct flowi6 *);
};

struct label_it {
    int i;
    int j;
};

struct ladder_device_state {
    struct {
        u32 promotion_count;
        u32 demotion_count;
        u64 promotion_time_ns;
        u64 demotion_time_ns;
    } threshold;
    struct {
        int promotion_count;
        int demotion_count;
    } stats;
};

struct ladder_device {
    struct ladder_device_state states[10];
};

struct usb_anchor {
    struct list_head urb_list;
    wait_queue_head_t wait;
    spinlock_t lock;
    atomic_t suspend_wakeups;
    unsigned int poisoned: 1;
};

struct lan78xx_statstage {
    u32 rx_fcs_errors;
    u32 rx_alignment_errors;
    u32 rx_fragment_errors;
    u32 rx_jabber_errors;
    u32 rx_undersize_frame_errors;
    u32 rx_oversize_frame_errors;
    u32 rx_dropped_frames;
    u32 rx_unicast_byte_count;
    u32 rx_broadcast_byte_count;
    u32 rx_multicast_byte_count;
    u32 rx_unicast_frames;
    u32 rx_broadcast_frames;
    u32 rx_multicast_frames;
    u32 rx_pause_frames;
    u32 rx_64_byte_frames;
    u32 rx_65_127_byte_frames;
    u32 rx_128_255_byte_frames;
    u32 rx_256_511_bytes_frames;
    u32 rx_512_1023_byte_frames;
    u32 rx_1024_1518_byte_frames;
    u32 rx_greater_1518_byte_frames;
    u32 eee_rx_lpi_transitions;
    u32 eee_rx_lpi_time;
    u32 tx_fcs_errors;
    u32 tx_excess_deferral_errors;
    u32 tx_carrier_errors;
    u32 tx_bad_byte_count;
    u32 tx_single_collisions;
    u32 tx_multiple_collisions;
    u32 tx_excessive_collision;
    u32 tx_late_collisions;
    u32 tx_unicast_byte_count;
    u32 tx_broadcast_byte_count;
    u32 tx_multicast_byte_count;
    u32 tx_unicast_frames;
    u32 tx_broadcast_frames;
    u32 tx_multicast_frames;
    u32 tx_pause_frames;
    u32 tx_64_byte_frames;
    u32 tx_65_127_byte_frames;
    u32 tx_128_255_byte_frames;
    u32 tx_256_511_bytes_frames;
    u32 tx_512_1023_byte_frames;
    u32 tx_1024_1518_byte_frames;
    u32 tx_greater_1518_byte_frames;
    u32 eee_tx_lpi_transitions;
    u32 eee_tx_lpi_time;
};

struct lan78xx_statstage64 {
    u64 rx_fcs_errors;
    u64 rx_alignment_errors;
    u64 rx_fragment_errors;
    u64 rx_jabber_errors;
    u64 rx_undersize_frame_errors;
    u64 rx_oversize_frame_errors;
    u64 rx_dropped_frames;
    u64 rx_unicast_byte_count;
    u64 rx_broadcast_byte_count;
    u64 rx_multicast_byte_count;
    u64 rx_unicast_frames;
    u64 rx_broadcast_frames;
    u64 rx_multicast_frames;
    u64 rx_pause_frames;
    u64 rx_64_byte_frames;
    u64 rx_65_127_byte_frames;
    u64 rx_128_255_byte_frames;
    u64 rx_256_511_bytes_frames;
    u64 rx_512_1023_byte_frames;
    u64 rx_1024_1518_byte_frames;
    u64 rx_greater_1518_byte_frames;
    u64 eee_rx_lpi_transitions;
    u64 eee_rx_lpi_time;
    u64 tx_fcs_errors;
    u64 tx_excess_deferral_errors;
    u64 tx_carrier_errors;
    u64 tx_bad_byte_count;
    u64 tx_single_collisions;
    u64 tx_multiple_collisions;
    u64 tx_excessive_collision;
    u64 tx_late_collisions;
    u64 tx_unicast_byte_count;
    u64 tx_broadcast_byte_count;
    u64 tx_multicast_byte_count;
    u64 tx_unicast_frames;
    u64 tx_broadcast_frames;
    u64 tx_multicast_frames;
    u64 tx_pause_frames;
    u64 tx_64_byte_frames;
    u64 tx_65_127_byte_frames;
    u64 tx_128_255_byte_frames;
    u64 tx_256_511_bytes_frames;
    u64 tx_512_1023_byte_frames;
    u64 tx_1024_1518_byte_frames;
    u64 tx_greater_1518_byte_frames;
    u64 eee_tx_lpi_transitions;
    u64 eee_tx_lpi_time;
};

struct statstage {
    struct mutex access_lock;
    struct lan78xx_statstage saved;
    struct lan78xx_statstage rollover_count;
    struct lan78xx_statstage rollover_max;
    struct lan78xx_statstage64 curr_stat;
};

struct lan78xx_net {
    struct net_device *net;
    struct usb_device *udev;
    struct usb_interface *intf;
    void *driver_priv;
    unsigned int tx_pend_data_len;
    size_t n_tx_urbs;
    size_t n_rx_urbs;
    size_t tx_urb_size;
    size_t rx_urb_size;
    struct sk_buff_head rxq_free;
    struct sk_buff_head rxq;
    struct sk_buff_head rxq_done;
    struct sk_buff_head rxq_overflow;
    struct sk_buff_head txq_free;
    struct sk_buff_head txq;
    struct sk_buff_head txq_pend;
    struct napi_struct napi;
    struct delayed_work wq;
    int msg_enable;
    struct urb *urb_intr;
    struct usb_anchor deferred;
    struct mutex dev_mutex;
    struct mutex mdiobus_mutex;
    unsigned int pipe_in;
    unsigned int pipe_out;
    unsigned int pipe_intr;
    unsigned int bulk_in_delay;
    unsigned int burst_cap;
    long unsigned int flags;
    wait_queue_head_t *wait;
    unsigned char suspend_count;
    unsigned int maxpacket;
    struct timer_list stat_monitor;
    long unsigned int data[5];
    int link_on;
    u8 mdix_ctrl;
    u32 chipid;
    u32 chiprev;
    struct mii_bus *mdiobus;
    phy_interface_t interface;
    int fc_autoneg;
    u8 fc_request_control;
    int delta;
    struct statstage stats;
    struct irq_domain_data domain_data;
};

struct lan78xx_priv {
    struct lan78xx_net *dev;
    u32 rfe_ctl;
    u32 mchash_table[16];
    u32 pfilter_table[66];
    u32 vlan_table[128];
    struct mutex dataport_mutex;
    spinlock_t rfe_ctl_lock;
    struct work_struct set_multicast;
    struct work_struct set_vlan;
    u32 wol;
};

struct lan88xx_priv {
    int chip_id;
    int chip_rev;
    __u32 wolopts;
};

struct landlock_ruleset;

struct landlock_cred_security {
    struct landlock_ruleset *domain;
};

struct landlock_erratum {
    const int abi;
    const u8 number;
};

struct landlock_file_security {
    access_mask_t allowed_access;
    struct landlock_ruleset *fown_domain;
};

struct landlock_hierarchy {
    struct landlock_hierarchy *parent;
    refcount_t usage;
};

struct landlock_object;

union landlock_key {
    struct landlock_object *object;
    uintptr_t data;
};

struct landlock_id {
    union landlock_key key;
    const enum landlock_key_type type;
};

struct landlock_inode_security {
    struct landlock_object *object;
};

struct landlock_layer {
    u16 level;
    access_mask_t access;
};

struct landlock_net_port_attr {
    __u64 allowed_access;
    __u64 port;
};

struct landlock_object_underops;

struct landlock_object {
    refcount_t usage;
    spinlock_t lock;
    void *underobj;
    union {
        struct callback_head rcu_free;
        const struct landlock_object_underops *underops;
    };
};

struct landlock_object_underops {
    void (*release)(struct landlock_object * const);
};

struct landlock_path_beneath_attr {
    __u64 allowed_access;
    __s32 parent_fd;
} __attribute__((packed));

struct landlock_rule {
    struct rb_node node;
    union landlock_key key;
    u32 num_layers;
    struct landlock_layer layers[0];
};

struct landlock_ruleset {
    struct rb_root root_inode;
    struct rb_root root_net_port;
    struct landlock_hierarchy *hierarchy;
    union {
        struct work_struct work_free;
        struct {
            struct mutex lock;
            refcount_t usage;
            u32 num_rules;
            u32 num_layers;
            struct access_masks access_masks[0];
        };
    };
};

struct landlock_ruleset_attr {
    __u64 handled_access_fs;
    __u64 handled_access_net;
    __u64 scoped;
};

struct landlock_superblock_security {
    atomic_long_t inode_refs;
};

struct latch_tree_ops {
    bool (*less)(struct latch_tree_node *, struct latch_tree_node *);
    int (*comp)(void *, struct latch_tree_node *);
};

struct latch_tree_root {
    seqcount_latch_t seq;
    struct rb_root tree[2];
};

struct latched_seq {
    seqcount_latch_t latch;
    u64 val[2];
};

struct latency_record {
    long unsigned int backtrace[12];
    unsigned int count;
    long unsigned int time;
    long unsigned int max;
};

struct sched_domain;

struct lb_env {
    struct sched_domain *sd;
    struct rq *src_rq;
    int src_cpu;
    int dst_cpu;
    struct rq *dst_rq;
    struct cpumask *dst_grpmask;
    int new_dst_cpu;
    enum cpu_idle_type idle;
    long int imbalance;
    struct cpumask *cpus;
    unsigned int flags;
    unsigned int loop;
    unsigned int loop_break;
    unsigned int loop_max;
    enum fbq_type fbq_type;
    enum migration_type migration_type;
    struct list_head tasks;
};

struct ld_semaphore {
    atomic_long_t count;
    raw_spinlock_t wait_lock;
    unsigned int wait_readers;
    struct list_head read_wait;
    struct list_head write_wait;
};

struct ldsem_waiter {
    struct list_head list;
    struct task_struct *task;
};

struct leaf_walk_data {
    kvm_pte_t pte;
    s8 level;
};

struct lease_manager_operations {
    bool (*lm_break)(struct file_lease *);
    int (*lm_change)(struct file_lease *, int, struct list_head *);
    void (*lm_setup)(struct file_lease *, void **);
    bool (*lm_breaker_owns_lease)(struct file_lease *);
};

struct mc_subled;

struct led_classdev_mc {
    struct led_classdev led_cdev;
    unsigned int num_colors;
    struct mc_subled *subled_info;
};

struct led_hw_trigger_type {
    int dummy;
};

struct led_init_data {
    struct fwnode_handle *fwnode;
    const char *default_label;
    const char *devicename;
    bool devname_mandatory;
};

struct led_lookup_data {
    struct list_head list;
    const char *provider;
    const char *dev_id;
    const char *con_id;
};

struct led_pattern {
    u32 delta_t;
    int brightness;
};

struct led_properties {
    u32 color;
    bool color_present;
    const char *function;
    u32 func_enum;
    bool func_enum_present;
    const char *label;
};

struct led_trigger_cpu {
    bool is_active;
    char name[8];
    struct led_trigger *_trig;
};

struct legacy_fs_context {
    char *legacy_data;
    size_t data_size;
    enum legacy_fs_param param_type;
};

struct level_datum {
    struct mls_level level;
    unsigned char isalias;
};

struct limit_names {
    const char *name;
    const char *unit;
};

struct linereq;

struct line {
    struct gpio_desc *desc;
    struct linereq *req;
    unsigned int irq;
    u64 edflags;
    u64 timestamp_ns;
    u32 req_seqno;
    u32 line_seqno;
    struct delayed_work work;
    unsigned int sw_debounced;
    unsigned int level;
};

struct linear_range {
    unsigned int min;
    unsigned int min_sel;
    unsigned int max_sel;
    unsigned int step;
};

struct lineevent_state {
    struct gpio_device *gdev;
    const char *label;
    struct gpio_desc *desc;
    u32 eflags;
    int irq;
    wait_queue_head_t wait;
    struct notifier_block device_unregistered_nb;
    struct {
        union {
            struct __kfifo kfifo;
            struct gpioevent_data *type;
            const struct gpioevent_data *const_type;
            char (*rectype)[0];
            struct gpioevent_data *ptr;
            const struct gpioevent_data *ptr_const;
        };
        struct gpioevent_data buf[16];
    } events;
    u64 timestamp;
};

struct linehandle_state {
    struct gpio_device *gdev;
    const char *label;
    struct gpio_desc *descs[64];
    u32 num_descs;
};

struct lineinfo_changed_ctx {
    struct work_struct work;
    struct gpio_v2_line_info_changed chg;
    struct gpio_device *gdev;
    struct gpio_chardev_data *cdev;
};

struct linereq {
    struct gpio_device *gdev;
    const char *label;
    u32 num_lines;
    wait_queue_head_t wait;
    struct notifier_block device_unregistered_nb;
    u32 event_buffer_size;
    struct {
        union {
            struct __kfifo kfifo;
            struct gpio_v2_line_event *type;
            const struct gpio_v2_line_event *const_type;
            char (*rectype)[0];
            struct gpio_v2_line_event *ptr;
            const struct gpio_v2_line_event *ptr_const;
        };
        struct gpio_v2_line_event buf[0];
    } events;
    atomic_t seqno;
    struct mutex config_mutex;
    struct line lines[0];
};

struct linger {
    int l_onoff;
    int l_linger;
};

struct link_mode_info {
    int speed;
    u8 lanes;
    u8 duplex;
};

struct linked_reg {
    u8 frameno;
    union {
        u8 spi;
        u8 regno;
    };
    bool is_reg;
};

struct linked_regs {
    int cnt;
    struct linked_reg entries[6];
};

struct linkinfo_reply_data {
    struct ethnl_reply_data base;
    struct ethtool_link_ksettings ksettings;
    struct ethtool_link_settings *lsettings;
};

struct linkmodes_reply_data {
    struct ethnl_reply_data base;
    struct ethtool_link_ksettings ksettings;
    struct ethtool_link_settings *lsettings;
    bool peer_empty;
};

struct linkstate_reply_data {
    struct ethnl_reply_data base;
    int link;
    int sqi;
    int sqi_max;
    struct ethtool_link_ext_stats link_stats;
    bool link_ext_state_provided;
    struct ethtool_link_ext_state_info ethtool_link_ext_state_info;
};

struct linux_binprm;

struct linux_binfmt {
    struct list_head lh;
    struct module *module;
    int (*load_binary)(struct linux_binprm *);
    int (*load_shlib)(struct file *);
    int (*core_dump)(struct coredump_params *);
    long unsigned int min_coredump;
};

struct linux_binprm {
    struct vm_area_struct *vma;
    long unsigned int vma_pages;
    long unsigned int argmin;
    struct mm_struct *mm;
    long unsigned int p;
    unsigned int have_execfd: 1;
    unsigned int execfd_creds: 1;
    unsigned int secureexec: 1;
    unsigned int point_of_no_return: 1;
    unsigned int comm_from_dentry: 1;
    unsigned int is_check: 1;
    struct file *executable;
    struct file *interpreter;
    struct file *file;
    struct cred *cred;
    int unsafe;
    unsigned int per_clear;
    int argc;
    int envc;
    const char *filename;
    const char *interp;
    const char *fdpath;
    unsigned int interp_flags;
    int execfd;
    long unsigned int loader;
    long unsigned int exec;
    struct rlimit rlim_stack;
    char buf[256];
};

struct linux_binprm__safe_trusted {
    struct file *file;
};

struct linux_dirent {
    long unsigned int d_ino;
    long unsigned int d_off;
    short unsigned int d_reclen;
    char d_name[0];
};

struct linux_dirent64 {
    u64 d_ino;
    s64 d_off;
    short unsigned int d_reclen;
    unsigned char d_type;
    char d_name[0];
};

struct linux_efi_initrd {
    long unsigned int base;
    long unsigned int size;
};

struct linux_efi_memreserve {
    int size;
    atomic_t count;
    phys_addr_t next;
    struct {
        phys_addr_t base;
        phys_addr_t size;
    } entry[0];
};

struct linux_efi_random_seed {
    u32 size;
    u8 bits[0];
};

struct linux_efi_tpm_eventlog {
    u32 size;
    u32 final_events_preboot_size;
    u8 version;
    u8 log[0];
};

struct linux_logo {
    int type;
    unsigned int width;
    unsigned int height;
    unsigned int clutsize;
    const unsigned char *clut;
    const unsigned char *data;
};

struct linux_mib {
    long unsigned int mibs[133];
};

struct linux_tls_mib {
    long unsigned int mibs[18];
};

struct linux_xfrm_mib {
    long unsigned int mibs[33];
};

struct lirc_scancode {
    __u64 timestamp;
    __u16 flags;
    __u16 rc_proto;
    __u32 keycode;
    __u64 scancode;
};

struct lirc_fh {
    struct list_head list;
    struct rc_dev *rc;
    int carrier_low;
    struct {
        union {
            struct __kfifo kfifo;
            unsigned int *type;
            const unsigned int *const_type;
            char (*rectype)[0];
            unsigned int *ptr;
            const unsigned int *ptr_const;
        };
        unsigned int buf[0];
    } rawir;
    struct {
        union {
            struct __kfifo kfifo;
            struct lirc_scancode *type;
            const struct lirc_scancode *const_type;
            char (*rectype)[0];
            struct lirc_scancode *ptr;
            const struct lirc_scancode *ptr_const;
        };
        struct lirc_scancode buf[0];
    } scancodes;
    wait_queue_head_t wait_poll;
    u8 send_mode;
    u8 rec_mode;
};

struct list_lru_node;

struct list_lru {
    struct list_lru_node *node;
    struct list_head list;
    int shrinker_id;
    bool memcg_aware;
    struct xarray xa;
};

struct list_lru_one {
    struct list_head list;
    long int nr_items;
    spinlock_t lock;
};

struct list_lru_memcg {
    struct callback_head rcu;
    struct list_lru_one node[0];
};

struct list_lru_node {
    struct list_lru_one lru;
    atomic_long_t nr_items;
    long: 64;
    long: 64;
    long: 64;
};

struct listener {
    struct list_head list;
    pid_t pid;
    char valid;
};

struct listener_list {
    struct rw_semaphore sem;
    struct list_head list;
};

struct listeners {
    struct callback_head rcu;
    long unsigned int masks[0];
};

struct load_info {
    const char *name;
    struct module *mod;
    Elf64_Ehdr *hdr;
    long unsigned int len;
    Elf64_Shdr *sechdrs;
    char *secstrings;
    char *strtab;
    long unsigned int symoffs;
    long unsigned int stroffs;
    long unsigned int init_typeoffs;
    long unsigned int core_typeoffs;
    bool sig_ok;
    long unsigned int mod_kallsyms_init_off;
    struct page **pages;
    unsigned int max_pages;
    unsigned int used_pages;
    struct {
        unsigned int sym;
        unsigned int str;
        unsigned int mod;
        unsigned int vers;
        unsigned int info;
        unsigned int pcpu;
        unsigned int vers_ext_crc;
        unsigned int vers_ext_name;
    } index;
};

struct location;

struct loc_track {
    long unsigned int max;
    long unsigned int count;
    struct location *loc;
    loff_t idx;
};

struct local_ports {
    u32 range;
    bool warned;
};

struct location {
    depot_stack_handle_t handle;
    long unsigned int count;
    long unsigned int addr;
    long unsigned int waste;
    long long int sum_time;
    long int min_time;
    long int max_time;
    long int min_pid;
    long int max_pid;
    long unsigned int cpus[4];
    nodemask_t nodes;
};

struct lock_manager_operations {
    void *lm_mod_owner;
    fl_owner_t (*lm_get_owner)(fl_owner_t);
    void (*lm_put_owner)(fl_owner_t);
    void (*lm_notify)(struct file_lock *);
    int (*lm_grant)(struct file_lock *, int);
    bool (*lm_lock_expirable)(struct file_lock *);
    void (*lm_expire_lock)(void);
};

struct locks_iterator {
    int li_cpu;
    loff_t li_pos;
};

struct logic_pio_host_ops {
    u32 (*in)(void *, long unsigned int, size_t);
    void (*out)(void *, long unsigned int, u32, size_t);
    u32 (*ins)(void *, long unsigned int, void *, size_t, unsigned int);
    void (*outs)(void *, long unsigned int, const void *, size_t, unsigned int);
};

struct logic_pio_hwaddr {
    struct list_head list;
    const struct fwnode_handle *fwnode;
    resource_size_t hw_start;
    resource_size_t io_start;
    resource_size_t size;
    long unsigned int flags;
    void *hostdata;
    const struct logic_pio_host_ops *ops;
};

struct logo_data {
    int depth;
    int needs_directpalette;
    int needs_truepalette;
    int needs_cmapreset;
    const struct linux_logo *logo;
};

struct lookup_args {
    int offset;
    const struct in6_addr *addr;
};

struct loop_cmd {
    struct list_head list_entry;
    bool use_aio;
    atomic_t ref;
    long int ret;
    struct kiocb iocb;
    struct bio_vec *bvec;
    struct cgroup_subsys_state *blkcg_css;
    struct cgroup_subsys_state *memcg_css;
};

struct loop_info64 {
    __u64 lo_device;
    __u64 lo_inode;
    __u64 lo_rdevice;
    __u64 lo_offset;
    __u64 lo_sizelimit;
    __u32 lo_number;
    __u32 lo_encrypt_type;
    __u32 lo_encrypt_key_size;
    __u32 lo_flags;
    __u8 lo_file_name[64];
    __u8 lo_crypt_name[64];
    __u8 lo_encrypt_key[32];
    __u64 lo_init[2];
};

struct loop_config {
    __u32 fd;
    __u32 block_size;
    struct loop_info64 info;
    __u64 __reserved[8];
};

struct loop_device {
    int lo_number;
    loff_t lo_offset;
    loff_t lo_sizelimit;
    int lo_flags;
    char lo_file_name[64];
    struct file *lo_backing_file;
    struct block_device *lo_device;
    gfp_t old_gfp_mask;
    spinlock_t lo_lock;
    int lo_state;
    spinlock_t lo_work_lock;
    struct workqueue_struct *workqueue;
    struct work_struct rootcg_work;
    struct list_head rootcg_cmd_list;
    struct list_head idle_worker_list;
    struct rb_root worker_tree;
    struct timer_list timer;
    bool sysfs_inited;
    struct request_queue *lo_queue;
    struct blk_mq_tag_set tag_set;
    struct gendisk *lo_disk;
    struct mutex lo_mutex;
    bool idr_visible;
};

struct loop_info {
    int lo_number;
    __kernel_old_dev_t lo_device;
    long unsigned int lo_inode;
    __kernel_old_dev_t lo_rdevice;
    int lo_offset;
    int lo_encrypt_type;
    int lo_encrypt_key_size;
    int lo_flags;
    char lo_name[64];
    unsigned char lo_encrypt_key[32];
    long unsigned int lo_init[2];
    char reserved[4];
};

struct loop_worker {
    struct rb_node rb_node;
    struct work_struct work;
    struct list_head cmd_list;
    struct list_head idle_list;
    struct loop_device *lo;
    struct cgroup_subsys_state *blkcg_css;
    long unsigned int last_ran_at;
};

union lower_chunk {
    union lower_chunk *next;
    long unsigned int data[256];
};

struct lpi_range {
    struct list_head entry;
    u32 base_id;
    u32 span;
};

struct lpm_trie_node;

struct lpm_trie {
    struct bpf_map map;
    struct lpm_trie_node *root;
    struct bpf_mem_alloc ma;
    size_t n_entries;
    size_t max_prefixlen;
    size_t data_size;
    raw_spinlock_t lock;
};

struct lpm_trie_node {
    struct lpm_trie_node *child[2];
    u32 prefixlen;
    u32 flags;
    u8 data[0];
};

struct lru_gen_folio {
    long unsigned int max_seq;
    long unsigned int min_seq[2];
    long unsigned int timestamps[4];
    struct list_head folios[32];
    long int nr_pages[32];
    long unsigned int avg_refaulted[8];
    long unsigned int avg_total[8];
    long unsigned int protected[8];
    atomic_long_t evicted[8];
    atomic_long_t refaulted[8];
    bool enabled;
    u8 gen;
    u8 seg;
    struct hlist_nulls_node list;
};

struct lru_gen_memcg {
    long unsigned int seq;
    long unsigned int nr_memcgs[3];
    struct hlist_nulls_head fifo[24];
    spinlock_t lock;
};

struct lru_gen_mm_list {
    struct list_head fifo;
    spinlock_t lock;
};

struct lru_gen_mm_state {
    long unsigned int seq;
    struct list_head *head;
    struct list_head *tail;
    long unsigned int *filters[2];
    long unsigned int stats[4];
};

struct lruvec;

struct lru_gen_mm_walk {
    struct lruvec *lruvec;
    long unsigned int seq;
    long unsigned int next_addr;
    int nr_pages[32];
    int mm_stats[4];
    int batched;
    int swappiness;
    bool force_scan;
};

struct zswap_lruvec_state {
    atomic_long_t nr_disk_swapins;
};

struct pglist_data;

struct lruvec {
    struct list_head lists[5];
    spinlock_t lru_lock;
    long unsigned int anon_cost;
    long unsigned int file_cost;
    atomic_long_t nonresident_age;
    long unsigned int refaults[2];
    long unsigned int flags;
    struct lru_gen_folio lrugen;
    struct lru_gen_mm_state mm_state;
    struct pglist_data *pgdat;
    struct zswap_lruvec_state zswap_lruvec_state;
};

struct lruvec_stats {
    long int state[31];
    long int state_local[31];
    long int state_pending[31];
};

struct lruvec_stats_percpu {
    long int state[31];
    long int state_prev[31];
};

struct skcipher_alg_common {
    unsigned int min_keysize;
    unsigned int max_keysize;
    unsigned int ivsize;
    unsigned int chunksize;
    unsigned int statesize;
    struct crypto_alg base;
};

struct lskcipher_alg {
    int (*setkey)(struct crypto_lskcipher *, const u8 *, unsigned int);
    int (*encrypt)(struct crypto_lskcipher *, const u8 *, u8 *, unsigned int, u8 *, u32);
    int (*decrypt)(struct crypto_lskcipher *, const u8 *, u8 *, unsigned int, u8 *, u32);
    int (*init)(struct crypto_lskcipher *);
    void (*exit)(struct crypto_lskcipher *);
    struct skcipher_alg_common co;
};

struct lskcipher_instance {
    void (*free)(struct lskcipher_instance *);
    union {
        struct {
            char head[64];
            struct crypto_instance base;
        } s;
        struct lskcipher_alg alg;
    };
};

struct lsm_blob_sizes {
    int lbs_cred;
    int lbs_file;
    int lbs_ib;
    int lbs_inode;
    int lbs_sock;
    int lbs_superblock;
    int lbs_ipc;
    int lbs_key;
    int lbs_msg_msg;
    int lbs_perf_event;
    int lbs_task;
    int lbs_xattr_count;
    int lbs_tun_dev;
    int lbs_bdev;
    bool lbs_secmark;
};

struct lsm_context {
    char *context;
    u32 len;
    int id;
};

struct lsm_ctx {
    __u64 id;
    __u64 flags;
    __u64 len;
    __u64 ctx_len;
    __u8 ctx[0];
};

struct lsm_ibendport_audit {
    const char *dev_name;
    u8 port;
};

struct lsm_ibpkey_audit {
    u64 subnet_prefix;
    u16 pkey;
};

struct lsm_id {
    const char *name;
    u64 id;
    bool lsmprop;
};

struct lsm_info {
    const char *name;
    enum lsm_order order;
    long unsigned int flags;
    int *enabled;
    int (*init)(void);
    struct lsm_blob_sizes *blobs;
};

struct lsm_ioctlop_audit {
    struct path path;
    u16 cmd;
};

struct lsm_network_audit {
    int netif;
    const struct sock *sk;
    u16 family;
    __be16 dport;
    __be16 sport;
    union {
        struct {
            __be32 daddr;
            __be32 saddr;
        } v4;
        struct {
            struct in6_addr daddr;
            struct in6_addr saddr;
        } v6;
    } fam;
};

struct lwq {
    spinlock_t lock;
    struct llist_node *ready;
    struct llist_head new;
};

struct lwq_node {
    struct llist_node node;
};

struct lwtunnel_encap_ops {
    int (*build_state)(struct net *, struct nlattr *, unsigned int, const void *, struct lwtunnel_state **, struct netlink_ext_ack *);
    void (*destroy_state)(struct lwtunnel_state *);
    int (*output)(struct net *, struct sock *, struct sk_buff *);
    int (*input)(struct sk_buff *);
    int (*fill_encap)(struct sk_buff *, struct lwtunnel_state *);
    int (*get_encap_size)(struct lwtunnel_state *);
    int (*cmp_encap)(struct lwtunnel_state *, struct lwtunnel_state *);
    int (*xmit)(struct sk_buff *);
    struct module *owner;
};

struct lwtunnel_state {
    __u16 type;
    __u16 flags;
    __u16 headroom;
    atomic_t refcnt;
    int (*orig_output)(struct net *, struct sock *, struct sk_buff *);
    int (*orig_input)(struct sk_buff *);
    struct callback_head rcu;
    __u8 data[0];
};

struct lz4_comp_opts {
    __le32 version;
    __le32 flags;
};

struct lzma2_dec {
    enum lzma2_seq sequence;
    enum lzma2_seq next_sequence;
    uint32_t uncompressed;
    uint32_t compressed;
    bool need_dict_reset;
    bool need_props;
    bool pedantic_microlzma;
};

struct lzma_len_dec {
    uint16_t choice;
    uint16_t choice2;
    uint16_t low[128];
    uint16_t mid[128];
    uint16_t high[256];
};

struct lzma_dec {
    uint32_t rep0;
    uint32_t rep1;
    uint32_t rep2;
    uint32_t rep3;
    enum lzma_state state;
    uint32_t len;
    uint32_t lc;
    uint32_t literal_pos_mask;
    uint32_t pos_mask;
    uint16_t is_match[192];
    uint16_t is_rep[12];
    uint16_t is_rep0[12];
    uint16_t is_rep1[12];
    uint16_t is_rep2[12];
    uint16_t is_rep0_long[192];
    uint16_t dist_slot[256];
    uint16_t dist_special[114];
    uint16_t dist_align[16];
    struct lzma_len_dec match_len_dec;
    struct lzma_len_dec rep_len_dec;
    uint16_t literal[12288];
};

struct lzma_header {
    uint8_t pos;
    uint32_t dict_size;
    uint64_t dst_size;
} __attribute__((packed));

struct lzo_ctx {
    void *lzo_comp_mem;
};

struct lzorle_ctx {
    void *lzorle_comp_mem;
};

struct ma_topiary {
    struct maple_enode *head;
    struct maple_enode *tail;
    struct maple_tree *mtree;
};

struct maple_node;

struct ma_wr_state {
    struct ma_state *mas;
    struct maple_node *node;
    long unsigned int r_min;
    long unsigned int r_max;
    enum maple_type type;
    unsigned char offset_end;
    long unsigned int *pivots;
    long unsigned int end_piv;
    void **slots;
    void *entry;
    void *content;
};

struct mac_addr {
    unsigned char addr[6];
};

typedef struct mac_addr mac_addr;

struct mac_address {
    u8 addr[6];
};

struct mac_driver_desc {
    __be16 signature;
    __be16 block_size;
    __be32 block_count;
};

struct mac_partition {
    __be16 signature;
    __be16 res1;
    __be32 map_count;
    __be32 start_block;
    __be32 block_count;
    char name[32];
    char type[32];
    __be32 data_start;
    __be32 data_count;
    __be32 status;
    __be32 boot_start;
    __be32 boot_size;
    __be32 boot_load;
    __be32 boot_load2;
    __be32 boot_entry;
    __be32 boot_entry2;
    __be32 boot_cksum;
    char processor[16];
};

struct macsec_secy;

struct macsec_rx_sc;

struct macsec_rx_sa;

struct macsec_tx_sa;

struct macsec_tx_sc_stats;

struct macsec_tx_sa_stats;

struct macsec_rx_sc_stats;

struct macsec_rx_sa_stats;

struct macsec_dev_stats;

struct macsec_context {
    union {
        struct net_device *netdev;
        struct phy_device *phydev;
    };
    enum macsec_offload offload;
    struct macsec_secy *secy;
    struct macsec_rx_sc *rx_sc;
    struct {
        bool update_pn;
        unsigned char assoc_num;
        u8 key[128];
        union {
            struct macsec_rx_sa *rx_sa;
            struct macsec_tx_sa *tx_sa;
        };
    } sa;
    union {
        struct macsec_tx_sc_stats *tx_sc_stats;
        struct macsec_tx_sa_stats *tx_sa_stats;
        struct macsec_rx_sc_stats *rx_sc_stats;
        struct macsec_rx_sa_stats *rx_sa_stats;
        struct macsec_dev_stats *dev_stats;
    } stats;
};

struct macsec_dev_stats {
    __u64 OutPktsUntagged;
    __u64 InPktsUntagged;
    __u64 OutPktsTooLong;
    __u64 InPktsNoTag;
    __u64 InPktsBadTag;
    __u64 InPktsUnknownSCI;
    __u64 InPktsNoSCI;
    __u64 InPktsOverrun;
};

struct macsec_info {
    sci_t sci;
};

union salt {
    struct {
        ssci_t ssci;
        __be64 pn;
    } __attribute__((packed));
    u8 bytes[12];
};

typedef union salt salt_t;

struct macsec_key {
    u8 id[16];
    struct crypto_aead *tfm;
    salt_t salt;
};

struct macsec_ops {
    int (*mdo_dev_open)(struct macsec_context *);
    int (*mdo_dev_stop)(struct macsec_context *);
    int (*mdo_add_secy)(struct macsec_context *);
    int (*mdo_upd_secy)(struct macsec_context *);
    int (*mdo_del_secy)(struct macsec_context *);
    int (*mdo_add_rxsc)(struct macsec_context *);
    int (*mdo_upd_rxsc)(struct macsec_context *);
    int (*mdo_del_rxsc)(struct macsec_context *);
    int (*mdo_add_rxsa)(struct macsec_context *);
    int (*mdo_upd_rxsa)(struct macsec_context *);
    int (*mdo_del_rxsa)(struct macsec_context *);
    int (*mdo_add_txsa)(struct macsec_context *);
    int (*mdo_upd_txsa)(struct macsec_context *);
    int (*mdo_del_txsa)(struct macsec_context *);
    int (*mdo_get_dev_stats)(struct macsec_context *);
    int (*mdo_get_tx_sc_stats)(struct macsec_context *);
    int (*mdo_get_tx_sa_stats)(struct macsec_context *);
    int (*mdo_get_rx_sc_stats)(struct macsec_context *);
    int (*mdo_get_rx_sa_stats)(struct macsec_context *);
    int (*mdo_insert_tx_tag)(struct phy_device *, struct sk_buff *);
    unsigned int needed_headroom;
    unsigned int needed_tailroom;
    bool rx_uses_md_dst;
};

union pn {
    struct {
        u32 lower;
        u32 upper;
    };
    u64 full64;
};

typedef union pn pn_t;

struct macsec_rx_sa {
    struct macsec_key key;
    ssci_t ssci;
    spinlock_t lock;
    union {
        pn_t next_pn_halves;
        u64 next_pn;
    };
    refcount_t refcnt;
    bool active;
    struct macsec_rx_sa_stats *stats;
    struct macsec_rx_sc *sc;
    struct callback_head rcu;
};

struct macsec_rx_sa_stats {
    __u32 InPktsOK;
    __u32 InPktsInvalid;
    __u32 InPktsNotValid;
    __u32 InPktsNotUsingSA;
    __u32 InPktsUnusedSA;
};

struct pcpu_rx_sc_stats;

struct macsec_rx_sc {
    struct macsec_rx_sc *next;
    sci_t sci;
    bool active;
    struct macsec_rx_sa *sa[4];
    struct pcpu_rx_sc_stats *stats;
    refcount_t refcnt;
    struct callback_head callback_head;
};

struct macsec_rx_sc_stats {
    __u64 InOctetsValidated;
    __u64 InOctetsDecrypted;
    __u64 InPktsUnchecked;
    __u64 InPktsDelayed;
    __u64 InPktsOK;
    __u64 InPktsInvalid;
    __u64 InPktsLate;
    __u64 InPktsNotValid;
    __u64 InPktsNotUsingSA;
    __u64 InPktsUnusedSA;
};

struct pcpu_tx_sc_stats;

struct macsec_tx_sc {
    bool active;
    u8 encoding_sa;
    bool encrypt;
    bool send_sci;
    bool end_station;
    bool scb;
    struct macsec_tx_sa *sa[4];
    struct pcpu_tx_sc_stats *stats;
    struct metadata_dst *md_dst;
};

struct macsec_secy {
    struct net_device *netdev;
    unsigned int n_rx_sc;
    sci_t sci;
    u16 key_len;
    u16 icv_len;
    enum macsec_validation_type validate_frames;
    bool xpn;
    bool operational;
    bool protect_frames;
    bool replay_protect;
    u32 replay_window;
    struct macsec_tx_sc tx_sc;
    struct macsec_rx_sc *rx_sc;
};

struct macsec_tx_sa {
    struct macsec_key key;
    ssci_t ssci;
    spinlock_t lock;
    union {
        pn_t next_pn_halves;
        u64 next_pn;
    };
    refcount_t refcnt;
    bool active;
    struct macsec_tx_sa_stats *stats;
    struct callback_head rcu;
};

struct macsec_tx_sa_stats {
    __u32 OutPktsProtected;
    __u32 OutPktsEncrypted;
};

struct macsec_tx_sc_stats {
    __u64 OutPktsProtected;
    __u64 OutPktsEncrypted;
    __u64 OutOctetsProtected;
    __u64 OutOctetsEncrypted;
};

struct mmu_gather;

struct madvise_walk_private {
    struct mmu_gather *tlb;
    bool pageout;
};

struct mafield {
    const char *prefix;
    int field;
};

struct map_files_info {
    long unsigned int start;
    long unsigned int end;
    fmode_t mode;
};

struct map_info {
    struct map_info *next;
    struct mm_struct *mm;
    long unsigned int vaddr;
};

struct map_iter {
    void *key;
    bool done;
};

struct maple_alloc {
    long unsigned int total;
    unsigned char node_count;
    unsigned int request_count;
    struct maple_alloc *slot[30];
};

struct maple_pnode;

struct maple_metadata {
    unsigned char end;
    unsigned char gap;
};

struct maple_arange_64 {
    struct maple_pnode *parent;
    long unsigned int pivot[9];
    void *slot[10];
    long unsigned int gap[10];
    struct maple_metadata meta;
};

struct maple_big_node {
    long unsigned int pivot[33];
    union {
        struct maple_enode *slot[34];
        struct {
            long unsigned int padding[21];
            long unsigned int gap[21];
        };
    };
    unsigned char b_end;
    enum maple_type type;
};

struct maple_range_64 {
    struct maple_pnode *parent;
    long unsigned int pivot[15];
    union {
        void *slot[16];
        struct {
            void *pad[15];
            struct maple_metadata meta;
        };
    };
};

struct maple_node {
    union {
        struct {
            struct maple_pnode *parent;
            void *slot[31];
        };
        struct {
            void *pad;
            struct callback_head rcu;
            struct maple_enode *piv_parent;
            unsigned char parent_slot;
            enum maple_type type;
            unsigned char slot_len;
            unsigned int ma_flags;
        };
        struct maple_range_64 mr64;
        struct maple_arange_64 ma64;
        struct maple_alloc alloc;
    };
};

struct maple_subtree_state {
    struct ma_state *orig_l;
    struct ma_state *orig_r;
    struct ma_state *l;
    struct ma_state *m;
    struct ma_state *r;
    struct ma_topiary *free;
    struct ma_topiary *destroy;
    struct maple_big_node *bn;
};

struct maple_topiary {
    struct maple_pnode *parent;
    struct maple_enode *next;
};

struct match {
    u32 mode;
    u32 area;
    u8 depth;
};

struct match_addr {
    const char *addrp;
    enum addr_type addrtype;
    int len;
    __be16 port;
};

struct match_token {
    int token;
    const char *pattern;
};

struct match_workbuf {
    unsigned int count;
    unsigned int pos;
    unsigned int len;
    unsigned int size;
    unsigned int history[24];
};

struct mb_cache {
    struct hlist_bl_head *c_hash;
    int c_bucket_bits;
    long unsigned int c_max_entries;
    spinlock_t c_list_lock;
    struct list_head c_list;
    long unsigned int c_entry_count;
    struct shrinker *c_shrink;
    struct work_struct c_shrink_work;
};

struct mb_cache_entry {
    struct list_head e_list;
    struct hlist_bl_node e_hash_list;
    atomic_t e_refcnt;
    u32 e_key;
    long unsigned int e_flags;
    u64 e_value;
};

struct mbi_range {
    u32 spi_start;
    u32 nr_spis;
    long unsigned int *bm;
};

struct mbox_client;

struct mbox_chan {
    struct mbox_controller *mbox;
    unsigned int txdone_method;
    struct mbox_client *cl;
    struct completion tx_complete;
    void *active_req;
    unsigned int msg_count;
    unsigned int msg_free;
    void *msg_data[20];
    spinlock_t lock;
    void *con_priv;
};

struct mbox_chan_ops {
    int (*send_data)(struct mbox_chan *, void *);
    int (*flush)(struct mbox_chan *, long unsigned int);
    int (*startup)(struct mbox_chan *);
    void (*shutdown)(struct mbox_chan *);
    bool (*last_tx_done)(struct mbox_chan *);
    bool (*peek_data)(struct mbox_chan *);
};

struct mbox_client {
    struct device *dev;
    bool tx_block;
    long unsigned int tx_tout;
    bool knows_txdone;
    void (*rx_callback)(struct mbox_client *, void *);
    void (*tx_prepare)(struct mbox_client *, void *);
    void (*tx_done)(struct mbox_client *, void *, int);
};

struct mc_subled {
    unsigned int color_index;
    unsigned int brightness;
    unsigned int intensity;
    unsigned int channel;
};

struct mcs_spinlock {
    struct mcs_spinlock *next;
    int locked;
    int count;
};

struct mctrl_gpios {
    struct uart_port *port;
    struct gpio_desc *gpio[6];
    int irq[6];
    unsigned int mctrl_prev;
    bool mctrl_on;
};

struct md5_state {
    u32 hash[4];
    u32 block[16];
    u64 byte_count;
};

struct mdio_board_info {
    const char *bus_id;
    char modalias[32];
    int mdio_addr;
    const void *platform_data;
};

struct mdio_board_entry {
    struct list_head list;
    struct mdio_board_info board_info;
};

struct mdio_bus_stat_attr {
    int addr;
    unsigned int field_offset;
};

struct mdio_bus_stats {
    u64_stats_t transfers;
    u64_stats_t errors;
    u64_stats_t writes;
    u64_stats_t reads;
    struct u64_stats_sync syncp;
};

struct mdio_device {
    struct device dev;
    struct mii_bus *bus;
    char modalias[32];
    int (*bus_match)(struct device *, const struct device_driver *);
    void (*device_free)(struct mdio_device *);
    void (*device_remove)(struct mdio_device *);
    int addr;
    int flags;
    int reset_state;
    struct gpio_desc *reset_gpio;
    struct reset_control *reset_ctrl;
    unsigned int reset_assert_delay;
    unsigned int reset_deassert_delay;
};

struct mdio_device_id {
    __u32 phy_id;
    __u32 phy_id_mask;
};

struct mdio_driver_common {
    struct device_driver driver;
    int flags;
};

struct mdio_driver {
    struct mdio_driver_common mdiodrv;
    int (*probe)(struct mdio_device *);
    void (*remove)(struct mdio_device *);
    void (*shutdown)(struct mdio_device *);
};

struct mdiobus_devres {
    struct mii_bus *mii;
};

struct mem_cgroup_id {
    int id;
    refcount_t ref;
};

struct vmpressure {
    long unsigned int scanned;
    long unsigned int reclaimed;
    long unsigned int tree_scanned;
    long unsigned int tree_reclaimed;
    spinlock_t sr_lock;
    struct list_head events;
    struct mutex events_lock;
    struct work_struct work;
};

struct wb_domain {
    spinlock_t lock;
    struct fprop_global completions;
    struct timer_list period_timer;
    long unsigned int period_time;
    long unsigned int dirty_limit_tstamp;
    long unsigned int dirty_limit;
};

struct wb_completion {
    atomic_t cnt;
    wait_queue_head_t *waitq;
};

struct memcg_cgwb_frn {
    u64 bdi_id;
    int memcg_id;
    u64 at;
    struct wb_completion done;
};

struct memcg_vmstats;

struct memcg_vmstats_percpu;

struct mem_cgroup_per_node;

struct mem_cgroup {
    struct cgroup_subsys_state css;
    struct mem_cgroup_id id;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    struct page_counter memory;
    union {
        struct page_counter swap;
        struct page_counter memsw;
    };
    struct list_head memory_peaks;
    struct list_head swap_peaks;
    spinlock_t peaks_lock;
    struct work_struct high_work;
    long unsigned int zswap_max;
    bool zswap_writeback;
    struct vmpressure vmpressure;
    bool oom_group;
    int swappiness;
    struct cgroup_file events_file;
    struct cgroup_file events_local_file;
    struct cgroup_file swap_events_file;
    struct memcg_vmstats *vmstats;
    atomic_long_t memory_events[9];
    atomic_long_t memory_events_local[9];
    long unsigned int socket_pressure;
    int kmemcg_id;
    struct obj_cgroup *objcg;
    struct obj_cgroup *orig_objcg;
    struct list_head objcg_list;
    struct memcg_vmstats_percpu *vmstats_percpu;
    struct list_head cgwb_list;
    struct wb_domain cgwb_domain;
    struct memcg_cgwb_frn cgwb_frn[4];
    struct deferred_split deferred_split_queue;
    struct lru_gen_mm_list mm_list;
    struct mem_cgroup_per_node *nodeinfo[0];
    long: 64;
    long: 64;
    long: 64;
    long: 64;
};

struct mem_cgroup_reclaim_iter {
    struct mem_cgroup *position;
    atomic_t generation;
};

struct shrinker_info;

struct mem_cgroup_per_node {
    struct mem_cgroup *memcg;
    struct lruvec_stats_percpu *lruvec_stats_percpu;
    struct lruvec_stats *lruvec_stats;
    struct shrinker_info *shrinker_info;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    struct cacheline_padding _pad1_;
    struct lruvec lruvec;
    long: 64;
    long: 64;
    struct cacheline_padding _pad2_;
    long unsigned int lru_zone_size[20];
    struct mem_cgroup_reclaim_iter iter;
    long: 64;
    long: 64;
};

typedef struct pglist_data pg_data_t;

struct mem_cgroup_reclaim_cookie {
    pg_data_t *pgdat;
    int generation;
};

struct mcidev_sysfs_attribute;

struct mem_ctl_info {
    struct device dev;
    const struct bus_type *bus;
    struct list_head link;
    struct module *owner;
    long unsigned int mtype_cap;
    long unsigned int edac_ctl_cap;
    long unsigned int edac_cap;
    long unsigned int scrub_cap;
    enum scrub_type scrub_mode;
    int (*set_sdram_scrub_rate)(struct mem_ctl_info *, u32);
    int (*get_sdram_scrub_rate)(struct mem_ctl_info *);
    void (*edac_check)(struct mem_ctl_info *);
    long unsigned int (*ctl_page_to_phys)(struct mem_ctl_info *, long unsigned int);
    int mc_idx;
    struct csrow_info **csrows;
    unsigned int nr_csrows;
    unsigned int num_cschannel;
    unsigned int n_layers;
    struct edac_mc_layer *layers;
    bool csbased;
    unsigned int tot_dimms;
    struct dimm_info **dimms;
    struct device *pdev;
    const char *mod_name;
    const char *ctl_name;
    const char *dev_name;
    void *pvt_info;
    long unsigned int start_time;
    u32 ce_noinfo_count;
    u32 ue_noinfo_count;
    u32 ue_mc;
    u32 ce_mc;
    struct completion complete;
    const struct mcidev_sysfs_attribute *mc_driver_sysfs_attributes;
    struct delayed_work work;
    struct edac_raw_error_desc error_desc;
    int op_state;
    struct dentry *debugfs;
    u8 fake_inject_layer[3];
    bool fake_inject_ue;
    u16 fake_inject_count;
};

struct quota_format_type;

struct mem_dqinfo {
    struct quota_format_type *dqi_format;
    int dqi_fmt_id;
    struct list_head dqi_dirty_list;
    long unsigned int dqi_flags;
    unsigned int dqi_bgrace;
    unsigned int dqi_igrace;
    qsize_t dqi_max_spc_limit;
    qsize_t dqi_max_ino_limit;
    void *dqi_priv;
};

struct mem_section_usage;

struct mem_section {
    long unsigned int section_mem_map;
    struct mem_section_usage *usage;
};

struct mem_section_usage {
    struct callback_head rcu;
    long unsigned int subsection_map[1];
    long unsigned int pageblock_flags[0];
};

struct mem_size_stats {
    long unsigned int resident;
    long unsigned int shared_clean;
    long unsigned int shared_dirty;
    long unsigned int private_clean;
    long unsigned int private_dirty;
    long unsigned int referenced;
    long unsigned int anonymous;
    long unsigned int lazyfree;
    long unsigned int anonymous_thp;
    long unsigned int shmem_thp;
    long unsigned int file_thp;
    long unsigned int swap;
    long unsigned int shared_hugetlb;
    long unsigned int private_hugetlb;
    long unsigned int ksm;
    u64 pss;
    u64 pss_anon;
    u64 pss_file;
    u64 pss_shmem;
    u64 pss_dirty;
    u64 pss_locked;
    u64 swap_pss;
};

struct memblock_region;

struct memblock_type {
    long unsigned int cnt;
    long unsigned int max;
    phys_addr_t total_size;
    struct memblock_region *regions;
    char *name;
};

struct memblock {
    bool bottom_up;
    phys_addr_t current_limit;
    struct memblock_type memory;
    struct memblock_type reserved;
};

struct memblock_region {
    phys_addr_t base;
    phys_addr_t size;
    enum memblock_flags flags;
};

struct membuf {
    void *p;
    size_t left;
};

struct memcg_stock_pcp {
    local_lock_t stock_lock;
    struct mem_cgroup *cached;
    unsigned int nr_pages;
    struct obj_cgroup *cached_objcg;
    struct pglist_data *cached_pgdat;
    unsigned int nr_bytes;
    int nr_slab_reclaimable_b;
    int nr_slab_unreclaimable_b;
    struct work_struct work;
    long unsigned int flags;
};

struct memcg_vmstats {
    long int state[38];
    long unsigned int events[24];
    long int state_local[38];
    long unsigned int events_local[24];
    long int state_pending[38];
    long unsigned int events_pending[24];
    atomic64_t stats_updates;
};

struct memcg_vmstats_percpu {
    unsigned int stats_updates;
    struct memcg_vmstats_percpu *parent;
    struct memcg_vmstats *vmstats;
    long int state[38];
    long unsigned int events[24];
    long int state_prev[38];
    long unsigned int events_prev[24];
    long: 64;
};

struct memdev {
    const char *name;
    const struct file_operations *fops;
    fmode_t fmode;
    umode_t mode;
};

struct memory_notify {
    long unsigned int altmap_start_pfn;
    long unsigned int altmap_nr_pages;
    long unsigned int start_pfn;
    long unsigned int nr_pages;
    int status_change_nid_normal;
    int status_change_nid;
};

struct memory_stat {
    const char *name;
    unsigned int idx;
};

struct mempolicy {};

struct menu_device {
    int needs_update;
    int tick_wakeup;
    u64 next_timer_ns;
    unsigned int bucket;
    unsigned int correction_factor[6];
    unsigned int intervals[8];
    int interval_ptr;
};

struct meta_entry {
    u64 data_block;
    unsigned int index_block;
    short unsigned int offset;
    short unsigned int pad;
};

struct meta_index {
    unsigned int inode_number;
    unsigned int offset;
    short unsigned int entries;
    short unsigned int skip;
    short unsigned int locked;
    short unsigned int pad;
    struct meta_entry meta_entry[127];
};

struct xfrm_md_info {
    u32 if_id;
    int link;
    struct dst_entry *dst_orig;
};

struct metadata_dst {
    struct dst_entry dst;
    enum metadata_type type;
    union {
        struct ip_tunnel_info tun_info;
        struct hw_port_info port_info;
        struct macsec_info macsec_info;
        struct xfrm_md_info xfrm_info;
    } u;
};

struct mf6cctl {
    struct sockaddr_in6 mf6cc_origin;
    struct sockaddr_in6 mf6cc_mcastgrp;
    mifi_t mf6cc_parent;
    struct if_set mf6cc_ifset;
};

struct mr_mfc {
    struct rhlist_head mnode;
    short unsigned int mfc_parent;
    int mfc_flags;
    union {
        struct {
            long unsigned int expires;
            struct sk_buff_head unresolved;
        } unres;
        struct {
            long unsigned int last_assert;
            int minvif;
            int maxvif;
            atomic_long_t bytes;
            atomic_long_t pkt;
            atomic_long_t wrong_if;
            long unsigned int lastuse;
            unsigned char ttls[32];
            refcount_t refcount;
        } res;
    } mfc_un;
    struct list_head list;
    struct callback_head rcu;
    void (*free)(struct callback_head *);
};

struct mfc6_cache_cmp_arg {
    struct in6_addr mf6c_mcastgrp;
    struct in6_addr mf6c_origin;
};

struct mfc6_cache {
    struct mr_mfc _c;
    union {
        struct {
            struct in6_addr mf6c_mcastgrp;
            struct in6_addr mf6c_origin;
        };
        struct mfc6_cache_cmp_arg cmparg;
    };
};

struct mfc_cache_cmp_arg {
    __be32 mfc_mcastgrp;
    __be32 mfc_origin;
};

struct mfc_cache {
    struct mr_mfc _c;
    union {
        struct {
            __be32 mfc_mcastgrp;
            __be32 mfc_origin;
        };
        struct mfc_cache_cmp_arg cmparg;
    };
};

struct mfc_entry_notifier_info {
    struct fib_notifier_info info;
    struct mr_mfc *mfc;
    u32 tb_id;
};

struct mfcctl {
    struct in_addr mfcc_origin;
    struct in_addr mfcc_mcastgrp;
    vifi_t mfcc_parent;
    unsigned char mfcc_ttls[32];
    unsigned int mfcc_pkt_cnt;
    unsigned int mfcc_byte_cnt;
    unsigned int mfcc_wrong_if;
    int mfcc_expire;
};

struct mfd_cell_acpi_match;

struct mfd_cell {
    const char *name;
    int id;
    int level;
    int (*suspend)(struct platform_device *);
    int (*resume)(struct platform_device *);
    const void *platform_data;
    size_t pdata_size;
    const struct mfd_cell_acpi_match *acpi_match;
    const struct software_node *swnode;
    const char *of_compatible;
    u64 of_reg;
    bool use_of_reg;
    int num_resources;
    const struct resource *resources;
    bool ignore_resource_conflicts;
    bool pm_runtime_no_callbacks;
    int num_parent_supplies;
    const char * const *parent_supplies;
};

struct mfd_cell_acpi_match {
    const char *pnpid;
    const long long unsigned int adr;
};

struct mfd_of_node_entry {
    struct list_head list;
    struct device *dev;
    struct device_node *np;
};

struct mif6ctl {
    mifi_t mif6c_mifi;
    unsigned char mif6c_flags;
    unsigned char vifc_threshold;
    __u16 mif6c_pifi;
    unsigned int vifc_rate_limit;
};

struct migrate_pages_stats {
    int nr_succeeded;
    int nr_failed_pages;
    int nr_thp_succeeded;
    int nr_thp_failed;
    int nr_thp_split;
    int nr_split;
};

struct migrate_struct {
    ext4_lblk_t first_block;
    ext4_lblk_t last_block;
    ext4_lblk_t curr_block;
    ext4_fsblk_t first_pblock;
    ext4_fsblk_t last_pblock;
};

struct set_affinity_pending;

struct migration_arg {
    struct task_struct *task;
    int dest_cpu;
    struct set_affinity_pending *pending;
};

struct migration_target_control {
    int nid;
    nodemask_t *nmask;
    gfp_t gfp_mask;
    enum migrate_reason reason;
};

struct phy_package_shared;

struct mii_bus {
    struct module *owner;
    const char *name;
    char id[61];
    void *priv;
    int (*read)(struct mii_bus *, int, int);
    int (*write)(struct mii_bus *, int, int, u16);
    int (*read_c45)(struct mii_bus *, int, int, int);
    int (*write_c45)(struct mii_bus *, int, int, int, u16);
    int (*reset)(struct mii_bus *);
    struct mdio_bus_stats stats[32];
    struct mutex mdio_lock;
    struct device *parent;
    enum {
        MDIOBUS_ALLOCATED = 1,
        MDIOBUS_REGISTERED = 2,
        MDIOBUS_UNREGISTERED = 3,
        MDIOBUS_RELEASED = 4,
    } state;
    struct device dev;
    struct mdio_device *mdio_map[32];
    u32 phy_mask;
    u32 phy_ignore_ta_mask;
    int irq[32];
    int reset_delay_us;
    int reset_post_delay_us;
    struct gpio_desc *reset_gpiod;
    struct mutex shared_lock;
    struct phy_package_shared *shared[32];
};

struct mii_if_info {
    int phy_id;
    int advertising;
    int phy_id_mask;
    int reg_num_mask;
    unsigned int full_duplex: 1;
    unsigned int force_media: 1;
    unsigned int supports_gmii: 1;
    struct net_device *dev;
    int (*mdio_read)(struct net_device *, int, int);
    void (*mdio_write)(struct net_device *, int, int, int);
};

struct mii_ioctl_data {
    __u16 phy_id;
    __u16 reg_num;
    __u16 val_in;
    __u16 val_out;
};

struct mii_timestamping_ctrl {
    struct mii_timestamper * (*probe_channel)(struct device *, unsigned int);
    void (*release_channel)(struct device *, struct mii_timestamper *);
};

struct mii_timestamping_desc {
    struct list_head list;
    struct mii_timestamping_ctrl *ctrl;
    struct device *device;
};

struct min_heap_callbacks {
    bool (*less)(const void *, const void *, void *);
    void (*swp)(void *, void *, void *);
};

struct min_heap_char {
    size_t nr;
    size_t size;
    char *data;
    char preallocated[0];
};

typedef struct min_heap_char min_heap_char;

struct tcf_proto;

struct mini_Qdisc {
    struct tcf_proto *filter_list;
    struct tcf_block *block;
    struct gnet_stats_basic_sync *cpu_bstats;
    struct gnet_stats_queue *cpu_qstats;
    long unsigned int rcu_state;
};

struct mini_Qdisc_pair {
    struct mini_Qdisc miniq1;
    struct mini_Qdisc miniq2;
    struct mini_Qdisc **p_miniq;
};

struct minimode {
    short int w;
    short int h;
    short int r;
    short int rb;
};

struct minmax_sample {
    u32 t;
    u32 v;
};

struct minmax {
    struct minmax_sample s[3];
};

struct mip_priv {
    spinlock_t lock;
    void *base;
    u64 msg_addr;
    u32 msi_base;
    u32 num_msis;
    u32 msi_offset;
    long unsigned int *bitmap;
    struct irq_domain *parent;
    struct device *dev;
};

struct mipi_dsi_host;

struct mipi_dsi_device {
    struct mipi_dsi_host *host;
    struct device dev;
    bool attached;
    char name[20];
    unsigned int channel;
    unsigned int lanes;
    enum mipi_dsi_pixel_format format;
    long unsigned int mode_flags;
    long unsigned int hs_rate;
    long unsigned int lp_rate;
    struct drm_dsc_config *dsc;
};

struct mipi_dsi_device_info {
    char type[20];
    u32 channel;
    struct device_node *node;
};

struct mipi_dsi_driver {
    struct device_driver driver;
    int (*probe)(struct mipi_dsi_device *);
    void (*remove)(struct mipi_dsi_device *);
    void (*shutdown)(struct mipi_dsi_device *);
};

struct mipi_dsi_host_ops;

struct mipi_dsi_host {
    struct device *dev;
    const struct mipi_dsi_host_ops *ops;
    struct list_head list;
};

struct mipi_dsi_msg;

struct mipi_dsi_host_ops {
    int (*attach)(struct mipi_dsi_host *, struct mipi_dsi_device *);
    int (*detach)(struct mipi_dsi_host *, struct mipi_dsi_device *);
    ssize_t (*transfer)(struct mipi_dsi_host *, const struct mipi_dsi_msg *);
};

struct mipi_dsi_msg {
    u8 channel;
    u8 type;
    u16 flags;
    size_t tx_len;
    const void *tx_buf;
    size_t rx_len;
    void *rx_buf;
};

struct mipi_dsi_multi_context {
    struct mipi_dsi_device *dsi;
    int accum_err;
};

struct mipi_dsi_packet {
    size_t size;
    u8 header[4];
    size_t payload_length;
    const u8 *payload;
};

struct misc_res {
    u64 max;
    atomic64_t watermark;
    atomic64_t usage;
    atomic64_t events;
    atomic64_t events_local;
};

struct misc_cg {
    struct cgroup_subsys_state css;
    struct cgroup_file events_file;
    struct cgroup_file events_local_file;
    struct misc_res res[0];
};

struct miscdevice {
    int minor;
    const char *name;
    const struct file_operations *fops;
    struct list_head list;
    struct device *parent;
    struct device *this_device;
    const struct attribute_group **groups;
    const char *nodename;
    umode_t mode;
};

struct mld2_grec {
    __u8 grec_type;
    __u8 grec_auxwords;
    __be16 grec_nsrcs;
    struct in6_addr grec_mca;
    struct in6_addr grec_src[0];
};

struct mld2_query {
    struct icmp6hdr mld2q_hdr;
    struct in6_addr mld2q_mca;
    __u8 mld2q_qrv: 3;
    __u8 mld2q_suppress: 1;
    __u8 mld2q_resv2: 4;
    __u8 mld2q_qqic;
    __be16 mld2q_nsrcs;
    struct in6_addr mld2q_srcs[0];
};

struct mld2_report {
    struct icmp6hdr mld2r_hdr;
    struct mld2_grec mld2r_grec[0];
};

struct mld_msg {
    struct icmp6hdr mld_hdr;
    struct in6_addr mld_mca;
};

struct mlock_fbatch {
    local_lock_t lock;
    struct folio_batch fbatch;
};

struct mm_cid {
    u64 time;
    int cid;
    int recent_cid;
};

struct mm_reply_data {
    struct ethnl_reply_data base;
    struct ethtool_mm_state state;
    struct ethtool_mm_stats stats;
};

struct xol_area;

struct uprobes_state {
    struct xol_area *xol_area;
};

struct mmu_notifier_subscriptions;

struct mm_struct {
    struct {
        struct {
            atomic_t mm_count;
            long: 64;
            long: 64;
            long: 64;
            long: 64;
            long: 64;
            long: 64;
            long: 64;
        };
        struct maple_tree mm_mt;
        long unsigned int mmap_base;
        long unsigned int mmap_legacy_base;
        long unsigned int task_size;
        pgd_t *pgd;
        atomic_t membarrier_state;
        atomic_t mm_users;
        struct mm_cid *pcpu_cid;
        long unsigned int mm_cid_next_scan;
        unsigned int nr_cpus_allowed;
        atomic_t max_nr_cid;
        raw_spinlock_t cpus_allowed_lock;
        atomic_long_t pgtables_bytes;
        int map_count;
        spinlock_t page_table_lock;
        struct rw_semaphore mmap_lock;
        struct list_head mmlist;
        seqcount_t mm_lock_seq;
        long unsigned int hiwater_rss;
        long unsigned int hiwater_vm;
        long unsigned int total_vm;
        long unsigned int locked_vm;
        atomic64_t pinned_vm;
        long unsigned int data_vm;
        long unsigned int exec_vm;
        long unsigned int stack_vm;
        long unsigned int def_flags;
        seqcount_t write_protect_seq;
        spinlock_t arg_lock;
        long unsigned int start_code;
        long unsigned int end_code;
        long unsigned int start_data;
        long unsigned int end_data;
        long unsigned int start_brk;
        long unsigned int brk;
        long unsigned int start_stack;
        long unsigned int arg_start;
        long unsigned int arg_end;
        long unsigned int env_start;
        long unsigned int env_end;
        long unsigned int saved_auxv[50];
        struct percpu_counter rss_stat[4];
        struct linux_binfmt *binfmt;
        mm_context_t context;
        long unsigned int flags;
        spinlock_t ioctx_lock;
        struct kioctx_table *ioctx_table;
        struct task_struct *owner;
        struct user_namespace *user_ns;
        struct file *exe_file;
        struct mmu_notifier_subscriptions *notifier_subscriptions;
        atomic_t tlb_flush_pending;
        atomic_t tlb_flush_batched;
        struct uprobes_state uprobes_state;
        atomic_long_t hugetlb_usage;
        struct work_struct async_put_work;
        struct iommu_mm_data *iommu_mm;
        struct {
            struct list_head list;
            long unsigned int bitmap;
            struct mem_cgroup *memcg;
        } lru_gen;
        long: 64;
        long: 64;
        long: 64;
        long: 64;
        long: 64;
        long: 64;
    };
    long unsigned int cpu_bitmap[0];
};

struct mm_struct__safe_rcu_or_null {
    struct file *exe_file;
};

struct mm_walk_ops;

struct mm_walk {
    const struct mm_walk_ops *ops;
    struct mm_struct *mm;
    pgd_t *pgd;
    struct vm_area_struct *vma;
    enum page_walk_action action;
    bool no_vma;
    void *private;
};

struct mm_walk_ops {
    int (*pgd_entry)(pgd_t *, long unsigned int, long unsigned int, struct mm_walk *);
    int (*p4d_entry)(p4d_t *, long unsigned int, long unsigned int, struct mm_walk *);
    int (*pud_entry)(pud_t *, long unsigned int, long unsigned int, struct mm_walk *);
    int (*pmd_entry)(pmd_t *, long unsigned int, long unsigned int, struct mm_walk *);
    int (*pte_entry)(pte_t *, long unsigned int, long unsigned int, struct mm_walk *);
    int (*pte_hole)(long unsigned int, long unsigned int, int, struct mm_walk *);
    int (*hugetlb_entry)(pte_t *, long unsigned int, long unsigned int, long unsigned int, struct mm_walk *);
    int (*test_walk)(long unsigned int, long unsigned int, struct mm_walk *);
    int (*pre_vma)(long unsigned int, long unsigned int, struct mm_walk *);
    void (*post_vma)(struct mm_walk *);
    int (*install_pte)(long unsigned int, long unsigned int, pte_t *, struct mm_walk *);
    enum page_walk_lock walk_lock;
};

struct vma_munmap_struct {
    struct vma_iterator *vmi;
    struct vm_area_struct *vma;
    struct vm_area_struct *prev;
    struct vm_area_struct *next;
    struct list_head *uf;
    long unsigned int start;
    long unsigned int end;
    long unsigned int unmap_start;
    long unsigned int unmap_end;
    int vma_count;
    bool unlock;
    bool clear_ptes;
    long unsigned int nr_pages;
    long unsigned int locked_vm;
    long unsigned int nr_accounted;
    long unsigned int exec_vm;
    long unsigned int stack_vm;
    long unsigned int data_vm;
};

struct mmap_state {
    struct mm_struct *mm;
    struct vma_iterator *vmi;
    long unsigned int addr;
    long unsigned int end;
    long unsigned int pgoff;
    long unsigned int pglen;
    long unsigned int flags;
    struct file *file;
    long unsigned int charged;
    bool retry_merge;
    struct vm_area_struct *prev;
    struct vm_area_struct *next;
    struct vma_munmap_struct vms;
    struct ma_state mas_detach;
    struct maple_tree mt_detach;
};

struct mmap_unlock_irq_work {
    struct irq_work irq_work;
    struct mm_struct *mm;
};

struct uhs2_command {
    u16 header;
    u16 arg;
    __be32 payload[2];
    u8 payload_len;
    u8 packet_len;
    u8 tmode_half_duplex;
    u8 uhs2_resp[20];
    u8 uhs2_resp_len;
};

struct mmc_host;

struct mmc_request {
    struct mmc_command *sbc;
    struct mmc_command *cmd;
    struct mmc_data *data;
    struct mmc_command *stop;
    struct completion completion;
    struct completion cmd_completion;
    void (*done)(struct mmc_request *);
    void (*recovery_notifier)(struct mmc_request *);
    struct mmc_host *host;
    bool cap_cmd_during_tfr;
    int tag;
    const struct bio_crypt_ctx *crypto_ctx;
    int crypto_key_slot;
    struct uhs2_command uhs2_cmd;
};

struct mmc_command {
    u32 opcode;
    u32 arg;
    u32 resp[4];
    unsigned int flags;
    unsigned int retries;
    int error;
    unsigned int busy_timeout;
    struct mmc_data *data;
    struct mmc_request *mrq;
    struct uhs2_command *uhs2_cmd;
    bool has_ext_addr;
    u8 ext_addr;
};

struct mmc_data {
    unsigned int timeout_ns;
    unsigned int timeout_clks;
    unsigned int blksz;
    unsigned int blocks;
    unsigned int blk_addr;
    int error;
    unsigned int flags;
    unsigned int bytes_xfered;
    struct mmc_command *stop;
    struct mmc_request *mrq;
    unsigned int sg_len;
    int sg_count;
    struct scatterlist *sg;
    s32 host_cookie;
};

struct mmc_blk_request {
    struct mmc_request mrq;
    struct mmc_command sbc;
    struct mmc_command cmd;
    struct mmc_command stop;
    struct mmc_data data;
};

struct mmc_bus_ops {
    void (*remove)(struct mmc_host *);
    void (*detect)(struct mmc_host *);
    int (*pre_suspend)(struct mmc_host *);
    int (*suspend)(struct mmc_host *);
    int (*resume)(struct mmc_host *);
    int (*runtime_suspend)(struct mmc_host *);
    int (*runtime_resume)(struct mmc_host *);
    int (*alive)(struct mmc_host *);
    int (*shutdown)(struct mmc_host *);
    int (*hw_reset)(struct mmc_host *);
    int (*sw_reset)(struct mmc_host *);
    bool (*cache_enabled)(struct mmc_host *);
    int (*flush_cache)(struct mmc_host *);
};

struct mmc_busy_data {
    struct mmc_card *card;
    bool retry_crc_err;
    enum mmc_busy_cmd busy_cmd;
};

struct mmc_cid {
    unsigned int manfid;
    char prod_name[8];
    unsigned char prv;
    unsigned int serial;
    short unsigned int oemid;
    short unsigned int year;
    unsigned char hwrev;
    unsigned char fwrev;
    unsigned char month;
};

struct mmc_csd {
    unsigned char structure;
    unsigned char mmca_vsn;
    short unsigned int cmdclass;
    short unsigned int taac_clks;
    unsigned int taac_ns;
    unsigned int c_size;
    unsigned int r2w_factor;
    unsigned int max_dtr;
    unsigned int erase_size;
    unsigned int wp_grp_size;
    unsigned int read_blkbits;
    unsigned int write_blkbits;
    sector_t capacity;
    unsigned int read_partial: 1;
    unsigned int read_misalign: 1;
    unsigned int write_partial: 1;
    unsigned int write_misalign: 1;
    unsigned int dsr_imp: 1;
};

struct mmc_ext_csd {
    u8 rev;
    u8 erase_group_def;
    u8 sec_feature_support;
    u8 rel_sectors;
    u8 rel_param;
    bool enhanced_rpmb_supported;
    u8 part_config;
    u8 cache_ctrl;
    u8 rst_n_function;
    unsigned int part_time;
    unsigned int sa_timeout;
    unsigned int generic_cmd6_time;
    unsigned int power_off_longtime;
    u8 power_off_notification;
    unsigned int hs_max_dtr;
    unsigned int hs200_max_dtr;
    unsigned int sectors;
    unsigned int hc_erase_size;
    unsigned int hc_erase_timeout;
    unsigned int sec_trim_mult;
    unsigned int sec_erase_mult;
    unsigned int trim_timeout;
    bool partition_setting_completed;
    long long unsigned int enhanced_area_offset;
    unsigned int enhanced_area_size;
    unsigned int cache_size;
    bool hpi_en;
    bool hpi;
    unsigned int hpi_cmd;
    bool bkops;
    bool man_bkops_en;
    bool auto_bkops_en;
    unsigned int data_sector_size;
    unsigned int data_tag_unit_size;
    unsigned int boot_ro_lock;
    bool boot_ro_lockable;
    bool ffu_capable;
    bool cmdq_en;
    bool cmdq_support;
    unsigned int cmdq_depth;
    u8 fwrev[8];
    u8 raw_exception_status;
    u8 raw_partition_support;
    u8 raw_rpmb_size_mult;
    u8 raw_erased_mem_count;
    u8 strobe_support;
    u8 raw_ext_csd_structure;
    u8 raw_card_type;
    u8 raw_driver_strength;
    u8 out_of_int_time;
    u8 raw_pwr_cl_52_195;
    u8 raw_pwr_cl_26_195;
    u8 raw_pwr_cl_52_360;
    u8 raw_pwr_cl_26_360;
    u8 raw_s_a_timeout;
    u8 raw_hc_erase_gap_size;
    u8 raw_erase_timeout_mult;
    u8 raw_hc_erase_grp_size;
    u8 raw_boot_mult;
    u8 raw_sec_trim_mult;
    u8 raw_sec_erase_mult;
    u8 raw_sec_feature_support;
    u8 raw_trim_mult;
    u8 raw_pwr_cl_200_195;
    u8 raw_pwr_cl_200_360;
    u8 raw_pwr_cl_ddr_52_195;
    u8 raw_pwr_cl_ddr_52_360;
    u8 raw_pwr_cl_ddr_200_360;
    u8 raw_bkops_status;
    u8 raw_sectors[4];
    u8 pre_eol_info;
    u8 device_life_time_est_typ_a;
    u8 device_life_time_est_typ_b;
    unsigned int feature_support;
};

struct sd_scr {
    unsigned char sda_vsn;
    unsigned char sda_spec3;
    unsigned char sda_spec4;
    unsigned char sda_specx;
    unsigned char bus_widths;
    unsigned char cmds;
};

struct sd_ssr {
    unsigned int au;
    unsigned int erase_timeout;
    unsigned int erase_offset;
};

struct sd_switch_caps {
    unsigned int hs_max_dtr;
    unsigned int uhs_max_dtr;
    unsigned int sd3_bus_mode;
    unsigned int sd3_drv_type;
    unsigned int sd3_curr_limit;
};

struct sd_ext_reg {
    u8 fno;
    u8 page;
    u16 offset;
    u8 rev;
    u8 feature_enabled;
    u8 feature_support;
};

struct sd_uhs2_config {
    u32 node_id;
    u32 n_fcu;
    u32 maxblk_len;
    u8 n_lanes;
    u8 dadr_len;
    u8 app_type;
    u8 phy_minor_rev;
    u8 phy_major_rev;
    u8 can_hibernate;
    u8 n_lss_sync;
    u8 n_lss_dir;
    u8 link_minor_rev;
    u8 link_major_rev;
    u8 dev_type;
    u8 n_data_gap;
    u32 n_fcu_set;
    u32 maxblk_len_set;
    u8 n_lanes_set;
    u8 speed_range_set;
    u8 n_lss_sync_set;
    u8 n_lss_dir_set;
    u8 n_data_gap_set;
    u8 max_retry_set;
};

struct sdio_cccr {
    unsigned int sdio_vsn;
    unsigned int sd_vsn;
    unsigned int multi_block: 1;
    unsigned int low_speed: 1;
    unsigned int wide_bus: 1;
    unsigned int high_power: 1;
    unsigned int high_speed: 1;
    unsigned int disable_cd: 1;
    unsigned int enable_async_irq: 1;
};

struct sdio_cis {
    short unsigned int vendor;
    short unsigned int device;
    short unsigned int blksize;
    unsigned int max_dtr;
};

struct mmc_part {
    u64 size;
    unsigned int part_cfg;
    char name[20];
    bool force_ro;
    unsigned int area_type;
};

struct sdio_func_tuple;

struct mmc_card {
    struct mmc_host *host;
    struct device dev;
    u32 ocr;
    unsigned int rca;
    unsigned int type;
    unsigned int state;
    unsigned int quirks;
    unsigned int quirk_max_rate;
    bool written_flag;
    bool reenable_cmdq;
    unsigned int erase_size;
    unsigned int erase_shift;
    unsigned int pref_erase;
    unsigned int eg_boundary;
    unsigned int erase_arg;
    u8 erased_byte;
    unsigned int wp_grp_size;
    u32 raw_cid[4];
    u32 raw_csd[4];
    u32 raw_scr[2];
    u32 raw_ssr[16];
    struct mmc_cid cid;
    struct mmc_csd csd;
    struct mmc_ext_csd ext_csd;
    struct sd_scr scr;
    struct sd_ssr ssr;
    struct sd_switch_caps sw_caps;
    struct sd_ext_reg ext_power;
    struct sd_ext_reg ext_perf;
    u8 *ext_reg_buf;
    struct sd_uhs2_config uhs2_config;
    unsigned int sdio_funcs;
    atomic_t sdio_funcs_probed;
    struct sdio_cccr cccr;
    struct sdio_cis cis;
    struct sdio_func *sdio_func[7];
    struct sdio_func *sdio_single_irq;
    u8 major_rev;
    u8 minor_rev;
    unsigned int num_info;
    const char **info;
    struct sdio_func_tuple *tuples;
    unsigned int sd_bus_speed;
    unsigned int mmc_avail_type;
    unsigned int drive_strength;
    struct dentry *debugfs_root;
    struct mmc_part part[7];
    unsigned int nr_parts;
    struct workqueue_struct *complete_wq;
    unsigned int max_posted_writes;
};

struct mmc_clk_phase {
    bool valid;
    u16 in_deg;
    u16 out_deg;
};

struct mmc_clk_phase_map {
    struct mmc_clk_phase phase[11];
};

struct mmc_cqe_ops {
    int (*cqe_enable)(struct mmc_host *, struct mmc_card *);
    void (*cqe_disable)(struct mmc_host *);
    int (*cqe_request)(struct mmc_host *, struct mmc_request *);
    void (*cqe_post_req)(struct mmc_host *, struct mmc_request *);
    void (*cqe_off)(struct mmc_host *);
    int (*cqe_wait_for_idle)(struct mmc_host *);
    bool (*cqe_timeout)(struct mmc_host *, struct mmc_request *, bool *);
    void (*cqe_recovery_start)(struct mmc_host *);
    void (*cqe_recovery_finish)(struct mmc_host *);
};

struct mmc_ctx {
    struct task_struct *task;
};

struct mmc_driver {
    struct device_driver drv;
    int (*probe)(struct mmc_card *);
    void (*remove)(struct mmc_card *);
    void (*shutdown)(struct mmc_card *);
};

struct mmc_fixup {
    const char *name;
    u64 rev_start;
    u64 rev_end;
    unsigned int manfid;
    short unsigned int oemid;
    short unsigned int year;
    unsigned char month;
    u16 cis_vendor;
    u16 cis_device;
    unsigned int ext_csd_rev;
    const char *of_compatible;
    void (*vendor_fixup)(struct mmc_card *, int);
    int data;
};

struct mmc_gpio {
    struct gpio_desc *ro_gpio;
    struct gpio_desc *cd_gpio;
    irq_handler_t cd_gpio_isr;
    char *ro_label;
    char *cd_label;
    u32 cd_debounce_delay_ms;
    int cd_irq;
};

struct sd_uhs2_caps {
    u32 dap;
    u32 gap;
    u32 group_desc;
    u32 maxblk_len;
    u32 n_fcu;
    u8 n_lanes;
    u8 addr64;
    u8 card_type;
    u8 phy_rev;
    u8 speed_range;
    u8 n_lss_sync;
    u8 n_lss_dir;
    u8 link_rev;
    u8 host_type;
    u8 n_data_gap;
    u32 maxblk_len_set;
    u32 n_fcu_set;
    u8 n_lanes_set;
    u8 n_lss_sync_set;
    u8 n_lss_dir_set;
    u8 n_data_gap_set;
    u8 max_retry_set;
};

struct mmc_ios {
    unsigned int clock;
    short unsigned int vdd;
    unsigned int power_delay_ms;
    unsigned char bus_mode;
    unsigned char chip_select;
    unsigned char power_mode;
    unsigned char bus_width;
    unsigned char timing;
    unsigned char signal_voltage;
    unsigned char vqmmc2_voltage;
    unsigned char drv_type;
    bool enhanced_strobe;
};

struct mmc_slot {
    int cd_irq;
    bool cd_wake_enabled;
    void *handler_priv;
};

struct mmc_supply {
    struct regulator *vmmc;
    struct regulator *vqmmc;
    struct regulator *vqmmc2;
};

struct mmc_host_ops;

struct mmc_pwrseq;

struct mmc_host {
    struct device *parent;
    struct device class_dev;
    int index;
    const struct mmc_host_ops *ops;
    struct mmc_pwrseq *pwrseq;
    unsigned int f_min;
    unsigned int f_max;
    unsigned int f_init;
    u32 ocr_avail;
    u32 ocr_avail_sdio;
    u32 ocr_avail_sd;
    u32 ocr_avail_mmc;
    struct wakeup_source *ws;
    u32 max_current_330;
    u32 max_current_300;
    u32 max_current_180;
    u32 caps;
    u32 caps2;
    bool uhs2_sd_tran;
    bool uhs2_app_cmd;
    struct sd_uhs2_caps uhs2_caps;
    int fixed_drv_type;
    mmc_pm_flag_t pm_caps;
    unsigned int max_seg_size;
    short unsigned int max_segs;
    short unsigned int unused;
    unsigned int max_req_size;
    unsigned int max_blk_size;
    unsigned int max_blk_count;
    unsigned int max_busy_timeout;
    spinlock_t lock;
    struct mmc_ios ios;
    unsigned int use_spi_crc: 1;
    unsigned int claimed: 1;
    unsigned int doing_init_tune: 1;
    unsigned int can_retune: 1;
    unsigned int doing_retune: 1;
    unsigned int retune_now: 1;
    unsigned int retune_paused: 1;
    unsigned int retune_crc_disable: 1;
    unsigned int can_dma_map_merge: 1;
    unsigned int vqmmc_enabled: 1;
    int rescan_disable;
    int rescan_entered;
    int need_retune;
    int hold_retune;
    unsigned int retune_period;
    struct timer_list retune_timer;
    bool trigger_card_event;
    struct mmc_card *card;
    wait_queue_head_t wq;
    struct mmc_ctx *claimer;
    int claim_cnt;
    struct mmc_ctx default_ctx;
    struct delayed_work detect;
    int detect_change;
    struct mmc_slot slot;
    const struct mmc_bus_ops *bus_ops;
    unsigned int sdio_irqs;
    struct task_struct *sdio_irq_thread;
    struct work_struct sdio_irq_work;
    bool sdio_irq_pending;
    atomic_t sdio_irq_thread_abort;
    mmc_pm_flag_t pm_flags;
    struct led_trigger *led;
    bool regulator_enabled;
    struct mmc_supply supply;
    struct dentry *debugfs_root;
    struct mmc_request *ongoing_mrq;
    unsigned int actual_clock;
    unsigned int slotno;
    int dsr_req;
    u32 dsr;
    const struct mmc_cqe_ops *cqe_ops;
    void *cqe_private;
    int cqe_qdepth;
    bool cqe_enabled;
    bool cqe_on;
    struct blk_crypto_profile crypto_profile;
    bool hsq_enabled;
    int hsq_depth;
    u32 err_stats[15];
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long unsigned int private[0];
};

struct mmc_host_ops {
    void (*post_req)(struct mmc_host *, struct mmc_request *, int);
    void (*pre_req)(struct mmc_host *, struct mmc_request *);
    void (*request)(struct mmc_host *, struct mmc_request *);
    int (*request_atomic)(struct mmc_host *, struct mmc_request *);
    void (*set_ios)(struct mmc_host *, struct mmc_ios *);
    int (*get_ro)(struct mmc_host *);
    int (*get_cd)(struct mmc_host *);
    void (*enable_sdio_irq)(struct mmc_host *, int);
    void (*ack_sdio_irq)(struct mmc_host *);
    void (*init_card)(struct mmc_host *, struct mmc_card *);
    int (*start_signal_voltage_switch)(struct mmc_host *, struct mmc_ios *);
    int (*card_busy)(struct mmc_host *);
    int (*execute_tuning)(struct mmc_host *, u32);
    int (*prepare_hs400_tuning)(struct mmc_host *, struct mmc_ios *);
    int (*execute_hs400_tuning)(struct mmc_host *, struct mmc_card *);
    int (*prepare_sd_hs_tuning)(struct mmc_host *, struct mmc_card *);
    int (*execute_sd_hs_tuning)(struct mmc_host *, struct mmc_card *);
    int (*hs400_prepare_ddr)(struct mmc_host *);
    void (*hs400_downgrade)(struct mmc_host *);
    void (*hs400_complete)(struct mmc_host *);
    void (*hs400_enhanced_strobe)(struct mmc_host *, struct mmc_ios *);
    int (*select_drive_strength)(struct mmc_card *, unsigned int, int, int, int *);
    void (*card_hw_reset)(struct mmc_host *);
    void (*card_event)(struct mmc_host *);
    int (*multi_io_quirk)(struct mmc_card *, unsigned int, int);
    int (*init_sd_express)(struct mmc_host *, struct mmc_ios *);
    int (*uhs2_control)(struct mmc_host *, enum sd_uhs2_operation);
};

struct mmc_hsq {
    struct mmc_host *mmc;
    struct mmc_request *mrq;
    wait_queue_head_t wait_queue;
    struct hsq_slot *slot;
    spinlock_t lock;
    struct work_struct retry_work;
    int next_tag;
    int num_slots;
    int qcnt;
    int tail_tag;
    int tag_slot[64];
    bool enabled;
    bool waiting_for_idle;
    bool recovery_halt;
};

struct mmc_op_cond_busy_data {
    struct mmc_host *host;
    u32 ocr;
    struct mmc_command *cmd;
};

struct mmc_pwrseq_ops;

struct mmc_pwrseq {
    const struct mmc_pwrseq_ops *ops;
    struct device *dev;
    struct list_head pwrseq_node;
    struct module *owner;
};

struct mmc_pwrseq_emmc {
    struct mmc_pwrseq pwrseq;
    struct notifier_block reset_nb;
    struct gpio_desc *reset_gpio;
};

struct mmc_pwrseq_ops {
    void (*pre_power_on)(struct mmc_host *);
    void (*post_power_on)(struct mmc_host *);
    void (*power_off)(struct mmc_host *);
    void (*reset)(struct mmc_host *);
};

struct mmc_pwrseq_simple {
    struct mmc_pwrseq pwrseq;
    bool clk_enabled;
    u32 post_power_on_delay_ms;
    u32 power_off_delay_us;
    struct clk *ext_clk;
    struct gpio_descs *reset_gpios;
    struct reset_control *reset_ctrl;
};

struct mmc_queue_req {
    struct mmc_blk_request brq;
    struct scatterlist *sg;
    enum mmc_drv_op drv_op;
    int drv_op_result;
    void *drv_op_data;
    unsigned int ioc_count;
    int retries;
};

struct mmp_struct {
    __le32 mmp_magic;
    __le32 mmp_seq;
    __le64 mmp_time;
    char mmp_nodename[64];
    char mmp_bdevname[32];
    __le16 mmp_check_interval;
    __le16 mmp_pad1;
    __le32 mmp_pad2[226];
    __le32 mmp_checksum;
};

struct mmpin {
    struct user_struct *user;
    unsigned int num_pg;
};

struct user_msghdr {
    void *msg_name;
    int msg_namelen;
    struct iovec *msg_iov;
    __kernel_size_t msg_iovlen;
    void *msg_control;
    __kernel_size_t msg_controllen;
    unsigned int msg_flags;
};

struct mmsghdr {
    struct user_msghdr msg_hdr;
    unsigned int msg_len;
};

struct mmu_config {
    u64 ttbr0;
    u64 ttbr1;
    u64 tcr;
    u64 mair;
    u64 tcr2;
    u64 pir;
    u64 pire0;
    u64 por_el0;
    u64 por_el1;
    u64 sctlr;
    u64 vttbr;
    u64 vtcr;
    u64 hcr;
};

struct encoded_page;

struct mmu_gather_batch {
    struct mmu_gather_batch *next;
    unsigned int nr;
    unsigned int max;
    struct encoded_page *encoded_pages[0];
};

struct mmu_table_batch;

struct mmu_gather {
    struct mm_struct *mm;
    struct mmu_table_batch *batch;
    long unsigned int start;
    long unsigned int end;
    unsigned int fullmm: 1;
    unsigned int need_flush_all: 1;
    unsigned int freed_tables: 1;
    unsigned int delayed_rmap: 1;
    unsigned int cleared_ptes: 1;
    unsigned int cleared_pmds: 1;
    unsigned int cleared_puds: 1;
    unsigned int cleared_p4ds: 1;
    unsigned int vma_exec: 1;
    unsigned int vma_huge: 1;
    unsigned int vma_pfn: 1;
    unsigned int batch_count;
    struct mmu_gather_batch *active;
    struct mmu_gather_batch local;
    struct page *__pages[8];
};

struct mmu_interval_notifier_ops;

struct mmu_interval_notifier {
    struct interval_tree_node interval_tree;
    const struct mmu_interval_notifier_ops *ops;
    struct mm_struct *mm;
    struct hlist_node deferred_item;
    long unsigned int invalidate_seq;
};

struct mmu_interval_notifier_ops {
    bool (*invalidate)(struct mmu_interval_notifier *, const struct mmu_notifier_range *, long unsigned int);
};

struct mmu_notifier_ops {
    void (*release)(struct mmu_notifier *, struct mm_struct *);
    int (*clear_flush_young)(struct mmu_notifier *, struct mm_struct *, long unsigned int, long unsigned int);
    int (*clear_young)(struct mmu_notifier *, struct mm_struct *, long unsigned int, long unsigned int);
    int (*test_young)(struct mmu_notifier *, struct mm_struct *, long unsigned int);
    int (*invalidate_range_start)(struct mmu_notifier *, const struct mmu_notifier_range *);
    void (*invalidate_range_end)(struct mmu_notifier *, const struct mmu_notifier_range *);
    void (*arch_invalidate_secondary_tlbs)(struct mmu_notifier *, struct mm_struct *, long unsigned int, long unsigned int);
    struct mmu_notifier * (*alloc_notifier)(struct mm_struct *);
    void (*free_notifier)(struct mmu_notifier *);
};

struct mmu_notifier_subscriptions {
    struct hlist_head list;
    bool has_itree;
    spinlock_t lock;
    long unsigned int invalidate_seq;
    long unsigned int active_invalidate_ranges;
    struct rb_root_cached itree;
    wait_queue_head_t wq;
    struct hlist_head deferred_list;
};

struct mmu_table_batch {
    struct callback_head rcu;
    unsigned int nr;
    void *tables[0];
};

struct mnt_id_req {
    __u32 size;
    __u32 spare;
    __u64 mnt_id;
    __u64 param;
    __u64 mnt_ns_id;
};

struct uid_gid_extent {
    u32 first;
    u32 lower_first;
    u32 count;
};

struct uid_gid_map {
    union {
        struct {
            struct uid_gid_extent extent[5];
            u32 nr_extents;
        };
        struct {
            struct uid_gid_extent *forward;
            struct uid_gid_extent *reverse;
        };
    };
};

struct mnt_idmap {
    struct uid_gid_map uid_map;
    struct uid_gid_map gid_map;
    refcount_t count;
};

struct mount;

struct mnt_namespace {
    struct ns_common ns;
    struct mount *root;
    struct {
        struct rb_root mounts;
        struct rb_node *mnt_last_node;
        struct rb_node *mnt_first_node;
    };
    struct user_namespace *user_ns;
    struct ucounts *ucounts;
    u64 seq;
    union {
        wait_queue_head_t poll;
        struct callback_head mnt_ns_rcu;
    };
    u64 event;
    unsigned int nr_mounts;
    unsigned int pending_mounts;
    struct rb_node mnt_ns_tree_node;
    struct list_head mnt_ns_list;
    refcount_t passive;
};

struct mnt_ns_info {
    __u32 size;
    __u32 nr_mounts;
    __u64 mnt_ns_id;
};

struct mnt_pcp {
    int mnt_count;
    int mnt_writers;
};

struct mod_plt_sec {
    int plt_shndx;
    int plt_num_entries;
    int plt_max_entries;
};

struct plt_entry;

struct mod_arch_specific {
    struct mod_plt_sec core;
    struct mod_plt_sec init;
    struct plt_entry *ftrace_trampolines;
};

struct mod_initfree {
    struct llist_node node;
    void *init_text;
    void *init_data;
    void *init_rodata;
};

struct mod_kallsyms {
    Elf64_Sym *symtab;
    unsigned int num_symtab;
    char *strtab;
    char *typetab;
};

struct mod_tree_node {
    struct module *mod;
    struct latch_tree_node node;
};

struct mod_tree_root {
    struct latch_tree_root root;
    long unsigned int addr_min;
    long unsigned int addr_max;
};

struct module_param_attrs;

struct module_kobject {
    struct kobject kobj;
    struct module *mod;
    struct kobject *drivers_dir;
    struct module_param_attrs *mp;
    struct completion *kobj_completion;
};

struct module_memory {
    void *base;
    void *rw_copy;
    bool is_rox;
    unsigned int size;
    struct mod_tree_node mtn;
};

struct module_attribute;

struct module_sect_attrs;

struct module_notes_attrs;

struct trace_event_call;

struct trace_eval_map;

struct module {
    enum module_state state;
    struct list_head list;
    char name[56];
    struct module_kobject mkobj;
    struct module_attribute *modinfo_attrs;
    const char *version;
    const char *srcversion;
    struct kobject *holders_dir;
    const struct kernel_symbol *syms;
    const u32 *crcs;
    unsigned int num_syms;
    struct mutex param_lock;
    struct kernel_param *kp;
    unsigned int num_kp;
    unsigned int num_gpl_syms;
    const struct kernel_symbol *gpl_syms;
    const u32 *gpl_crcs;
    bool using_gplonly_symbols;
    bool sig_ok;
    bool async_probe_requested;
    unsigned int num_exentries;
    struct exception_table_entry *extable;
    int (*init)(void);
    struct module_memory mem[7];
    struct mod_arch_specific arch;
    long unsigned int taints;
    unsigned int num_bugs;
    struct list_head bug_list;
    struct bug_entry *bug_table;
    struct mod_kallsyms *kallsyms;
    struct mod_kallsyms core_kallsyms;
    struct module_sect_attrs *sect_attrs;
    struct module_notes_attrs *notes_attrs;
    char *args;
    void *percpu;
    unsigned int percpu_size;
    void *noinstr_text_start;
    unsigned int noinstr_text_size;
    unsigned int num_tracepoints;
    tracepoint_ptr_t *tracepoints_ptrs;
    unsigned int num_srcu_structs;
    struct srcu_struct **srcu_struct_ptrs;
    unsigned int num_bpf_raw_events;
    struct bpf_raw_event_map *bpf_raw_events;
    unsigned int btf_data_size;
    unsigned int btf_base_data_size;
    void *btf_data;
    void *btf_base_data;
    struct jump_entry *jump_entries;
    unsigned int num_jump_entries;
    unsigned int num_trace_bprintk_fmt;
    const char **trace_bprintk_fmt_start;
    struct trace_event_call **trace_events;
    unsigned int num_trace_events;
    struct trace_eval_map **trace_evals;
    unsigned int num_trace_evals;
    unsigned int num_ftrace_callsites;
    long unsigned int *ftrace_callsites;
    void *kprobes_text_start;
    unsigned int kprobes_text_size;
    long unsigned int *kprobe_blacklist;
    unsigned int num_kprobe_blacklist;
    struct list_head source_list;
    struct list_head target_list;
    void (*exit)(void);
    atomic_t refcnt;
    struct _ddebug_info dyndbg_info;
};

struct module_attribute {
    struct attribute attr;
    ssize_t (*show)(const struct module_attribute *, struct module_kobject *, char *);
    ssize_t (*store)(const struct module_attribute *, struct module_kobject *, const char *, size_t);
    void (*setup)(struct module *, const char *);
    int (*test)(struct module *);
    void (*free)(struct module *);
};

struct module_notes_attrs {
    struct attribute_group grp;
    struct bin_attribute attrs[0];
};

struct param_attribute {
    struct module_attribute mattr;
    const struct kernel_param *param;
};

struct module_param_attrs {
    unsigned int num;
    struct attribute_group grp;
    struct param_attribute attrs[0];
};

struct module_reply_data {
    struct ethnl_reply_data base;
    struct ethtool_module_power_mode_params power;
};

struct module_sect_attrs {
    struct attribute_group grp;
    struct bin_attribute attrs[0];
};

struct module_signature {
    u8 algo;
    u8 hash;
    u8 id_type;
    u8 signer_len;
    u8 key_id_len;
    u8 __pad[3];
    __be32 sig_len;
};

struct module_string {
    struct list_head next;
    struct module *module;
    char *str;
};

struct module_use {
    struct list_head source_list;
    struct list_head target_list;
    struct module *source;
    struct module *target;
};

struct module_version_attribute {
    struct module_attribute mattr;
    const char *module_name;
    const char *version;
};

struct modules_array {
    struct module **mods;
    int mods_cnt;
    int mods_cap;
};

struct modversion_info {
    long unsigned int crc;
    char name[56];
};

struct modversion_info_ext {
    size_t remaining;
    const u32 *crc;
    const char *name;
};

struct vfsmount {
    struct dentry *mnt_root;
    struct super_block *mnt_sb;
    int mnt_flags;
    struct mnt_idmap *mnt_idmap;
};

struct mountpoint;

struct mount {
    struct hlist_node mnt_hash;
    struct mount *mnt_parent;
    struct dentry *mnt_mountpoint;
    struct vfsmount mnt;
    union {
        struct rb_node mnt_node;
        struct callback_head mnt_rcu;
        struct llist_node mnt_llist;
    };
    struct mnt_pcp *mnt_pcp;
    struct list_head mnt_mounts;
    struct list_head mnt_child;
    struct list_head mnt_instance;
    const char *mnt_devname;
    struct list_head mnt_list;
    struct list_head mnt_expire;
    struct list_head mnt_share;
    struct list_head mnt_slave_list;
    struct list_head mnt_slave;
    struct mount *mnt_master;
    struct mnt_namespace *mnt_ns;
    struct mountpoint *mnt_mp;
    union {
        struct hlist_node mnt_mp_list;
        struct hlist_node mnt_umount;
    };
    struct list_head mnt_umounting;
    struct fsnotify_mark_connector *mnt_fsnotify_marks;
    __u32 mnt_fsnotify_mask;
    int mnt_id;
    u64 mnt_id_unique;
    int mnt_group_id;
    int mnt_expiry_mark;
    struct hlist_head mnt_pins;
    struct hlist_head mnt_stuck_children;
};

struct mount_attr {
    __u64 attr_set;
    __u64 attr_clr;
    __u64 propagation;
    __u64 userns_fd;
};

struct mount_kattr {
    unsigned int attr_set;
    unsigned int attr_clr;
    unsigned int propagation;
    unsigned int lookup_flags;
    bool recurse;
    struct user_namespace *mnt_userns;
    struct mnt_idmap *mnt_idmap;
};

struct mount_opts {
    int token;
    int mount_opt;
    int flags;
};

struct mountpoint {
    struct hlist_node m_hash;
    struct dentry *m_dentry;
    struct hlist_head m_list;
    int m_count;
};

struct mousedev_hw_data {
    int dx;
    int dy;
    int dz;
    int x;
    int y;
    int abs_event;
    long unsigned int buttons;
};

struct mousedev {
    int open;
    struct input_handle handle;
    wait_queue_head_t wait;
    struct list_head client_list;
    spinlock_t client_lock;
    struct mutex mutex;
    struct device dev;
    struct cdev cdev;
    bool exist;
    struct list_head mixdev_node;
    bool opened_by_mixdev;
    struct mousedev_hw_data packet;
    unsigned int pkt_count;
    int old_x[4];
    int old_y[4];
    int frac_dx;
    int frac_dy;
    long unsigned int touch;
    int (*open_device)(struct mousedev *);
    void (*close_device)(struct mousedev *);
};

struct mousedev_motion {
    int dx;
    int dy;
    int dz;
    long unsigned int buttons;
};

struct mousedev_client {
    struct fasync_struct *fasync;
    struct mousedev *mousedev;
    struct list_head node;
    struct mousedev_motion packets[16];
    unsigned int head;
    unsigned int tail;
    spinlock_t packet_lock;
    int pos_x;
    int pos_y;
    u8 ps2[6];
    unsigned char ready;
    unsigned char buffer;
    unsigned char bufsiz;
    unsigned char imexseq;
    unsigned char impsseq;
    enum mousedev_emul mode;
    long unsigned int last_buttons;
};

struct movable_operations {
    bool (*isolate_page)(struct page *, isolate_mode_t);
    int (*migrate_page)(struct page *, struct page *, enum migrate_mode);
    void (*putback_page)(struct page *);
};

struct move_extent {
    __u32 reserved;
    __u32 donor_fd;
    __u64 orig_start;
    __u64 donor_start;
    __u64 len;
    __u64 moved_len;
};

struct mpage_da_data {
    struct inode *inode;
    struct writeback_control *wbc;
    unsigned int can_map: 1;
    long unsigned int first_page;
    long unsigned int next_page;
    long unsigned int last_page;
    struct ext4_map_blocks map;
    struct ext4_io_submit io_submit;
    unsigned int do_map: 1;
    unsigned int scanned_until_end: 1;
    unsigned int journalled_more_data: 1;
};

struct mpage_data {
    struct bio *bio;
    sector_t last_block_in_bio;
    get_block_t *get_block;
};

struct mpage_readpage_args {
    struct bio *bio;
    struct folio *folio;
    unsigned int nr_pages;
    bool is_readahead;
    sector_t last_block_in_bio;
    struct buffer_head map_bh;
    long unsigned int first_logical_block;
    get_block_t *get_block;
};

struct mpfs_gpio_reg_offsets;

struct mpfs_gpio_chip {
    struct regmap *regs;
    const struct mpfs_gpio_reg_offsets *offsets;
    struct gpio_chip gc;
};

struct mpfs_gpio_reg_offsets {
    u8 inp;
    u8 outp;
};

struct mpidr_hash {
    u64 mask;
    u32 shift_aff[4];
    u32 bits;
};

struct mpls_label {
    __be32 entry;
};

struct mpls_shim_hdr {
    __be32 label_stack_entry;
};

struct mptcp_addr_info {
    u8 id;
    sa_family_t family;
    __be16 port;
    union {
        struct in_addr addr;
        struct in6_addr addr6;
    };
};

struct mptcp_data_frag {
    struct list_head list;
    u64 data_seq;
    u16 data_len;
    u16 offset;
    u16 overhead;
    u16 already_sent;
    struct page *page;
};

struct mptcp_delegated_action {
    struct napi_struct napi;
    struct list_head head;
};

struct mptcp_ext {
    union {
        u64 data_ack;
        u32 data_ack32;
    };
    u64 data_seq;
    u32 subflow_seq;
    u16 data_len;
    __sum16 csum;
    u8 use_map: 1;
    u8 dsn64: 1;
    u8 data_fin: 1;
    u8 use_ack: 1;
    u8 ack64: 1;
    u8 mpc_map: 1;
    u8 frozen: 1;
    u8 reset_transient: 1;
    u8 reset_reason: 4;
    u8 csum_reqd: 1;
    u8 infinite_map: 1;
};

struct mptcp_info {
    __u8 mptcpi_subflows;
    __u8 mptcpi_add_addr_signal;
    __u8 mptcpi_add_addr_accepted;
    __u8 mptcpi_subflows_max;
    __u8 mptcpi_add_addr_signal_max;
    __u8 mptcpi_add_addr_accepted_max;
    __u32 mptcpi_flags;
    __u32 mptcpi_token;
    __u64 mptcpi_write_seq;
    __u64 mptcpi_snd_una;
    __u64 mptcpi_rcv_nxt;
    __u8 mptcpi_local_addr_used;
    __u8 mptcpi_local_addr_max;
    __u8 mptcpi_csum_enabled;
    __u32 mptcpi_retransmits;
    __u64 mptcpi_bytes_retrans;
    __u64 mptcpi_bytes_sent;
    __u64 mptcpi_bytes_received;
    __u64 mptcpi_bytes_acked;
    __u8 mptcpi_subflows_total;
    __u8 reserved[3];
    __u32 mptcpi_last_data_sent;
    __u32 mptcpi_last_data_recv;
    __u32 mptcpi_last_ack_recv;
};

struct mptcp_full_info {
    __u32 size_tcpinfo_kernel;
    __u32 size_tcpinfo_user;
    __u32 size_sfinfo_kernel;
    __u32 size_sfinfo_user;
    __u32 num_subflows;
    __u32 size_arrays_user;
    __u64 subflow_info;
    __u64 tcp_info;
    struct mptcp_info mptcp_info;
};

struct mptcp_mib {
    long unsigned int mibs[71];
};

struct mptcp_rm_list {
    u8 ids[8];
    u8 nr;
};

struct mptcp_options_received {
    u64 sndr_key;
    u64 rcvr_key;
    u64 data_ack;
    u64 data_seq;
    u32 subflow_seq;
    u16 data_len;
    __sum16 csum;
    union {
        struct {
            u16 suboptions;
            u16 use_map: 1;
            u16 dsn64: 1;
            u16 data_fin: 1;
            u16 use_ack: 1;
            u16 ack64: 1;
            u16 mpc_map: 1;
            u16 reset_reason: 4;
            u16 reset_transient: 1;
            u16 echo: 1;
            u16 backup: 1;
            u16 deny_join_id0: 1;
            u16 __unused: 2;
        };
        struct {
            u16 suboptions;
            u16 use_map: 1;
            u16 dsn64: 1;
            u16 data_fin: 1;
            u16 use_ack: 1;
            u16 ack64: 1;
            u16 mpc_map: 1;
            u16 reset_reason: 4;
            u16 reset_transient: 1;
            u16 echo: 1;
            u16 backup: 1;
            u16 deny_join_id0: 1;
            u16 __unused: 2;
        } status;
    };
    u8 join_id;
    u32 token;
    u32 nonce;
    u64 thmac;
    u8 hmac[20];
    struct mptcp_addr_info addr;
    struct mptcp_rm_list rm_list;
    u64 ahmac;
    u64 fail_seq;
};

struct mptcp_out_options {
    u16 suboptions;
    struct mptcp_rm_list rm_list;
    u8 join_id;
    u8 backup;
    u8 reset_reason: 4;
    u8 reset_transient: 1;
    u8 csum_reqd: 1;
    u8 allow_join_id0: 1;
    union {
        struct {
            u64 sndr_key;
            u64 rcvr_key;
            u64 data_seq;
            u32 subflow_seq;
            u16 data_len;
            __sum16 csum;
        };
        struct {
            struct mptcp_addr_info addr;
            u64 ahmac;
        };
        struct {
            struct mptcp_ext ext_copy;
            u64 fail_seq;
        };
        struct {
            u32 nonce;
            u32 token;
            u64 thmac;
            u8 hmac[20];
        };
    };
};

struct mptcp_pernet {
    struct ctl_table_header *ctl_table_hdr;
    unsigned int add_addr_timeout;
    unsigned int blackhole_timeout;
    unsigned int close_timeout;
    unsigned int stale_loss_cnt;
    atomic_t active_disable_times;
    u8 syn_retrans_before_tcp_fallback;
    long unsigned int active_disable_stamp;
    u8 mptcp_enabled;
    u8 checksum_enabled;
    u8 allow_join_initial_addr_port;
    u8 pm_type;
    char scheduler[16];
};

struct mptcp_sock;

struct mptcp_pm_add_entry {
    struct list_head list;
    struct mptcp_addr_info addr;
    u8 retrans_times;
    struct timer_list add_timer;
    struct mptcp_sock *sock;
};

struct mptcp_pm_addr_entry {
    struct list_head list;
    struct mptcp_addr_info addr;
    u8 flags;
    int ifindex;
    struct socket *lsk;
};

struct mptcp_pm_data {
    struct mptcp_addr_info local;
    struct mptcp_addr_info remote;
    struct list_head anno_list;
    struct list_head userspace_pm_local_addr_list;
    spinlock_t lock;
    u8 addr_signal;
    bool server_side;
    bool work_pending;
    bool accept_addr;
    bool accept_subflow;
    bool remote_deny_join_id0;
    u8 add_addr_signaled;
    u8 add_addr_accepted;
    u8 local_addr_used;
    u8 pm_type;
    u8 subflows;
    u8 status;
    long unsigned int id_avail_bitmap[4];
    struct mptcp_rm_list rm_list_tx;
    struct mptcp_rm_list rm_list_rx;
};

struct mptcp_pm_local {
    struct mptcp_addr_info addr;
    u8 flags;
    int ifindex;
};

struct mptcp_subflow_context;

struct mptcp_sched_data {
    bool reinject;
    u8 subflows;
    struct mptcp_subflow_context *contexts[8];
};

struct mptcp_sched_ops {
    int (*get_subflow)(struct mptcp_sock *, struct mptcp_sched_data *);
    char name[16];
    struct module *owner;
    struct list_head list;
    void (*init)(struct mptcp_sock *);
    void (*release)(struct mptcp_sock *);
};

struct mptcp_sendmsg_info {
    int mss_now;
    int size_goal;
    u16 limit;
    u16 sent;
    unsigned int flags;
    bool data_lock_held;
};

struct mptcp_skb_cb {
    u64 map_seq;
    u64 end_seq;
    u32 offset;
    u8 has_rxtstamp: 1;
};

struct mptcp_sock {
    struct inet_connection_sock sk;
    u64 local_key;
    u64 remote_key;
    u64 write_seq;
    u64 bytes_sent;
    u64 snd_nxt;
    u64 bytes_received;
    u64 ack_seq;
    atomic64_t rcv_wnd_sent;
    u64 rcv_data_fin_seq;
    u64 bytes_retrans;
    u64 bytes_consumed;
    int rmem_fwd_alloc;
    int snd_burst;
    int old_wspace;
    u64 recovery_snd_nxt;
    u64 bytes_acked;
    u64 snd_una;
    u64 wnd_end;
    u32 last_data_sent;
    u32 last_data_recv;
    u32 last_ack_recv;
    long unsigned int timer_ival;
    u32 token;
    int rmem_released;
    long unsigned int flags;
    long unsigned int cb_flags;
    bool recovery;
    bool can_ack;
    bool fully_established;
    bool rcv_data_fin;
    bool snd_data_fin_enable;
    bool rcv_fastclose;
    bool use_64bit_ack;
    bool csum_enabled;
    bool allow_infinite_fallback;
    u8 pending_state;
    u8 mpc_endpoint_id;
    u8 recvmsg_inq: 1;
    u8 cork: 1;
    u8 nodelay: 1;
    u8 fastopening: 1;
    u8 in_accept_queue: 1;
    u8 free_first: 1;
    u8 rcvspace_init: 1;
    u32 notsent_lowat;
    int keepalive_cnt;
    int keepalive_idle;
    int keepalive_intvl;
    struct work_struct work;
    struct sk_buff *ooo_last_skb;
    struct rb_root out_of_order_queue;
    struct sk_buff_head receive_queue;
    struct list_head conn_list;
    struct list_head rtx_queue;
    struct mptcp_data_frag *first_pending;
    struct list_head join_list;
    struct sock *first;
    struct mptcp_pm_data pm;
    struct mptcp_sched_ops *sched;
    struct {
        u32 space;
        u32 copied;
        u64 time;
        u64 rtt_us;
    } rcvq_space;
    u8 scaling_ratio;
    u32 subflow_id;
    u32 setsockopt_seq;
    char ca_name[16];
};

struct sockaddr_in {
    __kernel_sa_family_t sin_family;
    __be16 sin_port;
    struct in_addr sin_addr;
    unsigned char __pad[8];
};

struct mptcp_subflow_addrs {
    union {
        __kernel_sa_family_t sa_family;
        struct sockaddr sa_local;
        struct sockaddr_in sin_local;
        struct sockaddr_in6 sin6_local;
        struct __kernel_sockaddr_storage ss_local;
    };
    union {
        struct sockaddr sa_remote;
        struct sockaddr_in sin_remote;
        struct sockaddr_in6 sin6_remote;
        struct __kernel_sockaddr_storage ss_remote;
    };
};

struct mptcp_subflow_context {
    struct list_head node;
    union {
        struct {
            long unsigned int avg_pacing_rate;
            u64 local_key;
            u64 remote_key;
            u64 idsn;
            u64 map_seq;
            u32 snd_isn;
            u32 token;
            u32 rel_write_seq;
            u32 map_subflow_seq;
            u32 ssn_offset;
            u32 map_data_len;
            __wsum map_data_csum;
            u32 map_csum_len;
            u32 request_mptcp: 1;
            u32 request_join: 1;
            u32 request_bkup: 1;
            u32 mp_capable: 1;
            u32 mp_join: 1;
            u32 pm_notified: 1;
            u32 conn_finished: 1;
            u32 map_valid: 1;
            u32 map_csum_reqd: 1;
            u32 map_data_fin: 1;
            u32 mpc_map: 1;
            u32 backup: 1;
            u32 send_mp_prio: 1;
            u32 send_mp_fail: 1;
            u32 send_fastclose: 1;
            u32 send_infinite_map: 1;
            u32 remote_key_valid: 1;
            u32 disposable: 1;
            u32 stale: 1;
            u32 valid_csum_seen: 1;
            u32 is_mptfo: 1;
            u32 close_event_done: 1;
            u32 mpc_drop: 1;
            u32 __unused: 9;
            bool data_avail;
            bool scheduled;
            bool pm_listener;
            bool fully_established;
            u32 remote_nonce;
            u64 thmac;
            u32 local_nonce;
            u32 remote_token;
            union {
                u8 hmac[20];
                u64 iasn;
            };
            s16 local_id;
            u8 remote_id;
            u8 reset_seen: 1;
            u8 reset_transient: 1;
            u8 reset_reason: 4;
            u8 stale_count;
            u32 subflow_id;
            long int delegated_status;
            long unsigned int fail_tout;
        };
        struct {
            long unsigned int avg_pacing_rate;
            u64 local_key;
            u64 remote_key;
            u64 idsn;
            u64 map_seq;
            u32 snd_isn;
            u32 token;
            u32 rel_write_seq;
            u32 map_subflow_seq;
            u32 ssn_offset;
            u32 map_data_len;
            __wsum map_data_csum;
            u32 map_csum_len;
            u32 request_mptcp: 1;
            u32 request_join: 1;
            u32 request_bkup: 1;
            u32 mp_capable: 1;
            u32 mp_join: 1;
            u32 pm_notified: 1;
            u32 conn_finished: 1;
            u32 map_valid: 1;
            u32 map_csum_reqd: 1;
            u32 map_data_fin: 1;
            u32 mpc_map: 1;
            u32 backup: 1;
            u32 send_mp_prio: 1;
            u32 send_mp_fail: 1;
            u32 send_fastclose: 1;
            u32 send_infinite_map: 1;
            u32 remote_key_valid: 1;
            u32 disposable: 1;
            u32 stale: 1;
            u32 valid_csum_seen: 1;
            u32 is_mptfo: 1;
            u32 close_event_done: 1;
            u32 mpc_drop: 1;
            u32 __unused: 9;
            bool data_avail;
            bool scheduled;
            bool pm_listener;
            bool fully_established;
            u32 remote_nonce;
            u64 thmac;
            u32 local_nonce;
            u32 remote_token;
            union {
                u8 hmac[20];
                u64 iasn;
            };
            s16 local_id;
            u8 remote_id;
            u8 reset_seen: 1;
            u8 reset_transient: 1;
            u8 reset_reason: 4;
            u8 stale_count;
            u32 subflow_id;
            long int delegated_status;
            long unsigned int fail_tout;
        } reset;
    };
    struct list_head delegated_node;
    u32 setsockopt_seq;
    u32 stale_rcv_tstamp;
    int cached_sndbuf;
    struct sock *tcp_sock;
    struct sock *conn;
    const struct inet_connection_sock_af_ops *icsk_af_ops;
    void (*tcp_state_change)(struct sock *);
    void (*tcp_error_report)(struct sock *);
    struct callback_head rcu;
};

struct mptcp_subflow_data {
    __u32 size_subflow_data;
    __u32 num_subflows;
    __u32 size_kernel;
    __u32 size_user;
};

struct mptcp_subflow_info {
    __u32 id;
    struct mptcp_subflow_addrs addrs;
};

struct tcp_request_sock_ops;

struct tcp_request_sock {
    struct inet_request_sock req;
    const struct tcp_request_sock_ops *af_specific;
    u64 snt_synack;
    bool tfo_listener;
    bool is_mptcp;
    bool req_usec_ts;
    bool drop_req;
    u32 txhash;
    u32 rcv_isn;
    u32 snt_isn;
    u32 ts_off;
    u32 last_oow_ack_time;
    u32 rcv_nxt;
    u8 syn_tos;
    u8 ao_keyid;
    u8 ao_rcv_next;
    bool used_tcp_ao;
};

struct mptcp_subflow_request_sock {
    struct tcp_request_sock sk;
    u16 mp_capable: 1;
    u16 mp_join: 1;
    u16 backup: 1;
    u16 request_bkup: 1;
    u16 csum_reqd: 1;
    u16 allow_join_id0: 1;
    u8 local_id;
    u8 remote_id;
    u64 local_key;
    u64 idsn;
    u32 token;
    u32 ssn_offset;
    u64 thmac;
    u32 local_nonce;
    u32 remote_nonce;
    struct mptcp_sock *msk;
    struct hlist_nulls_node token_node;
};

struct mq_inflight {
    struct block_device *part;
    unsigned int inflight[2];
};

struct mq_sched {
    struct Qdisc **qdiscs;
};

struct mqueue_fs_context {
    struct ipc_namespace *ipc_ns;
    bool newns;
};

struct sigevent {
    sigval_t sigev_value;
    int sigev_signo;
    int sigev_notify;
    union {
        int _pad[12];
        int _tid;
        struct {
            void (*_function)(sigval_t);
            void *_attribute;
        } _sigev_thread;
    } _sigev_un;
};

struct posix_msg_tree_node;

struct mqueue_inode_info {
    spinlock_t lock;
    struct inode vfs_inode;
    wait_queue_head_t wait_q;
    struct rb_root msg_tree;
    struct rb_node *msg_tree_rightmost;
    struct posix_msg_tree_node *node_cache;
    struct mq_attr attr;
    struct sigevent notify;
    struct pid *notify_owner;
    u32 notify_self_exec_id;
    struct user_namespace *notify_user_ns;
    struct ucounts *ucounts;
    struct sock *notify_sock;
    struct sk_buff *notify_cookie;
    struct ext_wait_queue e_wait_q[2];
    long unsigned int qsize;
};

struct mr_mfc_iter {
    struct seq_net_private p;
    struct mr_table *mrt;
    struct list_head *cache;
    spinlock_t *lock;
};

struct mr_table_ops {
    const struct rhashtable_params *rht_params;
    void *cmparg_any;
};

struct vif_device {
    struct net_device *dev;
    netdevice_tracker dev_tracker;
    long unsigned int bytes_in;
    long unsigned int bytes_out;
    long unsigned int pkt_in;
    long unsigned int pkt_out;
    long unsigned int rate_limit;
    unsigned char threshold;
    short unsigned int flags;
    int link;
    struct netdev_phys_item_id dev_parent_id;
    __be32 local;
    __be32 remote;
};

struct rhltable {
    struct rhashtable ht;
};

struct mr_table {
    struct list_head list;
    possible_net_t net;
    struct mr_table_ops ops;
    u32 id;
    struct sock *mroute_sk;
    struct timer_list ipmr_expire_timer;
    struct list_head mfc_unres_queue;
    struct vif_device vif_table[32];
    struct rhltable mfc_hash;
    struct list_head mfc_cache_list;
    int maxvif;
    atomic_t cache_resolve_queue_len;
    bool mroute_do_assert;
    bool mroute_do_pim;
    bool mroute_do_wrvifwhole;
    int mroute_reg_vif_num;
};

struct mr_vif_iter {
    struct seq_net_private p;
    struct mr_table *mrt;
    int ct;
};

struct mrt6msg {
    __u8 im6_mbz;
    __u8 im6_msgtype;
    __u16 im6_mif;
    __u32 im6_pad;
    struct in6_addr im6_src;
    struct in6_addr im6_dst;
};

struct msdos_dir_entry {
    __u8 name[11];
    __u8 attr;
    __u8 lcase;
    __u8 ctime_cs;
    __le16 ctime;
    __le16 cdate;
    __le16 adate;
    __le16 starthi;
    __le16 time;
    __le16 date;
    __le16 start;
    __le32 size;
};

struct msdos_dir_slot {
    __u8 id;
    __u8 name0_4[10];
    __u8 attr;
    __u8 reserved;
    __u8 alias_checksum;
    __u8 name5_10[12];
    __le16 start;
    __u8 name11_12[4];
};

struct msdos_inode_info {
    spinlock_t cache_lru_lock;
    struct list_head cache_lru;
    int nr_caches;
    unsigned int cache_valid_id;
    loff_t mmu_private;
    int i_start;
    int i_logstart;
    int i_attrs;
    loff_t i_pos;
    struct hlist_node i_fat_hash;
    struct hlist_node i_dir_hash;
    struct rw_semaphore truncate_lock;
    struct timespec64 i_crtime;
    struct inode vfs_inode;
};

struct msdos_partition {
    u8 boot_ind;
    u8 head;
    u8 sector;
    u8 cyl;
    u8 sys_ind;
    u8 end_head;
    u8 end_sector;
    u8 end_cyl;
    __le32 start_sect;
    __le32 nr_sects;
};

struct nls_table;

struct msdos_sb_info {
    short unsigned int sec_per_clus;
    short unsigned int cluster_bits;
    unsigned int cluster_size;
    unsigned char fats;
    unsigned char fat_bits;
    short unsigned int fat_start;
    long unsigned int fat_length;
    long unsigned int dir_start;
    short unsigned int dir_entries;
    long unsigned int data_start;
    long unsigned int max_cluster;
    long unsigned int root_cluster;
    long unsigned int fsinfo_sector;
    struct mutex fat_lock;
    struct mutex nfs_build_inode_lock;
    struct mutex s_lock;
    unsigned int prev_free;
    unsigned int free_clusters;
    unsigned int free_clus_valid;
    struct fat_mount_options options;
    struct nls_table *nls_disk;
    struct nls_table *nls_io;
    const void *dir_ops;
    int dir_per_block;
    int dir_per_block_bits;
    unsigned int vol_id;
    int fatent_shift;
    const struct fatent_operations *fatent_ops;
    struct inode *fat_inode;
    struct inode *fsinfo_inode;
    struct ratelimit_state ratelimit;
    spinlock_t inode_hash_lock;
    struct hlist_head inode_hashtable[256];
    spinlock_t dir_hash_lock;
    struct hlist_head dir_hashtable[256];
    unsigned int dirty;
    struct callback_head rcu;
};

struct msg_msgseg;

struct msg_msg {
    struct list_head m_list;
    long int m_type;
    size_t m_ts;
    struct msg_msgseg *next;
    void *security;
};

struct msg_msgseg {
    struct msg_msgseg *next;
};

struct msg_queue {
    struct kern_ipc_perm q_perm;
    time64_t q_stime;
    time64_t q_rtime;
    time64_t q_ctime;
    long unsigned int q_cbytes;
    long unsigned int q_qnum;
    long unsigned int q_qbytes;
    struct pid *q_lspid;
    struct pid *q_lrpid;
    struct list_head q_messages;
    struct list_head q_receivers;
    struct list_head q_senders;
    long: 64;
    long: 64;
};

struct msg_receiver {
    struct list_head r_list;
    struct task_struct *r_tsk;
    int r_mode;
    long int r_msgtype;
    long int r_maxsize;
    struct msg_msg *r_msg;
};

struct msg_security_struct {
    u32 sid;
};

struct msg_sender {
    struct list_head list;
    struct task_struct *tsk;
    size_t msgsz;
};

struct msgbuf {
    __kernel_long_t mtype;
    char mtext[1];
};

struct msginfo {
    int msgpool;
    int msgmap;
    int msgmax;
    int msgmnb;
    int msgmni;
    int msgssz;
    int msgtql;
    short unsigned int msgseg;
};

struct msi_ctrl {
    unsigned int domid;
    unsigned int first;
    unsigned int last;
    unsigned int nirqs;
};

struct msi_msg {
    union {
        u32 address_lo;
        arch_msi_msg_addr_lo_t arch_addr_lo;
    };
    union {
        u32 address_hi;
        arch_msi_msg_addr_hi_t arch_addr_hi;
    };
    union {
        u32 data;
        arch_msi_msg_data_t arch_data;
    };
};

struct pci_msi_desc {
    union {
        u32 msi_mask;
        u32 msix_ctrl;
    };
    struct {
        u8 is_msix: 1;
        u8 multiple: 3;
        u8 multi_cap: 3;
        u8 can_mask: 1;
        u8 is_64: 1;
        u8 is_virtual: 1;
        unsigned int default_irq;
    } msi_attrib;
    union {
        u8 mask_pos;
        void *mask_base;
    };
};

union msi_domain_cookie {
    u64 value;
    void *ptr;
    void *iobase;
};

union msi_instance_cookie {
    u64 value;
    void *ptr;
};

struct msi_desc_data {
    union msi_domain_cookie dcookie;
    union msi_instance_cookie icookie;
};

struct msi_desc {
    unsigned int irq;
    unsigned int nvec_used;
    struct device *dev;
    struct msi_msg msg;
    struct irq_affinity_desc *affinity;
    const void *iommu_cookie;
    struct device_attribute *sysfs_attrs;
    void (*write_msi_msg)(struct msi_desc *, void *);
    void *write_msi_msg_data;
    u16 msi_index;
    union {
        struct pci_msi_desc pci;
        struct msi_desc_data data;
    };
};

struct msi_dev_domain {
    struct xarray store;
    struct irq_domain *domain;
};

struct msi_device_data {
    long unsigned int properties;
    struct mutex mutex;
    struct msi_dev_domain __domains[1];
    long unsigned int __iter_idx;
};

struct msi_domain_ops;

struct msi_domain_info {
    u32 flags;
    enum irq_domain_bus_token bus_token;
    unsigned int hwsize;
    struct msi_domain_ops *ops;
    struct irq_chip *chip;
    void *chip_data;
    irq_flow_handler_t handler;
    void *handler_data;
    const char *handler_name;
    void *data;
};

struct msi_domain_ops {
    irq_hw_number_t (*get_hwirq)(struct msi_domain_info *, msi_alloc_info_t *);
    int (*msi_init)(struct irq_domain *, struct msi_domain_info *, unsigned int, irq_hw_number_t, msi_alloc_info_t *);
    void (*msi_free)(struct irq_domain *, struct msi_domain_info *, unsigned int);
    int (*msi_prepare)(struct irq_domain *, struct device *, int, msi_alloc_info_t *);
    void (*prepare_desc)(struct irq_domain *, msi_alloc_info_t *, struct msi_desc *);
    void (*set_desc)(msi_alloc_info_t *, struct msi_desc *);
    int (*domain_alloc_irqs)(struct irq_domain *, struct device *, int);
    void (*domain_free_irqs)(struct irq_domain *, struct device *);
    void (*msi_post_free)(struct irq_domain *, struct device *);
    int (*msi_translate)(struct irq_domain *, struct irq_fwspec *, irq_hw_number_t *, unsigned int *);
};

struct msi_domain_template {
    char name[48];
    struct irq_chip chip;
    struct msi_domain_ops ops;
    struct msi_domain_info info;
};

struct msi_map {
    int index;
    int virq;
};

struct msi_parent_ops {
    u32 supported_flags;
    u32 required_flags;
    u32 bus_select_token;
    u32 bus_select_mask;
    const char *prefix;
    bool (*init_dev_msi_info)(struct device *, struct irq_domain *, struct irq_domain *, struct msi_domain_info *);
};

struct msix_entry {
    u32 vector;
    u16 entry;
};

struct msqid64_ds {
    struct ipc64_perm msg_perm;
    long int msg_stime;
    long int msg_rtime;
    long int msg_ctime;
    long unsigned int msg_cbytes;
    long unsigned int msg_qnum;
    long unsigned int msg_qbytes;
    __kernel_pid_t msg_lspid;
    __kernel_pid_t msg_lrpid;
    long unsigned int __unused4;
    long unsigned int __unused5;
};

struct msg;

struct msqid_ds {
    struct ipc_perm msg_perm;
    struct msg *msg_first;
    struct msg *msg_last;
    __kernel_old_time_t msg_stime;
    __kernel_old_time_t msg_rtime;
    __kernel_old_time_t msg_ctime;
    long unsigned int msg_lcbytes;
    long unsigned int msg_lqbytes;
    short unsigned int msg_cbytes;
    short unsigned int msg_qnum;
    short unsigned int msg_qbytes;
    __kernel_ipc_pid_t msg_lspid;
    __kernel_ipc_pid_t msg_lrpid;
};

struct mthp_stat {
    long unsigned int stats[170];
};

struct mtk_drive_desc {
    u8 min;
    u8 max;
    u8 step;
    u8 scal;
};

struct mtk_eint_hw;

struct mtk_eint_regs;

struct mtk_eint_xt;

struct mtk_eint {
    struct device *dev;
    void *base;
    struct irq_domain *domain;
    int irq;
    int *dual_edge;
    u32 *wake_mask;
    u32 *cur_mask;
    const struct mtk_eint_hw *hw;
    const struct mtk_eint_regs *regs;
    u16 num_db_time;
    void *pctl;
    const struct mtk_eint_xt *gpio_xlate;
};

struct mtk_eint_desc {
    u16 eint_m;
    u16 eint_n;
};

struct mtk_eint_hw {
    u8 port_mask;
    u8 ports;
    unsigned int ap_num;
    unsigned int db_cnt;
    const unsigned int *db_time;
};

struct mtk_eint_regs {
    unsigned int stat;
    unsigned int ack;
    unsigned int mask;
    unsigned int mask_set;
    unsigned int mask_clr;
    unsigned int sens;
    unsigned int sens_set;
    unsigned int sens_clr;
    unsigned int soft;
    unsigned int soft_set;
    unsigned int soft_clr;
    unsigned int pol;
    unsigned int pol_set;
    unsigned int pol_clr;
    unsigned int dom_en;
    unsigned int dbnc_ctrl;
    unsigned int dbnc_set;
    unsigned int dbnc_clr;
};

struct mtk_eint_xt {
    int (*get_gpio_n)(void *, long unsigned int, unsigned int *, struct gpio_chip **);
    int (*get_gpio_state)(void *, long unsigned int);
    int (*set_gpio_as_eint)(void *, long unsigned int);
};

struct mtk_func_desc {
    const char *name;
    u8 muxval;
};

struct mtk_pin_desc {
    unsigned int number;
    const char *name;
    struct mtk_eint_desc eint;
    u8 drv_n;
    struct mtk_func_desc *funcs;
};

struct mtk_pin_field {
    u8 index;
    u32 offset;
    u32 mask;
    u8 bitpos;
    u8 next;
};

struct mtk_pin_field_calc {
    u16 s_pin;
    u16 e_pin;
    u8 i_base;
    u32 s_addr;
    u8 x_addrs;
    u8 s_bit;
    u8 x_bits;
    u8 sz_reg;
    u8 fixed;
};

struct mtk_pin_reg_calc {
    const struct mtk_pin_field_calc *range;
    unsigned int nranges;
};

struct mtk_pin_rsel {
    u16 s_pin;
    u16 e_pin;
    u16 rsel_index;
    u32 up_rsel;
    u32 down_rsel;
};

struct mtk_pinctrl;

struct mtk_pin_soc {
    const struct mtk_pin_reg_calc *reg_cal;
    const struct mtk_pin_desc *pins;
    unsigned int npins;
    const struct group_desc *grps;
    unsigned int ngrps;
    const struct function_desc *funcs;
    unsigned int nfuncs;
    const struct mtk_eint_regs *eint_regs;
    const struct mtk_eint_hw *eint_hw;
    u8 gpio_m;
    bool ies_present;
    const char * const *base_names;
    unsigned int nbase_names;
    const unsigned int *pull_type;
    const struct mtk_pin_rsel *pin_rsel;
    unsigned int npin_rsel;
    int (*bias_disable_set)(struct mtk_pinctrl *, const struct mtk_pin_desc *);
    int (*bias_disable_get)(struct mtk_pinctrl *, const struct mtk_pin_desc *, int *);
    int (*bias_set)(struct mtk_pinctrl *, const struct mtk_pin_desc *, bool);
    int (*bias_get)(struct mtk_pinctrl *, const struct mtk_pin_desc *, bool, int *);
    int (*bias_set_combo)(struct mtk_pinctrl *, const struct mtk_pin_desc *, u32, u32);
    int (*bias_get_combo)(struct mtk_pinctrl *, const struct mtk_pin_desc *, u32 *, u32 *);
    int (*drive_set)(struct mtk_pinctrl *, const struct mtk_pin_desc *, u32);
    int (*drive_get)(struct mtk_pinctrl *, const struct mtk_pin_desc *, int *);
    int (*adv_pull_set)(struct mtk_pinctrl *, const struct mtk_pin_desc *, bool, u32);
    int (*adv_pull_get)(struct mtk_pinctrl *, const struct mtk_pin_desc *, bool, u32 *);
    int (*adv_drive_set)(struct mtk_pinctrl *, const struct mtk_pin_desc *, u32);
    int (*adv_drive_get)(struct mtk_pinctrl *, const struct mtk_pin_desc *, u32 *);
    void *driver_data;
};

struct mtk_pinctrl_group;

struct mtk_pinctrl {
    struct pinctrl_dev *pctrl;
    void **base;
    u8 nbase;
    struct device *dev;
    struct gpio_chip chip;
    const struct mtk_pin_soc *soc;
    struct mtk_eint *eint;
    struct mtk_pinctrl_group *groups;
    const char **grp_names;
    spinlock_t lock;
    bool rsel_si_unit;
};

struct mtk_pinctrl_group {
    const char *name;
    long unsigned int config;
    unsigned int pin;
};

struct multi_stop_data {
    cpu_stop_fn_t fn;
    void *data;
    unsigned int num_threads;
    const struct cpumask *active_cpus;
    enum multi_stop_state state;
    atomic_t thread_ack;
};

struct multi_symbols_sort {
    const char **funcs;
    u64 *cookies;
};

struct multi_transaction {
    struct kref count;
    ssize_t size;
    char data[0];
};

struct multiprocess_signals {
    sigset_t signal;
    struct hlist_node node;
};

typedef struct mutex *class_mutex_t;

typedef class_mutex_t class_mutex_intr_t;

struct mutex_waiter {
    struct list_head list;
    struct task_struct *task;
    struct ww_acquire_ctx *ww_ctx;
};

struct mz_hdr {
    uint16_t magic;
    uint16_t lbsize;
    uint16_t blocks;
    uint16_t relocs;
    uint16_t hdrsize;
    uint16_t min_extra_pps;
    uint16_t max_extra_pps;
    uint16_t ss;
    uint16_t sp;
    uint16_t checksum;
    uint16_t ip;
    uint16_t cs;
    uint16_t reloc_table_offset;
    uint16_t overlay_num;
    uint16_t reserved0[4];
    uint16_t oem_id;
    uint16_t oem_info;
    uint16_t reserved1[10];
    uint32_t peaddr;
    char message[0];
};

struct n_tty_data {
    size_t read_head;
    size_t commit_head;
    size_t canon_head;
    size_t echo_head;
    size_t echo_commit;
    size_t echo_mark;
    long unsigned int char_map[4];
    long unsigned int overrun_time;
    unsigned int num_overrun;
    bool no_room;
    unsigned char lnext: 1;
    unsigned char erasing: 1;
    unsigned char raw: 1;
    unsigned char real_raw: 1;
    unsigned char icanon: 1;
    unsigned char push: 1;
    u8 read_buf[4096];
    long unsigned int read_flags[64];
    u8 echo_buf[4096];
    size_t read_tail;
    size_t line_start;
    size_t lookahead_count;
    unsigned int column;
    unsigned int canon_column;
    size_t echo_tail;
    struct mutex atomic_read_lock;
    struct mutex output_lock;
};

struct saved {
    struct path link;
    struct delayed_call done;
    const char *name;
    unsigned int seq;
};

struct nameidata {
    struct path path;
    struct qstr last;
    struct path root;
    struct inode *inode;
    unsigned int flags;
    unsigned int state;
    unsigned int seq;
    unsigned int next_seq;
    unsigned int m_seq;
    unsigned int r_seq;
    int last_type;
    unsigned int depth;
    int total_link_count;
    struct saved *stack;
    struct saved internal[2];
    struct filename *name;
    const char *pathname;
    struct nameidata *saved;
    unsigned int root_seq;
    int dfd;
    vfsuid_t dir_vfsuid;
    umode_t dir_mode;
};

struct page_frag_cache {
    long unsigned int encoded_page;
    __u32 offset;
    __u32 pagecnt_bias;
};

struct napi_alloc_cache {
    local_lock_t bh_lock;
    struct page_frag_cache page;
    unsigned int skb_count;
    void *skb_cache[64];
};

struct napi_config {
    u64 gro_flush_timeout;
    u64 irq_suspend_timeout;
    u32 defer_hard_irqs;
    unsigned int napi_id;
};

struct napi_gro_cb {
    union {
        struct {
            void *frag0;
            unsigned int frag0_len;
        };
        struct {
            struct sk_buff *last;
            long unsigned int age;
        };
    };
    int data_offset;
    u16 flush;
    u16 count;
    u16 proto;
    u16 pad;
    union {
        struct {
            u16 gro_remcsum_start;
            u8 same_flow: 1;
            u8 encap_mark: 1;
            u8 csum_valid: 1;
            u8 csum_cnt: 3;
            u8 free: 2;
            u8 is_ipv6: 1;
            u8 is_fou: 1;
            u8 ip_fixedid: 1;
            u8 recursion_counter: 4;
            u8 is_flist: 1;
        };
        struct {
            u16 gro_remcsum_start;
            u8 same_flow: 1;
            u8 encap_mark: 1;
            u8 csum_valid: 1;
            u8 csum_cnt: 3;
            u8 free: 2;
            u8 is_ipv6: 1;
            u8 is_fou: 1;
            u8 ip_fixedid: 1;
            u8 recursion_counter: 4;
            u8 is_flist: 1;
        } zeroed;
    };
    __wsum csum;
    union {
        struct {
            u16 network_offset;
            u16 inner_network_offset;
        };
        u16 network_offsets[2];
    };
};

struct nat_keepalive {
    struct net *net;
    u16 family;
    xfrm_address_t saddr;
    xfrm_address_t daddr;
    __be16 encap_sport;
    __be16 encap_dport;
    __u32 smark;
};

struct nat_keepalive_work_ctx {
    time64_t next_run;
    time64_t now;
};

struct nbcon_state {
    union {
        unsigned int atom;
        struct {
            unsigned int prio: 2;
            unsigned int req_prio: 2;
            unsigned int unsafe: 1;
            unsigned int unsafe_takeover: 1;
            unsigned int cpu: 24;
        };
    };
};

struct nbcon_write_context {
    struct nbcon_context ctxt;
    char *outbuf;
    unsigned int len;
    bool unsafe_takeover;
};

struct nd_msg {
    struct icmp6hdr icmph;
    struct in6_addr target;
    __u8 opt[0];
};

struct nd_opt_hdr {
    __u8 nd_opt_type;
    __u8 nd_opt_len;
};

struct nda_cacheinfo {
    __u32 ndm_confirmed;
    __u32 ndm_used;
    __u32 ndm_updated;
    __u32 ndm_refcnt;
};

struct ndisc_options;

struct prefix_info;

struct ndisc_ops {
    int (*parse_options)(const struct net_device *, struct nd_opt_hdr *, struct ndisc_options *);
    void (*update)(const struct net_device *, struct neighbour *, u32, u8, const struct ndisc_options *);
    int (*opt_addr_space)(const struct net_device *, u8, struct neighbour *, u8 *, u8 **);
    void (*fill_addr_option)(const struct net_device *, struct sk_buff *, u8, const u8 *);
    void (*prefix_rcv_add_addr)(struct net *, struct net_device *, const struct prefix_info *, struct inet6_dev *, struct in6_addr *, int, u32, bool, bool, __u32, u32, bool);
};

struct ndisc_options {
    struct nd_opt_hdr *nd_opt_array[15];
    struct nd_opt_hdr *nd_opts_ri;
    struct nd_opt_hdr *nd_opts_ri_end;
    struct nd_opt_hdr *nd_useropts;
    struct nd_opt_hdr *nd_useropts_end;
    struct nd_opt_hdr *nd_802154_opt_array[3];
};

struct ndmsg {
    __u8 ndm_family;
    __u8 ndm_pad1;
    __u16 ndm_pad2;
    __s32 ndm_ifindex;
    __u16 ndm_state;
    __u8 ndm_flags;
    __u8 ndm_type;
};

struct ndo_fdb_dump_context {
    long unsigned int ifindex;
    long unsigned int fdb_idx;
};

struct ndt_config {
    __u16 ndtc_key_len;
    __u16 ndtc_entry_size;
    __u32 ndtc_entries;
    __u32 ndtc_last_flush;
    __u32 ndtc_last_rand;
    __u32 ndtc_hash_rnd;
    __u32 ndtc_hash_mask;
    __u32 ndtc_hash_chain_gc;
    __u32 ndtc_proxy_qlen;
};

struct ndt_stats {
    __u64 ndts_allocs;
    __u64 ndts_destroys;
    __u64 ndts_hash_grows;
    __u64 ndts_res_failed;
    __u64 ndts_lookups;
    __u64 ndts_hits;
    __u64 ndts_rcv_probes_mcast;
    __u64 ndts_rcv_probes_ucast;
    __u64 ndts_periodic_gc_runs;
    __u64 ndts_forced_gc_runs;
    __u64 ndts_table_fulls;
};

struct ndtmsg {
    __u8 ndtm_family;
    __u8 ndtm_pad1;
    __u16 ndtm_pad2;
};

struct nduseroptmsg {
    unsigned char nduseropt_family;
    unsigned char nduseropt_pad1;
    short unsigned int nduseropt_opts_len;
    int nduseropt_ifindex;
    __u8 nduseropt_icmp_type;
    __u8 nduseropt_icmp_code;
    short unsigned int nduseropt_pad2;
    unsigned int nduseropt_pad3;
};

struct neigh_dump_filter {
    int master_idx;
    int dev_idx;
};

struct neigh_hash_table {
    struct hlist_head *hash_heads;
    unsigned int hash_shift;
    __u32 hash_rnd[4];
    struct callback_head rcu;
};

struct neigh_ops {
    int family;
    void (*solicit)(struct neighbour *, struct sk_buff *);
    void (*error_report)(struct neighbour *, struct sk_buff *);
    int (*output)(struct neighbour *, struct sk_buff *);
    int (*connected_output)(struct neighbour *, struct sk_buff *);
};

struct neigh_parms {
    possible_net_t net;
    struct net_device *dev;
    netdevice_tracker dev_tracker;
    struct list_head list;
    int (*neigh_setup)(struct neighbour *);
    struct neigh_table *tbl;
    void *sysctl_table;
    int dead;
    refcount_t refcnt;
    struct callback_head callback_head;
    int reachable_time;
    u32 qlen;
    int data[14];
    long unsigned int data_state[1];
};

struct neigh_seq_state {
    struct seq_net_private p;
    struct neigh_table *tbl;
    struct neigh_hash_table *nht;
    void * (*neigh_sub_iter)(struct neigh_seq_state *, struct neighbour *, loff_t *);
    unsigned int bucket;
    unsigned int flags;
};

struct neigh_statistics {
    long unsigned int allocs;
    long unsigned int destroys;
    long unsigned int hash_grows;
    long unsigned int res_failed;
    long unsigned int lookups;
    long unsigned int hits;
    long unsigned int rcv_probes_mcast;
    long unsigned int rcv_probes_ucast;
    long unsigned int periodic_gc_runs;
    long unsigned int forced_gc_runs;
    long unsigned int unres_discards;
    long unsigned int table_fulls;
};

struct neigh_sysctl_table {
    struct ctl_table_header *sysctl_header;
    struct ctl_table neigh_vars[21];
};

struct pneigh_entry;

struct neigh_table {
    int family;
    unsigned int entry_size;
    unsigned int key_len;
    __be16 protocol;
    __u32 (*hash)(const void *, const struct net_device *, __u32 *);
    bool (*key_eq)(const struct neighbour *, const void *);
    int (*constructor)(struct neighbour *);
    int (*pconstructor)(struct pneigh_entry *);
    void (*pdestructor)(struct pneigh_entry *);
    void (*proxy_redo)(struct sk_buff *);
    int (*is_multicast)(const void *);
    bool (*allow_add)(const struct net_device *, struct netlink_ext_ack *);
    char *id;
    struct neigh_parms parms;
    struct list_head parms_list;
    int gc_interval;
    int gc_thresh1;
    int gc_thresh2;
    int gc_thresh3;
    long unsigned int last_flush;
    struct delayed_work gc_work;
    struct delayed_work managed_work;
    struct timer_list proxy_timer;
    struct sk_buff_head proxy_queue;
    atomic_t entries;
    atomic_t gc_entries;
    struct list_head gc_list;
    struct list_head managed_list;
    rwlock_t lock;
    long unsigned int last_rand;
    struct neigh_statistics *stats;
    struct neigh_hash_table *nht;
    struct pneigh_entry **phash_buckets;
};

struct neighbour {
    struct hlist_node hash;
    struct hlist_node dev_list;
    struct neigh_table *tbl;
    struct neigh_parms *parms;
    long unsigned int confirmed;
    long unsigned int updated;
    rwlock_t lock;
    refcount_t refcnt;
    unsigned int arp_queue_len_bytes;
    struct sk_buff_head arp_queue;
    struct timer_list timer;
    long unsigned int used;
    atomic_t probes;
    u8 nud_state;
    u8 type;
    u8 dead;
    u8 protocol;
    u32 flags;
    seqlock_t ha_lock;
    long: 0;
    unsigned char ha[32];
    struct hh_cache hh;
    int (*output)(struct neighbour *, struct sk_buff *);
    const struct neigh_ops *ops;
    struct list_head gc_list;
    struct list_head managed_list;
    struct callback_head rcu;
    struct net_device *dev;
    netdevice_tracker dev_tracker;
    u8 primary_key[0];
};

struct neighbour_cb {
    long unsigned int sched_next;
    unsigned int flags;
};

union nested_table {
    union nested_table *table;
    struct rhash_lock_head *bucket;
};

struct ref_tracker_dir {};

struct prot_inuse;

struct netns_core {
    struct ctl_table_header *sysctl_hdr;
    int sysctl_somaxconn;
    int sysctl_optmem_max;
    u8 sysctl_txrehash;
    u8 sysctl_tstamp_allow_data;
    struct prot_inuse *prot_inuse;
    struct cpumask *rps_default_mask;
};

struct tcp_mib;

struct udp_mib;

struct netns_mib {
    struct ipstats_mib *ip_statistics;
    struct ipstats_mib *ipv6_statistics;
    struct tcp_mib *tcp_statistics;
    struct linux_mib *net_statistics;
    struct udp_mib *udp_statistics;
    struct udp_mib *udp_stats_in6;
    struct linux_xfrm_mib *xfrm_statistics;
    struct linux_tls_mib *tls_statistics;
    struct mptcp_mib *mptcp_statistics;
    struct udp_mib *udplite_statistics;
    struct udp_mib *udplite_stats_in6;
    struct icmp_mib *icmp_statistics;
    struct icmpmsg_mib *icmpmsg_statistics;
    struct icmpv6_mib *icmpv6_statistics;
    struct icmpv6msg_mib *icmpv6msg_statistics;
    struct proc_dir_entry *proc_net_devsnmp6;
};

struct netns_packet {
    struct mutex sklist_lock;
    struct hlist_head sklist;
};

struct unix_table {
    spinlock_t *locks;
    struct hlist_head *buckets;
};

struct netns_unix {
    struct unix_table table;
    int sysctl_max_dgram_qlen;
    struct ctl_table_header *ctl;
};

struct netns_nexthop {
    struct rb_root rb_root;
    struct hlist_head *devhash;
    unsigned int seq;
    u32 last_id_allocated;
    struct blocking_notifier_head notifier_chain;
};

struct ping_group_range {
    seqlock_t lock;
    kgid_t range[2];
};

struct sysctl_fib_multipath_hash_seed {
    u32 user_seed;
    u32 mp_seed;
};

struct netns_ipv4 {
    __u8 __cacheline_group_begin__netns_ipv4_read_tx[0];
    u8 sysctl_tcp_early_retrans;
    u8 sysctl_tcp_tso_win_divisor;
    u8 sysctl_tcp_tso_rtt_log;
    u8 sysctl_tcp_autocorking;
    int sysctl_tcp_min_snd_mss;
    unsigned int sysctl_tcp_notsent_lowat;
    int sysctl_tcp_limit_output_bytes;
    int sysctl_tcp_min_rtt_wlen;
    int sysctl_tcp_wmem[3];
    u8 sysctl_ip_fwd_use_pmtu;
    __u8 __cacheline_group_end__netns_ipv4_read_tx[0];
    __u8 __cacheline_group_begin__netns_ipv4_read_txrx[0];
    u8 sysctl_tcp_moderate_rcvbuf;
    __u8 __cacheline_group_end__netns_ipv4_read_txrx[0];
    __u8 __cacheline_group_begin__netns_ipv4_read_rx[0];
    u8 sysctl_ip_early_demux;
    u8 sysctl_tcp_early_demux;
    u8 sysctl_tcp_l3mdev_accept;
    int sysctl_tcp_reordering;
    int sysctl_tcp_rmem[3];
    __u8 __cacheline_group_end__netns_ipv4_read_rx[0];
    long: 64;
    struct inet_timewait_death_row tcp_death_row;
    struct udp_table *udp_table;
    struct ctl_table_header *forw_hdr;
    struct ctl_table_header *frags_hdr;
    struct ctl_table_header *ipv4_hdr;
    struct ctl_table_header *route_hdr;
    struct ctl_table_header *xfrm4_hdr;
    struct ipv4_devconf *devconf_all;
    struct ipv4_devconf *devconf_dflt;
    struct ip_ra_chain *ra_chain;
    struct mutex ra_mutex;
    struct fib_rules_ops *rules_ops;
    struct fib_table *fib_main;
    struct fib_table *fib_default;
    unsigned int fib_rules_require_fldissect;
    bool fib_has_custom_rules;
    bool fib_has_custom_local_routes;
    bool fib_offload_disabled;
    u8 sysctl_tcp_shrink_window;
    atomic_t fib_num_tclassid_users;
    struct hlist_head *fib_table_hash;
    struct sock *fibnl;
    struct sock *mc_autojoin_sk;
    struct inet_peer_base *peers;
    struct fqdir *fqdir;
    u8 sysctl_icmp_echo_ignore_all;
    u8 sysctl_icmp_echo_enable_probe;
    u8 sysctl_icmp_echo_ignore_broadcasts;
    u8 sysctl_icmp_ignore_bogus_error_responses;
    u8 sysctl_icmp_errors_use_inbound_ifaddr;
    int sysctl_icmp_ratelimit;
    int sysctl_icmp_ratemask;
    int sysctl_icmp_msgs_per_sec;
    int sysctl_icmp_msgs_burst;
    atomic_t icmp_global_credit;
    u32 icmp_global_stamp;
    u32 ip_rt_min_pmtu;
    int ip_rt_mtu_expires;
    int ip_rt_min_advmss;
    struct local_ports ip_local_ports;
    u8 sysctl_tcp_ecn;
    u8 sysctl_tcp_ecn_fallback;
    u8 sysctl_ip_default_ttl;
    u8 sysctl_ip_no_pmtu_disc;
    u8 sysctl_ip_fwd_update_priority;
    u8 sysctl_ip_nonlocal_bind;
    u8 sysctl_ip_autobind_reuse;
    u8 sysctl_ip_dynaddr;
    u8 sysctl_raw_l3mdev_accept;
    u8 sysctl_udp_early_demux;
    u8 sysctl_nexthop_compat_mode;
    u8 sysctl_fwmark_reflect;
    u8 sysctl_tcp_fwmark_accept;
    u8 sysctl_tcp_mtu_probing;
    int sysctl_tcp_mtu_probe_floor;
    int sysctl_tcp_base_mss;
    int sysctl_tcp_probe_threshold;
    u32 sysctl_tcp_probe_interval;
    int sysctl_tcp_keepalive_time;
    int sysctl_tcp_keepalive_intvl;
    u8 sysctl_tcp_keepalive_probes;
    u8 sysctl_tcp_syn_retries;
    u8 sysctl_tcp_synack_retries;
    u8 sysctl_tcp_syncookies;
    u8 sysctl_tcp_migrate_req;
    u8 sysctl_tcp_comp_sack_nr;
    u8 sysctl_tcp_backlog_ack_defer;
    u8 sysctl_tcp_pingpong_thresh;
    u8 sysctl_tcp_retries1;
    u8 sysctl_tcp_retries2;
    u8 sysctl_tcp_orphan_retries;
    u8 sysctl_tcp_tw_reuse;
    unsigned int sysctl_tcp_tw_reuse_delay;
    int sysctl_tcp_fin_timeout;
    u8 sysctl_tcp_sack;
    u8 sysctl_tcp_window_scaling;
    u8 sysctl_tcp_timestamps;
    int sysctl_tcp_rto_min_us;
    u8 sysctl_tcp_recovery;
    u8 sysctl_tcp_thin_linear_timeouts;
    u8 sysctl_tcp_slow_start_after_idle;
    u8 sysctl_tcp_retrans_collapse;
    u8 sysctl_tcp_stdurg;
    u8 sysctl_tcp_rfc1337;
    u8 sysctl_tcp_abort_on_overflow;
    u8 sysctl_tcp_fack;
    int sysctl_tcp_max_reordering;
    int sysctl_tcp_adv_win_scale;
    u8 sysctl_tcp_dsack;
    u8 sysctl_tcp_app_win;
    u8 sysctl_tcp_frto;
    u8 sysctl_tcp_nometrics_save;
    u8 sysctl_tcp_no_ssthresh_metrics_save;
    u8 sysctl_tcp_workaround_signed_windows;
    int sysctl_tcp_challenge_ack_limit;
    u8 sysctl_tcp_min_tso_segs;
    u8 sysctl_tcp_reflect_tos;
    int sysctl_tcp_invalid_ratelimit;
    int sysctl_tcp_pacing_ss_ratio;
    int sysctl_tcp_pacing_ca_ratio;
    unsigned int sysctl_tcp_child_ehash_entries;
    long unsigned int sysctl_tcp_comp_sack_delay_ns;
    long unsigned int sysctl_tcp_comp_sack_slack_ns;
    int sysctl_max_syn_backlog;
    int sysctl_tcp_fastopen;
    const struct tcp_congestion_ops *tcp_congestion_control;
    struct tcp_fastopen_context *tcp_fastopen_ctx;
    unsigned int sysctl_tcp_fastopen_blackhole_timeout;
    atomic_t tfo_active_disable_times;
    long unsigned int tfo_active_disable_stamp;
    u32 tcp_challenge_timestamp;
    u32 tcp_challenge_count;
    u8 sysctl_tcp_plb_enabled;
    u8 sysctl_tcp_plb_idle_rehash_rounds;
    u8 sysctl_tcp_plb_rehash_rounds;
    u8 sysctl_tcp_plb_suspend_rto_sec;
    int sysctl_tcp_plb_cong_thresh;
    int sysctl_udp_wmem_min;
    int sysctl_udp_rmem_min;
    u8 sysctl_fib_notify_on_flag_change;
    u8 sysctl_tcp_syn_linear_timeouts;
    u8 sysctl_udp_l3mdev_accept;
    u8 sysctl_igmp_llm_reports;
    int sysctl_igmp_max_memberships;
    int sysctl_igmp_max_msf;
    int sysctl_igmp_qrv;
    struct ping_group_range ping_group_range;
    atomic_t dev_addr_genid;
    unsigned int sysctl_udp_child_hash_entries;
    long unsigned int *sysctl_local_reserved_ports;
    int sysctl_ip_prot_sock;
    struct list_head mr_tables;
    struct fib_rules_ops *mr_rules_ops;
    struct sysctl_fib_multipath_hash_seed sysctl_fib_multipath_hash_seed;
    u32 sysctl_fib_multipath_hash_fields;
    u8 sysctl_fib_multipath_use_neigh;
    u8 sysctl_fib_multipath_hash_policy;
    struct fib_notifier_ops *notifier_ops;
    unsigned int fib_seq;
    struct fib_notifier_ops *ipmr_notifier_ops;
    unsigned int ipmr_seq;
    atomic_t rt_genid;
    siphash_key_t ip_id_key;
    struct hlist_head *inet_addr_lst;
    struct delayed_work addr_chk_work;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
};

struct netns_sysctl_ipv6 {
    struct ctl_table_header *hdr;
    struct ctl_table_header *route_hdr;
    struct ctl_table_header *icmp_hdr;
    struct ctl_table_header *frags_hdr;
    struct ctl_table_header *xfrm6_hdr;
    int flush_delay;
    int ip6_rt_max_size;
    int ip6_rt_gc_min_interval;
    int ip6_rt_gc_timeout;
    int ip6_rt_gc_interval;
    int ip6_rt_gc_elasticity;
    int ip6_rt_mtu_expires;
    int ip6_rt_min_advmss;
    u32 multipath_hash_fields;
    u8 multipath_hash_policy;
    u8 bindv6only;
    u8 flowlabel_consistency;
    u8 auto_flowlabels;
    int icmpv6_time;
    u8 icmpv6_echo_ignore_all;
    u8 icmpv6_echo_ignore_multicast;
    u8 icmpv6_echo_ignore_anycast;
    long unsigned int icmpv6_ratemask[4];
    long unsigned int *icmpv6_ratemask_ptr;
    u8 anycast_src_echo_reply;
    u8 ip_nonlocal_bind;
    u8 fwmark_reflect;
    u8 flowlabel_state_ranges;
    int idgen_retries;
    int idgen_delay;
    int flowlabel_reflect;
    int max_dst_opts_cnt;
    int max_hbh_opts_cnt;
    int max_dst_opts_len;
    int max_hbh_opts_len;
    int seg6_flowlabel;
    u32 ioam6_id;
    u64 ioam6_id_wide;
    u8 skip_notify_on_dev_down;
    u8 fib_notify_on_flag_change;
    u8 icmpv6_error_anycast_as_unicast;
};

struct rt6_statistics;

struct seg6_pernet_data;

struct netns_ipv6 {
    struct dst_ops ip6_dst_ops;
    struct netns_sysctl_ipv6 sysctl;
    struct ipv6_devconf *devconf_all;
    struct ipv6_devconf *devconf_dflt;
    struct inet_peer_base *peers;
    struct fqdir *fqdir;
    struct fib6_info *fib6_null_entry;
    struct rt6_info *ip6_null_entry;
    struct rt6_statistics *rt6_stats;
    struct timer_list ip6_fib_timer;
    struct hlist_head *fib_table_hash;
    struct fib6_table *fib6_main_tbl;
    struct list_head fib6_walkers;
    rwlock_t fib6_walker_lock;
    spinlock_t fib6_gc_lock;
    atomic_t ip6_rt_gc_expire;
    long unsigned int ip6_rt_last_gc;
    unsigned char flowlabel_has_excl;
    bool fib6_has_custom_rules;
    unsigned int fib6_rules_require_fldissect;
    unsigned int fib6_routes_require_src;
    struct rt6_info *ip6_prohibit_entry;
    struct rt6_info *ip6_blk_hole_entry;
    struct fib6_table *fib6_local_tbl;
    struct fib_rules_ops *fib6_rules_ops;
    struct sock *ndisc_sk;
    struct sock *tcp_sk;
    struct sock *igmp_sk;
    struct sock *mc_autojoin_sk;
    struct hlist_head *inet6_addr_lst;
    spinlock_t addrconf_hash_lock;
    struct delayed_work addr_chk_work;
    struct list_head mr6_tables;
    struct fib_rules_ops *mr6_rules_ops;
    atomic_t dev_addr_genid;
    atomic_t fib6_sernum;
    struct seg6_pernet_data *seg6_data;
    struct fib_notifier_ops *notifier_ops;
    struct fib_notifier_ops *ip6mr_notifier_ops;
    unsigned int ipmr_seq;
    struct {
        struct hlist_head head;
        spinlock_t lock;
        u32 seq;
    } ip6addrlbl_table;
    struct ioam6_pernet_data *ioam6_data;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
};

struct netns_sysctl_lowpan {
    struct ctl_table_header *frags_hdr;
};

struct netns_ieee802154_lowpan {
    struct netns_sysctl_lowpan sysctl;
    struct fqdir *fqdir;
};

struct sctp_mib;

struct netns_sctp {
    struct sctp_mib *sctp_statistics;
    struct proc_dir_entry *proc_net_sctp;
    struct ctl_table_header *sysctl_header;
    struct sock *ctl_sock;
    struct sock *udp4_sock;
    struct sock *udp6_sock;
    int udp_port;
    int encap_port;
    struct list_head local_addr_list;
    struct list_head addr_waitq;
    struct timer_list addr_wq_timer;
    struct list_head auto_asconf_splist;
    spinlock_t addr_wq_lock;
    spinlock_t local_addr_lock;
    unsigned int rto_initial;
    unsigned int rto_min;
    unsigned int rto_max;
    int rto_alpha;
    int rto_beta;
    int max_burst;
    int cookie_preserve_enable;
    char *sctp_hmac_alg;
    unsigned int valid_cookie_life;
    unsigned int sack_timeout;
    unsigned int hb_interval;
    unsigned int probe_interval;
    int max_retrans_association;
    int max_retrans_path;
    int max_retrans_init;
    int pf_retrans;
    int ps_retrans;
    int pf_enable;
    int pf_expose;
    int sndbuf_policy;
    int rcvbuf_policy;
    int default_auto_asconf;
    int addip_enable;
    int addip_noauth;
    int prsctp_enable;
    int reconf_enable;
    int auth_enable;
    int intl_enable;
    int ecn_enable;
    int scope_policy;
    int rwnd_upd_shift;
    long unsigned int max_autoclose;
    int l3mdev_accept;
};

struct nf_logger;

struct nf_hook_entries;

struct netns_nf {
    struct proc_dir_entry *proc_netfilter;
    const struct nf_logger *nf_loggers[11];
    struct ctl_table_header *nf_log_dir_header;
    struct ctl_table_header *nf_lwtnl_dir_header;
    struct nf_hook_entries *hooks_ipv4[5];
    struct nf_hook_entries *hooks_ipv6[5];
    struct nf_hook_entries *hooks_arp[3];
    struct nf_hook_entries *hooks_bridge[5];
    unsigned int defrag_ipv4_users;
    unsigned int defrag_ipv6_users;
};

struct nf_generic_net {
    unsigned int timeout;
};

struct nf_tcp_net {
    unsigned int timeouts[14];
    u8 tcp_loose;
    u8 tcp_be_liberal;
    u8 tcp_max_retrans;
    u8 tcp_ignore_invalid_rst;
    unsigned int offload_timeout;
};

struct nf_udp_net {
    unsigned int timeouts[2];
    unsigned int offload_timeout;
};

struct nf_icmp_net {
    unsigned int timeout;
};

struct nf_dccp_net {
    u8 dccp_loose;
    unsigned int dccp_timeout[10];
};

struct nf_sctp_net {
    unsigned int timeouts[10];
};

struct nf_gre_net {
    struct list_head keymap_list;
    unsigned int timeouts[2];
};

struct nf_ip_net {
    struct nf_generic_net generic;
    struct nf_tcp_net tcp;
    struct nf_udp_net udp;
    struct nf_icmp_net icmp;
    struct nf_icmp_net icmpv6;
    struct nf_dccp_net dccp;
    struct nf_sctp_net sctp;
    struct nf_gre_net gre;
};

struct nf_ct_event_notifier;

struct netns_ct {
    bool ecache_dwork_pending;
    u8 sysctl_log_invalid;
    u8 sysctl_events;
    u8 sysctl_acct;
    u8 sysctl_tstamp;
    u8 sysctl_checksum;
    struct ip_conntrack_stat *stat;
    struct nf_ct_event_notifier *nf_conntrack_event_cb;
    struct nf_ip_net nf_ct_proto;
    atomic_t labels_used;
};

struct netns_nftables {
    u8 gencursor;
};

struct nf_flow_table_stat;

struct netns_ft {
    struct nf_flow_table_stat *stat;
};

struct netns_bpf {
    struct bpf_prog_array *run_array[2];
    struct bpf_prog *progs[2];
    struct list_head links[2];
};

struct xfrm_policy_hash {
    struct hlist_head *table;
    unsigned int hmask;
    u8 dbits4;
    u8 sbits4;
    u8 dbits6;
    u8 sbits6;
};

struct xfrm_policy_hthresh {
    struct work_struct work;
    seqlock_t lock;
    u8 lbits4;
    u8 rbits4;
    u8 lbits6;
    u8 rbits6;
};

struct netns_xfrm {
    struct list_head state_all;
    struct hlist_head *state_bydst;
    struct hlist_head *state_bysrc;
    struct hlist_head *state_byspi;
    struct hlist_head *state_byseq;
    struct hlist_head *state_cache_input;
    unsigned int state_hmask;
    unsigned int state_num;
    struct work_struct state_hash_work;
    struct list_head policy_all;
    struct hlist_head *policy_byidx;
    unsigned int policy_idx_hmask;
    unsigned int idx_generator;
    struct xfrm_policy_hash policy_bydst[3];
    unsigned int policy_count[6];
    struct work_struct policy_hash_work;
    struct xfrm_policy_hthresh policy_hthresh;
    struct list_head inexact_bins;
    struct sock *nlsk;
    struct sock *nlsk_stash;
    u32 sysctl_aevent_etime;
    u32 sysctl_aevent_rseqth;
    int sysctl_larval_drop;
    u32 sysctl_acq_expires;
    u8 policy_default[3];
    struct ctl_table_header *sysctl_hdr;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    struct dst_ops xfrm4_dst_ops;
    struct dst_ops xfrm6_dst_ops;
    spinlock_t xfrm_state_lock;
    seqcount_spinlock_t xfrm_state_hash_generation;
    seqcount_spinlock_t xfrm_policy_hash_generation;
    spinlock_t xfrm_policy_lock;
    struct mutex xfrm_cfg_mutex;
    struct delayed_work nat_keepalive_work;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
};

struct netns_ipvs;

struct mpls_route;

struct netns_mpls {
    int ip_ttl_propagate;
    int default_ttl;
    size_t platform_labels;
    struct mpls_route **platform_label;
    struct ctl_table_header *ctl;
};

struct can_dev_rcv_lists;

struct can_pkg_stats;

struct can_rcv_lists_stats;

struct netns_can {
    struct proc_dir_entry *proc_dir;
    struct proc_dir_entry *pde_stats;
    struct proc_dir_entry *pde_reset_stats;
    struct proc_dir_entry *pde_rcvlist_all;
    struct proc_dir_entry *pde_rcvlist_fil;
    struct proc_dir_entry *pde_rcvlist_inv;
    struct proc_dir_entry *pde_rcvlist_sff;
    struct proc_dir_entry *pde_rcvlist_eff;
    struct proc_dir_entry *pde_rcvlist_err;
    struct proc_dir_entry *bcmproc_dir;
    struct can_dev_rcv_lists *rx_alldev_list;
    spinlock_t rcvlists_lock;
    struct timer_list stattimer;
    struct can_pkg_stats *pkg_stats;
    struct can_rcv_lists_stats *rcv_lists_stats;
    struct hlist_head cgw_list;
};

struct netns_xdp {
    struct mutex lock;
    struct hlist_head list;
};

struct smc_stats;

struct smc_stats_rsn;

struct netns_smc {
    struct smc_stats *smc_stats;
    struct mutex mutex_fback_rsn;
    struct smc_stats_rsn *fback_rsn;
    bool limit_smc_hs;
    struct ctl_table_header *smc_hdr;
    unsigned int sysctl_autocorking_size;
    unsigned int sysctl_smcr_buf_type;
    int sysctl_smcr_testlink_time;
    int sysctl_wmem;
    int sysctl_rmem;
    int sysctl_max_links_per_lgr;
    int sysctl_max_conns_per_lgr;
};

struct uevent_sock;

struct net_generic;

struct net {
    refcount_t passive;
    spinlock_t rules_mod_lock;
    unsigned int dev_base_seq;
    u32 ifindex;
    spinlock_t nsid_lock;
    atomic_t fnhe_genid;
    struct list_head list;
    struct list_head exit_list;
    struct llist_node defer_free_list;
    struct llist_node cleanup_list;
    struct key_tag *key_domain;
    struct user_namespace *user_ns;
    struct ucounts *ucounts;
    struct idr netns_ids;
    struct ns_common ns;
    struct ref_tracker_dir refcnt_tracker;
    struct ref_tracker_dir notrefcnt_tracker;
    struct list_head dev_base_head;
    struct proc_dir_entry *proc_net;
    struct proc_dir_entry *proc_net_stat;
    struct ctl_table_set sysctls;
    struct sock *rtnl;
    struct sock *genl_sock;
    struct uevent_sock *uevent_sock;
    struct hlist_head *dev_name_head;
    struct hlist_head *dev_index_head;
    struct xarray dev_by_index;
    struct raw_notifier_head netdev_chain;
    u32 hash_mix;
    struct net_device *loopback_dev;
    struct list_head rules_ops;
    struct netns_core core;
    struct netns_mib mib;
    struct netns_packet packet;
    struct netns_unix unx;
    struct netns_nexthop nexthop;
    long: 64;
    long: 64;
    struct netns_ipv4 ipv4;
    struct netns_ipv6 ipv6;
    struct netns_ieee802154_lowpan ieee802154_lowpan;
    struct netns_sctp sctp;
    struct netns_nf nf;
    struct netns_ct ct;
    struct netns_nftables nft;
    struct netns_ft ft;
    struct sk_buff_head wext_nlevents;
    struct net_generic *gen;
    struct netns_bpf bpf;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    struct netns_xfrm xfrm;
    u64 net_cookie;
    struct netns_ipvs *ipvs;
    struct netns_mpls mpls;
    struct netns_can can;
    struct netns_xdp xdp;
    struct sock *crypto_nlsk;
    struct sock *diag_nlsk;
    struct netns_smc smc;
    long: 64;
    long: 64;
    long: 64;
};

struct rtable {
    struct dst_entry dst;
    int rt_genid;
    unsigned int rt_flags;
    __u16 rt_type;
    __u8 rt_is_input;
    __u8 rt_uses_gateway;
    int rt_iif;
    u8 rt_gw_family;
    union {
        __be32 rt_gw4;
        struct in6_addr rt_gw6;
    };
    u32 rt_mtu_locked: 1;
    u32 rt_pmtu: 31;
};

struct rt6_info {
    struct dst_entry dst;
    struct fib6_info *from;
    int sernum;
    struct rt6key rt6i_dst;
    struct rt6key rt6i_src;
    struct in6_addr rt6i_gateway;
    struct inet6_dev *rt6i_idev;
    u32 rt6i_flags;
    short unsigned int rt6i_nfheader_len;
};

struct net_bridge;

struct net_bridge_vlan;

struct net_bridge_mcast {
    struct net_bridge *br;
    struct net_bridge_vlan *vlan;
    u32 multicast_last_member_count;
    u32 multicast_startup_query_count;
    u8 multicast_querier;
    u8 multicast_igmp_version;
    u8 multicast_router;
    u8 multicast_mld_version;
    long unsigned int multicast_last_member_interval;
    long unsigned int multicast_membership_interval;
    long unsigned int multicast_querier_interval;
    long unsigned int multicast_query_interval;
    long unsigned int multicast_query_response_interval;
    long unsigned int multicast_startup_query_interval;
    struct hlist_head ip4_mc_router_list;
    struct timer_list ip4_mc_router_timer;
    struct bridge_mcast_other_query ip4_other_query;
    struct bridge_mcast_own_query ip4_own_query;
    struct bridge_mcast_querier ip4_querier;
    struct hlist_head ip6_mc_router_list;
    struct timer_list ip6_mc_router_timer;
    struct bridge_mcast_other_query ip6_other_query;
    struct bridge_mcast_own_query ip6_own_query;
    struct bridge_mcast_querier ip6_querier;
};

struct net_bridge_vlan_group;

struct net_bridge {
    spinlock_t lock;
    spinlock_t hash_lock;
    struct hlist_head frame_type_list;
    struct net_device *dev;
    long unsigned int options;
    __be16 vlan_proto;
    u16 default_pvid;
    struct net_bridge_vlan_group *vlgrp;
    struct rhashtable fdb_hash_tbl;
    struct list_head port_list;
    union {
        struct rtable fake_rtable;
        struct rt6_info fake_rt6_info;
    };
    u16 group_fwd_mask;
    u16 group_fwd_mask_required;
    bridge_id designated_root;
    bridge_id bridge_id;
    unsigned char topology_change;
    unsigned char topology_change_detected;
    u16 root_port;
    long unsigned int max_age;
    long unsigned int hello_time;
    long unsigned int forward_delay;
    long unsigned int ageing_time;
    long unsigned int bridge_max_age;
    long unsigned int bridge_hello_time;
    long unsigned int bridge_forward_delay;
    long unsigned int bridge_ageing_time;
    u32 root_path_cost;
    u8 group_addr[6];
    enum {
        BR_NO_STP = 0,
        BR_KERNEL_STP = 1,
        BR_USER_STP = 2,
    } stp_enabled;
    struct net_bridge_mcast multicast_ctx;
    struct bridge_mcast_stats *mcast_stats;
    u32 hash_max;
    spinlock_t multicast_lock;
    struct rhashtable mdb_hash_tbl;
    struct rhashtable sg_port_tbl;
    struct hlist_head mcast_gc_list;
    struct hlist_head mdb_list;
    struct work_struct mcast_gc_work;
    struct timer_list hello_timer;
    struct timer_list tcn_timer;
    struct timer_list topology_change_timer;
    struct delayed_work gc_work;
    struct kobject *ifobj;
    u32 auto_cnt;
    atomic_t fdb_n_learned;
    u32 fdb_max_learned;
    int last_hwdom;
    long unsigned int busy_hwdoms;
    struct hlist_head fdb_list;
    struct hlist_head mrp_list;
    struct hlist_head mep_list;
};

struct net_bridge_fdb_key {
    mac_addr addr;
    u16 vlan_id;
};

struct net_bridge_port;

struct net_bridge_fdb_entry {
    struct rhash_head rhnode;
    struct net_bridge_port *dst;
    struct net_bridge_fdb_key key;
    struct hlist_node fdb_node;
    long unsigned int flags;
    long: 64;
    long: 64;
    long unsigned int updated;
    long unsigned int used;
    struct callback_head rcu;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
};

struct net_bridge_mcast_port {
    struct net_bridge_port *port;
    struct net_bridge_vlan *vlan;
    struct bridge_mcast_own_query ip4_own_query;
    struct timer_list ip4_mc_router_timer;
    struct hlist_node ip4_rlist;
    struct bridge_mcast_own_query ip6_own_query;
    struct timer_list ip6_mc_router_timer;
    struct hlist_node ip6_rlist;
    unsigned char multicast_router;
    u32 mdb_n_entries;
    u32 mdb_max_entries;
};

struct netpoll;

struct net_bridge_port {
    struct net_bridge *br;
    struct net_device *dev;
    netdevice_tracker dev_tracker;
    struct list_head list;
    long unsigned int flags;
    struct net_bridge_vlan_group *vlgrp;
    struct net_bridge_port *backup_port;
    u32 backup_nhid;
    u8 priority;
    u8 state;
    u16 port_no;
    unsigned char topology_change_ack;
    unsigned char config_pending;
    port_id port_id;
    port_id designated_port;
    bridge_id designated_root;
    bridge_id designated_bridge;
    u32 path_cost;
    u32 designated_cost;
    long unsigned int designated_age;
    struct timer_list forward_delay_timer;
    struct timer_list hold_timer;
    struct timer_list message_age_timer;
    struct kobject kobj;
    struct callback_head rcu;
    struct net_bridge_mcast_port multicast_ctx;
    struct bridge_mcast_stats *mcast_stats;
    u32 multicast_eht_hosts_limit;
    u32 multicast_eht_hosts_cnt;
    struct hlist_head mglist;
    char sysfs_name[16];
    struct netpoll *np;
    int hwdom;
    int offload_count;
    struct netdev_phys_item_id ppid;
    u16 group_fwd_mask;
    u16 backup_redirected_cnt;
    struct bridge_stp_xstats stp_xstats;
};

struct pcpu_sw_netstats;

struct net_bridge_vlan {
    struct rhash_head vnode;
    struct rhash_head tnode;
    u16 vid;
    u16 flags;
    u16 priv_flags;
    u8 state;
    struct pcpu_sw_netstats *stats;
    union {
        struct net_bridge *br;
        struct net_bridge_port *port;
    };
    union {
        refcount_t refcnt;
        struct net_bridge_vlan *brvlan;
    };
    struct br_tunnel_info tinfo;
    union {
        struct net_bridge_mcast br_mcast_ctx;
        struct net_bridge_mcast_port port_mcast_ctx;
    };
    u16 msti;
    struct list_head vlist;
    struct callback_head rcu;
};

struct net_bridge_vlan_group {
    struct rhashtable vlan_hash;
    struct rhashtable tunnel_hash;
    struct list_head vlan_list;
    u16 num_vlans;
    u16 pvid;
    u8 pvid_state;
};

struct netdev_tc_txq {
    u16 count;
    u16 offset;
};

typedef rx_handler_result_t rx_handler_func_t(struct sk_buff **);

struct net_device_stats {
    union {
        long unsigned int rx_packets;
        atomic_long_t __rx_packets;
    };
    union {
        long unsigned int tx_packets;
        atomic_long_t __tx_packets;
    };
    union {
        long unsigned int rx_bytes;
        atomic_long_t __rx_bytes;
    };
    union {
        long unsigned int tx_bytes;
        atomic_long_t __tx_bytes;
    };
    union {
        long unsigned int rx_errors;
        atomic_long_t __rx_errors;
    };
    union {
        long unsigned int tx_errors;
        atomic_long_t __tx_errors;
    };
    union {
        long unsigned int rx_dropped;
        atomic_long_t __rx_dropped;
    };
    union {
        long unsigned int tx_dropped;
        atomic_long_t __tx_dropped;
    };
    union {
        long unsigned int multicast;
        atomic_long_t __multicast;
    };
    union {
        long unsigned int collisions;
        atomic_long_t __collisions;
    };
    union {
        long unsigned int rx_length_errors;
        atomic_long_t __rx_length_errors;
    };
    union {
        long unsigned int rx_over_errors;
        atomic_long_t __rx_over_errors;
    };
    union {
        long unsigned int rx_crc_errors;
        atomic_long_t __rx_crc_errors;
    };
    union {
        long unsigned int rx_frame_errors;
        atomic_long_t __rx_frame_errors;
    };
    union {
        long unsigned int rx_fifo_errors;
        atomic_long_t __rx_fifo_errors;
    };
    union {
        long unsigned int rx_missed_errors;
        atomic_long_t __rx_missed_errors;
    };
    union {
        long unsigned int tx_aborted_errors;
        atomic_long_t __tx_aborted_errors;
    };
    union {
        long unsigned int tx_carrier_errors;
        atomic_long_t __tx_carrier_errors;
    };
    union {
        long unsigned int tx_fifo_errors;
        atomic_long_t __tx_fifo_errors;
    };
    union {
        long unsigned int tx_heartbeat_errors;
        atomic_long_t __tx_heartbeat_errors;
    };
    union {
        long unsigned int tx_window_errors;
        atomic_long_t __tx_window_errors;
    };
    union {
        long unsigned int rx_compressed;
        atomic_long_t __rx_compressed;
    };
    union {
        long unsigned int tx_compressed;
        atomic_long_t __tx_compressed;
    };
};

struct netdev_hw_addr_list {
    struct list_head list;
    int count;
    struct rb_root tree;
};

struct tipc_bearer;

struct mpls_dev;

struct garp_port;

struct mrp_port;

struct dm_hw_stat_delta;

struct udp_tunnel_nic;

struct net_device_ops;

struct xps_dev_maps;

struct pcpu_lstats;

struct pcpu_dstats;

struct netdev_rx_queue;

struct netpoll_info;

struct netdev_name_node;

struct xdp_metadata_ops;

struct xsk_tx_metadata_ops;

struct net_device_core_stats;

struct xfrmdev_ops;

struct tlsdev_ops;

struct vlan_info;

struct wireless_dev;

struct wpan_dev;

struct xdp_dev_bulk_queue;

struct rtnl_link_ops;

struct netdev_stat_ops;

struct netdev_queue_mgmt_ops;

struct netprio_map;

struct phy_link_topology;

struct sfp_bus;

struct udp_tunnel_nic_info;

struct netdev_config;

struct rtnl_hw_stats64;

struct net_shaper_hierarchy;

struct net_device {
    __u8 __cacheline_group_begin__net_device_read_tx[0];
    union {
        struct {
            long unsigned int priv_flags: 32;
            long unsigned int lltx: 1;
        };
        struct {
            long unsigned int priv_flags: 32;
            long unsigned int lltx: 1;
        } priv_flags_fast;
    };
    const struct net_device_ops *netdev_ops;
    const struct header_ops *header_ops;
    struct netdev_queue *_tx;
    netdev_features_t gso_partial_features;
    unsigned int real_num_tx_queues;
    unsigned int gso_max_size;
    unsigned int gso_ipv4_max_size;
    u16 gso_max_segs;
    s16 num_tc;
    unsigned int mtu;
    short unsigned int needed_headroom;
    struct netdev_tc_txq tc_to_txq[16];
    struct xps_dev_maps *xps_maps[2];
    struct nf_hook_entries *nf_hooks_egress;
    struct bpf_mprog_entry *tcx_egress;
    __u8 __cacheline_group_end__net_device_read_tx[0];
    __u8 __cacheline_group_begin__net_device_read_txrx[0];
    union {
        struct pcpu_lstats *lstats;
        struct pcpu_sw_netstats *tstats;
        struct pcpu_dstats *dstats;
    };
    long unsigned int state;
    unsigned int flags;
    short unsigned int hard_header_len;
    netdev_features_t features;
    struct inet6_dev *ip6_ptr;
    __u8 __cacheline_group_end__net_device_read_txrx[0];
    __u8 __cacheline_group_begin__net_device_read_rx[0];
    struct bpf_prog *xdp_prog;
    struct list_head ptype_specific;
    int ifindex;
    unsigned int real_num_rx_queues;
    struct netdev_rx_queue *_rx;
    unsigned int gro_max_size;
    unsigned int gro_ipv4_max_size;
    rx_handler_func_t *rx_handler;
    void *rx_handler_data;
    possible_net_t nd_net;
    struct netpoll_info *npinfo;
    struct bpf_mprog_entry *tcx_ingress;
    __u8 __cacheline_group_end__net_device_read_rx[0];
    char name[16];
    struct netdev_name_node *name_node;
    struct dev_ifalias *ifalias;
    long unsigned int mem_end;
    long unsigned int mem_start;
    long unsigned int base_addr;
    struct list_head dev_list;
    struct list_head napi_list;
    struct list_head unreg_list;
    struct list_head close_list;
    struct list_head ptype_all;
    struct {
        struct list_head upper;
        struct list_head lower;
    } adj_list;
    xdp_features_t xdp_features;
    const struct xdp_metadata_ops *xdp_metadata_ops;
    const struct xsk_tx_metadata_ops *xsk_tx_metadata_ops;
    short unsigned int gflags;
    short unsigned int needed_tailroom;
    netdev_features_t hw_features;
    netdev_features_t wanted_features;
    netdev_features_t vlan_features;
    netdev_features_t hw_enc_features;
    netdev_features_t mpls_features;
    unsigned int min_mtu;
    unsigned int max_mtu;
    short unsigned int type;
    unsigned char min_header_len;
    unsigned char name_assign_type;
    int group;
    struct net_device_stats stats;
    struct net_device_core_stats *core_stats;
    atomic_t carrier_up_count;
    atomic_t carrier_down_count;
    const struct iw_handler_def *wireless_handlers;
    const struct ethtool_ops *ethtool_ops;
    const struct l3mdev_ops *l3mdev_ops;
    const struct ndisc_ops *ndisc_ops;
    const struct xfrmdev_ops *xfrmdev_ops;
    const struct tlsdev_ops *tlsdev_ops;
    unsigned int operstate;
    unsigned char link_mode;
    unsigned char if_port;
    unsigned char dma;
    unsigned char perm_addr[32];
    unsigned char addr_assign_type;
    unsigned char addr_len;
    unsigned char upper_level;
    unsigned char lower_level;
    short unsigned int neigh_priv_len;
    short unsigned int dev_id;
    short unsigned int dev_port;
    int irq;
    u32 priv_len;
    spinlock_t addr_list_lock;
    struct netdev_hw_addr_list uc;
    struct netdev_hw_addr_list mc;
    struct netdev_hw_addr_list dev_addrs;
    struct kset *queues_kset;
    unsigned int promiscuity;
    unsigned int allmulti;
    bool uc_promisc;
    struct in_device *ip_ptr;
    struct hlist_head fib_nh_head;
    struct vlan_info *vlan_info;
    struct dsa_port *dsa_ptr;
    struct tipc_bearer *tipc_ptr;
    void *atalk_ptr;
    struct ax25_dev *ax25_ptr;
    struct wireless_dev *ieee80211_ptr;
    struct wpan_dev *ieee802154_ptr;
    struct mpls_dev *mpls_ptr;
    const unsigned char *dev_addr;
    unsigned int num_rx_queues;
    unsigned int xdp_zc_max_segs;
    struct netdev_queue *ingress_queue;
    struct nf_hook_entries *nf_hooks_ingress;
    unsigned char broadcast[32];
    struct cpu_rmap *rx_cpu_rmap;
    struct hlist_node index_hlist;
    unsigned int num_tx_queues;
    struct Qdisc *qdisc;
    unsigned int tx_queue_len;
    spinlock_t tx_global_lock;
    struct xdp_dev_bulk_queue *xdp_bulkq;
    struct hlist_head qdisc_hash[16];
    struct timer_list watchdog_timer;
    int watchdog_timeo;
    u32 proto_down_reason;
    struct list_head todo_list;
    int *pcpu_refcnt;
    struct ref_tracker_dir refcnt_tracker;
    struct list_head link_watch_list;
    u8 reg_state;
    bool dismantle;
    enum {
        RTNL_LINK_INITIALIZED = 0,
        RTNL_LINK_INITIALIZING = 1,
    } rtnl_link_state: 16;
    bool needs_free_netdev;
    void (*priv_destructor)(struct net_device *);
    void *ml_priv;
    enum netdev_ml_priv_type ml_priv_type;
    enum netdev_stat_type pcpu_stat_type: 8;
    struct garp_port *garp_port;
    struct mrp_port *mrp_port;
    struct dm_hw_stat_delta *dm_private;
    struct device dev;
    const struct attribute_group *sysfs_groups[4];
    const struct attribute_group *sysfs_rx_queue_group;
    const struct rtnl_link_ops *rtnl_link_ops;
    const struct netdev_stat_ops *stat_ops;
    const struct netdev_queue_mgmt_ops *queue_mgmt_ops;
    unsigned int tso_max_size;
    u16 tso_max_segs;
    const struct dcbnl_rtnl_ops *dcbnl_ops;
    u8 prio_tc_map[16];
    unsigned int fcoe_ddp_xid;
    struct netprio_map *priomap;
    struct phy_link_topology *link_topo;
    struct phy_device *phydev;
    struct sfp_bus *sfp_bus;
    struct lock_class_key *qdisc_tx_busylock;
    bool proto_down;
    bool threaded;
    long unsigned int see_all_hwtstamp_requests: 1;
    long unsigned int change_proto_down: 1;
    long unsigned int netns_local: 1;
    long unsigned int fcoe_mtu: 1;
    struct list_head net_notifier_list;
    const struct macsec_ops *macsec_ops;
    const struct udp_tunnel_nic_info *udp_tunnel_nic_info;
    struct udp_tunnel_nic *udp_tunnel_nic;
    struct netdev_config *cfg;
    struct netdev_config *cfg_pending;
    struct ethtool_netdev_state *ethtool;
    struct bpf_xdp_entity xdp_state[3];
    u8 dev_addr_shadow[32];
    netdevice_tracker linkwatch_dev_tracker;
    netdevice_tracker watchdog_dev_tracker;
    netdevice_tracker dev_registered_tracker;
    struct rtnl_hw_stats64 *offload_xstats_l3;
    struct devlink_port *devlink_port;
    struct dpll_pin *dpll_pin;
    struct hlist_head page_pools;
    struct dim_irq_moder *irq_moder;
    u64 max_pacing_offload_horizon;
    struct napi_config *napi_config;
    long unsigned int gro_flush_timeout;
    u32 napi_defer_hard_irqs;
    bool up;
    struct mutex lock;
    struct net_shaper_hierarchy *net_shaper_hierarchy;
    struct hlist_head neighbours[2];
    struct hwtstamp_provider *hwprov;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    u8 priv[0];
};

struct net_device_core_stats {
    long unsigned int rx_dropped;
    long unsigned int tx_dropped;
    long unsigned int rx_nohandler;
    long unsigned int rx_otherhost_dropped;
};

struct net_device_devres {
    struct net_device *ndev;
};

struct netdev_fcoe_hbainfo;

struct netdev_bpf;

struct xdp_frame;

struct net_device_path_ctx;

struct net_device_path;

struct skb_shared_hwtstamps;

struct net_shaper_ops;

struct net_device_ops {
    int (*ndo_init)(struct net_device *);
    void (*ndo_uninit)(struct net_device *);
    int (*ndo_open)(struct net_device *);
    int (*ndo_stop)(struct net_device *);
    netdev_tx_t (*ndo_start_xmit)(struct sk_buff *, struct net_device *);
    netdev_features_t (*ndo_features_check)(struct sk_buff *, struct net_device *, netdev_features_t);
    u16 (*ndo_select_queue)(struct net_device *, struct sk_buff *, struct net_device *);
    void (*ndo_change_rx_flags)(struct net_device *, int);
    void (*ndo_set_rx_mode)(struct net_device *);
    int (*ndo_set_mac_address)(struct net_device *, void *);
    int (*ndo_validate_addr)(struct net_device *);
    int (*ndo_do_ioctl)(struct net_device *, struct ifreq *, int);
    int (*ndo_eth_ioctl)(struct net_device *, struct ifreq *, int);
    int (*ndo_siocbond)(struct net_device *, struct ifreq *, int);
    int (*ndo_siocwandev)(struct net_device *, struct if_settings *);
    int (*ndo_siocdevprivate)(struct net_device *, struct ifreq *, void *, int);
    int (*ndo_set_config)(struct net_device *, struct ifmap *);
    int (*ndo_change_mtu)(struct net_device *, int);
    int (*ndo_neigh_setup)(struct net_device *, struct neigh_parms *);
    void (*ndo_tx_timeout)(struct net_device *, unsigned int);
    void (*ndo_get_stats64)(struct net_device *, struct rtnl_link_stats64 *);
    bool (*ndo_has_offload_stats)(const struct net_device *, int);
    int (*ndo_get_offload_stats)(int, const struct net_device *, void *);
    struct net_device_stats * (*ndo_get_stats)(struct net_device *);
    int (*ndo_vlan_rx_add_vid)(struct net_device *, __be16, u16);
    int (*ndo_vlan_rx_kill_vid)(struct net_device *, __be16, u16);
    void (*ndo_poll_controller)(struct net_device *);
    int (*ndo_netpoll_setup)(struct net_device *);
    void (*ndo_netpoll_cleanup)(struct net_device *);
    int (*ndo_set_vf_mac)(struct net_device *, int, u8 *);
    int (*ndo_set_vf_vlan)(struct net_device *, int, u16, u8, __be16);
    int (*ndo_set_vf_rate)(struct net_device *, int, int, int);
    int (*ndo_set_vf_spoofchk)(struct net_device *, int, bool);
    int (*ndo_set_vf_trust)(struct net_device *, int, bool);
    int (*ndo_get_vf_config)(struct net_device *, int, struct ifla_vf_info *);
    int (*ndo_set_vf_link_state)(struct net_device *, int, int);
    int (*ndo_get_vf_stats)(struct net_device *, int, struct ifla_vf_stats *);
    int (*ndo_set_vf_port)(struct net_device *, int, struct nlattr **);
    int (*ndo_get_vf_port)(struct net_device *, int, struct sk_buff *);
    int (*ndo_get_vf_guid)(struct net_device *, int, struct ifla_vf_guid *, struct ifla_vf_guid *);
    int (*ndo_set_vf_guid)(struct net_device *, int, u64, int);
    int (*ndo_set_vf_rss_query_en)(struct net_device *, int, bool);
    int (*ndo_setup_tc)(struct net_device *, enum tc_setup_type, void *);
    int (*ndo_fcoe_enable)(struct net_device *);
    int (*ndo_fcoe_disable)(struct net_device *);
    int (*ndo_fcoe_ddp_setup)(struct net_device *, u16, struct scatterlist *, unsigned int);
    int (*ndo_fcoe_ddp_done)(struct net_device *, u16);
    int (*ndo_fcoe_ddp_target)(struct net_device *, u16, struct scatterlist *, unsigned int);
    int (*ndo_fcoe_get_hbainfo)(struct net_device *, struct netdev_fcoe_hbainfo *);
    int (*ndo_fcoe_get_wwn)(struct net_device *, u64 *, int);
    int (*ndo_rx_flow_steer)(struct net_device *, const struct sk_buff *, u16, u32);
    int (*ndo_add_slave)(struct net_device *, struct net_device *, struct netlink_ext_ack *);
    int (*ndo_del_slave)(struct net_device *, struct net_device *);
    struct net_device * (*ndo_get_xmit_slave)(struct net_device *, struct sk_buff *, bool);
    struct net_device * (*ndo_sk_get_lower_dev)(struct net_device *, struct sock *);
    netdev_features_t (*ndo_fix_features)(struct net_device *, netdev_features_t);
    int (*ndo_set_features)(struct net_device *, netdev_features_t);
    int (*ndo_neigh_construct)(struct net_device *, struct neighbour *);
    void (*ndo_neigh_destroy)(struct net_device *, struct neighbour *);
    int (*ndo_fdb_add)(struct ndmsg *, struct nlattr **, struct net_device *, const unsigned char *, u16, u16, bool *, struct netlink_ext_ack *);
    int (*ndo_fdb_del)(struct ndmsg *, struct nlattr **, struct net_device *, const unsigned char *, u16, bool *, struct netlink_ext_ack *);
    int (*ndo_fdb_del_bulk)(struct nlmsghdr *, struct net_device *, struct netlink_ext_ack *);
    int (*ndo_fdb_dump)(struct sk_buff *, struct netlink_callback *, struct net_device *, struct net_device *, int *);
    int (*ndo_fdb_get)(struct sk_buff *, struct nlattr **, struct net_device *, const unsigned char *, u16, u32, u32, struct netlink_ext_ack *);
    int (*ndo_mdb_add)(struct net_device *, struct nlattr **, u16, struct netlink_ext_ack *);
    int (*ndo_mdb_del)(struct net_device *, struct nlattr **, struct netlink_ext_ack *);
    int (*ndo_mdb_del_bulk)(struct net_device *, struct nlattr **, struct netlink_ext_ack *);
    int (*ndo_mdb_dump)(struct net_device *, struct sk_buff *, struct netlink_callback *);
    int (*ndo_mdb_get)(struct net_device *, struct nlattr **, u32, u32, struct netlink_ext_ack *);
    int (*ndo_bridge_setlink)(struct net_device *, struct nlmsghdr *, u16, struct netlink_ext_ack *);
    int (*ndo_bridge_getlink)(struct sk_buff *, u32, u32, struct net_device *, u32, int);
    int (*ndo_bridge_dellink)(struct net_device *, struct nlmsghdr *, u16);
    int (*ndo_change_carrier)(struct net_device *, bool);
    int (*ndo_get_phys_port_id)(struct net_device *, struct netdev_phys_item_id *);
    int (*ndo_get_port_parent_id)(struct net_device *, struct netdev_phys_item_id *);
    int (*ndo_get_phys_port_name)(struct net_device *, char *, size_t);
    void * (*ndo_dfwd_add_station)(struct net_device *, struct net_device *);
    void (*ndo_dfwd_del_station)(struct net_device *, void *);
    int (*ndo_set_tx_maxrate)(struct net_device *, int, u32);
    int (*ndo_get_iflink)(const struct net_device *);
    int (*ndo_fill_metadata_dst)(struct net_device *, struct sk_buff *);
    void (*ndo_set_rx_headroom)(struct net_device *, int);
    int (*ndo_bpf)(struct net_device *, struct netdev_bpf *);
    int (*ndo_xdp_xmit)(struct net_device *, int, struct xdp_frame **, u32);
    struct net_device * (*ndo_xdp_get_xmit_slave)(struct net_device *, struct xdp_buff *);
    int (*ndo_xsk_wakeup)(struct net_device *, u32, u32);
    int (*ndo_tunnel_ctl)(struct net_device *, struct ip_tunnel_parm_kern *, int);
    struct net_device * (*ndo_get_peer_dev)(struct net_device *);
    int (*ndo_fill_forward_path)(struct net_device_path_ctx *, struct net_device_path *);
    ktime_t (*ndo_get_tstamp)(struct net_device *, const struct skb_shared_hwtstamps *, bool);
    int (*ndo_hwtstamp_get)(struct net_device *, struct kernel_hwtstamp_config *);
    int (*ndo_hwtstamp_set)(struct net_device *, struct kernel_hwtstamp_config *, struct netlink_ext_ack *);
    const struct net_shaper_ops *net_shaper_ops;
};

struct net_device_path {
    enum net_device_path_type type;
    const struct net_device *dev;
    union {
        struct {
            u16 id;
            __be16 proto;
            u8 h_dest[6];
        } encap;
        struct {
            enum {
                DEV_PATH_BR_VLAN_KEEP = 0,
                DEV_PATH_BR_VLAN_TAG = 1,
                DEV_PATH_BR_VLAN_UNTAG = 2,
                DEV_PATH_BR_VLAN_UNTAG_HW = 3,
            } vlan_mode;
            u16 vlan_id;
            __be16 vlan_proto;
        } bridge;
        struct {
            int port;
            u16 proto;
        } dsa;
        struct {
            u8 wdma_idx;
            u8 queue;
            u16 wcid;
            u8 bss;
            u8 amsdu;
        } mtk_wdma;
    };
};

struct net_device_path_ctx {
    const struct net_device *dev;
    u8 daddr[6];
    int num_vlans;
    struct {
        u16 id;
        __be16 proto;
    } vlan[2];
};

struct net_device_path_stack {
    int num_paths;
    struct net_device_path path[5];
};

struct net_devmem_dmabuf_binding {
    struct dma_buf *dmabuf;
    struct dma_buf_attachment *attachment;
    struct sg_table *sgt;
    struct net_device *dev;
    struct gen_pool *chunk_pool;
    refcount_t ref;
    struct list_head list;
    struct xarray bound_rxqs;
    u32 id;
};

struct net_fill_args {
    u32 portid;
    u32 seq;
    int flags;
    int cmd;
    int nsid;
    bool add_ref;
    int ref_nsid;
};

struct net_generic {
    union {
        struct {
            unsigned int len;
            struct callback_head rcu;
        } s;
        struct {
            struct {} __empty_ptr;
            void *ptr[0];
        };
    };
};

struct offload_callbacks {
    struct sk_buff * (*gso_segment)(struct sk_buff *, netdev_features_t);
    struct sk_buff * (*gro_receive)(struct list_head *, struct sk_buff *);
    int (*gro_complete)(struct sk_buff *, int);
};

struct packet_offload {
    __be16 type;
    u16 priority;
    struct offload_callbacks callbacks;
    struct list_head list;
};

struct net_offload {
    struct offload_callbacks callbacks;
    unsigned int flags;
    u32 secret;
};

struct net_protocol {
    int (*handler)(struct sk_buff *);
    int (*err_handler)(struct sk_buff *, u32);
    unsigned int no_policy: 1;
    unsigned int icmp_strict_tag_validation: 1;
    u32 secret;
};

struct rps_sock_flow_table;

struct net_hotdata {
    struct packet_offload ip_packet_offload;
    struct net_offload tcpv4_offload;
    struct net_protocol tcp_protocol;
    struct net_offload udpv4_offload;
    struct net_protocol udp_protocol;
    struct packet_offload ipv6_packet_offload;
    struct net_offload tcpv6_offload;
    struct inet6_protocol tcpv6_protocol;
    struct inet6_protocol udpv6_protocol;
    struct net_offload udpv6_offload;
    struct list_head offload_base;
    struct list_head ptype_all;
    struct kmem_cache *skbuff_cache;
    struct kmem_cache *skbuff_fclone_cache;
    struct kmem_cache *skb_small_head_cache;
    struct rps_sock_flow_table *rps_sock_flow_table;
    u32 rps_cpu_mask;
    int gro_normal_batch;
    int netdev_budget;
    int netdev_budget_usecs;
    int tstamp_prequeue;
    int max_backlog;
    int dev_tx_weight;
    int dev_rx_weight;
    int sysctl_max_skb_frags;
    int sysctl_skb_defer_max;
    int sysctl_mem_pcpu_rsv;
};

struct net_iov {
    long unsigned int __unused_padding;
    long unsigned int pp_magic;
    struct page_pool *pp;
    struct dmabuf_genpool_chunk_owner *owner;
    long unsigned int dma_addr;
    atomic_long_t pp_ref_count;
};

struct net_packet_attrs {
    const unsigned char *src;
    const unsigned char *dst;
    u32 ip_src;
    u32 ip_dst;
    bool tcp;
    u16 sport;
    u16 dport;
    int timeout;
    int size;
    int max_size;
    u8 id;
    u16 queue_mapping;
};

struct net_proto_family {
    int family;
    int (*create)(struct net *, struct socket *, int, int);
    struct module *owner;
};

struct net_rate_estimator {
    struct gnet_stats_basic_sync *bstats;
    spinlock_t *stats_lock;
    bool running;
    struct gnet_stats_basic_sync *cpu_bstats;
    u8 ewma_log;
    u8 intvl_log;
    seqcount_t seq;
    u64 last_packets;
    u64 last_bytes;
    u64 avpps;
    u64 avbps;
    long unsigned int next_jiffies;
    struct timer_list timer;
    struct callback_head rcu;
};

struct net_shaper_handle {
    enum net_shaper_scope scope;
    u32 id;
};

struct net_shaper {
    struct net_shaper_handle parent;
    struct net_shaper_handle handle;
    enum net_shaper_metric metric;
    u64 bw_min;
    u64 bw_max;
    u64 burst;
    u32 priority;
    u32 weight;
    u32 leaves;
    struct callback_head rcu;
};

struct net_shaper_binding {
    enum net_shaper_binding_type type;
    union {
        struct net_device *netdev;
        struct devlink *devlink;
    };
};

struct net_shaper_hierarchy {
    struct xarray shapers;
};

struct net_shaper_nl_ctx {
    struct net_shaper_binding binding;
    netdevice_tracker dev_tracker;
    long unsigned int start_index;
};

struct net_shaper_ops {
    int (*group)(struct net_shaper_binding *, int, const struct net_shaper *, const struct net_shaper *, struct netlink_ext_ack *);
    int (*set)(struct net_shaper_binding *, const struct net_shaper *, struct netlink_ext_ack *);
    int (*delete)(struct net_shaper_binding *, const struct net_shaper_handle *, struct netlink_ext_ack *);
    void (*capabilities)(struct net_shaper_binding *, enum net_shaper_scope, long unsigned int *);
};

struct net_test {
    char name[32];
    int (*fn)(struct net_device *);
};

struct packet_type {
    __be16 type;
    bool ignore_outgoing;
    struct net_device *dev;
    netdevice_tracker dev_tracker;
    int (*func)(struct sk_buff *, struct net_device *, struct packet_type *, struct net_device *);
    void (*list_func)(struct list_head *, struct packet_type *, struct net_device *);
    bool (*id_match)(struct packet_type *, struct sock *);
    struct net *af_packet_net;
    void *af_packet_priv;
    struct list_head list;
};

struct net_test_priv {
    struct net_packet_attrs *packet;
    struct packet_type pt;
    struct completion comp;
    int double_vlan;
    int vlan_id;
    int ok;
};

struct netconfmsg {
    __u8 ncm_family;
};

struct netdev_adjacent {
    struct net_device *dev;
    netdevice_tracker dev_tracker;
    bool master;
    bool ignore;
    u16 ref_nr;
    void *private;
    struct list_head list;
    struct callback_head rcu;
};

struct netdev_bonding_info {
    ifslave slave;
    ifbond master;
};

struct xsk_buff_pool;

struct netdev_bpf {
    enum bpf_netdev_command command;
    union {
        struct {
            u32 flags;
            struct bpf_prog *prog;
            struct netlink_ext_ack *extack;
        };
        struct {
            struct bpf_offloaded_map *offmap;
        };
        struct {
            struct xsk_buff_pool *pool;
            u16 queue_id;
        } xsk;
    };
};

struct netdev_config {
    u32 hds_thresh;
    u8 hds_config;
};

struct netdev_fcoe_hbainfo {
    char manufacturer[64];
    char serial_number[64];
    char hardware_version[64];
    char driver_version[64];
    char optionrom_version[64];
    char firmware_version[64];
    char model[256];
    char model_description[256];
};

struct netdev_hw_addr {
    struct list_head list;
    struct rb_node node;
    unsigned char addr[32];
    unsigned char type;
    bool global_use;
    int sync_cnt;
    int refcount;
    int synced;
    struct callback_head callback_head;
};

struct netdev_lag_upper_info {
    enum netdev_lag_tx_type tx_type;
    enum netdev_lag_hash hash_type;
};

struct netdev_name_node {
    struct hlist_node hlist;
    struct list_head list;
    struct net_device *dev;
    const char *name;
    struct callback_head rcu;
};

struct netdev_nested_priv {
    unsigned char flags;
    void *data;
};

struct netdev_net_notifier {
    struct list_head list;
    struct notifier_block *nb;
};

struct netdev_nl_dump_ctx {
    long unsigned int ifindex;
    unsigned int rxq_idx;
    unsigned int txq_idx;
    unsigned int napi_id;
};

struct netdev_notifier_info {
    struct net_device *dev;
    struct netlink_ext_ack *extack;
};

struct netdev_notifier_bonding_info {
    struct netdev_notifier_info info;
    struct netdev_bonding_info bonding_info;
};

struct netdev_notifier_change_info {
    struct netdev_notifier_info info;
    unsigned int flags_changed;
};

struct netdev_notifier_changelowerstate_info {
    struct netdev_notifier_info info;
    void *lower_state_info;
};

struct netdev_notifier_changeupper_info {
    struct netdev_notifier_info info;
    struct net_device *upper_dev;
    bool master;
    bool linking;
    void *upper_info;
};

struct netdev_notifier_info_ext {
    struct netdev_notifier_info info;
    union {
        u32 mtu;
    } ext;
};

struct netdev_notifier_offload_xstats_rd;

struct netdev_notifier_offload_xstats_ru;

struct netdev_notifier_offload_xstats_info {
    struct netdev_notifier_info info;
    enum netdev_offload_xstats_type type;
    union {
        struct netdev_notifier_offload_xstats_rd *report_delta;
        struct netdev_notifier_offload_xstats_ru *report_used;
    };
};

struct rtnl_hw_stats64 {
    __u64 rx_packets;
    __u64 tx_packets;
    __u64 rx_bytes;
    __u64 tx_bytes;
    __u64 rx_errors;
    __u64 tx_errors;
    __u64 rx_dropped;
    __u64 tx_dropped;
    __u64 multicast;
};

struct netdev_notifier_offload_xstats_rd {
    struct rtnl_hw_stats64 stats;
    bool used;
};

struct netdev_notifier_offload_xstats_ru {
    bool used;
};

struct netdev_notifier_pre_changeaddr_info {
    struct netdev_notifier_info info;
    const unsigned char *dev_addr;
};

struct netdev_queue {
    struct net_device *dev;
    netdevice_tracker dev_tracker;
    struct Qdisc *qdisc;
    struct Qdisc *qdisc_sleeping;
    struct kobject kobj;
    long unsigned int tx_maxrate;
    atomic_long_t trans_timeout;
    struct net_device *sb_dev;
    struct xsk_buff_pool *pool;
    long: 64;
    struct dql dql;
    spinlock_t _xmit_lock;
    int xmit_lock_owner;
    long unsigned int trans_start;
    long unsigned int state;
    struct napi_struct *napi;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
};

struct netdev_queue_attribute {
    struct attribute attr;
    ssize_t (*show)(struct netdev_queue *, char *);
    ssize_t (*store)(struct netdev_queue *, const char *, size_t);
};

struct netdev_queue_mgmt_ops {
    size_t ndo_queue_mem_size;
    int (*ndo_queue_mem_alloc)(struct net_device *, void *, int);
    void (*ndo_queue_mem_free)(struct net_device *, void *);
    int (*ndo_queue_start)(struct net_device *, void *, int);
    int (*ndo_queue_stop)(struct net_device *, void *, int);
};

struct netdev_queue_stats_rx {
    u64 bytes;
    u64 packets;
    u64 alloc_fail;
    u64 hw_drops;
    u64 hw_drop_overruns;
    u64 csum_unnecessary;
    u64 csum_none;
    u64 csum_bad;
    u64 hw_gro_packets;
    u64 hw_gro_bytes;
    u64 hw_gro_wire_packets;
    u64 hw_gro_wire_bytes;
    u64 hw_drop_ratelimits;
};

struct netdev_queue_stats_tx {
    u64 bytes;
    u64 packets;
    u64 hw_drops;
    u64 hw_drop_errors;
    u64 csum_none;
    u64 needs_csum;
    u64 hw_gso_packets;
    u64 hw_gso_bytes;
    u64 hw_gso_wire_packets;
    u64 hw_gso_wire_bytes;
    u64 hw_drop_ratelimits;
    u64 stop;
    u64 wake;
};

struct xdp_mem_info {
    u32 type;
    u32 id;
};

struct xdp_rxq_info {
    struct net_device *dev;
    u32 queue_index;
    u32 reg_state;
    struct xdp_mem_info mem;
    u32 frag_size;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
};

struct pp_memory_provider_params {
    void *mp_priv;
};

struct rps_map;

struct rps_dev_flow_table;

struct netdev_rx_queue {
    struct xdp_rxq_info xdp_rxq;
    struct rps_map *rps_map;
    struct rps_dev_flow_table *rps_flow_table;
    struct kobject kobj;
    struct net_device *dev;
    netdevice_tracker dev_tracker;
    struct xsk_buff_pool *pool;
    struct napi_struct *napi;
    struct pp_memory_provider_params mp_params;
    long: 64;
    long: 64;
};

struct netdev_stat_ops {
    void (*get_queue_stats_rx)(struct net_device *, int, struct netdev_queue_stats_rx *);
    void (*get_queue_stats_tx)(struct net_device *, int, struct netdev_queue_stats_tx *);
    void (*get_base_stats)(struct net_device *, struct netdev_queue_stats_rx *, struct netdev_queue_stats_tx *);
};

struct netdev_xmit {
    u16 recursion;
    u8 more;
    u8 skip_txqueue;
};

struct netevent_redirect {
    struct dst_entry *old;
    struct dst_entry *new;
    struct neighbour *neigh;
    const void *daddr;
};

struct netif_security_struct {
    struct net *ns;
    int ifindex;
    u32 sid;
};

struct netkit {
    struct net_device *peer;
    struct bpf_mprog_entry *active;
    enum netkit_action policy;
    enum netkit_scrub scrub;
    struct bpf_mprog_bundle bundle;
    enum netkit_mode mode;
    bool primary;
    u32 headroom;
};

struct netkit_link {
    struct bpf_link link;
    struct net_device *dev;
    u32 location;
};

struct netlbl_af4list {
    __be32 addr;
    __be32 mask;
    u32 valid;
    struct list_head list;
};

struct netlbl_af6list {
    struct in6_addr addr;
    struct in6_addr mask;
    u32 valid;
    struct list_head list;
};

struct netlbl_audit {
    struct lsm_prop prop;
    kuid_t loginuid;
    unsigned int sessionid;
};

struct netlbl_calipso_doiwalk_arg {
    struct netlink_callback *nl_cb;
    struct sk_buff *skb;
    u32 seq;
};

struct netlbl_lsm_secattr;

struct netlbl_calipso_ops {
    int (*doi_add)(struct calipso_doi *, struct netlbl_audit *);
    void (*doi_free)(struct calipso_doi *);
    int (*doi_remove)(u32, struct netlbl_audit *);
    struct calipso_doi * (*doi_getdef)(u32);
    void (*doi_putdef)(struct calipso_doi *);
    int (*doi_walk)(u32 *, int (*)(struct calipso_doi *, void *), void *);
    int (*sock_getattr)(struct sock *, struct netlbl_lsm_secattr *);
    int (*sock_setattr)(struct sock *, const struct calipso_doi *, const struct netlbl_lsm_secattr *);
    void (*sock_delattr)(struct sock *);
    int (*req_setattr)(struct request_sock *, const struct calipso_doi *, const struct netlbl_lsm_secattr *);
    void (*req_delattr)(struct request_sock *);
    int (*opt_getattr)(const unsigned char *, struct netlbl_lsm_secattr *);
    unsigned char * (*skbuff_optptr)(const struct sk_buff *);
    int (*skbuff_setattr)(struct sk_buff *, const struct calipso_doi *, const struct netlbl_lsm_secattr *);
    int (*skbuff_delattr)(struct sk_buff *);
    void (*cache_invalidate)(void);
    int (*cache_add)(const unsigned char *, const struct netlbl_lsm_secattr *);
};

struct netlbl_cipsov4_doiwalk_arg {
    struct netlink_callback *nl_cb;
    struct sk_buff *skb;
    u32 seq;
};

struct netlbl_domaddr_map;

struct netlbl_dommap_def {
    u32 type;
    union {
        struct netlbl_domaddr_map *addrsel;
        struct cipso_v4_doi *cipso;
        struct calipso_doi *calipso;
    };
};

struct netlbl_dom_map {
    char *domain;
    struct netlbl_dommap_def def;
    u16 family;
    u32 valid;
    struct list_head list;
    struct callback_head rcu;
};

struct netlbl_domaddr4_map {
    struct netlbl_dommap_def def;
    struct netlbl_af4list list;
};

struct netlbl_domaddr6_map {
    struct netlbl_dommap_def def;
    struct netlbl_af6list list;
};

struct netlbl_domaddr_map {
    struct list_head list4;
    struct list_head list6;
};

struct netlbl_domhsh_tbl {
    struct list_head *tbl;
    u32 size;
};

struct netlbl_domhsh_walk_arg {
    struct netlink_callback *nl_cb;
    struct sk_buff *skb;
    u32 seq;
};

struct netlbl_domhsh_walk_arg___2 {
    struct netlbl_audit *audit_info;
    u32 doi;
};

struct netlbl_lsm_cache {
    refcount_t refcount;
    void (*free)(const void *);
    void *data;
};

struct netlbl_lsm_catmap {
    u32 startbit;
    u64 bitmap[4];
    struct netlbl_lsm_catmap *next;
};

struct netlbl_lsm_secattr {
    u32 flags;
    u32 type;
    char *domain;
    struct netlbl_lsm_cache *cache;
    struct {
        struct {
            struct netlbl_lsm_catmap *cat;
            u32 lvl;
        } mls;
        u32 secid;
    } attr;
};

struct netlbl_unlhsh_addr4 {
    u32 secid;
    struct netlbl_af4list list;
    struct callback_head rcu;
};

struct netlbl_unlhsh_addr6 {
    u32 secid;
    struct netlbl_af6list list;
    struct callback_head rcu;
};

struct netlbl_unlhsh_iface {
    int ifindex;
    struct list_head addr4_list;
    struct list_head addr6_list;
    u32 valid;
    struct list_head list;
    struct callback_head rcu;
};

struct netlbl_unlhsh_tbl {
    struct list_head *tbl;
    u32 size;
};

struct netlbl_unlhsh_walk_arg {
    struct netlink_callback *nl_cb;
    struct sk_buff *skb;
    u32 seq;
};

struct netlink_broadcast_data {
    struct sock *exclude_sk;
    struct net *net;
    u32 portid;
    u32 group;
    int failure;
    int delivery_failure;
    int congested;
    int delivered;
    gfp_t allocation;
    struct sk_buff *skb;
    struct sk_buff *skb2;
    int (*tx_filter)(struct sock *, struct sk_buff *, void *);
    void *tx_data;
};

struct netlink_callback {
    struct sk_buff *skb;
    const struct nlmsghdr *nlh;
    int (*dump)(struct sk_buff *, struct netlink_callback *);
    int (*done)(struct netlink_callback *);
    void *data;
    struct module *module;
    struct netlink_ext_ack *extack;
    u16 family;
    u16 answer_flags;
    u32 min_dump_alloc;
    unsigned int prev_seq;
    unsigned int seq;
    int flags;
    bool strict_check;
    union {
        u8 ctx[48];
        long int args[6];
    };
};

struct netlink_compare_arg {
    possible_net_t pnet;
    u32 portid;
};

struct netlink_dump_control {
    int (*start)(struct netlink_callback *);
    int (*dump)(struct sk_buff *, struct netlink_callback *);
    int (*done)(struct netlink_callback *);
    struct netlink_ext_ack *extack;
    void *data;
    struct module *module;
    u32 min_dump_alloc;
    int flags;
};

struct netlink_ext_ack {
    const char *_msg;
    const struct nlattr *bad_attr;
    const struct nla_policy *policy;
    const struct nlattr *miss_nest;
    u16 miss_type;
    u8 cookie[20];
    u8 cookie_len;
    char _msg_buf[80];
};

struct netlink_kernel_cfg {
    unsigned int groups;
    unsigned int flags;
    void (*input)(struct sk_buff *);
    int (*bind)(struct net *, int);
    void (*unbind)(struct net *, int);
    void (*release)(struct sock *, long unsigned int *);
};

struct netlink_notify {
    struct net *net;
    u32 portid;
    int protocol;
};

struct netlink_policy_dump_state {
    unsigned int policy_idx;
    unsigned int attr_idx;
    unsigned int n_alloc;
    struct {
        const struct nla_policy *policy;
        unsigned int maxtype;
    } policies[0];
};

struct netlink_range_validation {
    u64 min;
    u64 max;
};

struct netlink_range_validation_signed {
    s64 min;
    s64 max;
};

struct netlink_set_err_data {
    struct sock *exclude_sk;
    u32 portid;
    u32 group;
    int code;
};

struct scm_creds {
    u32 pid;
    kuid_t uid;
    kgid_t gid;
};

struct netlink_skb_parms {
    struct scm_creds creds;
    __u32 portid;
    __u32 dst_group;
    __u32 flags;
    struct sock *sk;
    bool nsid_is_set;
    int nsid;
};

struct netlink_sock {
    struct sock sk;
    long unsigned int flags;
    u32 portid;
    u32 dst_portid;
    u32 dst_group;
    u32 subscriptions;
    u32 ngroups;
    long unsigned int *groups;
    long unsigned int state;
    size_t max_recvmsg_len;
    wait_queue_head_t wait;
    bool bound;
    bool cb_running;
    int dump_done_errno;
    struct netlink_callback cb;
    struct mutex nl_cb_mutex;
    void (*netlink_rcv)(struct sk_buff *);
    int (*netlink_bind)(struct net *, int);
    void (*netlink_unbind)(struct net *, int);
    void (*netlink_release)(struct sock *, long unsigned int *);
    struct module *module;
    struct rhash_head node;
    struct callback_head rcu;
};

struct netlink_table {
    struct rhashtable hash;
    struct hlist_head mc_list;
    struct listeners *listeners;
    unsigned int flags;
    unsigned int groups;
    struct mutex *cb_mutex;
    struct module *module;
    int (*bind)(struct net *, int);
    void (*unbind)(struct net *, int);
    void (*release)(struct sock *, long unsigned int *);
    int registered;
};

struct netlink_tap {
    struct net_device *dev;
    struct module *module;
    struct list_head list;
};

struct netlink_tap_net {
    struct list_head netlink_tap_all;
    struct mutex netlink_tap_lock;
};

struct netnode_security_struct {
    union {
        __be32 ipv4;
        struct in6_addr ipv6;
    } addr;
    u32 sid;
    u16 family;
};

struct netpoll {
    struct net_device *dev;
    netdevice_tracker dev_tracker;
    char dev_name[16];
    const char *name;
    union inet_addr local_ip;
    union inet_addr remote_ip;
    bool ipv6;
    u16 local_port;
    u16 remote_port;
    u8 remote_mac[6];
    struct sk_buff_head skb_pool;
};

struct netpoll_info {
    refcount_t refcnt;
    struct semaphore dev_lock;
    struct sk_buff_head txq;
    struct delayed_work tx_work;
    struct netpoll *netpoll;
    struct callback_head rcu;
};

struct netport_security_struct {
    u32 sid;
    u16 port;
    u8 protocol;
};

struct netprio_map {
    struct callback_head rcu;
    u32 priomap_len;
    u32 priomap[0];
};

struct netsfhdr {
    __be32 version;
    __be64 magic;
    u8 id;
} __attribute__((packed));

struct new_utsname {
    char sysname[65];
    char nodename[65];
    char release[65];
    char version[65];
    char machine[65];
    char domainname[65];
};

struct nh_info;

struct nh_group;

struct nexthop {
    struct rb_node rb_node;
    struct list_head fi_list;
    struct list_head f6i_list;
    struct list_head fdb_list;
    struct list_head grp_list;
    struct net *net;
    u32 id;
    u8 protocol;
    u8 nh_flags;
    bool is_group;
    refcount_t refcnt;
    struct callback_head rcu;
    union {
        struct nh_info *nh_info;
        struct nh_group *nh_grp;
    };
};

struct nexthop_grp {
    __u32 id;
    __u8 weight;
    __u8 weight_high;
    __u16 resvd2;
};

struct nf_bridge_info {
    enum {
        BRNF_PROTO_UNCHANGED = 0,
        BRNF_PROTO_8021Q = 1,
        BRNF_PROTO_PPPOE = 2,
    } orig_proto: 8;
    u8 pkt_otherhost: 1;
    u8 in_prerouting: 1;
    u8 bridged_dnat: 1;
    u8 sabotage_in_done: 1;
    __u16 frag_max_size;
    int physinif;
    struct net_device *physoutdev;
    union {
        __be32 ipv4_daddr;
        struct in6_addr ipv6_daddr;
        char neigh_header[8];
    };
};

struct nf_conntrack {
    refcount_t use;
};

struct nf_conntrack_zone {
    u16 id;
    u8 flags;
    u8 dir;
};

union nf_inet_addr {
    __u32 all[4];
    __be32 ip;
    __be32 ip6[4];
    struct in_addr in;
    struct in6_addr in6;
};

union nf_conntrack_man_proto {
    __be16 all;
    struct {
        __be16 port;
    } tcp;
    struct {
        __be16 port;
    } udp;
    struct {
        __be16 id;
    } icmp;
    struct {
        __be16 port;
    } dccp;
    struct {
        __be16 port;
    } sctp;
    struct {
        __be16 key;
    } gre;
};

struct nf_conntrack_man {
    union nf_inet_addr u3;
    union nf_conntrack_man_proto u;
    u_int16_t l3num;
};

struct nf_conntrack_tuple {
    struct nf_conntrack_man src;
    struct {
        union nf_inet_addr u3;
        union {
            __be16 all;
            struct {
                __be16 port;
            } tcp;
            struct {
                __be16 port;
            } udp;
            struct {
                u_int8_t type;
                u_int8_t code;
            } icmp;
            struct {
                __be16 port;
            } dccp;
            struct {
                __be16 port;
            } sctp;
            struct {
                __be16 key;
            } gre;
        } u;
        u_int8_t protonum;
        struct {} __nfct_hash_offsetend;
        u_int8_t dir;
    } dst;
};

struct nf_conntrack_tuple_hash {
    struct hlist_nulls_node hnnode;
    struct nf_conntrack_tuple tuple;
};

struct nf_ct_dccp {
    u_int8_t role[2];
    u_int8_t state;
    u_int8_t last_pkt;
    u_int8_t last_dir;
    u_int64_t handshake_seq;
};

struct nf_ct_udp {
    long unsigned int stream_ts;
};

struct nf_ct_gre {
    unsigned int stream_timeout;
    unsigned int timeout;
};

union nf_conntrack_proto {
    struct nf_ct_dccp dccp;
    struct ip_ct_sctp sctp;
    struct ip_ct_tcp tcp;
    struct nf_ct_udp udp;
    struct nf_ct_gre gre;
    unsigned int tmpl_padto;
};

struct nf_ct_ext;

struct nf_conn {
    struct nf_conntrack ct_general;
    spinlock_t lock;
    u32 timeout;
    struct nf_conntrack_zone zone;
    struct nf_conntrack_tuple_hash tuplehash[2];
    long unsigned int status;
    possible_net_t ct_net;
    struct hlist_node nat_bysource;
    struct {} __nfct_init_offset;
    struct nf_conn *master;
    u_int32_t mark;
    u_int32_t secmark;
    struct nf_ct_ext *ext;
    union nf_conntrack_proto proto;
};

struct nf_conn___init {
    struct nf_conn ct;
};

struct nf_conn_labels {
    long unsigned int bits[2];
};

struct nf_conntrack_tuple_mask {
    struct {
        union nf_inet_addr u3;
        union nf_conntrack_man_proto u;
    } src;
};

struct nf_conntrack_helper;

struct nf_conntrack_expect {
    struct hlist_node lnode;
    struct hlist_node hnode;
    struct nf_conntrack_tuple tuple;
    struct nf_conntrack_tuple_mask mask;
    refcount_t use;
    unsigned int flags;
    unsigned int class;
    void (*expectfn)(struct nf_conn *, struct nf_conntrack_expect *);
    struct nf_conntrack_helper *helper;
    struct nf_conn *master;
    struct timer_list timeout;
    union nf_inet_addr saved_addr;
    union nf_conntrack_man_proto saved_proto;
    enum ip_conntrack_dir dir;
    struct callback_head rcu;
};

struct nf_ct_event {
    struct nf_conn *ct;
    u32 portid;
    int report;
};

struct nf_exp_event;

struct nf_ct_event_notifier {
    int (*ct_event)(unsigned int, const struct nf_ct_event *);
    int (*exp_event)(unsigned int, const struct nf_exp_event *);
};

struct nf_ct_ext {
    u8 offset[10];
    u8 len;
    unsigned int gen_id;
    char data[0];
};

struct nf_ct_hook {
    int (*update)(struct net *, struct sk_buff *);
    void (*destroy)(struct nf_conntrack *);
    bool (*get_tuple_skb)(struct nf_conntrack_tuple *, const struct sk_buff *);
    void (*attach)(struct sk_buff *, const struct sk_buff *);
    void (*set_closing)(struct nf_conntrack *);
    int (*confirm)(struct sk_buff *);
};

struct nf_defrag_hook {
    struct module *owner;
    int (*enable)(struct net *);
    void (*disable)(struct net *);
};

struct nf_exp_event {
    struct nf_conntrack_expect *exp;
    u32 portid;
    int report;
};

struct nf_flow_table_stat {
    unsigned int count_wq_add;
    unsigned int count_wq_del;
    unsigned int count_wq_stats;
};

struct nf_hook_entry {
    nf_hookfn *hook;
    void *priv;
};

struct nf_hook_entries {
    u16 num_hook_entries;
    struct nf_hook_entry hooks[0];
};

struct nf_hook_entries_rcu_head {
    struct callback_head head;
    void *allocation;
};

struct nf_hook_state {
    u8 hook;
    u8 pf;
    struct net_device *in;
    struct net_device *out;
    struct sock *sk;
    struct net *net;
    int (*okfn)(struct net *, struct sock *, struct sk_buff *);
};

struct nf_queue_entry;

struct nf_ipv6_ops {
    void (*route_input)(struct sk_buff *);
    int (*fragment)(struct net *, struct sock *, struct sk_buff *, int (*)(struct net *, struct sock *, struct sk_buff *));
    int (*reroute)(struct sk_buff *, const struct nf_queue_entry *);
};

struct nf_log_buf {
    unsigned int count;
    char buf[1020];
};

struct nf_loginfo;

typedef void nf_logfn(struct net *, u_int8_t, unsigned int, const struct sk_buff *, const struct net_device *, const struct net_device *, const struct nf_loginfo *, const char *);

struct nf_logger {
    char *name;
    enum nf_log_type type;
    nf_logfn *logfn;
    struct module *me;
};

struct nf_loginfo {
    u_int8_t type;
    union {
        struct {
            u_int32_t copy_len;
            u_int16_t group;
            u_int16_t qthreshold;
            u_int16_t flags;
        } ulog;
        struct {
            u_int8_t level;
            u_int8_t logflags;
        } log;
    } u;
};

struct nf_nat_hook {
    int (*parse_nat_setup)(struct nf_conn *, enum nf_nat_manip_type, const struct nlattr *);
    void (*decode_session)(struct sk_buff *, struct flowi *);
    void (*remove_nat_bysrc)(struct nf_conn *);
};

struct nf_queue_entry {
    struct list_head list;
    struct sk_buff *skb;
    unsigned int id;
    unsigned int hook_index;
    struct net_device *physin;
    struct net_device *physout;
    struct nf_hook_state state;
    u16 size;
};

struct nf_queue_handler {
    int (*outfn)(struct nf_queue_entry *, unsigned int);
    void (*nf_hook_drop)(struct net *);
};

struct nf_sockopt_ops {
    struct list_head list;
    u_int8_t pf;
    int set_optmin;
    int set_optmax;
    int (*set)(struct sock *, int, sockptr_t, unsigned int);
    int get_optmin;
    int get_optmax;
    int (*get)(struct sock *, int, void *, int *);
    struct module *owner;
};

struct nfnl_ct_hook {
    size_t (*build_size)(const struct nf_conn *);
    int (*build)(struct sk_buff *, struct nf_conn *, enum ip_conntrack_info, u_int16_t, u_int16_t);
    int (*parse)(const struct nlattr *, struct nf_conn *);
    int (*attach_expect)(const struct nlattr *, struct nf_conn *, u32, u32);
    void (*seq_adjust)(struct sk_buff *, struct nf_conn *, enum ip_conntrack_info, s32);
};

struct nfstime4 {
    int64_t seconds;
    uint32_t nseconds;
};

struct nfs41_impl_id {
    char domain[1025];
    char name[1025];
    struct nfstime4 date;
};

struct nfs41_server_owner {
    uint64_t minor_id;
    uint32_t major_id_sz;
    char major_id[1024];
};

struct nfs41_server_scope {
    uint32_t server_scope_sz;
    char server_scope[1024];
};

struct nfs4_change_info {
    u32 atomic;
    u64 before;
    u64 after;
};

struct nfs4_string {
    unsigned int len;
    char *data;
};

struct nfs4_pathname {
    unsigned int ncomponents;
    struct nfs4_string components[512];
};

struct nfs4_fs_location {
    unsigned int nservers;
    struct nfs4_string servers[10];
    struct nfs4_pathname rootpath;
};

struct nfs_fattr;

struct nfs_server;

struct nfs4_fs_locations {
    struct nfs_fattr *fattr;
    const struct nfs_server *server;
    struct nfs4_pathname fs_path;
    int nlocations;
    struct nfs4_fs_location locations[10];
};

struct nfs4_label {
    uint32_t lfs;
    uint32_t pi;
    u32 lsmid;
    u32 len;
    char *label;
};

struct rpc_timer {
    struct list_head list;
    long unsigned int expires;
    struct delayed_work dwork;
};

struct rpc_wait_queue {
    spinlock_t lock;
    struct list_head tasks[4];
    unsigned char maxpriority;
    unsigned char priority;
    unsigned char nr;
    unsigned int qlen;
    struct rpc_timer timer_list;
    const char *name;
};

struct nfs_seqid_counter {
    ktime_t create_time;
    u64 owner_id;
    int flags;
    u32 counter;
    spinlock_t lock;
    struct list_head list;
    struct rpc_wait_queue wait;
};

struct nfs4_stateid_struct {
    union {
        char data[16];
        struct {
            __be32 seqid;
            char other[12];
        };
    };
    enum {
        NFS4_INVALID_STATEID_TYPE = 0,
        NFS4_SPECIAL_STATEID_TYPE = 1,
        NFS4_OPEN_STATEID_TYPE = 2,
        NFS4_LOCK_STATEID_TYPE = 3,
        NFS4_DELEGATION_STATEID_TYPE = 4,
        NFS4_LAYOUT_STATEID_TYPE = 5,
        NFS4_PNFS_DS_STATEID_TYPE = 6,
        NFS4_REVOKED_STATEID_TYPE = 7,
    } type;
};

typedef struct nfs4_stateid_struct nfs4_stateid;

struct nfs4_state;

struct nfs4_lock_state {
    struct list_head ls_locks;
    struct nfs4_state *ls_state;
    long unsigned int ls_flags;
    struct nfs_seqid_counter ls_seqid;
    nfs4_stateid ls_stateid;
    refcount_t ls_count;
    fl_owner_t ls_owner;
};

struct nfs_fh;

struct nfs4_mig_recovery_ops {
    int (*get_locations)(struct nfs_server *, struct nfs_fh *, struct nfs4_fs_locations *, struct page *, const struct cred *);
    int (*fsid_present)(struct inode *, const struct cred *);
};

struct nfs_client;

struct nfs_fsinfo;

struct nfs_seqid;

struct rpc_clnt;

struct rpc_xprt;

struct rpc_call_ops;

struct nfs4_state_recovery_ops;

struct nfs4_state_maintenance_ops;

struct nfs4_minor_version_ops {
    u32 minor_version;
    unsigned int init_caps;
    int (*init_client)(struct nfs_client *);
    void (*shutdown_client)(struct nfs_client *);
    bool (*match_stateid)(const nfs4_stateid *, const nfs4_stateid *);
    int (*find_root_sec)(struct nfs_server *, struct nfs_fh *, struct nfs_fsinfo *);
    void (*free_lock_state)(struct nfs_server *, struct nfs4_lock_state *);
    int (*test_and_free_expired)(struct nfs_server *, const nfs4_stateid *, const struct cred *);
    struct nfs_seqid * (*alloc_seqid)(struct nfs_seqid_counter *, gfp_t);
    void (*session_trunk)(struct rpc_clnt *, struct rpc_xprt *, void *);
    const struct rpc_call_ops *call_sync_ops;
    const struct nfs4_state_recovery_ops *reboot_recovery_ops;
    const struct nfs4_state_recovery_ops *nograce_recovery_ops;
    const struct nfs4_state_maintenance_ops *state_renewal_ops;
    const struct nfs4_mig_recovery_ops *mig_recovery_ops;
};

struct nfs4_slot;

struct nfs4_sequence_args {
    struct nfs4_slot *sa_slot;
    u8 sa_cache_this: 1;
    u8 sa_privileged: 1;
};

struct nfs4_sequence_res {
    struct nfs4_slot *sr_slot;
    long unsigned int sr_timestamp;
    int sr_status;
    u32 sr_status_flags;
    u32 sr_highest_slotid;
    u32 sr_target_highest_slotid;
};

struct nfs4_ssc_client_ops {
    struct file * (*sco_open)(struct vfsmount *, struct nfs_fh *, nfs4_stateid *);
    void (*sco_close)(struct file *);
};

struct nfs4_state_owner;

struct nfs4_state {
    struct list_head open_states;
    struct list_head inode_states;
    struct list_head lock_states;
    struct nfs4_state_owner *owner;
    struct inode *inode;
    long unsigned int flags;
    spinlock_t state_lock;
    seqlock_t seqlock;
    nfs4_stateid stateid;
    nfs4_stateid open_stateid;
    unsigned int n_rdonly;
    unsigned int n_wronly;
    unsigned int n_rdwr;
    fmode_t state;
    refcount_t count;
    wait_queue_head_t waitq;
    struct callback_head callback_head;
};

struct nfs4_state_maintenance_ops {
    int (*sched_state_renewal)(struct nfs_client *, const struct cred *, unsigned int);
    const struct cred * (*get_state_renewal_cred)(struct nfs_client *);
    int (*renew_lease)(struct nfs_client *, const struct cred *);
};

struct nfs4_state_owner {
    struct nfs_server *so_server;
    struct list_head so_lru;
    long unsigned int so_expires;
    struct rb_node so_server_node;
    const struct cred *so_cred;
    spinlock_t so_lock;
    atomic_t so_count;
    long unsigned int so_flags;
    struct list_head so_states;
    struct nfs_seqid_counter so_seqid;
    struct mutex so_delegreturn_mutex;
};

struct nfs4_state_recovery_ops {
    int owner_flag_bit;
    int state_flag_bit;
    int (*recover_open)(struct nfs4_state_owner *, struct nfs4_state *);
    int (*recover_lock)(struct nfs4_state *, struct file_lock *);
    int (*establish_clid)(struct nfs_client *, const struct cred *);
    int (*reclaim_complete)(struct nfs_client *, const struct cred *);
    int (*detect_trunking)(struct nfs_client *, struct nfs_client **, const struct cred *);
};

struct nfs4_threshold {
    __u32 bm;
    __u32 l_type;
    __u64 rd_sz;
    __u64 wr_sz;
    __u64 rd_io_sz;
    __u64 wr_io_sz;
};

struct nfs_access_entry {
    struct rb_node rb_node;
    struct list_head lru;
    kuid_t fsuid;
    kgid_t fsgid;
    struct group_info *group_info;
    u64 timestamp;
    __u32 mask;
    struct callback_head callback_head;
};

struct nfs_auth_info {
    unsigned int flavor_len;
    rpc_authflavor_t flavors[12];
};

struct nfs_subversion;

struct xprtsec_parms {
    enum xprtsec_policies policy;
    key_serial_t cert_serial;
    key_serial_t privkey_serial;
};

struct idmap;

struct nfs4_slot_table;

struct nfs4_session;

struct nfs_rpc_ops;

struct nfs_client {
    refcount_t cl_count;
    atomic_t cl_mds_count;
    int cl_cons_state;
    long unsigned int cl_res_state;
    long unsigned int cl_flags;
    struct __kernel_sockaddr_storage cl_addr;
    size_t cl_addrlen;
    char *cl_hostname;
    char *cl_acceptor;
    struct list_head cl_share_link;
    struct list_head cl_superblocks;
    struct rpc_clnt *cl_rpcclient;
    const struct nfs_rpc_ops *rpc_ops;
    int cl_proto;
    struct nfs_subversion *cl_nfs_mod;
    u32 cl_minorversion;
    unsigned int cl_nconnect;
    unsigned int cl_max_connect;
    const char *cl_principal;
    struct xprtsec_parms cl_xprtsec;
    struct list_head cl_ds_clients;
    u64 cl_clientid;
    nfs4_verifier cl_confirm;
    long unsigned int cl_state;
    spinlock_t cl_lock;
    long unsigned int cl_lease_time;
    long unsigned int cl_last_renewal;
    struct delayed_work cl_renewd;
    struct rpc_wait_queue cl_rpcwaitq;
    struct idmap *cl_idmap;
    const char *cl_owner_id;
    u32 cl_cb_ident;
    const struct nfs4_minor_version_ops *cl_mvops;
    long unsigned int cl_mig_gen;
    struct nfs4_slot_table *cl_slot_tbl;
    u32 cl_seqid;
    u32 cl_exchange_flags;
    struct nfs4_session *cl_session;
    bool cl_preserve_clid;
    struct nfs41_server_owner *cl_serverowner;
    struct nfs41_server_scope *cl_serverscope;
    struct nfs41_impl_id *cl_implid;
    long unsigned int cl_sp4_flags;
    wait_queue_head_t cl_lock_waitq;
    char cl_ipaddr[48];
    struct net *cl_net;
    struct list_head pending_cb_stateids;
    struct callback_head rcu;
};

struct nfs_page;

struct nfs_commit_data;

struct nfs_commit_info;

struct nfs_commit_completion_ops {
    void (*completion)(struct nfs_commit_data *);
    void (*resched_write)(struct nfs_commit_info *, struct nfs_page *);
};

struct rpc_wait {
    struct list_head list;
    struct list_head links;
    struct list_head timer_list;
};

struct rpc_procinfo;

struct rpc_message {
    const struct rpc_procinfo *rpc_proc;
    void *rpc_argp;
    void *rpc_resp;
    const struct cred *rpc_cred;
};

struct rpc_cred;

struct rpc_rqst;

struct rpc_task {
    atomic_t tk_count;
    int tk_status;
    struct list_head tk_task;
    void (*tk_callback)(struct rpc_task *);
    void (*tk_action)(struct rpc_task *);
    long unsigned int tk_timeout;
    long unsigned int tk_runstate;
    struct rpc_wait_queue *tk_waitqueue;
    union {
        struct work_struct tk_work;
        struct rpc_wait tk_wait;
    } u;
    struct rpc_message tk_msg;
    void *tk_calldata;
    const struct rpc_call_ops *tk_ops;
    struct rpc_clnt *tk_client;
    struct rpc_xprt *tk_xprt;
    struct rpc_cred *tk_op_cred;
    struct rpc_rqst *tk_rqstp;
    struct workqueue_struct *tk_workqueue;
    ktime_t tk_start;
    pid_t tk_owner;
    int tk_rpc_status;
    short unsigned int tk_flags;
    short unsigned int tk_timeouts;
    short unsigned int tk_pid;
    unsigned char tk_priority: 2;
    unsigned char tk_garb_retry: 2;
    unsigned char tk_cred_retry: 2;
};

struct nfs_fsid {
    uint64_t major;
    uint64_t minor;
};

struct nfs_fattr {
    unsigned int valid;
    umode_t mode;
    __u32 nlink;
    kuid_t uid;
    kgid_t gid;
    dev_t rdev;
    __u64 size;
    union {
        struct {
            __u32 blocksize;
            __u32 blocks;
        } nfs2;
        struct {
            __u64 used;
        } nfs3;
    } du;
    struct nfs_fsid fsid;
    __u64 fileid;
    __u64 mounted_on_fileid;
    struct timespec64 atime;
    struct timespec64 mtime;
    struct timespec64 ctime;
    __u64 change_attr;
    __u64 pre_change_attr;
    __u64 pre_size;
    struct timespec64 pre_mtime;
    struct timespec64 pre_ctime;
    long unsigned int time_start;
    long unsigned int gencount;
    struct nfs4_string *owner_name;
    struct nfs4_string *group_name;
    struct nfs4_threshold *mdsthreshold;
    struct nfs4_label *label;
};

struct nfs_write_verifier {
    char data[8];
};

struct nfs_writeverf {
    struct nfs_write_verifier verifier;
    enum nfs3_stable_how committed;
};

struct nfs_direct_req;

struct nfs_commitargs {
    struct nfs4_sequence_args seq_args;
    struct nfs_fh *fh;
    __u64 offset;
    __u32 count;
    const u32 *bitmask;
};

struct nfs_commitres {
    struct nfs4_sequence_res seq_res;
    __u32 op_status;
    struct nfs_fattr *fattr;
    struct nfs_writeverf *verf;
    const struct nfs_server *server;
};

struct pnfs_layout_segment;

struct nfs_open_context;

struct nfs_commit_data {
    struct rpc_task task;
    struct inode *inode;
    const struct cred *cred;
    struct nfs_fattr fattr;
    struct nfs_writeverf verf;
    struct list_head pages;
    struct list_head list;
    struct nfs_direct_req *dreq;
    struct nfs_commitargs args;
    struct nfs_commitres res;
    struct nfs_open_context *context;
    struct pnfs_layout_segment *lseg;
    struct nfs_client *ds_clp;
    int ds_commit_index;
    loff_t lwb;
    const struct rpc_call_ops *mds_ops;
    const struct nfs_commit_completion_ops *completion_ops;
    int (*commit_done_cb)(struct rpc_task *, struct nfs_commit_data *);
    long unsigned int flags;
};

struct nfs_mds_commit_info;

struct pnfs_ds_commit_info;

struct nfs_commit_info {
    struct inode *inode;
    struct nfs_mds_commit_info *mds;
    struct pnfs_ds_commit_info *ds;
    struct nfs_direct_req *dreq;
    const struct nfs_commit_completion_ops *completion_ops;
};

struct nfs_entry {
    __u64 ino;
    __u64 cookie;
    const char *name;
    unsigned int len;
    int eof;
    struct nfs_fh *fh;
    struct nfs_fattr *fattr;
    unsigned char d_type;
    struct nfs_server *server;
};

struct nfs_fh {
    short unsigned int size;
    unsigned char data[128];
};

struct nfsd_file;

struct nfs_file_localio {
    struct nfsd_file *ro_file;
    struct nfsd_file *rw_file;
    struct list_head list;
    void *nfs_uuid;
};

struct nfs_fsinfo {
    struct nfs_fattr *fattr;
    __u32 rtmax;
    __u32 rtpref;
    __u32 rtmult;
    __u32 wtmax;
    __u32 wtpref;
    __u32 wtmult;
    __u32 dtpref;
    __u64 maxfilesize;
    struct timespec64 time_delta;
    __u32 lease_time;
    __u32 nlayouttypes;
    __u32 layouttype[8];
    __u32 blksize;
    __u32 clone_blksize;
    enum nfs4_change_attr_type change_attr_type;
    __u32 xattr_support;
};

struct nfs_fsstat {
    struct nfs_fattr *fattr;
    __u64 tbytes;
    __u64 fbytes;
    __u64 abytes;
    __u64 tfiles;
    __u64 ffiles;
    __u64 afiles;
};

struct nfs_lock_context {
    refcount_t count;
    struct list_head list;
    struct nfs_open_context *open_context;
    fl_owner_t lockowner;
    atomic_t io_count;
    struct callback_head callback_head;
};

struct nfs_mds_commit_info {
    atomic_t rpcs_out;
    atomic_long_t ncommit;
    struct list_head list;
};

struct nfs_open_context {
    struct nfs_lock_context lock_context;
    fl_owner_t flock_owner;
    struct dentry *dentry;
    const struct cred *cred;
    struct rpc_cred *ll_cred;
    struct nfs4_state *state;
    fmode_t mode;
    int error;
    long unsigned int flags;
    struct nfs4_threshold *mdsthreshold;
    struct list_head list;
    struct callback_head callback_head;
    struct nfs_file_localio nfl;
};

struct nfs_page_array {
    struct page **pagevec;
    unsigned int npages;
    struct page *page_array[8];
};

struct nfs_pathconf {
    struct nfs_fattr *fattr;
    __u32 max_link;
    __u32 max_namelen;
};

struct nfs_pgio_args {
    struct nfs4_sequence_args seq_args;
    struct nfs_fh *fh;
    struct nfs_open_context *context;
    struct nfs_lock_context *lock_context;
    nfs4_stateid stateid;
    __u64 offset;
    __u32 count;
    unsigned int pgbase;
    struct page **pages;
    union {
        unsigned int replen;
        struct {
            const u32 *bitmask;
            u32 bitmask_store[3];
            enum nfs3_stable_how stable;
        };
    };
};

struct nfs_pgio_header;

struct nfs_pgio_completion_ops {
    void (*error_cleanup)(struct list_head *, int);
    void (*init_hdr)(struct nfs_pgio_header *);
    void (*completion)(struct nfs_pgio_header *);
    void (*reschedule_io)(struct nfs_pgio_header *);
};

struct nfs_rw_ops;

struct nfs_io_completion;

struct nfs_pgio_res {
    struct nfs4_sequence_res seq_res;
    struct nfs_fattr *fattr;
    __u64 count;
    __u32 op_status;
    union {
        struct {
            unsigned int replen;
            int eof;
            void *scratch;
        };
        struct {
            struct nfs_writeverf *verf;
            const struct nfs_server *server;
        };
    };
};

struct nfs_pgio_header {
    struct inode *inode;
    const struct cred *cred;
    struct list_head pages;
    struct nfs_page *req;
    struct nfs_writeverf verf;
    fmode_t rw_mode;
    struct pnfs_layout_segment *lseg;
    loff_t io_start;
    const struct rpc_call_ops *mds_ops;
    void (*release)(struct nfs_pgio_header *);
    const struct nfs_pgio_completion_ops *completion_ops;
    const struct nfs_rw_ops *rw_ops;
    struct nfs_io_completion *io_completion;
    struct nfs_direct_req *dreq;
    void *netfs;
    int pnfs_error;
    int error;
    unsigned int good_bytes;
    long unsigned int flags;
    struct rpc_task task;
    struct nfs_fattr fattr;
    struct nfs_pgio_args args;
    struct nfs_pgio_res res;
    long unsigned int timestamp;
    int (*pgio_done_cb)(struct rpc_task *, struct nfs_pgio_header *);
    __u64 mds_offset;
    struct nfs_page_array page_array;
    struct nfs_client *ds_clp;
    u32 ds_commit_idx;
    u32 pgio_mirror_idx;
};

struct nfs_readdir_arg {
    struct dentry *dentry;
    const struct cred *cred;
    __be32 *verf;
    u64 cookie;
    struct page **pages;
    unsigned int page_len;
    bool plus;
};

struct nfs_readdir_res {
    __be32 *verf;
};

struct nfs_removeargs {
    struct nfs4_sequence_args seq_args;
    const struct nfs_fh *fh;
    struct qstr name;
};

struct nfs_removeres {
    struct nfs4_sequence_res seq_res;
    struct nfs_server *server;
    struct nfs_fattr *dir_attr;
    struct nfs4_change_info cinfo;
};

struct nfs_renameargs {
    struct nfs4_sequence_args seq_args;
    const struct nfs_fh *old_dir;
    const struct nfs_fh *new_dir;
    const struct qstr *old_name;
    const struct qstr *new_name;
};

struct nfs_renameres {
    struct nfs4_sequence_res seq_res;
    struct nfs_server *server;
    struct nfs4_change_info old_cinfo;
    struct nfs_fattr *old_fattr;
    struct nfs4_change_info new_cinfo;
    struct nfs_fattr *new_fattr;
};

struct nfs_renamedata {
    struct nfs_renameargs args;
    struct nfs_renameres res;
    struct rpc_task task;
    const struct cred *cred;
    struct inode *old_dir;
    struct dentry *old_dentry;
    struct nfs_fattr old_fattr;
    struct inode *new_dir;
    struct dentry *new_dentry;
    struct nfs_fattr new_fattr;
    void (*complete)(struct rpc_task *, struct nfs_renamedata *);
    long int timeout;
    bool cancelled;
};

struct nlmclnt_operations;

struct nfs_client_initdata;

struct nfs_unlinkdata;

struct xdr_stream;

struct nfs_rpc_ops {
    u32 version;
    const struct dentry_operations *dentry_ops;
    const struct inode_operations *dir_inode_ops;
    const struct inode_operations *file_inode_ops;
    const struct file_operations *file_ops;
    const struct nlmclnt_operations *nlmclnt_ops;
    int (*getroot)(struct nfs_server *, struct nfs_fh *, struct nfs_fsinfo *);
    int (*submount)(struct fs_context *, struct nfs_server *);
    int (*try_get_tree)(struct fs_context *);
    int (*getattr)(struct nfs_server *, struct nfs_fh *, struct nfs_fattr *, struct inode *);
    int (*setattr)(struct dentry *, struct nfs_fattr *, struct iattr *);
    int (*lookup)(struct inode *, struct dentry *, const struct qstr *, struct nfs_fh *, struct nfs_fattr *);
    int (*lookupp)(struct inode *, struct nfs_fh *, struct nfs_fattr *);
    int (*access)(struct inode *, struct nfs_access_entry *, const struct cred *);
    int (*readlink)(struct inode *, struct page *, unsigned int, unsigned int);
    int (*create)(struct inode *, struct dentry *, struct iattr *, int);
    int (*remove)(struct inode *, struct dentry *);
    void (*unlink_setup)(struct rpc_message *, struct dentry *, struct inode *);
    void (*unlink_rpc_prepare)(struct rpc_task *, struct nfs_unlinkdata *);
    int (*unlink_done)(struct rpc_task *, struct inode *);
    void (*rename_setup)(struct rpc_message *, struct dentry *, struct dentry *);
    void (*rename_rpc_prepare)(struct rpc_task *, struct nfs_renamedata *);
    int (*rename_done)(struct rpc_task *, struct inode *, struct inode *);
    int (*link)(struct inode *, struct inode *, const struct qstr *);
    int (*symlink)(struct inode *, struct dentry *, struct folio *, unsigned int, struct iattr *);
    int (*mkdir)(struct inode *, struct dentry *, struct iattr *);
    int (*rmdir)(struct inode *, const struct qstr *);
    int (*readdir)(struct nfs_readdir_arg *, struct nfs_readdir_res *);
    int (*mknod)(struct inode *, struct dentry *, struct iattr *, dev_t);
    int (*statfs)(struct nfs_server *, struct nfs_fh *, struct nfs_fsstat *);
    int (*fsinfo)(struct nfs_server *, struct nfs_fh *, struct nfs_fsinfo *);
    int (*pathconf)(struct nfs_server *, struct nfs_fh *, struct nfs_pathconf *);
    int (*set_capabilities)(struct nfs_server *, struct nfs_fh *);
    int (*decode_dirent)(struct xdr_stream *, struct nfs_entry *, bool);
    int (*pgio_rpc_prepare)(struct rpc_task *, struct nfs_pgio_header *);
    void (*read_setup)(struct nfs_pgio_header *, struct rpc_message *);
    int (*read_done)(struct rpc_task *, struct nfs_pgio_header *);
    void (*write_setup)(struct nfs_pgio_header *, struct rpc_message *, struct rpc_clnt **);
    int (*write_done)(struct rpc_task *, struct nfs_pgio_header *);
    void (*commit_setup)(struct nfs_commit_data *, struct rpc_message *, struct rpc_clnt **);
    void (*commit_rpc_prepare)(struct rpc_task *, struct nfs_commit_data *);
    int (*commit_done)(struct rpc_task *, struct nfs_commit_data *);
    int (*lock)(struct file *, int, struct file_lock *);
    int (*lock_check_bounds)(const struct file_lock *);
    void (*clear_acl_cache)(struct inode *);
    void (*close_context)(struct nfs_open_context *, int);
    struct inode * (*open_context)(struct inode *, struct nfs_open_context *, int, struct iattr *, int *);
    int (*have_delegation)(struct inode *, fmode_t, int);
    int (*return_delegation)(struct inode *);
    struct nfs_client * (*alloc_client)(const struct nfs_client_initdata *);
    struct nfs_client * (*init_client)(struct nfs_client *, const struct nfs_client_initdata *);
    void (*free_client)(struct nfs_client *);
    struct nfs_server * (*create_server)(struct fs_context *);
    struct nfs_server * (*clone_server)(struct nfs_server *, struct nfs_fh *, struct nfs_fattr *, rpc_authflavor_t);
    int (*discover_trunking)(struct nfs_server *, struct nfs_fh *);
    void (*enable_swap)(struct inode *);
    void (*disable_swap)(struct inode *);
};

struct nfs_seqid {
    struct nfs_seqid_counter *sequence;
    struct list_head list;
    struct rpc_task *task;
};

struct nlm_host;

struct nfs_iostats;

struct fscache_volume;

struct pnfs_layoutdriver_type;

struct nfs_server {
    struct nfs_client *nfs_client;
    struct list_head client_link;
    struct list_head master_link;
    struct rpc_clnt *client;
    struct rpc_clnt *client_acl;
    struct nlm_host *nlm_host;
    struct nfs_iostats *io_stats;
    wait_queue_head_t write_congestion_wait;
    atomic_long_t writeback;
    unsigned int write_congested;
    unsigned int flags;
    unsigned int fattr_valid;
    unsigned int caps;
    unsigned int rsize;
    unsigned int rpages;
    unsigned int wsize;
    unsigned int wpages;
    unsigned int wtmult;
    unsigned int dtsize;
    short unsigned int port;
    unsigned int bsize;
    unsigned int gxasize;
    unsigned int sxasize;
    unsigned int lxasize;
    unsigned int acregmin;
    unsigned int acregmax;
    unsigned int acdirmin;
    unsigned int acdirmax;
    unsigned int namelen;
    unsigned int options;
    unsigned int clone_blksize;
    enum nfs4_change_attr_type change_attr_type;
    struct nfs_fsid fsid;
    int s_sysfs_id;
    __u64 maxfilesize;
    struct timespec64 time_delta;
    long unsigned int mount_time;
    struct super_block *super;
    dev_t s_dev;
    struct nfs_auth_info auth_info;
    struct fscache_volume *fscache;
    char *fscache_uniq;
    u32 pnfs_blksize;
    u32 attr_bitmask[3];
    u32 attr_bitmask_nl[3];
    u32 exclcreat_bitmask[3];
    u32 cache_consistency_bitmask[3];
    u32 acl_bitmask;
    u32 fh_expire_type;
    struct pnfs_layoutdriver_type *pnfs_curr_ld;
    struct rpc_wait_queue roc_rpcwaitq;
    void *pnfs_ld_data;
    struct rb_root state_owners;
    atomic64_t owner_ctr;
    struct list_head state_owners_lru;
    struct list_head layouts;
    struct list_head delegations;
    struct list_head ss_copies;
    struct list_head ss_src_copies;
    long unsigned int delegation_flags;
    long unsigned int delegation_gen;
    long unsigned int mig_gen;
    long unsigned int mig_status;
    void (*destroy)(struct nfs_server *);
    atomic_t active;
    struct __kernel_sockaddr_storage mountd_address;
    size_t mountd_addrlen;
    u32 mountd_version;
    short unsigned int mountd_port;
    short unsigned int mountd_protocol;
    struct rpc_wait_queue uoc_rpcwaitq;
    unsigned int read_hdrsize;
    const struct cred *cred;
    bool has_sec_mnt_opts;
    struct kobject kobj;
    struct callback_head rcu;
};

struct nfs_ssc_client_ops {
    void (*sco_sb_deactive)(struct super_block *);
};

struct nfs_ssc_client_ops_tbl {
    const struct nfs4_ssc_client_ops *ssc_nfs4_ops;
    const struct nfs_ssc_client_ops *ssc_nfs_ops;
};

struct nfs_unlinkdata {
    struct nfs_removeargs args;
    struct nfs_removeres res;
    struct dentry *dentry;
    wait_queue_head_t wq;
    const struct cred *cred;
    struct nfs_fattr dir_attr;
    long int timeout;
};

struct nh_config {
    u32 nh_id;
    u8 nh_family;
    u8 nh_protocol;
    u8 nh_blackhole;
    u8 nh_fdb;
    u32 nh_flags;
    int nh_ifindex;
    struct net_device *dev;
    union {
        __be32 ipv4;
        struct in6_addr ipv6;
    } gw;
    struct nlattr *nh_grp;
    u16 nh_grp_type;
    u16 nh_grp_res_num_buckets;
    long unsigned int nh_grp_res_idle_timer;
    long unsigned int nh_grp_res_unbalanced_timer;
    bool nh_grp_res_has_num_buckets;
    bool nh_grp_res_has_idle_timer;
    bool nh_grp_res_has_unbalanced_timer;
    bool nh_hw_stats;
    struct nlattr *nh_encap;
    u16 nh_encap_type;
    u32 nlflags;
    struct nl_info nlinfo;
};

struct nh_dump_filter {
    u32 nh_id;
    int dev_idx;
    int master_idx;
    bool group_filter;
    bool fdb_filter;
    u32 res_bucket_nh_id;
    u32 op_flags;
};

struct nh_grp_entry_stats;

struct nh_grp_entry {
    struct nexthop *nh;
    struct nh_grp_entry_stats *stats;
    u16 weight;
    union {
        struct {
            atomic_t upper_bound;
        } hthr;
        struct {
            struct list_head uw_nh_entry;
            u16 count_buckets;
            u16 wants_buckets;
        } res;
    };
    struct list_head nh_list;
    struct nexthop *nh_parent;
    u64 packets_hw;
};

struct nh_res_table;

struct nh_group {
    struct nh_group *spare;
    u16 num_nh;
    bool is_multipath;
    bool hash_threshold;
    bool resilient;
    bool fdb_nh;
    bool has_v4;
    bool hw_stats;
    struct nh_res_table *res_table;
    struct nh_grp_entry nh_entries[0];
};

struct nh_grp_entry_stats {
    u64_stats_t packets;
    struct u64_stats_sync syncp;
};

struct nh_info {
    struct hlist_node dev_hash;
    struct nexthop *nh_parent;
    u8 family;
    bool reject_nh;
    bool fdb_nh;
    union {
        struct fib_nh_common fib_nhc;
        struct fib_nh fib_nh;
        struct fib6_nh fib6_nh;
    };
};

struct nh_notifier_single_info {
    struct net_device *dev;
    u8 gw_family;
    union {
        __be32 ipv4;
        struct in6_addr ipv6;
    };
    u32 id;
    u8 is_reject: 1;
    u8 is_fdb: 1;
    u8 has_encap: 1;
};

struct nh_notifier_grp_entry_info {
    u16 weight;
    struct nh_notifier_single_info nh;
};

struct nh_notifier_grp_hw_stats_entry_info {
    u32 id;
    u64 packets;
};

struct nh_notifier_grp_hw_stats_info {
    u16 num_nh;
    bool hw_stats_used;
    struct nh_notifier_grp_hw_stats_entry_info stats[0];
};

struct nh_notifier_grp_info {
    u16 num_nh;
    bool is_fdb;
    bool hw_stats;
    struct nh_notifier_grp_entry_info nh_entries[0];
};

struct nh_notifier_res_table_info;

struct nh_notifier_res_bucket_info;

struct nh_notifier_info {
    struct net *net;
    struct netlink_ext_ack *extack;
    u32 id;
    enum nh_notifier_info_type type;
    union {
        struct nh_notifier_single_info *nh;
        struct nh_notifier_grp_info *nh_grp;
        struct nh_notifier_res_table_info *nh_res_table;
        struct nh_notifier_res_bucket_info *nh_res_bucket;
        struct nh_notifier_grp_hw_stats_info *nh_grp_hw_stats;
    };
};

struct nh_notifier_res_bucket_info {
    u16 bucket_index;
    unsigned int idle_timer_ms;
    bool force;
    struct nh_notifier_single_info old_nh;
    struct nh_notifier_single_info new_nh;
};

struct nh_notifier_res_table_info {
    u16 num_nh_buckets;
    bool hw_stats;
    struct nh_notifier_single_info nhs[0];
};

struct nh_res_bucket {
    struct nh_grp_entry *nh_entry;
    atomic_long_t used_time;
    long unsigned int migrated_time;
    bool occupied;
    u8 nh_flags;
};

struct nh_res_table {
    struct net *net;
    u32 nhg_id;
    struct delayed_work upkeep_dw;
    struct list_head uw_nh_entries;
    long unsigned int unbalanced_since;
    u32 idle_timer;
    u32 unbalanced_timer;
    u16 num_nh_buckets;
    struct nh_res_bucket nh_buckets[0];
};

struct nhmsg {
    unsigned char nh_family;
    unsigned char nh_scope;
    unsigned char nh_protocol;
    unsigned char resvd;
    unsigned int nh_flags;
};

struct nl80211_vendor_cmd_info {
    __u32 vendor_id;
    __u32 subcmd;
};

struct nl80211_wowlan_tcp_data_token_feature {
    __u32 min_len;
    __u32 max_len;
    __u32 bufsize;
};

struct nl_pktinfo {
    __u32 group;
};

struct rhashtable_walker {
    struct list_head list;
    struct bucket_table *tbl;
};

struct rhashtable_iter {
    struct rhashtable *ht;
    struct rhash_head *p;
    struct rhlist_head *list;
    struct rhashtable_walker walker;
    unsigned int slot;
    unsigned int skip;
    bool end_of_table;
};

struct nl_seq_iter {
    struct seq_net_private p;
    struct rhashtable_iter hti;
    int link;
};

struct nla_bitfield32 {
    __u32 value;
    __u32 selector;
};

struct nla_policy {
    u8 type;
    u8 validation_type;
    u16 len;
    union {
        u16 strict_start_type;
        const u32 bitfield32_valid;
        const u32 mask;
        const char *reject_message;
        const struct nla_policy *nested_policy;
        const struct netlink_range_validation *range;
        const struct netlink_range_validation_signed *range_signed;
        struct {
            s16 min;
            s16 max;
        };
        int (*validate)(const struct nlattr *, struct netlink_ext_ack *);
    };
};

struct nlattr {
    __u16 nla_len;
    __u16 nla_type;
};

struct nlmsg_perm {
    u16 nlmsg_type;
    u32 perm;
};

struct nlmsghdr {
    __u32 nlmsg_len;
    __u16 nlmsg_type;
    __u16 nlmsg_flags;
    __u32 nlmsg_seq;
    __u32 nlmsg_pid;
};

struct nlmsgerr {
    int error;
    struct nlmsghdr msg;
};

struct nls_table {
    const char *charset;
    const char *alias;
    int (*uni2char)(wchar_t, unsigned char *, int);
    int (*char2uni)(const unsigned char *, int, wchar_t *);
    const unsigned char *charset2lower;
    const unsigned char *charset2upper;
    struct module *owner;
    struct nls_table *next;
};

struct nmi_ctx {
    u64 hcr;
    unsigned int cnt;
};

struct node_groups {
    unsigned int id;
    union {
        unsigned int ngroups;
        unsigned int ncpus;
    };
};

struct notification {
    atomic_t requests;
    u32 flags;
    u64 next_id;
    struct list_head notifications;
};

struct npem;

struct npem_led {
    const struct indication *indication;
    struct npem *npem;
    char name[64];
    struct led_classdev led;
};

struct npem_ops;

struct npem {
    struct pci_dev *dev;
    const struct npem_ops *ops;
    struct mutex lock;
    u16 pos;
    u32 supported_indications;
    u32 active_indications;
    unsigned int active_inds_initialized: 1;
    int led_cnt;
    struct npem_led leds[0];
};

struct npem_ops {
    int (*get_active_indications)(struct npem *, u32 *);
    int (*set_active_indications)(struct npem *, u32);
    const struct indication *inds;
    const char *name;
};

struct ns_get_path_bpf_map_args {
    struct bpf_offloaded_map *offmap;
    struct bpf_map_info *info;
};

struct ns_get_path_bpf_prog_args {
    struct bpf_prog *prog;
    struct bpf_prog_info *info;
};

struct ns_get_path_task_args {
    const struct proc_ns_operations *ns_ops;
    struct task_struct *task;
};

struct uts_namespace;

struct time_namespace;

struct nsproxy {
    refcount_t count;
    struct uts_namespace *uts_ns;
    struct ipc_namespace *ipc_ns;
    struct mnt_namespace *mnt_ns;
    struct pid_namespace *pid_ns_for_children;
    struct net *net_ns;
    struct time_namespace *time_ns;
    struct time_namespace *time_ns_for_children;
    struct cgroup_namespace *cgroup_ns;
};

struct nsset {
    unsigned int flags;
    struct nsproxy *nsproxy;
    struct fs_struct *fs;
    const struct cred *cred;
};

struct nt_partition_info {
    u32 xlink_enabled;
    u32 target_part_low;
    u32 target_part_high;
    u32 reserved;
};

struct ntb_ctrl_regs {
    u32 partition_status;
    u32 partition_op;
    u32 partition_ctrl;
    u32 bar_setup;
    u32 bar_error;
    u16 lut_table_entries;
    u16 lut_table_offset;
    u32 lut_error;
    u16 req_id_table_size;
    u16 req_id_table_offset;
    u32 req_id_error;
    u32 reserved1[7];
    struct {
        u32 ctl;
        u32 win_size;
        u64 xlate_addr;
    } bar_entry[6];
    struct {
        u32 win_size;
        u32 reserved[3];
    } bar_ext_entry[6];
    u32 reserved2[192];
    u32 req_id_table[512];
    u32 reserved3[256];
    u64 lut_entry[512];
};

struct ntb_info_regs {
    u8 partition_count;
    u8 partition_id;
    u16 reserved1;
    u64 ep_map;
    u16 requester_id;
    u16 reserved2;
    u32 reserved3[4];
    struct nt_partition_info ntp_info[48];
} __attribute__((packed));

struct ntp_data {
    long unsigned int tick_usec;
    u64 tick_length;
    u64 tick_length_base;
    int time_state;
    int time_status;
    s64 time_offset;
    long int time_constant;
    long int time_maxerror;
    long int time_esterror;
    s64 time_freq;
    time64_t time_reftime;
    long int time_adjust;
    s64 ntp_tick_adj;
    time64_t ntp_next_leap_sec;
};

struct nvmem_cell_entry;

struct nvmem_cell {
    struct nvmem_cell_entry *entry;
    const char *id;
    int index;
};

typedef int (*nvmem_cell_post_process_t)(void *, const char *, int, unsigned int, void *, size_t);

struct nvmem_device;

struct nvmem_cell_entry {
    const char *name;
    int offset;
    size_t raw_len;
    int bytes;
    int bit_offset;
    int nbits;
    nvmem_cell_post_process_t read_post_process;
    void *priv;
    struct device_node *np;
    struct nvmem_device *nvmem;
    struct list_head node;
};

struct nvmem_cell_info {
    const char *name;
    unsigned int offset;
    size_t raw_len;
    unsigned int bytes;
    unsigned int bit_offset;
    unsigned int nbits;
    struct device_node *np;
    nvmem_cell_post_process_t read_post_process;
    void *priv;
};

struct nvmem_cell_lookup {
    const char *nvmem_name;
    const char *cell_name;
    const char *dev_id;
    const char *con_id;
    struct list_head node;
};

struct nvmem_cell_table {
    const char *nvmem_name;
    const struct nvmem_cell_info *cells;
    size_t ncells;
    struct list_head node;
};

typedef int (*nvmem_reg_read_t)(void *, unsigned int, void *, size_t);

typedef int (*nvmem_reg_write_t)(void *, unsigned int, void *, size_t);

struct nvmem_keepout;

struct nvmem_layout;

struct nvmem_config {
    struct device *dev;
    const char *name;
    int id;
    struct module *owner;
    const struct nvmem_cell_info *cells;
    int ncells;
    bool add_legacy_fixed_of_cells;
    void (*fixup_dt_cell_info)(struct nvmem_device *, struct nvmem_cell_info *);
    const struct nvmem_keepout *keepout;
    unsigned int nkeepout;
    enum nvmem_type type;
    bool read_only;
    bool root_only;
    bool ignore_wp;
    struct nvmem_layout *layout;
    struct device_node *of_node;
    nvmem_reg_read_t reg_read;
    nvmem_reg_write_t reg_write;
    int size;
    int word_size;
    int stride;
    void *priv;
    bool compat;
    struct device *base_dev;
};

struct nvmem_device {
    struct module *owner;
    struct device dev;
    struct list_head node;
    int stride;
    int word_size;
    int id;
    struct kref refcnt;
    size_t size;
    bool read_only;
    bool root_only;
    int flags;
    enum nvmem_type type;
    struct bin_attribute eeprom;
    struct device *base_dev;
    struct list_head cells;
    void (*fixup_dt_cell_info)(struct nvmem_device *, struct nvmem_cell_info *);
    const struct nvmem_keepout *keepout;
    unsigned int nkeepout;
    nvmem_reg_read_t reg_read;
    nvmem_reg_write_t reg_write;
    struct gpio_desc *wp_gpio;
    struct nvmem_layout *layout;
    void *priv;
    bool sysfs_cells_populated;
};

struct nvmem_keepout {
    unsigned int start;
    unsigned int end;
    unsigned char value;
};

struct nvmem_layout {
    struct device dev;
    struct nvmem_device *nvmem;
    int (*add_cells)(struct nvmem_layout *);
};

struct nvmem_layout_driver {
    struct device_driver driver;
    int (*probe)(struct nvmem_layout *);
    void (*remove)(struct nvmem_layout *);
};

struct obj_cgroup {
    struct percpu_ref refcnt;
    struct mem_cgroup *memcg;
    atomic_t nr_charged_bytes;
    union {
        struct list_head list;
        struct callback_head rcu;
    };
};

struct objpool_slot {
    uint32_t head;
    uint32_t tail;
    uint32_t last;
    uint32_t mask;
    void *entries[0];
};

struct obs_kernel_param {
    const char *str;
    int (*setup_func)(char *);
    int early;
};

struct ocontext {
    union {
        char *name;
        struct {
            u8 protocol;
            u16 low_port;
            u16 high_port;
        } port;
        struct {
            u32 addr;
            u32 mask;
        } node;
        struct {
            u32 addr[4];
            u32 mask[4];
        } node6;
        struct {
            u64 subnet_prefix;
            u16 low_pkey;
            u16 high_pkey;
        } ibpkey;
        struct {
            char *dev_name;
            u8 port;
        } ibendport;
    } u;
    union {
        u32 sclass;
        u32 behavior;
    } v;
    struct context context[2];
    u32 sid[2];
    struct ocontext *next;
};

struct od_dbs_tuners {
    unsigned int powersave_bias;
};

struct od_ops {
    unsigned int (*powersave_bias_target)(struct cpufreq_policy *, unsigned int, unsigned int);
};

struct od_policy_dbs_info {
    struct policy_dbs_info policy_dbs;
    unsigned int freq_lo;
    unsigned int freq_lo_delay_us;
    unsigned int freq_hi_delay_us;
    unsigned int sample_type: 1;
};

struct of_bus {
    void (*count_cells)(const void *, int, int *, int *);
    u64 (*map)(__be32 *, const __be32 *, int, int, int);
    int (*translate)(__be32 *, u64, int);
};

struct of_bus___2 {
    const char *name;
    const char *addresses;
    int (*match)(struct device_node *);
    void (*count_cells)(struct device_node *, int *, int *);
    u64 (*map)(__be32 *, const __be32 *, int, int, int, int);
    int (*translate)(__be32 *, u64, int);
    int flag_cells;
    unsigned int (*get_flags)(const __be32 *);
};

struct of_changeset {
    struct list_head entries;
};

struct of_changeset_entry {
    struct list_head node;
    long unsigned int action;
    struct device_node *np;
    struct property *prop;
    struct property *old_prop;
};

struct of_clk_provider {
    struct list_head link;
    struct device_node *node;
    struct clk * (*get)(struct of_phandle_args *, void *);
    struct clk_hw * (*get_hw)(struct of_phandle_args *, void *);
    void *data;
};

struct of_dev_auxdata {
    char *compatible;
    resource_size_t phys_addr;
    char *name;
    void *platform_data;
};

struct of_device_id {
    char name[32];
    char type[32];
    char compatible[128];
    const void *data;
};

struct of_dma {
    struct list_head of_dma_controllers;
    struct device_node *of_node;
    struct dma_chan * (*of_dma_xlate)(struct of_phandle_args *, struct of_dma *);
    void * (*of_dma_route_allocate)(struct of_phandle_args *, struct of_dma *);
    struct dma_router *dma_router;
    void *of_dma_data;
};

struct of_dma_filter_info {
    dma_cap_mask_t dma_cap;
    dma_filter_fn filter_fn;
};

struct of_endpoint {
    unsigned int port;
    unsigned int id;
    const struct device_node *local_node;
};

struct of_genpd_provider {
    struct list_head link;
    struct device_node *node;
    genpd_xlate_t xlate;
    void *data;
};

typedef int (*of_irq_init_cb_t)(struct device_node *, struct device_node *);

struct of_intc_desc {
    struct list_head list;
    of_irq_init_cb_t irq_init_cb;
    struct device_node *dev;
    struct device_node *interrupt_parent;
};

struct of_overlay_notify_data {
    struct device_node *overlay;
    struct device_node *target;
};

struct of_pci_iommu_alias_info {
    struct device *dev;
    struct device_node *np;
};

struct of_pci_range {
    union {
        u64 pci_addr;
        u64 bus_addr;
    };
    u64 cpu_addr;
    u64 parent_bus_addr;
    u64 size;
    u32 flags;
};

struct of_pci_range_parser {
    struct device_node *node;
    const struct of_bus___2 *bus;
    const __be32 *range;
    const __be32 *end;
    int na;
    int ns;
    int pna;
    bool dma;
};

struct of_phandle_args {
    struct device_node *np;
    int args_count;
    uint32_t args[16];
};

struct of_phandle_iterator {
    const char *cells_name;
    int cell_count;
    const struct device_node *parent;
    const __be32 *list_end;
    const __be32 *phandle_end;
    const __be32 *cur;
    uint32_t cur_count;
    phandle phandle;
    struct device_node *node;
};

struct of_reconfig_data {
    struct device_node *dn;
    struct property *prop;
    struct property *old_prop;
};

struct of_regulator_match {
    const char *name;
    void *driver_data;
    struct regulator_init_data *init_data;
    struct device_node *of_node;
    const struct regulator_desc *desc;
};

struct of_rename_gpio {
    const char *con_id;
    const char *legacy_id;
    const char *compatible;
};

struct of_serial_info {
    struct clk *clk;
    struct reset_control *rst;
    int type;
    int line;
    struct notifier_block clk_notifier;
};

struct of_timer_base {
    void *base;
    const char *name;
    int index;
};

struct of_timer_clk {
    struct clk *clk;
    const char *name;
    int index;
    long unsigned int rate;
    long unsigned int period;
};

struct of_timer_irq {
    int irq;
    int index;
    const char *name;
    long unsigned int flags;
    irq_handler_t handler;
};

struct offset_ctx {
    struct maple_tree mt;
    long unsigned int next_offset;
};

struct old_timespec32 {
    old_time32_t tv_sec;
    s32 tv_nsec;
};

struct old_itimerspec32 {
    struct old_timespec32 it_interval;
    struct old_timespec32 it_value;
};

struct old_itimerval32 {
    struct old_timeval32 it_interval;
    struct old_timeval32 it_value;
};

struct old_serial_port {
    unsigned int uart;
    unsigned int baud_base;
    unsigned int port;
    unsigned int irq;
    upf_t flags;
    unsigned char io_type;
    unsigned char *iomem_base;
    short unsigned int iomem_reg_shift;
};

struct old_timex32 {
    u32 modes;
    s32 offset;
    s32 freq;
    s32 maxerror;
    s32 esterror;
    s32 status;
    s32 constant;
    s32 precision;
    s32 tolerance;
    struct old_timeval32 time;
    s32 tick;
    s32 ppsfreq;
    s32 jitter;
    s32 shift;
    s32 stabil;
    s32 jitcnt;
    s32 calcnt;
    s32 errcnt;
    s32 stbcnt;
    s32 tai;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
};

struct old_utimbuf32 {
    old_time32_t actime;
    old_time32_t modtime;
};

struct onboard_dev_pdata {
    long unsigned int reset_us;
    long unsigned int power_on_delay_us;
    unsigned int num_supplies;
    const char * const supply_names[2];
    bool is_hub;
};

struct once_work {
    struct work_struct work;
    struct static_key_true *key;
    struct module *module;
};

struct oneshot_trig_data {
    unsigned int invert;
};

struct online_data {
    unsigned int cpu;
    bool online;
};

struct oom_control {
    struct zonelist *zonelist;
    nodemask_t *nodemask;
    struct mem_cgroup *memcg;
    const gfp_t gfp_mask;
    const int order;
    long unsigned int totalpages;
    struct task_struct *chosen;
    long int chosen_points;
    enum oom_constraint constraint;
};

struct opal_compacket {
    __be32 reserved0;
    u8 extendedComID[4];
    __be32 outstandingData;
    __be32 minTransfer;
    __be32 length;
};

struct opal_data_subpacket {
    u8 reserved0[6];
    __be16 kind;
    __be32 length;
};

typedef int sec_send_recv(void *, u16, u8, void *, size_t, bool);

struct opal_resp_tok {
    const u8 *pos;
    size_t len;
    enum opal_response_token type;
    enum opal_atom_width width;
    union {
        u64 u;
        s64 s;
    } stored;
};

struct parsed_resp {
    int num;
    struct opal_resp_tok toks[64];
};

struct opal_dev {
    u32 flags;
    void *data;
    sec_send_recv *send_recv;
    struct mutex dev_lock;
    u16 comid;
    u32 hsn;
    u32 tsn;
    u64 align;
    u64 lowest_lba;
    u32 logical_block_size;
    u8 align_required;
    size_t pos;
    u8 *cmd;
    u8 *resp;
    struct parsed_resp parsed;
    size_t prev_d_len;
    void *prev_data;
    struct list_head unlk_lst;
};

struct opal_discovery {
    __u64 data;
    __u64 size;
};

struct opal_geometry {
    __u8 align;
    __u32 logical_block_size;
    __u64 alignment_granularity;
    __u64 lowest_aligned_lba;
    __u8 __align[3];
};

struct opal_packet {
    __be32 tsn;
    __be32 hsn;
    __be32 seq_number;
    __be16 reserved0;
    __be16 ack_type;
    __be32 acknowledgment;
    __be32 length;
};

struct opal_header {
    struct opal_compacket cp;
    struct opal_packet pkt;
    struct opal_data_subpacket subpkt;
};

struct opal_key {
    __u8 lr;
    __u8 key_len;
    __u8 key_type;
    __u8 __align[5];
    __u8 key[256];
};

struct opal_session_info {
    __u32 sum;
    __u32 who;
    struct opal_key opal_key;
};

struct opal_lock_unlock {
    struct opal_session_info session;
    __u32 l_state;
    __u16 flags;
    __u8 __align[2];
};

struct opal_lr_act {
    struct opal_key key;
    __u32 sum;
    __u8 num_lrs;
    __u8 lr[9];
    __u8 align[2];
};

struct opal_lr_status {
    struct opal_session_info session;
    __u64 range_start;
    __u64 range_length;
    __u32 RLE;
    __u32 WLE;
    __u32 l_state;
    __u8 align[4];
};

struct opal_mbr_data {
    struct opal_key key;
    __u8 enable_disable;
    __u8 __align[7];
};

struct opal_mbr_done {
    struct opal_key key;
    __u8 done_flag;
    __u8 __align[7];
};

struct opal_new_pw {
    struct opal_session_info session;
    struct opal_session_info new_user_pw;
};

struct opal_read_write_table {
    struct opal_key key;
    const __u64 data;
    const __u8 table_uid[8];
    __u64 offset;
    __u64 size;
    __u64 flags;
    __u64 priv;
};

struct opal_revert_lsp {
    struct opal_key key;
    __u32 options;
    __u32 __pad;
};

struct opal_shadow_mbr {
    struct opal_key key;
    const __u64 data;
    __u64 offset;
    __u64 size;
};

struct opal_status {
    __u32 flags;
    __u32 reserved;
};

struct opal_step {
    int (*fn)(struct opal_dev *, void *);
    void *data;
};

struct opal_suspend_data {
    struct opal_lock_unlock unlk;
    u8 lr;
    struct list_head node;
};

struct opal_user_lr_setup {
    __u64 range_start;
    __u64 range_length;
    __u32 RLE;
    __u32 WLE;
    struct opal_session_info session;
};

struct open_flags {
    int open_flag;
    umode_t mode;
    int acc_mode;
    int intent;
    int lookup_flags;
};

struct opp_config_data {
    struct opp_table *opp_table;
    unsigned int flags;
    unsigned int required_dev_index;
};

struct opp_device {
    struct list_head node;
    const struct device *dev;
    struct dentry *dentry;
};

struct icc_path;

struct opp_table {
    struct list_head node;
    struct list_head lazy;
    struct blocking_notifier_head head;
    struct list_head dev_list;
    struct list_head opp_list;
    struct kref kref;
    struct mutex lock;
    struct device_node *np;
    long unsigned int clock_latency_ns_max;
    unsigned int voltage_tolerance_v1;
    unsigned int parsed_static_opps;
    enum opp_table_access shared_opp;
    long unsigned int current_rate_single_clk;
    struct dev_pm_opp *current_opp;
    struct dev_pm_opp *suspend_opp;
    struct opp_table **required_opp_tables;
    struct device **required_devs;
    unsigned int required_opp_count;
    unsigned int *supported_hw;
    unsigned int supported_hw_count;
    const char *prop_name;
    config_clks_t config_clks;
    struct clk **clks;
    struct clk *clk;
    int clk_count;
    config_regulators_t config_regulators;
    struct regulator **regulators;
    int regulator_count;
    struct icc_path **paths;
    unsigned int path_count;
    bool enabled;
    bool is_genpd;
    struct dentry *dentry;
    char dentry_name[255];
};

struct optimistic_spin_node {
    struct optimistic_spin_node *next;
    struct optimistic_spin_node *prev;
    int locked;
    int cpu;
};

struct orlov_stats {
    __u64 free_clusters;
    __u32 free_inodes;
    __u32 used_dirs;
};

struct osapsess {
    uint32_t handle;
    unsigned char secret[20];
    unsigned char enonce[20];
};

struct osnoise_entry {
    struct trace_entry ent;
    u64 noise;
    u64 runtime;
    u64 max_sample;
    unsigned int hw_count;
    unsigned int nmi_count;
    unsigned int irq_count;
    unsigned int softirq_count;
    unsigned int thread_count;
};

struct out_of_bounds_data {
    struct source_location location;
    struct type_descriptor *array_type;
    struct type_descriptor *index_type;
};

struct overflow_data {
    struct source_location location;
    struct type_descriptor *type;
};

struct overlay_changeset {
    int id;
    struct list_head ovcs_list;
    const void *new_fdt;
    const void *overlay_mem;
    struct device_node *overlay_root;
    enum of_overlay_notify_action notify_state;
    int count;
    struct fragment *fragments;
    bool symbols_fragment;
    struct of_changeset cset;
};

struct pacct_struct {
    int ac_flag;
    long int ac_exitcode;
    long unsigned int ac_mem;
    u64 ac_utime;
    u64 ac_stime;
    long unsigned int ac_minflt;
    long unsigned int ac_majflt;
};

struct packed_field_u16 {
    u16 startbit;
    u16 endbit;
    u16 offset;
    u16 size;
};

struct packed_field_u8 {
    u8 startbit;
    u8 endbit;
    u8 offset;
    u8 size;
};

struct scsi_sense_hdr;

struct packet_command {
    unsigned char cmd[12];
    unsigned char *buffer;
    unsigned int buflen;
    int stat;
    struct scsi_sense_hdr *sshdr;
    unsigned char data_direction;
    int quiet;
    int timeout;
    void *reserved[1];
};

struct packet_fanout {
    possible_net_t net;
    unsigned int num_members;
    u32 max_num_members;
    u16 id;
    u8 type;
    u8 flags;
    union {
        atomic_t rr_cur;
        struct bpf_prog *bpf_prog;
    };
    struct list_head list;
    spinlock_t lock;
    refcount_t sk_ref;
    long: 64;
    struct packet_type prot_hook;
    struct sock *arr[0];
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
};

struct packet_mclist {
    struct packet_mclist *next;
    int ifindex;
    int count;
    short unsigned int type;
    short unsigned int alen;
    unsigned char addr[32];
};

struct packet_mreq_max {
    int mr_ifindex;
    short unsigned int mr_type;
    short unsigned int mr_alen;
    unsigned char mr_address[32];
};

struct pgv;

struct tpacket_kbdq_core {
    struct pgv *pkbdq;
    unsigned int feature_req_word;
    unsigned int hdrlen;
    unsigned char reset_pending_on_curr_blk;
    unsigned char delete_blk_timer;
    short unsigned int kactive_blk_num;
    short unsigned int blk_sizeof_priv;
    short unsigned int last_kactive_blk_num;
    char *pkblk_start;
    char *pkblk_end;
    int kblk_size;
    unsigned int max_frame_len;
    unsigned int knum_blocks;
    uint64_t knxt_seq_num;
    char *prev;
    char *nxt_offset;
    struct sk_buff *skb;
    rwlock_t blk_fill_in_prog_lock;
    short unsigned int retire_blk_tov;
    short unsigned int version;
    long unsigned int tov_in_jiffies;
    struct timer_list retire_blk_timer;
};

struct packet_ring_buffer {
    struct pgv *pg_vec;
    unsigned int head;
    unsigned int frames_per_block;
    unsigned int frame_size;
    unsigned int frame_max;
    unsigned int pg_vec_order;
    unsigned int pg_vec_pages;
    unsigned int pg_vec_len;
    unsigned int *pending_refcnt;
    union {
        long unsigned int *rx_owner_map;
        struct tpacket_kbdq_core prb_bdqc;
    };
};

struct packet_rollover {
    int sock;
    atomic_long_t num;
    atomic_long_t num_huge;
    atomic_long_t num_failed;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    u32 history[16];
};

struct sockaddr_pkt {
    short unsigned int spkt_family;
    unsigned char spkt_device[14];
    __be16 spkt_protocol;
};

struct sockaddr_ll {
    short unsigned int sll_family;
    __be16 sll_protocol;
    int sll_ifindex;
    short unsigned int sll_hatype;
    unsigned char sll_pkttype;
    unsigned char sll_halen;
    unsigned char sll_addr[8];
};

struct packet_skb_cb {
    union {
        struct sockaddr_pkt pkt;
        union {
            unsigned int origlen;
            struct sockaddr_ll ll;
        };
    } sa;
};

struct tpacket_stats {
    unsigned int tp_packets;
    unsigned int tp_drops;
};

struct tpacket_stats_v3 {
    unsigned int tp_packets;
    unsigned int tp_drops;
    unsigned int tp_freeze_q_cnt;
};

union tpacket_stats_u {
    struct tpacket_stats stats1;
    struct tpacket_stats_v3 stats3;
};

struct packet_sock {
    struct sock sk;
    struct packet_fanout *fanout;
    union tpacket_stats_u stats;
    struct packet_ring_buffer rx_ring;
    struct packet_ring_buffer tx_ring;
    int copy_thresh;
    spinlock_t bind_lock;
    struct mutex pg_vec_lock;
    long unsigned int flags;
    int ifindex;
    u8 vnet_hdr_sz;
    __be16 num;
    struct packet_rollover *rollover;
    struct packet_mclist *mclist;
    atomic_long_t mapped;
    enum tpacket_versions tp_version;
    unsigned int tp_hdrlen;
    unsigned int tp_reserve;
    unsigned int tp_tstamp;
    struct completion skb_completion;
    struct net_device *cached_dev;
    long: 64;
    struct packet_type prot_hook;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    atomic_t tp_drops;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
};

struct padata_cpumask {
    cpumask_var_t pcpu;
    cpumask_var_t cbcpu;
};

struct padata_instance {
    struct hlist_node cpu_online_node;
    struct hlist_node cpu_dead_node;
    struct workqueue_struct *parallel_wq;
    struct workqueue_struct *serial_wq;
    struct list_head pslist;
    struct padata_cpumask cpumask;
    struct kobject kobj;
    struct mutex lock;
    u8 flags;
};

struct padata_list {
    struct list_head list;
    spinlock_t lock;
};

struct padata_mt_job {
    void (*thread_fn)(long unsigned int, long unsigned int, void *);
    void *fn_arg;
    long unsigned int start;
    long unsigned int size;
    long unsigned int align;
    long unsigned int min_chunk;
    int max_threads;
    bool numa_aware;
};

struct padata_mt_job_state {
    spinlock_t lock;
    struct completion completion;
    struct padata_mt_job *job;
    int nworks;
    int nworks_fini;
    long unsigned int chunk_size;
};

struct parallel_data;

struct padata_priv {
    struct list_head list;
    struct parallel_data *pd;
    int cb_cpu;
    unsigned int seq_nr;
    int info;
    void (*parallel)(struct padata_priv *);
    void (*serial)(struct padata_priv *);
};

struct padata_serial_queue {
    struct padata_list serial;
    struct work_struct work;
    struct parallel_data *pd;
};

struct padata_shell {
    struct padata_instance *pinst;
    struct parallel_data *pd;
    struct parallel_data *opd;
    struct list_head list;
};

struct padata_sysfs_entry {
    struct attribute attr;
    ssize_t (*show)(struct padata_instance *, struct attribute *, char *);
    ssize_t (*store)(struct padata_instance *, struct attribute *, const char *, size_t);
};

struct padata_work {
    struct work_struct pw_work;
    struct list_head pw_list;
    void *pw_data;
};

typedef struct page *pgtable_t;

struct page_change_data {
    pgprot_t set_mask;
    pgprot_t clear_mask;
};

struct printf_spec;

struct page_flags_fields {
    int width;
    int shift;
    int mask;
    const struct printf_spec *spec;
    const char *name;
};

struct page_pool_params_fast {
    unsigned int order;
    unsigned int pool_size;
    int nid;
    struct device *dev;
    struct napi_struct *napi;
    enum dma_data_direction dma_dir;
    unsigned int max_len;
    unsigned int offset;
};

struct page_pool_alloc_stats {
    u64 fast;
    u64 slow;
    u64 slow_high_order;
    u64 empty;
    u64 refill;
    u64 waive;
};

struct pp_alloc_cache {
    u32 count;
    netmem_ref cache[128];
};

struct ptr_ring {
    int producer;
    spinlock_t producer_lock;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    int consumer_head;
    int consumer_tail;
    spinlock_t consumer_lock;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    int size;
    int batch;
    void **queue;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
};

struct page_pool_params_slow {
    struct net_device *netdev;
    unsigned int queue_idx;
    unsigned int flags;
    void (*init_callback)(netmem_ref, void *);
    void *init_arg;
};

struct page_pool_recycle_stats;

struct page_pool {
    struct page_pool_params_fast p;
    int cpuid;
    u32 pages_state_hold_cnt;
    bool has_init_callback: 1;
    bool dma_map: 1;
    bool dma_sync: 1;
    bool dma_sync_for_cpu: 1;
    bool system: 1;
    long: 0;
    __u8 __cacheline_group_begin__frag[0];
    long int frag_users;
    netmem_ref frag_page;
    unsigned int frag_offset;
    long: 0;
    __u8 __cacheline_group_end__frag[0];
    long: 64;
    struct {} __cacheline_group_pad__frag;
    struct delayed_work release_dw;
    void (*disconnect)(void *);
    long unsigned int defer_start;
    long unsigned int defer_warn;
    struct page_pool_alloc_stats alloc_stats;
    u32 xdp_mem_id;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    struct pp_alloc_cache alloc;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    struct ptr_ring ring;
    void *mp_priv;
    struct page_pool_recycle_stats *recycle_stats;
    atomic_t pages_state_release_cnt;
    refcount_t user_cnt;
    u64 destroy_cnt;
    struct page_pool_params_slow slow;
    struct {
        struct hlist_node list;
        u64 detach_time;
        u32 id;
    } user;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
};

struct page_pool_dump_cb {
    long unsigned int ifindex;
    u32 pp_id;
};

struct page_pool_params {
    union {
        struct {
            unsigned int order;
            unsigned int pool_size;
            int nid;
            struct device *dev;
            struct napi_struct *napi;
            enum dma_data_direction dma_dir;
            unsigned int max_len;
            unsigned int offset;
        };
        struct page_pool_params_fast fast;
    };
    union {
        struct {
            struct net_device *netdev;
            unsigned int queue_idx;
            unsigned int flags;
            void (*init_callback)(netmem_ref, void *);
            void *init_arg;
        };
        struct page_pool_params_slow slow;
    };
};

struct page_pool_recycle_stats {
    u64 cached;
    u64 cache_full;
    u64 ring;
    u64 ring_full;
    u64 released_refcnt;
};

struct page_pool_stats {
    struct page_pool_alloc_stats alloc_stats;
    struct page_pool_recycle_stats recycle_stats;
};

struct page_region {
    __u64 start;
    __u64 end;
    __u64 categories;
};

struct page_reporting_dev_info {
    int (*report)(struct page_reporting_dev_info *, struct scatterlist *, unsigned int);
    struct delayed_work work;
    atomic_t state;
    unsigned int order;
};

struct page_vma_mapped_walk {
    long unsigned int pfn;
    long unsigned int nr_pages;
    long unsigned int pgoff;
    struct vm_area_struct *vma;
    long unsigned int address;
    pmd_t *pmd;
    pte_t *pte;
    spinlock_t *ptl;
    unsigned int flags;
};

struct pagelist {
    u32 length;
    u16 type;
    u16 offset;
    u32 addrs[1];
};

struct pm_scan_arg {
    __u64 size;
    __u64 flags;
    __u64 start;
    __u64 end;
    __u64 walk_end;
    __u64 vec;
    __u64 vec_len;
    __u64 max_pages;
    __u64 category_inverted;
    __u64 category_mask;
    __u64 category_anyof_mask;
    __u64 return_mask;
};

struct pagemap_scan_private {
    struct pm_scan_arg arg;
    long unsigned int masks_of_interest;
    long unsigned int cur_vma_category;
    struct page_region *vec_buf;
    long unsigned int vec_buf_len;
    long unsigned int vec_buf_index;
    long unsigned int found_pages;
    struct page_region *vec_out;
};

struct pagemapread {
    int pos;
    int len;
    pagemap_entry_t *buffer;
    bool show_pfn;
};

struct pages_devres {
    long unsigned int addr;
    unsigned int order;
};

struct pages_or_folios {
    union {
        struct page **pages;
        struct folio **folios;
        void **entries;
    };
    bool has_folios;
    long int nr_entries;
};

struct parallel_data {
    struct padata_shell *ps;
    struct padata_list *reorder_list;
    struct padata_serial_queue *squeue;
    refcount_t refcnt;
    unsigned int seq_nr;
    unsigned int processed;
    int cpu;
    struct padata_cpumask cpumask;
    struct work_struct reorder_work;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    spinlock_t lock;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
};

struct thermal_genl_cpu_caps;

struct param {
    struct nlattr **attrs;
    struct sk_buff *msg;
    const char *name;
    int tz_id;
    int cdev_id;
    int trip_id;
    int trip_temp;
    int trip_type;
    int trip_hyst;
    int temp;
    int prev_temp;
    int direction;
    int cdev_state;
    int cdev_max_state;
    struct thermal_genl_cpu_caps *cpu_capabilities;
    int cpu_capabilities_count;
};

struct parsed_desc {
    u32 mb;
    u32 valid;
};

struct partition_meta_info {
    char uuid[37];
    u8 volname[64];
};

struct parsed_partitions {
    struct gendisk *disk;
    char name[32];
    struct {
        sector_t from;
        sector_t size;
        int flags;
        bool has_info;
        struct partition_meta_info info;
    } *parts;
    int next;
    int limit;
    bool access_beyond_eod;
    char *pp_buf;
};

struct partial_cluster {
    ext4_fsblk_t pclu;
    ext4_lblk_t lblk;
    enum {
        initial = 0,
        tofree = 1,
        nofree = 2,
    } state;
};

struct partial_context {
    gfp_t flags;
    unsigned int orig_size;
    void *object;
};

struct partial_page {
    unsigned int offset;
    unsigned int len;
    long unsigned int private;
};

struct partition_affinity {
    cpumask_t mask;
    void *partition_id;
};

struct partition_desc {
    int nr_parts;
    struct partition_affinity *parts;
    struct irq_domain *domain;
    struct irq_desc *chained_desc;
    long unsigned int *bitmap;
    struct irq_domain_ops ops;
};

struct path_cond {
    kuid_t uid;
    umode_t mode;
};

struct pause_reply_data {
    struct ethnl_reply_data base;
    struct ethtool_pauseparam pauseparam;
    struct ethtool_pause_stats pausestat;
};

struct pause_req_info {
    struct ethnl_req_info base;
    enum ethtool_mac_stats_src src;
};

struct pci_acs {
    u16 cap;
    u16 ctrl;
    u16 fw_ctrl;
};

struct pci_ops;

struct pci_bus {
    struct list_head node;
    struct pci_bus *parent;
    struct list_head children;
    struct list_head devices;
    struct pci_dev *self;
    struct list_head slots;
    struct resource *resource[4];
    struct list_head resources;
    struct resource busn_res;
    struct pci_ops *ops;
    void *sysdata;
    struct proc_dir_entry *procdir;
    unsigned char number;
    unsigned char primary;
    unsigned char max_bus_speed;
    unsigned char cur_bus_speed;
    int domain_nr;
    char name[48];
    short unsigned int bridge_ctl;
    pci_bus_flags_t bus_flags;
    struct device *bridge;
    struct device dev;
    struct bin_attribute *legacy_io;
    struct bin_attribute *legacy_mem;
    unsigned int is_added: 1;
    unsigned int unsafe_warn: 1;
};

struct pci_bus_region {
    pci_bus_addr_t start;
    pci_bus_addr_t end;
};

struct pci_bus_resource {
    struct list_head list;
    struct resource *res;
};

struct pci_cap_saved_data {
    u16 cap_nr;
    bool cap_extended;
    unsigned int size;
    u32 data[0];
};

struct pci_cap_saved_state {
    struct hlist_node next;
    struct pci_cap_saved_data cap;
};

struct pci_ecam_ops;

struct pci_config_window {
    struct resource res;
    struct resource busr;
    unsigned int bus_shift;
    void *priv;
    const struct pci_ecam_ops *ops;
    union {
        void *win;
        void **winp;
    };
    struct device *parent;
};

struct pci_vpd {
    struct mutex lock;
    unsigned int len;
    u8 cap;
};

struct rcec_ea;

struct pcie_link_state;

struct pcie_bwctrl_data;

struct pci_sriov;

struct pci_dev {
    struct list_head bus_list;
    struct pci_bus *bus;
    struct pci_bus *subordinate;
    void *sysdata;
    struct proc_dir_entry *procent;
    struct pci_slot *slot;
    unsigned int devfn;
    short unsigned int vendor;
    short unsigned int device;
    short unsigned int subsystem_vendor;
    short unsigned int subsystem_device;
    unsigned int class;
    u8 revision;
    u8 hdr_type;
    u16 aer_cap;
    struct aer_stats *aer_stats;
    struct rcec_ea *rcec_ea;
    struct pci_dev *rcec;
    u32 devcap;
    u8 pcie_cap;
    u8 msi_cap;
    u8 msix_cap;
    u8 pcie_mpss: 3;
    u8 rom_base_reg;
    u8 pin;
    u16 pcie_flags_reg;
    long unsigned int *dma_alias_mask;
    struct pci_driver *driver;
    u64 dma_mask;
    struct device_dma_parameters dma_parms;
    pci_power_t current_state;
    u8 pm_cap;
    unsigned int pme_support: 5;
    unsigned int pme_poll: 1;
    unsigned int pinned: 1;
    unsigned int config_rrs_sv: 1;
    unsigned int imm_ready: 1;
    unsigned int d1_support: 1;
    unsigned int d2_support: 1;
    unsigned int no_d1d2: 1;
    unsigned int no_d3cold: 1;
    unsigned int bridge_d3: 1;
    unsigned int d3cold_allowed: 1;
    unsigned int mmio_always_on: 1;
    unsigned int wakeup_prepared: 1;
    unsigned int skip_bus_pm: 1;
    unsigned int ignore_hotplug: 1;
    unsigned int hotplug_user_indicators: 1;
    unsigned int clear_retrain_link: 1;
    unsigned int d3hot_delay;
    unsigned int d3cold_delay;
    u16 l1ss;
    struct pcie_link_state *link_state;
    unsigned int ltr_path: 1;
    unsigned int pasid_no_tlp: 1;
    unsigned int eetlp_prefix_max: 3;
    pci_channel_state_t error_state;
    struct device dev;
    int cfg_size;
    unsigned int irq;
    struct resource resource[17];
    struct resource driver_exclusive_resource;
    bool match_driver;
    unsigned int transparent: 1;
    unsigned int io_window: 1;
    unsigned int pref_window: 1;
    unsigned int pref_64_window: 1;
    unsigned int multifunction: 1;
    unsigned int is_busmaster: 1;
    unsigned int no_msi: 1;
    unsigned int no_64bit_msi: 1;
    unsigned int block_cfg_access: 1;
    unsigned int broken_parity_status: 1;
    unsigned int irq_reroute_variant: 2;
    unsigned int msi_enabled: 1;
    unsigned int msix_enabled: 1;
    unsigned int ari_enabled: 1;
    unsigned int ats_enabled: 1;
    unsigned int pasid_enabled: 1;
    unsigned int pri_enabled: 1;
    unsigned int tph_enabled: 1;
    unsigned int is_managed: 1;
    unsigned int is_msi_managed: 1;
    unsigned int needs_freset: 1;
    unsigned int state_saved: 1;
    unsigned int is_physfn: 1;
    unsigned int is_virtfn: 1;
    unsigned int is_hotplug_bridge: 1;
    unsigned int shpc_managed: 1;
    unsigned int is_thunderbolt: 1;
    unsigned int untrusted: 1;
    unsigned int external_facing: 1;
    unsigned int broken_intx_masking: 1;
    unsigned int io_window_1k: 1;
    unsigned int irq_managed: 1;
    unsigned int non_compliant_bars: 1;
    unsigned int is_probed: 1;
    unsigned int link_active_reporting: 1;
    unsigned int no_vf_scan: 1;
    unsigned int no_command_memory: 1;
    unsigned int rom_bar_overlap: 1;
    unsigned int rom_attr_enabled: 1;
    unsigned int aspm_os_control: 1;
    pci_dev_flags_t dev_flags;
    atomic_t enable_cnt;
    spinlock_t pcie_cap_lock;
    u32 saved_config_space[16];
    struct hlist_head saved_cap_space;
    struct bin_attribute *res_attr[17];
    struct bin_attribute *res_attr_wc[17];
    u16 ptm_cap;
    unsigned int ptm_root: 1;
    unsigned int ptm_enabled: 1;
    u8 ptm_granularity;
    void *msix_base;
    raw_spinlock_t msi_lock;
    struct pci_vpd vpd;
    u16 dpc_cap;
    unsigned int dpc_rp_extensions: 1;
    u8 dpc_rp_log_size;
    struct pcie_bwctrl_data *link_bwctrl;
    union {
        struct pci_sriov *sriov;
        struct pci_dev *physfn;
    };
    u16 ats_cap;
    u8 ats_stu;
    u16 pri_cap;
    u32 pri_reqs_alloc;
    unsigned int pasid_required: 1;
    u16 pasid_cap;
    u16 pasid_features;
    struct npem *npem;
    u16 acs_cap;
    u8 supported_speeds;
    phys_addr_t rom;
    size_t romlen;
    const char *driver_override;
    long unsigned int priv_flags;
    u8 reset_methods[8];
    u16 tph_cap;
    u8 tph_mode;
    u8 tph_req_type;
};

struct pci_dev_acs_enabled {
    u16 vendor;
    u16 device;
    int (*acs_enabled)(struct pci_dev *, u16);
};

struct pci_dev_acs_ops {
    u16 vendor;
    u16 device;
    int (*enable_acs)(struct pci_dev *);
    int (*disable_acs_redir)(struct pci_dev *);
};

struct pci_dev_reset_methods {
    u16 vendor;
    u16 device;
    int (*reset)(struct pci_dev *, bool);
};

struct pci_dev_resource {
    struct list_head list;
    struct resource *res;
    struct pci_dev *dev;
    resource_size_t start;
    resource_size_t end;
    resource_size_t add_size;
    resource_size_t min_align;
    long unsigned int flags;
};

struct pci_device_id {
    __u32 vendor;
    __u32 device;
    __u32 subvendor;
    __u32 subdevice;
    __u32 class;
    __u32 class_mask;
    kernel_ulong_t driver_data;
    __u32 override_only;
};

struct pci_domain_busn_res {
    struct list_head list;
    struct resource res;
    int domain_nr;
};

struct pci_dynids {
    spinlock_t lock;
    struct list_head list;
};

struct pci_error_handlers;

struct pci_driver {
    const char *name;
    const struct pci_device_id *id_table;
    int (*probe)(struct pci_dev *, const struct pci_device_id *);
    void (*remove)(struct pci_dev *);
    int (*suspend)(struct pci_dev *, pm_message_t);
    int (*resume)(struct pci_dev *);
    void (*shutdown)(struct pci_dev *);
    int (*sriov_configure)(struct pci_dev *, int);
    int (*sriov_set_msix_vec_count)(struct pci_dev *, int);
    u32 (*sriov_get_vf_total_msix)(struct pci_dev *);
    const struct pci_error_handlers *err_handler;
    const struct attribute_group **groups;
    const struct attribute_group **dev_groups;
    struct device_driver driver;
    struct pci_dynids dynids;
    bool driver_managed_dma;
};

struct pci_dynid {
    struct list_head node;
    struct pci_device_id id;
};

struct pci_ops {
    int (*add_bus)(struct pci_bus *);
    void (*remove_bus)(struct pci_bus *);
    void * (*map_bus)(struct pci_bus *, unsigned int, int);
    int (*read)(struct pci_bus *, unsigned int, int, int, u32 *);
    int (*write)(struct pci_bus *, unsigned int, int, int, u32);
};

struct pci_host_bridge;

struct pci_ecam_ops {
    unsigned int bus_shift;
    struct pci_ops pci_ops;
    int (*init)(struct pci_config_window *);
    int (*enable_device)(struct pci_host_bridge *, struct pci_dev *);
    void (*disable_device)(struct pci_host_bridge *, struct pci_dev *);
};

struct pci_error_handlers {
    pci_ers_result_t (*error_detected)(struct pci_dev *, pci_channel_state_t);
    pci_ers_result_t (*mmio_enabled)(struct pci_dev *);
    pci_ers_result_t (*slot_reset)(struct pci_dev *);
    void (*reset_prepare)(struct pci_dev *);
    void (*reset_done)(struct pci_dev *);
    void (*resume)(struct pci_dev *);
    void (*cor_error_detected)(struct pci_dev *);
};

struct pci_fixup {
    u16 vendor;
    u16 device;
    u32 class;
    unsigned int class_shift;
    int hook_offset;
};

struct pci_host_bridge {
    struct device dev;
    struct pci_bus *bus;
    struct pci_ops *ops;
    struct pci_ops *child_ops;
    void *sysdata;
    int busnr;
    int domain_nr;
    struct list_head windows;
    struct list_head dma_ranges;
    u8 (*swizzle_irq)(struct pci_dev *, u8 *);
    int (*map_irq)(const struct pci_dev *, u8, u8);
    void (*release_fn)(struct pci_host_bridge *);
    int (*enable_device)(struct pci_host_bridge *, struct pci_dev *);
    void (*disable_device)(struct pci_host_bridge *, struct pci_dev *);
    void *release_data;
    unsigned int ignore_reset_delay: 1;
    unsigned int no_ext_tags: 1;
    unsigned int no_inc_mrrs: 1;
    unsigned int native_aer: 1;
    unsigned int native_pcie_hotplug: 1;
    unsigned int native_shpc_hotplug: 1;
    unsigned int native_pme: 1;
    unsigned int native_ltr: 1;
    unsigned int native_dpc: 1;
    unsigned int native_cxl_error: 1;
    unsigned int preserve_config: 1;
    unsigned int size_windows: 1;
    unsigned int msi_domain: 1;
    resource_size_t (*align_resource)(struct pci_dev *, const struct resource *, resource_size_t, resource_size_t, resource_size_t);
    long: 64;
    long unsigned int private[0];
};

struct pci_p2pdma_map_state {
    struct dev_pagemap *pgmap;
    int map;
    u64 bus_off;
};

struct pci_pme_device {
    struct list_head list;
    struct pci_dev *dev;
};

struct pci_reset_fn_method {
    int (*reset_fn)(struct pci_dev *, bool);
    char *name;
};

struct pci_saved_state {
    u32 config_space[16];
    struct pci_cap_saved_data cap[0];
};

struct pci_slot {
    struct pci_bus *bus;
    struct list_head list;
    struct hotplug_slot *hotplug;
    unsigned char number;
    struct kobject kobj;
};

struct pci_slot_attribute {
    struct attribute attr;
    ssize_t (*show)(struct pci_slot *, char *);
    ssize_t (*store)(struct pci_slot *, const char *, size_t);
};

struct pci_sriov {
    int pos;
    int nres;
    u32 cap;
    u16 ctrl;
    u16 total_VFs;
    u16 initial_VFs;
    u16 num_VFs;
    u16 offset;
    u16 stride;
    u16 vf_device;
    u32 pgsz;
    u8 link;
    u8 max_VF_buses;
    u16 driver_max_VFs;
    struct pci_dev *dev;
    struct pci_dev *self;
    u32 class;
    u8 hdr_type;
    u16 subsystem_vendor;
    u16 subsystem_device;
    resource_size_t barsz[6];
    bool drivers_autoprobe;
};

struct pcie_bwctrl_data {
    struct mutex set_speed_mutex;
    atomic_t lbms_count;
    struct thermal_cooling_device *cdev;
};

struct pcie_cfg_data {
    const int *offsets;
    const enum pcie_soc_base soc_base;
    const bool has_phy;
    const u32 quirks;
    u8 num_inbound_wins;
    int (*perst_set)(struct brcm_pcie *, u32);
    int (*bridge_sw_init_set)(struct brcm_pcie *, u32);
    int (*post_setup)(struct brcm_pcie *);
};

struct pcie_device {
    int irq;
    struct pci_dev *port;
    u32 service;
    void *priv_data;
    struct device device;
};

struct pcie_link_state {
    struct pci_dev *pdev;
    struct pci_dev *downstream;
    struct pcie_link_state *root;
    struct pcie_link_state *parent;
    struct list_head sibling;
    u32 aspm_support: 7;
    u32 aspm_enabled: 7;
    u32 aspm_capable: 7;
    u32 aspm_default: 7;
    int: 4;
    u32 aspm_disable: 7;
    u32 clkpm_capable: 1;
    u32 clkpm_enabled: 1;
    u32 clkpm_default: 1;
    u32 clkpm_disable: 1;
};

struct pcie_pme_service_data {
    spinlock_t lock;
    struct pcie_device *srv;
    struct work_struct work;
    bool noirq;
};

struct pcie_port_service_driver {
    const char *name;
    int (*probe)(struct pcie_device *);
    void (*remove)(struct pcie_device *);
    int (*suspend)(struct pcie_device *);
    int (*resume_noirq)(struct pcie_device *);
    int (*resume)(struct pcie_device *);
    int (*runtime_suspend)(struct pcie_device *);
    int (*runtime_resume)(struct pcie_device *);
    int (*slot_reset)(struct pcie_device *);
    int port_type;
    u32 service;
    struct device_driver driver;
};

struct pcim_addr_devres {
    enum pcim_addr_devres_type type;
    void *baseaddr;
    long unsigned int offset;
    long unsigned int len;
    int bar;
};

struct pcim_intx_devres {
    int orig_intx;
};

struct pcim_iomap_devres {
    void *table[17];
};

struct pcpu_group_info {
    int nr_units;
    long unsigned int base_offset;
    unsigned int *cpu_map;
};

struct pcpu_alloc_info {
    size_t static_size;
    size_t reserved_size;
    size_t dyn_size;
    size_t unit_size;
    size_t atom_size;
    size_t alloc_size;
    size_t __ai_size;
    int nr_groups;
    struct pcpu_group_info groups[0];
};

struct pcpu_block_md {
    int scan_hint;
    int scan_hint_start;
    int contig_hint;
    int contig_hint_start;
    int left_free;
    int right_free;
    int first_free;
    int nr_bits;
};

struct pcpuobj_ext;

struct pcpu_chunk {
    struct list_head list;
    int free_bytes;
    struct pcpu_block_md chunk_md;
    long unsigned int *bound_map;
    void *base_addr;
    long unsigned int *alloc_map;
    struct pcpu_block_md *md_blocks;
    void *data;
    bool immutable;
    bool isolated;
    int start_offset;
    int end_offset;
    struct pcpuobj_ext *obj_exts;
    int nr_pages;
    int nr_populated;
    int nr_empty_pop_pages;
    long unsigned int populated[0];
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
};

struct pcpu_dstats {
    u64_stats_t rx_packets;
    u64_stats_t rx_bytes;
    u64_stats_t tx_packets;
    u64_stats_t tx_bytes;
    u64_stats_t rx_drops;
    u64_stats_t tx_drops;
    struct u64_stats_sync syncp;
    long: 64;
    long: 64;
};

struct pcpu_gen_cookie {
    local_t nesting;
    u64 last;
};

struct pcpu_lstats {
    u64_stats_t packets;
    u64_stats_t bytes;
    struct u64_stats_sync syncp;
};

struct pcpu_rx_sc_stats {
    struct macsec_rx_sc_stats stats;
    struct u64_stats_sync syncp;
};

struct pcpu_seg6_local_counters {
    u64_stats_t packets;
    u64_stats_t bytes;
    u64_stats_t errors;
    struct u64_stats_sync syncp;
};

struct pcpu_sw_netstats {
    u64_stats_t rx_packets;
    u64_stats_t rx_bytes;
    u64_stats_t tx_packets;
    u64_stats_t tx_bytes;
    struct u64_stats_sync syncp;
};

struct pcpu_tx_sc_stats {
    struct macsec_tx_sc_stats stats;
    struct u64_stats_sync syncp;
};

struct pcpuobj_ext {
    struct obj_cgroup *cgroup;
};

struct pde_opener {
    struct list_head lh;
    struct file *file;
    bool closing;
    struct completion *c;
};

struct pdev_list_entry {
    struct platform_device *pdev;
    struct list_head node;
};

struct pe32_opt_hdr {
    uint16_t magic;
    uint8_t ld_major;
    uint8_t ld_minor;
    uint32_t text_size;
    uint32_t data_size;
    uint32_t bss_size;
    uint32_t entry_point;
    uint32_t code_base;
    uint32_t data_base;
    uint32_t image_base;
    uint32_t section_align;
    uint32_t file_align;
    uint16_t os_major;
    uint16_t os_minor;
    uint16_t image_major;
    uint16_t image_minor;
    uint16_t subsys_major;
    uint16_t subsys_minor;
    uint32_t win32_version;
    uint32_t image_size;
    uint32_t header_size;
    uint32_t csum;
    uint16_t subsys;
    uint16_t dll_flags;
    uint32_t stack_size_req;
    uint32_t stack_size;
    uint32_t heap_size_req;
    uint32_t heap_size;
    uint32_t loader_flags;
    uint32_t data_dirs;
};

struct pe32plus_opt_hdr {
    uint16_t magic;
    uint8_t ld_major;
    uint8_t ld_minor;
    uint32_t text_size;
    uint32_t data_size;
    uint32_t bss_size;
    uint32_t entry_point;
    uint32_t code_base;
    uint64_t image_base;
    uint32_t section_align;
    uint32_t file_align;
    uint16_t os_major;
    uint16_t os_minor;
    uint16_t image_major;
    uint16_t image_minor;
    uint16_t subsys_major;
    uint16_t subsys_minor;
    uint32_t win32_version;
    uint32_t image_size;
    uint32_t header_size;
    uint32_t csum;
    uint16_t subsys;
    uint16_t dll_flags;
    uint64_t stack_size_req;
    uint64_t stack_size;
    uint64_t heap_size_req;
    uint64_t heap_size;
    uint32_t loader_flags;
    uint32_t data_dirs;
};

struct pe_hdr {
    uint32_t magic;
    uint16_t machine;
    uint16_t sections;
    uint32_t timestamp;
    uint32_t symbol_table;
    uint32_t symbols;
    uint16_t opt_hdr_size;
    uint16_t flags;
};

struct section_header;

struct pefile_context {
    unsigned int header_size;
    unsigned int image_checksum_offset;
    unsigned int cert_dirent_offset;
    unsigned int n_data_dirents;
    unsigned int n_sections;
    unsigned int certs_size;
    unsigned int sig_offset;
    unsigned int sig_len;
    const struct section_header *secs;
    const void *digest;
    unsigned int digest_len;
    const char *digest_algo;
};

struct pending_reservation {
    struct rb_node rb_node;
    ext4_lblk_t lclu;
};

struct per_cpu_nodestat {
    s8 stat_threshold;
    s8 vm_node_stat_diff[46];
};

struct per_cpu_pages {
    spinlock_t lock;
    int count;
    int high;
    int high_min;
    int high_max;
    int batch;
    u8 flags;
    u8 alloc_factor;
    short int free_count;
    struct list_head lists[14];
};

struct per_cpu_zonestat {
    s8 vm_stat_diff[11];
    s8 stat_threshold;
};

struct percpu_cluster {
    local_lock_t lock;
    unsigned int next[10];
};

struct percpu_free_defer {
    struct callback_head rcu;
    void *ptr;
};

typedef void percpu_ref_func_t(struct percpu_ref *);

struct percpu_ref_data {
    atomic_long_t count;
    percpu_ref_func_t *release;
    percpu_ref_func_t *confirm_switch;
    bool force_atomic: 1;
    bool allow_reinit: 1;
    struct callback_head rcu;
    struct percpu_ref *ref;
};

struct perf_addr_filter {
    struct list_head entry;
    struct path path;
    long unsigned int offset;
    long unsigned int size;
    enum perf_addr_filter_action_t action;
};

struct perf_addr_filter_range {
    long unsigned int start;
    long unsigned int size;
};

struct perf_addr_filters_head {
    struct list_head list;
    raw_spinlock_t lock;
    unsigned int nr_file_filters;
};

struct perf_event_header {
    __u32 type;
    __u16 misc;
    __u16 size;
};

struct perf_aux_event {
    struct perf_event_header header;
    u64 hw_id;
};

struct perf_aux_event___2 {
    struct perf_event_header header;
    u32 pid;
    u32 tid;
};

struct perf_aux_event___3 {
    struct perf_event_header header;
    u64 offset;
    u64 size;
    u64 flags;
};

struct perf_bpf_event {
    struct bpf_prog *prog;
    struct {
        struct perf_event_header header;
        u16 type;
        u16 flags;
        u32 id;
        u8 tag[8];
    } event_id;
};

struct perf_branch_entry {
    __u64 from;
    __u64 to;
    __u64 mispred: 1;
    __u64 predicted: 1;
    __u64 in_tx: 1;
    __u64 abort: 1;
    __u64 cycles: 16;
    __u64 type: 4;
    __u64 spec: 2;
    __u64 new_type: 4;
    __u64 priv: 3;
    __u64 reserved: 31;
};

struct perf_branch_stack {
    __u64 nr;
    __u64 hw_idx;
    struct perf_branch_entry entries[0];
};

struct perf_event_mmap_page;

struct perf_buffer {
    refcount_t refcount;
    struct callback_head callback_head;
    int nr_pages;
    int overwrite;
    int paused;
    atomic_t poll;
    local_t head;
    unsigned int nest;
    local_t events;
    local_t wakeup;
    local_t lost;
    long int watermark;
    long int aux_watermark;
    spinlock_t event_lock;
    struct list_head event_list;
    atomic_t mmap_count;
    long unsigned int mmap_locked;
    struct user_struct *mmap_user;
    struct mutex aux_mutex;
    long int aux_head;
    unsigned int aux_nest;
    long int aux_wakeup;
    long unsigned int aux_pgoff;
    int aux_nr_pages;
    int aux_overwrite;
    atomic_t aux_mmap_count;
    long unsigned int aux_mmap_locked;
    void (*free_aux)(void *);
    refcount_t aux_refcount;
    int aux_in_sampling;
    int aux_in_pause_resume;
    void **aux_pages;
    void *aux_priv;
    struct perf_event_mmap_page *user_page;
    void *data_pages[0];
};

struct perf_callchain_entry {
    __u64 nr;
    __u64 ip[0];
};

struct perf_callchain_entry_ctx {
    struct perf_callchain_entry *entry;
    u32 max_stack;
    u32 nr;
    short int contexts;
    bool contexts_maxed;
};

struct perf_cgroup_info;

struct perf_cgroup {
    struct cgroup_subsys_state css;
    struct perf_cgroup_info *info;
};

struct perf_cgroup_event {
    char *path;
    int path_size;
    struct {
        struct perf_event_header header;
        u64 id;
        char path[0];
    } event_id;
};

struct perf_cgroup_info {
    u64 time;
    u64 timestamp;
    u64 timeoffset;
    int active;
};

struct perf_comm_event {
    struct task_struct *task;
    char *comm;
    int comm_size;
    struct {
        struct perf_event_header header;
        u32 pid;
        u32 tid;
    } event_id;
};

struct perf_event_groups {
    struct rb_root tree;
    u64 index;
};

struct perf_event_context {
    raw_spinlock_t lock;
    struct mutex mutex;
    struct list_head pmu_ctx_list;
    struct perf_event_groups pinned_groups;
    struct perf_event_groups flexible_groups;
    struct list_head event_list;
    int nr_events;
    int nr_user;
    int is_active;
    int nr_task_data;
    int nr_stat;
    int nr_freq;
    int rotate_disable;
    refcount_t refcount;
    struct task_struct *task;
    u64 time;
    u64 timestamp;
    u64 timeoffset;
    struct perf_event_context *parent_ctx;
    u64 parent_gen;
    u64 generation;
    int pin_count;
    int nr_cgroups;
    struct callback_head callback_head;
    local_t nr_no_switch_fast;
};

struct perf_cpu_context {
    struct perf_event_context ctx;
    struct perf_event_context *task_ctx;
    int online;
    struct perf_cgroup *cgrp;
    int heap_size;
    struct perf_event **heap;
    struct perf_event *heap_default[2];
};

struct perf_event_pmu_context {
    struct pmu *pmu;
    struct perf_event_context *ctx;
    struct list_head pmu_ctx_entry;
    struct list_head pinned_active;
    struct list_head flexible_active;
    unsigned int embedded: 1;
    unsigned int nr_events;
    unsigned int nr_cgroups;
    unsigned int nr_freq;
    atomic_t refcount;
    struct callback_head callback_head;
    void *task_ctx_data;
    int rotate_necessary;
};

struct perf_cpu_pmu_context {
    struct perf_event_pmu_context epc;
    struct perf_event_pmu_context *task_epc;
    struct list_head sched_cb_entry;
    int sched_cb_usage;
    int active_oncpu;
    int exclusive;
    raw_spinlock_t hrtimer_lock;
    struct hrtimer hrtimer;
    ktime_t hrtimer_interval;
    unsigned int hrtimer_active;
};

struct perf_ctx_data {
    struct callback_head callback_head;
    refcount_t refcount;
    int global;
    struct kmem_cache *ctx_cache;
    void *data;
};

struct perf_domain {
    struct em_perf_domain *em_pd;
    struct perf_domain *next;
    struct callback_head rcu;
};

struct perf_event_attr {
    __u32 type;
    __u32 size;
    __u64 config;
    union {
        __u64 sample_period;
        __u64 sample_freq;
    };
    __u64 sample_type;
    __u64 read_format;
    __u64 disabled: 1;
    __u64 inherit: 1;
    __u64 pinned: 1;
    __u64 exclusive: 1;
    __u64 exclude_user: 1;
    __u64 exclude_kernel: 1;
    __u64 exclude_hv: 1;
    __u64 exclude_idle: 1;
    __u64 mmap: 1;
    __u64 comm: 1;
    __u64 freq: 1;
    __u64 inherit_stat: 1;
    __u64 enable_on_exec: 1;
    __u64 task: 1;
    __u64 watermark: 1;
    __u64 precise_ip: 2;
    __u64 mmap_data: 1;
    __u64 sample_id_all: 1;
    __u64 exclude_host: 1;
    __u64 exclude_guest: 1;
    __u64 exclude_callchain_kernel: 1;
    __u64 exclude_callchain_user: 1;
    __u64 mmap2: 1;
    __u64 comm_exec: 1;
    __u64 use_clockid: 1;
    __u64 context_switch: 1;
    __u64 write_backward: 1;
    __u64 namespaces: 1;
    __u64 ksymbol: 1;
    __u64 bpf_event: 1;
    __u64 aux_output: 1;
    __u64 cgroup: 1;
    __u64 text_poke: 1;
    __u64 build_id: 1;
    __u64 inherit_thread: 1;
    __u64 remove_on_exec: 1;
    __u64 sigtrap: 1;
    __u64 __reserved_1: 26;
    union {
        __u32 wakeup_events;
        __u32 wakeup_watermark;
    };
    __u32 bp_type;
    union {
        __u64 bp_addr;
        __u64 kprobe_func;
        __u64 uprobe_path;
        __u64 config1;
    };
    union {
        __u64 bp_len;
        __u64 kprobe_addr;
        __u64 probe_offset;
        __u64 config2;
    };
    __u64 branch_sample_type;
    __u64 sample_regs_user;
    __u32 sample_stack_user;
    __s32 clockid;
    __u64 sample_regs_intr;
    __u32 aux_watermark;
    __u16 sample_max_stack;
    __u16 __reserved_2;
    __u32 aux_sample_size;
    union {
        __u32 aux_action;
        struct {
            __u32 aux_start_paused: 1;
            __u32 aux_pause: 1;
            __u32 aux_resume: 1;
            __u32 __reserved_3: 29;
        };
    };
    __u64 sig_data;
    __u64 config3;
};

typedef void (*perf_overflow_handler_t)(struct perf_event *, struct perf_sample_data *, struct pt_regs *);

struct perf_event {
    struct list_head event_entry;
    struct list_head sibling_list;
    struct list_head active_list;
    struct rb_node group_node;
    u64 group_index;
    struct list_head migrate_entry;
    struct hlist_node hlist_entry;
    struct list_head active_entry;
    int nr_siblings;
    int event_caps;
    int group_caps;
    unsigned int group_generation;
    struct perf_event *group_leader;
    struct pmu *pmu;
    void *pmu_private;
    enum perf_event_state state;
    unsigned int attach_state;
    local64_t count;
    atomic64_t child_count;
    u64 total_time_enabled;
    u64 total_time_running;
    u64 tstamp;
    struct perf_event_attr attr;
    u16 header_size;
    u16 id_header_size;
    u16 read_size;
    struct hw_perf_event hw;
    struct perf_event_context *ctx;
    struct perf_event_pmu_context *pmu_ctx;
    atomic_long_t refcount;
    atomic64_t child_total_time_enabled;
    atomic64_t child_total_time_running;
    struct mutex child_mutex;
    struct list_head child_list;
    struct perf_event *parent;
    int oncpu;
    int cpu;
    struct list_head owner_entry;
    struct task_struct *owner;
    struct mutex mmap_mutex;
    atomic_t mmap_count;
    struct perf_buffer *rb;
    struct list_head rb_entry;
    long unsigned int rcu_batches;
    int rcu_pending;
    wait_queue_head_t waitq;
    struct fasync_struct *fasync;
    unsigned int pending_wakeup;
    unsigned int pending_kill;
    unsigned int pending_disable;
    long unsigned int pending_addr;
    struct irq_work pending_irq;
    struct irq_work pending_disable_irq;
    struct callback_head pending_task;
    unsigned int pending_work;
    atomic_t event_limit;
    struct perf_addr_filters_head addr_filters;
    struct perf_addr_filter_range *addr_filter_ranges;
    long unsigned int addr_filters_gen;
    struct perf_event *aux_event;
    void (*destroy)(struct perf_event *);
    struct callback_head callback_head;
    struct pid_namespace *ns;
    u64 id;
    atomic64_t lost_samples;
    u64 (*clock)(void);
    perf_overflow_handler_t overflow_handler;
    void *overflow_handler_context;
    struct bpf_prog *prog;
    u64 bpf_cookie;
    struct trace_event_call *tp_event;
    struct event_filter *filter;
    struct ftrace_ops ftrace_ops;
    struct perf_cgroup *cgrp;
    void *security;
    struct list_head sb_list;
    __u32 orig_type;
};

struct perf_event_min_heap {
    size_t nr;
    size_t size;
    struct perf_event **data;
    struct perf_event *preallocated[0];
};

struct perf_event_mmap_page {
    __u32 version;
    __u32 compat_version;
    __u32 lock;
    __u32 index;
    __s64 offset;
    __u64 time_enabled;
    __u64 time_running;
    union {
        __u64 capabilities;
        struct {
            __u64 cap_bit0: 1;
            __u64 cap_bit0_is_deprecated: 1;
            __u64 cap_user_rdpmc: 1;
            __u64 cap_user_time: 1;
            __u64 cap_user_time_zero: 1;
            __u64 cap_user_time_short: 1;
            __u64 cap_____res: 58;
        };
    };
    __u16 pmc_width;
    __u16 time_shift;
    __u32 time_mult;
    __u64 time_offset;
    __u64 time_zero;
    __u32 size;
    __u32 __reserved_1;
    __u64 time_cycles;
    __u64 time_mask;
    __u8 __reserved[928];
    __u64 data_head;
    __u64 data_tail;
    __u64 data_offset;
    __u64 data_size;
    __u64 aux_head;
    __u64 aux_tail;
    __u64 aux_offset;
    __u64 aux_size;
};

struct perf_event_query_bpf {
    __u32 ids_len;
    __u32 prog_cnt;
    __u32 ids[0];
};

struct perf_event_security_struct {
    u32 sid;
};

struct perf_guest_info_callbacks {
    unsigned int (*state)(void);
    long unsigned int (*get_ip)(void);
    unsigned int (*handle_intel_pt_intr)(void);
};

struct perf_ksymbol_event {
    const char *name;
    int name_len;
    struct {
        struct perf_event_header header;
        u64 addr;
        u32 len;
        u16 ksym_type;
        u16 flags;
    } event_id;
};

struct perf_mmap_event {
    struct vm_area_struct *vma;
    const char *file_name;
    int file_size;
    int maj;
    int min;
    u64 ino;
    u64 ino_generation;
    u32 prot;
    u32 flags;
    u8 build_id[20];
    u32 build_id_size;
    struct {
        struct perf_event_header header;
        u32 pid;
        u32 tid;
        u64 start;
        u64 len;
        u64 pgoff;
    } event_id;
};

struct perf_ns_link_info {
    __u64 dev;
    __u64 ino;
};

struct perf_namespaces_event {
    struct task_struct *task;
    struct {
        struct perf_event_header header;
        u32 pid;
        u32 tid;
        u64 nr_namespaces;
        struct perf_ns_link_info link_info[7];
    } event_id;
};

struct perf_output_handle {
    struct perf_event *event;
    struct perf_buffer *rb;
    long unsigned int wakeup;
    long unsigned int size;
    u64 aux_flags;
    union {
        void *addr;
        long unsigned int head;
    };
    int page;
};

struct perf_pmu_events_attr {
    struct device_attribute attr;
    u64 id;
    const char *event_str;
};

typedef long unsigned int (*perf_copy_f)(void *, const void *, long unsigned int, long unsigned int);

struct perf_raw_frag {
    union {
        struct perf_raw_frag *next;
        long unsigned int pad;
    };
    perf_copy_f copy;
    void *data;
    u32 size;
} __attribute__((packed));

struct perf_raw_record {
    struct perf_raw_frag frag;
    u32 size;
};

struct perf_read_data {
    struct perf_event *event;
    bool group;
    int ret;
};

struct perf_read_event {
    struct perf_event_header header;
    u32 pid;
    u32 tid;
};

struct perf_switch_event {
    struct task_struct *task;
    struct task_struct *next_prev;
    struct {
        struct perf_event_header header;
        u32 next_prev_pid;
        u32 next_prev_tid;
    } event_id;
};

struct perf_task_event {
    struct task_struct *task;
    struct perf_event_context *task_ctx;
    struct {
        struct perf_event_header header;
        u32 pid;
        u32 ppid;
        u32 tid;
        u32 ptid;
        u64 time;
    } event_id;
};

struct perf_text_poke_event {
    const void *old_bytes;
    const void *new_bytes;
    size_t pad;
    u16 old_len;
    u16 new_len;
    struct {
        struct perf_event_header header;
        u64 addr;
    } event_id;
};

struct perm_datum {
    u32 value;
};

struct pernet_operations {
    struct list_head list;
    int (*init)(struct net *);
    void (*pre_exit)(struct net *);
    void (*exit)(struct net *);
    void (*exit_batch)(struct list_head *);
    void (*exit_batch_rtnl)(struct list_head *, struct list_head *);
    unsigned int * const id;
    const size_t size;
};

struct pf_desc {
    u32 pseudoflavor;
    u32 qop;
    u32 service;
    char *name;
    char *auth_domain_name;
    struct auth_domain *domain;
    bool datatouch;
};

struct skb_array {
    struct ptr_ring ring;
};

struct pfifo_fast_priv {
    struct skb_array q[3];
};

struct zone {
    long unsigned int _watermark[4];
    long unsigned int watermark_boost;
    long unsigned int nr_reserved_highatomic;
    long unsigned int nr_free_highatomic;
    long int lowmem_reserve[4];
    struct pglist_data *zone_pgdat;
    struct per_cpu_pages *per_cpu_pageset;
    struct per_cpu_zonestat *per_cpu_zonestats;
    int pageset_high_min;
    int pageset_high_max;
    int pageset_batch;
    long unsigned int zone_start_pfn;
    atomic_long_t managed_pages;
    long unsigned int spanned_pages;
    long unsigned int present_pages;
    long unsigned int cma_pages;
    const char *name;
    long unsigned int nr_isolate_pageblock;
    int initialized;
    long: 0;
    struct cacheline_padding _pad1_;
    struct free_area free_area[11];
    long unsigned int flags;
    spinlock_t lock;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    struct cacheline_padding _pad2_;
    long unsigned int percpu_drift_mark;
    long unsigned int compact_cached_free_pfn;
    long unsigned int compact_cached_migrate_pfn[2];
    long unsigned int compact_init_migrate_pfn;
    long unsigned int compact_init_free_pfn;
    unsigned int compact_considered;
    unsigned int compact_defer_shift;
    int compact_order_failed;
    bool compact_blockskip_flush;
    bool contiguous;
    long: 0;
    struct cacheline_padding _pad3_;
    atomic_long_t vm_stat[11];
    atomic_long_t vm_numa_event[0];
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
};

struct zoneref {
    struct zone *zone;
    int zone_idx;
};

struct zonelist {
    struct zoneref _zonerefs[5];
};

struct pglist_data {
    struct zone node_zones[4];
    struct zonelist node_zonelists[1];
    int nr_zones;
    long unsigned int node_start_pfn;
    long unsigned int node_present_pages;
    long unsigned int node_spanned_pages;
    int node_id;
    wait_queue_head_t kswapd_wait;
    wait_queue_head_t pfmemalloc_wait;
    wait_queue_head_t reclaim_wait[4];
    atomic_t nr_writeback_throttled;
    long unsigned int nr_reclaim_start;
    struct task_struct *kswapd;
    int kswapd_order;
    enum zone_type kswapd_highest_zoneidx;
    int kswapd_failures;
    int kcompactd_max_order;
    enum zone_type kcompactd_highest_zoneidx;
    wait_queue_head_t kcompactd_wait;
    struct task_struct *kcompactd;
    bool proactive_compact_trigger;
    long unsigned int totalreserve_pages;
    long: 64;
    long: 64;
    long: 64;
    struct cacheline_padding _pad1_;
    struct deferred_split deferred_split_queue;
    struct lruvec __lruvec;
    long unsigned int flags;
    struct lru_gen_mm_walk mm_walk;
    struct lru_gen_memcg memcg_lru;
    long: 64;
    struct cacheline_padding _pad2_;
    struct per_cpu_nodestat *per_cpu_nodestats;
    atomic_long_t vm_stat[46];
    long: 64;
};

struct pgv {
    char *buffer;
};

struct phc_vclocks_reply_data {
    struct ethnl_reply_data base;
    int num;
    int *index;
};

struct phy_attrs {
    u32 bus_width;
    u32 max_link_rate;
    enum phy_mode mode;
};

struct phy_ops;

struct phy {
    struct device dev;
    int id;
    const struct phy_ops *ops;
    struct mutex mutex;
    int init_count;
    int power_count;
    struct phy_attrs attrs;
    struct regulator *pwr;
    struct dentry *debugfs;
};

struct phy_c45_device_ids {
    u32 devices_in_package;
    u32 mmds_present;
    u32 device_ids[32];
};

struct phy_configure_opts_mipi_dphy {
    unsigned int clk_miss;
    unsigned int clk_post;
    unsigned int clk_pre;
    unsigned int clk_prepare;
    unsigned int clk_settle;
    unsigned int clk_term_en;
    unsigned int clk_trail;
    unsigned int clk_zero;
    unsigned int d_term_en;
    unsigned int eot;
    unsigned int hs_exit;
    unsigned int hs_prepare;
    unsigned int hs_settle;
    unsigned int hs_skip;
    unsigned int hs_trail;
    unsigned int hs_zero;
    unsigned int init;
    unsigned int lpx;
    unsigned int ta_get;
    unsigned int ta_go;
    unsigned int ta_sure;
    unsigned int wakeup;
    long unsigned int hs_clk_rate;
    long unsigned int lp_clk_rate;
    unsigned char lanes;
};

struct phy_configure_opts_dp {
    unsigned int link_rate;
    unsigned int lanes;
    unsigned int voltage[4];
    unsigned int pre[4];
    u8 ssc: 1;
    u8 set_rate: 1;
    u8 set_lanes: 1;
    u8 set_voltages: 1;
};

struct phy_configure_opts_lvds {
    unsigned int bits_per_lane_and_dclk_cycle;
    long unsigned int differential_clk_rate;
    unsigned int lanes;
    bool is_slave;
};

union phy_configure_opts {
    struct phy_configure_opts_mipi_dphy mipi_dphy;
    struct phy_configure_opts_dp dp;
    struct phy_configure_opts_lvds lvds;
};

struct phy_driver;

struct phy_led_trigger;

struct pse_control;

struct phy_device {
    struct mdio_device mdio;
    const struct phy_driver *drv;
    struct device_link *devlink;
    u32 phyindex;
    u32 phy_id;
    struct phy_c45_device_ids c45_ids;
    unsigned int is_c45: 1;
    unsigned int is_internal: 1;
    unsigned int is_pseudo_fixed_link: 1;
    unsigned int is_gigabit_capable: 1;
    unsigned int has_fixups: 1;
    unsigned int suspended: 1;
    unsigned int suspended_by_mdio_bus: 1;
    unsigned int sysfs_links: 1;
    unsigned int loopback_enabled: 1;
    unsigned int downshifted_rate: 1;
    unsigned int is_on_sfp_module: 1;
    unsigned int mac_managed_pm: 1;
    unsigned int wol_enabled: 1;
    unsigned int autoneg: 1;
    unsigned int link: 1;
    unsigned int autoneg_complete: 1;
    unsigned int interrupts: 1;
    unsigned int irq_suspended: 1;
    unsigned int irq_rerun: 1;
    unsigned int default_timestamp: 1;
    int rate_matching;
    enum phy_state state;
    u32 dev_flags;
    phy_interface_t interface;
    long unsigned int possible_interfaces[1];
    int speed;
    int duplex;
    int port;
    int pause;
    int asym_pause;
    u8 master_slave_get;
    u8 master_slave_set;
    u8 master_slave_state;
    long unsigned int supported[2];
    long unsigned int advertising[2];
    long unsigned int lp_advertising[2];
    long unsigned int adv_old[2];
    long unsigned int supported_eee[2];
    long unsigned int advertising_eee[2];
    long unsigned int eee_broken_modes[2];
    bool enable_tx_lpi;
    bool eee_active;
    struct eee_config eee_cfg;
    long unsigned int host_interfaces[1];
    struct phy_led_trigger *phy_led_triggers;
    unsigned int phy_num_led_triggers;
    struct phy_led_trigger *last_triggered;
    struct phy_led_trigger *led_link_trigger;
    struct list_head leds;
    int irq;
    void *priv;
    struct phy_package_shared *shared;
    struct sk_buff *skb;
    void *ehdr;
    struct nlattr *nest;
    struct delayed_work state_queue;
    struct mutex lock;
    bool sfp_bus_attached;
    struct sfp_bus *sfp_bus;
    struct phylink *phylink;
    struct net_device *attached_dev;
    struct mii_timestamper *mii_ts;
    struct pse_control *psec;
    u8 mdix;
    u8 mdix_ctrl;
    int pma_extable;
    unsigned int link_down_events;
    void (*phy_link_change)(struct phy_device *, bool);
    void (*adjust_link)(struct net_device *);
    const struct macsec_ops *macsec_ops;
};

struct phy_device_node {
    enum phy_upstream upstream_type;
    union {
        struct net_device *netdev;
        struct phy_device *phydev;
    } upstream;
    struct sfp_bus *parent_sfp_bus;
    struct phy_device *phy;
};

struct usb_phy;

struct phy_devm {
    struct usb_phy *phy;
    struct notifier_block *nb;
};

struct phy_driver {
    struct mdio_driver_common mdiodrv;
    u32 phy_id;
    char *name;
    u32 phy_id_mask;
    const long unsigned int * const features;
    u32 flags;
    const void *driver_data;
    int (*soft_reset)(struct phy_device *);
    int (*config_init)(struct phy_device *);
    int (*probe)(struct phy_device *);
    int (*get_features)(struct phy_device *);
    unsigned int (*inband_caps)(struct phy_device *, phy_interface_t);
    int (*config_inband)(struct phy_device *, unsigned int);
    int (*get_rate_matching)(struct phy_device *, phy_interface_t);
    int (*suspend)(struct phy_device *);
    int (*resume)(struct phy_device *);
    int (*config_aneg)(struct phy_device *);
    int (*aneg_done)(struct phy_device *);
    int (*read_status)(struct phy_device *);
    int (*config_intr)(struct phy_device *);
    irqreturn_t (*handle_interrupt)(struct phy_device *);
    void (*remove)(struct phy_device *);
    int (*match_phy_device)(struct phy_device *);
    int (*set_wol)(struct phy_device *, struct ethtool_wolinfo *);
    void (*get_wol)(struct phy_device *, struct ethtool_wolinfo *);
    void (*link_change_notify)(struct phy_device *);
    int (*read_mmd)(struct phy_device *, int, u16);
    int (*write_mmd)(struct phy_device *, int, u16, u16);
    int (*read_page)(struct phy_device *);
    int (*write_page)(struct phy_device *, int);
    int (*module_info)(struct phy_device *, struct ethtool_modinfo *);
    int (*module_eeprom)(struct phy_device *, struct ethtool_eeprom *, u8 *);
    int (*cable_test_start)(struct phy_device *);
    int (*cable_test_tdr_start)(struct phy_device *, const struct phy_tdr_config *);
    int (*cable_test_get_status)(struct phy_device *, bool *);
    void (*get_phy_stats)(struct phy_device *, struct ethtool_eth_phy_stats *, struct ethtool_phy_stats *);
    void (*get_link_stats)(struct phy_device *, struct ethtool_link_ext_stats *);
    int (*update_stats)(struct phy_device *);
    int (*get_sset_count)(struct phy_device *);
    void (*get_strings)(struct phy_device *, u8 *);
    void (*get_stats)(struct phy_device *, struct ethtool_stats *, u64 *);
    int (*get_tunable)(struct phy_device *, struct ethtool_tunable *, void *);
    int (*set_tunable)(struct phy_device *, struct ethtool_tunable *, const void *);
    int (*set_loopback)(struct phy_device *, bool);
    int (*get_sqi)(struct phy_device *);
    int (*get_sqi_max)(struct phy_device *);
    int (*get_plca_cfg)(struct phy_device *, struct phy_plca_cfg *);
    int (*set_plca_cfg)(struct phy_device *, const struct phy_plca_cfg *);
    int (*get_plca_status)(struct phy_device *, struct phy_plca_status *);
    int (*led_brightness_set)(struct phy_device *, u8, enum led_brightness);
    int (*led_blink_set)(struct phy_device *, u8, long unsigned int *, long unsigned int *);
    int (*led_hw_is_supported)(struct phy_device *, u8, long unsigned int);
    int (*led_hw_control_set)(struct phy_device *, u8, long unsigned int);
    int (*led_hw_control_get)(struct phy_device *, u8, long unsigned int *);
    int (*led_polarity_set)(struct phy_device *, int, long unsigned int);
};

struct phy_fixup {
    struct list_head list;
    char bus_id[64];
    u32 phy_uid;
    u32 phy_uid_mask;
    int (*run)(struct phy_device *);
};

struct phy_led {
    struct list_head list;
    struct phy_device *phydev;
    struct led_classdev led_cdev;
    u8 index;
};

struct phy_led_trigger {
    struct led_trigger trigger;
    char name[76];
    unsigned int speed;
};

struct phy_link_topology {
    struct xarray phys;
    u32 next_phy_index;
};

struct phy_lookup {
    struct list_head node;
    const char *dev_id;
    const char *con_id;
    struct phy *phy;
};

struct phy_ops {
    int (*init)(struct phy *);
    int (*exit)(struct phy *);
    int (*power_on)(struct phy *);
    int (*power_off)(struct phy *);
    int (*set_mode)(struct phy *, enum phy_mode, int);
    int (*set_media)(struct phy *, enum phy_media);
    int (*set_speed)(struct phy *, int);
    int (*configure)(struct phy *, union phy_configure_opts *);
    int (*validate)(struct phy *, enum phy_mode, int, union phy_configure_opts *);
    int (*reset)(struct phy *);
    int (*calibrate)(struct phy *);
    int (*connect)(struct phy *, int);
    int (*disconnect)(struct phy *, int);
    void (*release)(struct phy *);
    struct module *owner;
};

struct phy_package_shared {
    u8 base_addr;
    struct device_node *np;
    refcount_t refcnt;
    long unsigned int flags;
    size_t priv_size;
    void *priv;
};

struct phy_plca_cfg {
    int version;
    int enabled;
    int node_id;
    int node_cnt;
    int to_tmr;
    int burst_cnt;
    int burst_tmr;
};

struct phy_plca_status {
    bool pst;
};

struct phy_provider {
    struct device *dev;
    struct device_node *children;
    struct module *owner;
    struct list_head list;
    struct phy * (*of_xlate)(struct device *, const struct of_phandle_args *);
};

struct phy_req_info {
    struct ethnl_req_info base;
    struct phy_device_node *pdn;
};

struct phy_setting {
    u32 speed;
    u8 duplex;
    u8 bit;
};

struct phy_tdr_config {
    u32 first;
    u32 last;
    u32 step;
    s8 pair;
};

struct phylib_stubs {
    int (*hwtstamp_get)(struct phy_device *, struct kernel_hwtstamp_config *);
    int (*hwtstamp_set)(struct phy_device *, struct kernel_hwtstamp_config *, struct netlink_ext_ack *);
    void (*get_phy_stats)(struct phy_device *, struct ethtool_eth_phy_stats *, struct ethtool_phy_stats *);
    void (*get_link_ext_stats)(struct phy_device *, struct ethtool_link_ext_stats *);
};

struct phylink_link_state {
    long unsigned int advertising[2];
    long unsigned int lp_advertising[2];
    phy_interface_t interface;
    int speed;
    int duplex;
    int pause;
    int rate_matching;
    unsigned int link: 1;
    unsigned int an_complete: 1;
};

struct phylink_pcs;

struct phylink_mac_ops {
    long unsigned int (*mac_get_caps)(struct phylink_config *, phy_interface_t);
    struct phylink_pcs * (*mac_select_pcs)(struct phylink_config *, phy_interface_t);
    int (*mac_prepare)(struct phylink_config *, unsigned int, phy_interface_t);
    void (*mac_config)(struct phylink_config *, unsigned int, const struct phylink_link_state *);
    int (*mac_finish)(struct phylink_config *, unsigned int, phy_interface_t);
    void (*mac_link_down)(struct phylink_config *, unsigned int, phy_interface_t);
    void (*mac_link_up)(struct phylink_config *, struct phy_device *, unsigned int, phy_interface_t, int, int, bool, bool);
    void (*mac_disable_tx_lpi)(struct phylink_config *);
    int (*mac_enable_tx_lpi)(struct phylink_config *, u32, bool);
};

struct phylink_pcs_ops;

struct phylink_pcs {
    long unsigned int supported_interfaces[1];
    const struct phylink_pcs_ops *ops;
    struct phylink *phylink;
    bool neg_mode;
    bool poll;
    bool rxc_always_on;
};

struct phylink_pcs_ops {
    int (*pcs_validate)(struct phylink_pcs *, long unsigned int *, const struct phylink_link_state *);
    unsigned int (*pcs_inband_caps)(struct phylink_pcs *, phy_interface_t);
    int (*pcs_enable)(struct phylink_pcs *);
    void (*pcs_disable)(struct phylink_pcs *);
    void (*pcs_pre_config)(struct phylink_pcs *, phy_interface_t);
    int (*pcs_post_config)(struct phylink_pcs *, phy_interface_t);
    void (*pcs_get_state)(struct phylink_pcs *, unsigned int, struct phylink_link_state *);
    int (*pcs_config)(struct phylink_pcs *, unsigned int, phy_interface_t, const long unsigned int *, bool);
    void (*pcs_an_restart)(struct phylink_pcs *);
    void (*pcs_link_up)(struct phylink_pcs *, unsigned int, phy_interface_t, int, int);
    int (*pcs_pre_init)(struct phylink_pcs *);
};

struct phys_vec {
    phys_addr_t paddr;
    u32 len;
};

struct upid {
    int nr;
    struct pid_namespace *ns;
};

struct pid {
    refcount_t count;
    unsigned int level;
    spinlock_t lock;
    struct dentry *stashed;
    u64 ino;
    struct rb_node pidfs_node;
    struct hlist_head tasks[4];
    struct hlist_head inodes;
    wait_queue_head_t wait_pidfd;
    struct callback_head rcu;
    struct upid numbers[0];
};

union proc_op {
    int (*proc_get_link)(struct dentry *, struct path *);
    int (*proc_show)(struct seq_file *, struct pid_namespace *, struct pid *, struct task_struct *);
    int lsmid;
};

struct pid_entry {
    const char *name;
    unsigned int len;
    umode_t mode;
    const struct inode_operations *iop;
    const struct file_operations *fop;
    union proc_op op;
};

struct pid_namespace {
    struct idr idr;
    struct callback_head rcu;
    unsigned int pid_allocated;
    struct task_struct *child_reaper;
    struct kmem_cache *pid_cachep;
    unsigned int level;
    int pid_max;
    struct pid_namespace *parent;
    struct fs_pin *bacct;
    struct user_namespace *user_ns;
    struct ucounts *ucounts;
    int reboot;
    struct ns_common ns;
    struct work_struct work;
    struct ctl_table_set set;
    struct ctl_table_header *sysctls;
    int memfd_noexec_scope;
};

struct pidfd_info {
    __u64 mask;
    __u64 cgroupid;
    __u32 pid;
    __u32 tgid;
    __u32 ppid;
    __u32 ruid;
    __u32 rgid;
    __u32 euid;
    __u32 egid;
    __u32 suid;
    __u32 sgid;
    __u32 fsuid;
    __u32 fsgid;
    __u32 spare0[1];
};

struct pids_cgroup {
    struct cgroup_subsys_state css;
    atomic64_t counter;
    atomic64_t limit;
    int64_t watermark;
    struct cgroup_file events_file;
    struct cgroup_file events_local_file;
    atomic64_t events[2];
    atomic64_t events_local[2];
};

struct pimreghdr {
    __u8 type;
    __u8 reserved;
    __be16 csum;
    __be32 flags;
};

struct pin_config_item {
    const enum pin_config_param param;
    const char * const display;
    const char * const format;
    bool has_arg;
};

struct pinctrl_setting_mux;

struct pin_desc {
    struct pinctrl_dev *pctldev;
    const char *name;
    bool dynamic_name;
    void *drv_data;
    unsigned int mux_usecount;
    const char *mux_owner;
    const struct pinctrl_setting_mux *mux_setting;
    const char *gpio_owner;
    struct mutex mux_lock;
};

struct pin_regs {
    u16 mux_bit;
    u16 pad_bit;
};

struct pinconf_generic_params {
    const char * const property;
    enum pin_config_param param;
    u32 default_value;
};

struct pinconf_ops {
    bool is_generic;
    int (*pin_config_get)(struct pinctrl_dev *, unsigned int, long unsigned int *);
    int (*pin_config_set)(struct pinctrl_dev *, unsigned int, long unsigned int *, unsigned int);
    int (*pin_config_group_get)(struct pinctrl_dev *, unsigned int, long unsigned int *);
    int (*pin_config_group_set)(struct pinctrl_dev *, unsigned int, long unsigned int *, unsigned int);
    void (*pin_config_dbg_show)(struct pinctrl_dev *, struct seq_file *, unsigned int);
    void (*pin_config_group_dbg_show)(struct pinctrl_dev *, struct seq_file *, unsigned int);
    void (*pin_config_config_dbg_show)(struct pinctrl_dev *, struct seq_file *, long unsigned int);
};

struct pinctrl {
    struct list_head node;
    struct device *dev;
    struct list_head states;
    struct pinctrl_state *state;
    struct list_head dt_maps;
    struct kref users;
};

struct pinctrl_dev {
    struct list_head node;
    struct pinctrl_desc *desc;
    struct xarray pin_desc_tree;
    struct xarray pin_group_tree;
    unsigned int num_groups;
    struct xarray pin_function_tree;
    unsigned int num_functions;
    struct list_head gpio_ranges;
    struct device *dev;
    struct module *owner;
    void *driver_data;
    struct pinctrl *p;
    struct pinctrl_state *hog_default;
    struct pinctrl_state *hog_sleep;
    struct mutex mutex;
    struct dentry *device_root;
};

struct pinctrl_map;

struct pinctrl_dt_map {
    struct list_head node;
    struct pinctrl_dev *pctldev;
    struct pinctrl_map *map;
    unsigned int num_maps;
};

struct pinctrl_map_mux {
    const char *group;
    const char *function;
};

struct pinctrl_map_configs {
    const char *group_or_pin;
    long unsigned int *configs;
    unsigned int num_configs;
};

struct pinctrl_map {
    const char *dev_name;
    const char *name;
    enum pinctrl_map_type type;
    const char *ctrl_dev_name;
    union {
        struct pinctrl_map_mux mux;
        struct pinctrl_map_configs configs;
    } data;
};

struct pinctrl_maps {
    struct list_head node;
    const struct pinctrl_map *maps;
    unsigned int num_maps;
};

struct pinctrl_ops {
    int (*get_groups_count)(struct pinctrl_dev *);
    const char * (*get_group_name)(struct pinctrl_dev *, unsigned int);
    int (*get_group_pins)(struct pinctrl_dev *, unsigned int, const unsigned int **, unsigned int *);
    void (*pin_dbg_show)(struct pinctrl_dev *, struct seq_file *, unsigned int);
    int (*dt_node_to_map)(struct pinctrl_dev *, struct device_node *, struct pinctrl_map **, unsigned int *);
    void (*dt_free_map)(struct pinctrl_dev *, struct pinctrl_map *, unsigned int);
};

struct pinctrl_pin_desc {
    unsigned int number;
    const char *name;
    void *drv_data;
};

struct pinctrl_setting_mux {
    unsigned int group;
    unsigned int func;
};

struct pinctrl_setting_configs {
    unsigned int group_or_pin;
    long unsigned int *configs;
    unsigned int num_configs;
};

struct pinctrl_setting {
    struct list_head node;
    enum pinctrl_map_type type;
    struct pinctrl_dev *pctldev;
    const char *dev_name;
    union {
        struct pinctrl_setting_mux mux;
        struct pinctrl_setting_configs configs;
    } data;
};

struct pinctrl_state {
    struct list_head node;
    const char *name;
    struct list_head settings;
};

struct ping_iter_state {
    struct seq_net_private p;
    int bucket;
    sa_family_t family;
};

struct ping_table {
    struct hlist_head hash[64];
    spinlock_t lock;
};

struct pingfakehdr {
    struct icmphdr icmph;
    struct msghdr *msg;
    sa_family_t family;
    __wsum wcheck;
};

struct pingv6_ops {
    int (*ipv6_recv_error)(struct sock *, struct msghdr *, int, int *);
    void (*ip6_datagram_recv_common_ctl)(struct sock *, struct msghdr *, struct sk_buff *);
    void (*ip6_datagram_recv_specific_ctl)(struct sock *, struct msghdr *, struct sk_buff *);
    int (*icmpv6_err_convert)(u8, u8, int *);
    void (*ipv6_icmp_error)(struct sock *, struct sk_buff *, int, __be16, u32, u8 *);
    int (*ipv6_chk_addr)(struct net *, const struct in6_addr *, const struct net_device *, int);
};

struct pinmux_ops {
    int (*request)(struct pinctrl_dev *, unsigned int);
    int (*free)(struct pinctrl_dev *, unsigned int);
    int (*get_functions_count)(struct pinctrl_dev *);
    const char * (*get_function_name)(struct pinctrl_dev *, unsigned int);
    int (*get_function_groups)(struct pinctrl_dev *, unsigned int, const char * const **, unsigned int *);
    int (*set_mux)(struct pinctrl_dev *, unsigned int, unsigned int);
    int (*gpio_request_enable)(struct pinctrl_dev *, struct pinctrl_gpio_range *, unsigned int);
    void (*gpio_disable_free)(struct pinctrl_dev *, struct pinctrl_gpio_range *, unsigned int);
    int (*gpio_set_direction)(struct pinctrl_dev *, struct pinctrl_gpio_range *, unsigned int, bool);
    bool strict;
};

struct pipe_buffer;

struct pipe_buf_operations {
    int (*confirm)(struct pipe_inode_info *, struct pipe_buffer *);
    void (*release)(struct pipe_inode_info *, struct pipe_buffer *);
    bool (*try_steal)(struct pipe_inode_info *, struct pipe_buffer *);
    bool (*get)(struct pipe_inode_info *, struct pipe_buffer *);
};

struct pipe_buffer {
    struct page *page;
    unsigned int offset;
    unsigned int len;
    const struct pipe_buf_operations *ops;
    unsigned int flags;
    long unsigned int private;
};

union pipe_index {
    long unsigned int head_tail;
    struct {
        pipe_index_t head;
        pipe_index_t tail;
    };
};

struct watch_queue;

struct pipe_inode_info {
    struct mutex mutex;
    wait_queue_head_t rd_wait;
    wait_queue_head_t wr_wait;
    union {
        long unsigned int head_tail;
        struct {
            pipe_index_t head;
            pipe_index_t tail;
        };
    };
    unsigned int max_usage;
    unsigned int ring_size;
    unsigned int nr_accounted;
    unsigned int readers;
    unsigned int writers;
    unsigned int files;
    unsigned int r_counter;
    unsigned int w_counter;
    bool poll_usage;
    bool note_loss;
    struct page *tmp_page;
    struct fasync_struct *fasync_readers;
    struct fasync_struct *fasync_writers;
    struct pipe_buffer *bufs;
    struct user_struct *user;
    struct watch_queue *watch_queue;
};

struct pipe_wait {
    struct trace_iterator *iter;
    int wait_index;
};

struct pkcs1pad_ctx {
    struct crypto_akcipher *child;
    unsigned int key_size;
};

struct pkcs1pad_inst_ctx {
    struct crypto_akcipher_spawn spawn;
};

struct pkcs1pad_request {
    struct scatterlist in_sg[2];
    struct scatterlist out_sg[1];
    uint8_t *in_buf;
    uint8_t *out_buf;
    struct akcipher_request child_req;
};

struct x509_certificate;

struct pkcs7_signed_info;

struct pkcs7_message {
    struct x509_certificate *certs;
    struct x509_certificate *crl;
    struct pkcs7_signed_info *signed_infos;
    u8 version;
    bool have_authattrs;
    enum OID data_type;
    size_t data_len;
    size_t data_hdrlen;
    const void *data;
};

struct pkcs7_parse_context {
    struct pkcs7_message *msg;
    struct pkcs7_signed_info *sinfo;
    struct pkcs7_signed_info **ppsinfo;
    struct x509_certificate *certs;
    struct x509_certificate **ppcerts;
    long unsigned int data;
    enum OID last_oid;
    unsigned int x509_index;
    unsigned int sinfo_index;
    const void *raw_serial;
    unsigned int raw_serial_size;
    unsigned int raw_issuer_size;
    const void *raw_issuer;
    const void *raw_skid;
    unsigned int raw_skid_size;
    bool expect_skid;
};

struct pkcs7_signed_info {
    struct pkcs7_signed_info *next;
    struct x509_certificate *signer;
    unsigned int index;
    bool unsupported_crypto;
    bool blacklisted;
    const void *msgdigest;
    unsigned int msgdigest_len;
    unsigned int authattrs_len;
    const void *authattrs;
    long unsigned int aa_set;
    time64_t signing_time;
    struct public_key_signature *sig;
};

struct pkvm_hyp_vcpu {
    struct kvm_vcpu vcpu;
    struct kvm_vcpu *host_vcpu;
    struct pkvm_hyp_vcpu **loaded_hyp_vcpu;
};

struct pkvm_hyp_vm {
    struct kvm kvm;
    struct kvm *host_kvm;
    struct kvm_pgtable pgt;
    struct kvm_pgtable_mm_ops mm_ops;
    struct hyp_pool pool;
    hyp_spinlock_t lock;
    unsigned int nr_vcpus;
    struct pkvm_hyp_vcpu *vcpus[0];
};

struct pkvm_mapping {
    struct rb_node node;
    u64 gfn;
    u64 pfn;
};

struct pl011_dmabuf {
    dma_addr_t dma;
    size_t len;
    char *buf;
};

struct pl011_dmarx_data {
    struct dma_chan *chan;
    struct completion complete;
    bool use_buf_b;
    struct pl011_dmabuf dbuf_a;
    struct pl011_dmabuf dbuf_b;
    dma_cookie_t cookie;
    bool running;
    struct timer_list timer;
    unsigned int last_residue;
    long unsigned int last_jiffies;
    bool auto_poll_rate;
    unsigned int poll_rate;
    unsigned int poll_timeout;
};

struct pl011_dmatx_data {
    struct dma_chan *chan;
    dma_addr_t dma;
    size_t len;
    char *buf;
    bool queued;
};

struct plat_serial8250_port {
    long unsigned int iobase;
    void *membase;
    resource_size_t mapbase;
    resource_size_t mapsize;
    unsigned int uartclk;
    unsigned int irq;
    long unsigned int irqflags;
    void *private_data;
    unsigned char regshift;
    unsigned char iotype;
    unsigned char hub6;
    unsigned char has_sysrq;
    unsigned int type;
    upf_t flags;
    u16 bugs;
    unsigned int (*serial_in)(struct uart_port *, int);
    void (*serial_out)(struct uart_port *, int, int);
    u32 (*dl_read)(struct uart_8250_port *);
    void (*dl_write)(struct uart_8250_port *, u32);
    void (*set_termios)(struct uart_port *, struct ktermios *, const struct ktermios *);
    void (*set_ldisc)(struct uart_port *, struct ktermios *);
    unsigned int (*get_mctrl)(struct uart_port *);
    int (*handle_irq)(struct uart_port *);
    void (*pm)(struct uart_port *, unsigned int, unsigned int);
    void (*handle_break)(struct uart_port *);
};

struct platform_device_id {
    char name[20];
    kernel_ulong_t driver_data;
};

struct property_entry;

struct platform_device_info {
    struct device *parent;
    struct fwnode_handle *fwnode;
    bool of_node_reused;
    const char *name;
    int id;
    const struct resource *res;
    unsigned int num_res;
    const void *data;
    size_t size_data;
    u64 dma_mask;
    const struct property_entry *properties;
};

struct platform_driver {
    int (*probe)(struct platform_device *);
    void (*remove)(struct platform_device *);
    void (*shutdown)(struct platform_device *);
    int (*suspend)(struct platform_device *, pm_message_t);
    int (*resume)(struct platform_device *);
    struct device_driver driver;
    const struct platform_device_id *id_table;
    bool prevent_deferred_probe;
    bool driver_managed_dma;
};

struct platform_object {
    struct platform_device pdev;
    char name[0];
};

struct platform_suspend_ops {
    int (*valid)(suspend_state_t);
    int (*begin)(suspend_state_t);
    int (*prepare)(void);
    int (*prepare_late)(void);
    int (*enter)(suspend_state_t);
    void (*wake)(void);
    void (*finish)(void);
    bool (*suspend_again)(void);
    void (*end)(void);
    void (*recover)(void);
};

struct plca_reply_data {
    struct ethnl_reply_data base;
    struct phy_plca_cfg plca_cfg;
    struct phy_plca_status plca_st;
};

struct plt_entry {
    __le32 adrp;
    __le32 add;
    __le32 br;
};

struct pm886_chip {
    struct i2c_client *client;
    unsigned int chip_id;
    struct regmap *regmap;
};

struct pm_clk_notifier_block {
    struct notifier_block nb;
    struct dev_pm_domain *pm_domain;
    char *con_ids[0];
};

struct pm_clock_entry {
    struct list_head node;
    char *con_id;
    struct clk *clk;
    enum pce_status status;
    bool enabled_when_prepared;
};

struct pm_nl_pernet {
    spinlock_t lock;
    struct list_head local_addr_list;
    unsigned int addrs;
    unsigned int stale_loss_cnt;
    unsigned int add_addr_signal_max;
    unsigned int add_addr_accept_max;
    unsigned int local_addr_max;
    unsigned int subflows_max;
    unsigned int next_id;
    long unsigned int id_bitmap[4];
};

struct pm_qos_request {
    struct plist_node node;
    struct pm_qos_constraints *qos;
};

struct pm_subsys_data {
    spinlock_t lock;
    unsigned int refcount;
    unsigned int clock_op_might_sleep;
    struct mutex clock_mutex;
    struct list_head clock_list;
    struct pm_domain_data *domain_data;
};

struct pmu_event_list {
    raw_spinlock_t lock;
    struct list_head list;
};

struct pmu_hw_events {
    struct perf_event *events[33];
    long unsigned int used_mask[1];
    struct arm_pmu *percpu_pmu;
    int irq;
};

struct pmu_irq_ops {
    void (*enable_pmuirq)(unsigned int);
    void (*disable_pmuirq)(unsigned int);
    void (*free_pmuirq)(unsigned int, int, void *);
};

typedef int (*armpmu_init_fn)(struct arm_pmu *);

struct pmu_probe_info {
    unsigned int cpuid;
    unsigned int mask;
    armpmu_init_fn init;
};

struct pneigh_entry {
    struct pneigh_entry *next;
    possible_net_t net;
    struct net_device *dev;
    netdevice_tracker dev_tracker;
    u32 flags;
    u8 protocol;
    u32 key[0];
};

struct pnfs_commit_ops;

struct pnfs_ds_commit_info {
    struct list_head commits;
    unsigned int nwritten;
    unsigned int ncommitting;
    const struct pnfs_commit_ops *ops;
};

struct pnp_protocol;

struct pnp_id;

struct pnp_card {
    struct device dev;
    unsigned char number;
    struct list_head global_list;
    struct list_head protocol_list;
    struct list_head devices;
    struct pnp_protocol *protocol;
    struct pnp_id *id;
    char name[50];
    unsigned char pnpver;
    unsigned char productver;
    unsigned int serial;
    unsigned char checksum;
    struct proc_dir_entry *procdir;
};

struct pnp_card_device_id {
    __u8 id[8];
    kernel_ulong_t driver_data;
    struct {
        __u8 id[8];
    } devs[8];
};

struct pnp_device_id;

struct pnp_dev;

struct pnp_driver {
    const char *name;
    const struct pnp_device_id *id_table;
    unsigned int flags;
    int (*probe)(struct pnp_dev *, const struct pnp_device_id *);
    void (*remove)(struct pnp_dev *);
    void (*shutdown)(struct pnp_dev *);
    int (*suspend)(struct pnp_dev *, pm_message_t);
    int (*resume)(struct pnp_dev *);
    struct device_driver driver;
};

struct pnp_card_link;

struct pnp_card_driver {
    struct list_head global_list;
    char *name;
    const struct pnp_card_device_id *id_table;
    unsigned int flags;
    int (*probe)(struct pnp_card_link *, const struct pnp_card_device_id *);
    void (*remove)(struct pnp_card_link *);
    int (*suspend)(struct pnp_card_link *, pm_message_t);
    int (*resume)(struct pnp_card_link *);
    struct pnp_driver link;
};

struct pnp_card_link {
    struct pnp_card *card;
    struct pnp_card_driver *driver;
    void *driver_data;
    pm_message_t pm_state;
};

struct pnp_dev {
    struct device dev;
    u64 dma_mask;
    unsigned int number;
    int status;
    struct list_head global_list;
    struct list_head protocol_list;
    struct list_head card_list;
    struct list_head rdev_list;
    struct pnp_protocol *protocol;
    struct pnp_card *card;
    struct pnp_driver *driver;
    struct pnp_card_link *card_link;
    struct pnp_id *id;
    int active;
    int capabilities;
    unsigned int num_dependent_sets;
    struct list_head resources;
    struct list_head options;
    char name[50];
    int flags;
    struct proc_dir_entry *procent;
    void *data;
};

struct pnp_device_id {
    __u8 id[8];
    kernel_ulong_t driver_data;
};

struct pnp_id {
    char id[8];
    struct pnp_id *next;
};

struct pnp_protocol {
    struct list_head protocol_list;
    char *name;
    int (*get)(struct pnp_dev *);
    int (*set)(struct pnp_dev *);
    int (*disable)(struct pnp_dev *);
    bool (*can_wakeup)(struct pnp_dev *);
    int (*suspend)(struct pnp_dev *, pm_message_t);
    int (*resume)(struct pnp_dev *);
    unsigned char number;
    struct device dev;
    struct list_head cards;
    struct list_head devices;
};

struct poe_context {
    struct _aarch64_ctx head;
    __u64 por_el0;
};

struct policy_file;

struct policy_data {
    struct policydb *p;
    struct policy_file *fp;
};

struct policy_file {
    char *data;
    size_t len;
};

struct policy_load_memory {
    size_t len;
    void *data;
};

struct role_datum;

struct user_datum;

struct type_datum;

struct role_allow;

struct policydb {
    int mls_enabled;
    struct symtab symtab[8];
    char **sym_val_to_name[8];
    struct class_datum **class_val_to_struct;
    struct role_datum **role_val_to_struct;
    struct user_datum **user_val_to_struct;
    struct type_datum **type_val_to_struct;
    struct avtab te_avtab;
    struct hashtab role_tr;
    struct ebitmap filename_trans_ttypes;
    struct hashtab filename_trans;
    u32 compat_filename_trans_count;
    struct cond_bool_datum **bool_val_to_struct;
    struct avtab te_cond_avtab;
    struct cond_node *cond_list;
    u32 cond_list_len;
    struct role_allow *role_allow;
    struct ocontext *ocontexts[9];
    struct genfs *genfs;
    struct hashtab range_tr;
    struct ebitmap *type_attr_map_array;
    struct ebitmap policycaps;
    struct ebitmap permissive_map;
    size_t len;
    unsigned int policyvers;
    unsigned int reject_unknown: 1;
    unsigned int allow_unknown: 1;
    u16 process_class;
    u32 process_trans_perms;
};

struct policydb_compat_info {
    unsigned int version;
    unsigned int sym_num;
    unsigned int ocon_num;
};

struct pollfd {
    int fd;
    short int events;
    short int revents;
};

struct poll_list {
    struct poll_list *next;
    unsigned int len;
    struct pollfd entries[0];
};

struct poll_table_entry {
    struct file *filp;
    __poll_t key;
    wait_queue_entry_t wait;
    wait_queue_head_t *wait_address;
};

struct poll_table_page {
    struct poll_table_page *next;
    struct poll_table_entry *entry;
    struct poll_table_entry entries[0];
};

struct poll_wqueues {
    poll_table pt;
    struct poll_table_page *table;
    struct task_struct *polling_task;
    int triggered;
    int error;
    int inline_index;
    struct poll_table_entry inline_entries[9];
};

struct worker_pool;

struct pool_workqueue {
    struct worker_pool *pool;
    struct workqueue_struct *wq;
    int work_color;
    int flush_color;
    int refcnt;
    int nr_in_flight[16];
    bool plugged;
    int nr_active;
    struct list_head inactive_works;
    struct list_head pending_node;
    struct list_head pwqs_node;
    struct list_head mayday_node;
    u64 stats[8];
    struct kthread_work release_work;
    struct callback_head rcu;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
};

struct port_identity {
    struct clock_identity clock_identity;
    __be16 port_number;
};

struct portdrv_service_data {
    struct pcie_port_service_driver *drv;
    struct device *dev;
    u32 service;
};

struct posix_acl_entry {
    short int e_tag;
    short unsigned int e_perm;
    union {
        kuid_t e_uid;
        kgid_t e_gid;
    };
};

struct posix_acl {
    refcount_t a_refcount;
    unsigned int a_count;
    struct callback_head a_rcu;
    struct posix_acl_entry a_entries[0];
};

struct posix_acl_xattr_entry {
    __le16 e_tag;
    __le16 e_perm;
    __le32 e_id;
};

struct posix_acl_xattr_header {
    __le32 a_version;
};

struct posix_clock;

struct posix_clock_context;

struct posix_clock_operations {
    struct module *owner;
    int (*clock_adjtime)(struct posix_clock *, struct __kernel_timex *);
    int (*clock_gettime)(struct posix_clock *, struct timespec64 *);
    int (*clock_getres)(struct posix_clock *, struct timespec64 *);
    int (*clock_settime)(struct posix_clock *, const struct timespec64 *);
    long int (*ioctl)(struct posix_clock_context *, unsigned int, long unsigned int);
    int (*open)(struct posix_clock_context *, fmode_t);
    __poll_t (*poll)(struct posix_clock_context *, struct file *, poll_table *);
    int (*release)(struct posix_clock_context *);
    ssize_t (*read)(struct posix_clock_context *, uint, char *, size_t);
};

struct posix_clock {
    struct posix_clock_operations ops;
    struct cdev cdev;
    struct device *dev;
    struct rw_semaphore rwsem;
    bool zombie;
};

struct posix_clock_context {
    struct posix_clock *clk;
    void *private_clkdata;
};

struct posix_clock_desc {
    struct file *fp;
    struct posix_clock *clk;
};

struct posix_cputimer_base {
    u64 nextevt;
    struct timerqueue_head tqhead;
};

struct posix_cputimers {
    struct posix_cputimer_base bases[3];
    unsigned int timers_active;
    unsigned int expiry_active;
};

struct posix_cputimers_work {
    struct callback_head work;
    struct mutex mutex;
    unsigned int scheduled;
};

struct posix_msg_tree_node {
    struct rb_node rb_node;
    struct list_head msg_list;
    int priority;
};

struct postprocess_bh_ctx {
    struct work_struct work;
    struct buffer_head *bh;
};

struct power_supply_desc;

struct power_supply_battery_info;

struct power_supply {
    const struct power_supply_desc *desc;
    char **supplied_to;
    size_t num_supplicants;
    char **supplied_from;
    size_t num_supplies;
    struct device_node *of_node;
    void *drv_data;
    struct device dev;
    struct work_struct changed_work;
    struct delayed_work deferred_register_work;
    spinlock_t changed_lock;
    bool changed;
    bool update_groups;
    bool initialized;
    bool removing;
    atomic_t use_cnt;
    struct power_supply_battery_info *battery_info;
    struct rw_semaphore extensions_sem;
    struct list_head extensions;
    struct thermal_zone_device *tzd;
    struct thermal_cooling_device *tcd;
    struct led_trigger *trig;
    struct led_trigger *charging_trig;
    struct led_trigger *full_trig;
    struct led_trigger *charging_blink_full_solid_trig;
    struct led_trigger *charging_orange_full_green_trig;
};

struct power_supply_attr {
    const char *prop_name;
    char attr_name[31];
    struct device_attribute dev_attr;
    const char * const *text_values;
    int text_values_len;
};

struct power_supply_maintenance_charge_table;

struct power_supply_battery_ocv_table;

struct power_supply_resistance_temp_table;

struct power_supply_vbat_ri_table;

struct power_supply_battery_info {
    unsigned int technology;
    int energy_full_design_uwh;
    int charge_full_design_uah;
    int voltage_min_design_uv;
    int voltage_max_design_uv;
    int tricklecharge_current_ua;
    int precharge_current_ua;
    int precharge_voltage_max_uv;
    int charge_term_current_ua;
    int charge_restart_voltage_uv;
    int overvoltage_limit_uv;
    int constant_charge_current_max_ua;
    int constant_charge_voltage_max_uv;
    const struct power_supply_maintenance_charge_table *maintenance_charge;
    int maintenance_charge_size;
    int alert_low_temp_charge_current_ua;
    int alert_low_temp_charge_voltage_uv;
    int alert_high_temp_charge_current_ua;
    int alert_high_temp_charge_voltage_uv;
    int factory_internal_resistance_uohm;
    int factory_internal_resistance_charging_uohm;
    int ocv_temp[20];
    int temp_ambient_alert_min;
    int temp_ambient_alert_max;
    int temp_alert_min;
    int temp_alert_max;
    int temp_min;
    int temp_max;
    const struct power_supply_battery_ocv_table *ocv_table[20];
    int ocv_table_size[20];
    const struct power_supply_resistance_temp_table *resist_table;
    int resist_table_size;
    const struct power_supply_vbat_ri_table *vbat2ri_discharging;
    int vbat2ri_discharging_size;
    const struct power_supply_vbat_ri_table *vbat2ri_charging;
    int vbat2ri_charging_size;
    int bti_resistance_ohm;
    int bti_resistance_tolerance;
};

struct power_supply_battery_ocv_table {
    int ocv;
    int capacity;
};

struct power_supply_config {
    struct device_node *of_node;
    struct fwnode_handle *fwnode;
    void *drv_data;
    const struct attribute_group **attr_grp;
    char **supplied_to;
    size_t num_supplicants;
    bool no_wakeup_source;
};

union power_supply_propval;

struct power_supply_desc {
    const char *name;
    enum power_supply_type type;
    u8 charge_behaviours;
    u32 charge_types;
    u32 usb_types;
    const enum power_supply_property *properties;
    size_t num_properties;
    int (*get_property)(struct power_supply *, enum power_supply_property, union power_supply_propval *);
    int (*set_property)(struct power_supply *, enum power_supply_property, const union power_supply_propval *);
    int (*property_is_writeable)(struct power_supply *, enum power_supply_property);
    void (*external_power_changed)(struct power_supply *);
    void (*set_charged)(struct power_supply *);
    bool no_thermal;
    int use_for_apm;
};

struct power_supply_ext {
    const char * const name;
    u8 charge_behaviours;
    const enum power_supply_property *properties;
    size_t num_properties;
    int (*get_property)(struct power_supply *, const struct power_supply_ext *, void *, enum power_supply_property, union power_supply_propval *);
    int (*set_property)(struct power_supply *, const struct power_supply_ext *, void *, enum power_supply_property, const union power_supply_propval *);
    int (*property_is_writeable)(struct power_supply *, const struct power_supply_ext *, void *, enum power_supply_property);
};

struct power_supply_ext_registration {
    struct list_head list_head;
    const struct power_supply_ext *ext;
    struct device *dev;
    void *data;
};

struct power_supply_hwmon {
    struct power_supply *psy;
    long unsigned int *props;
};

struct power_supply_led_trigger {
    struct led_trigger trig;
    struct power_supply *psy;
};

struct power_supply_maintenance_charge_table {
    int charge_current_max_ua;
    int charge_voltage_max_uv;
    int charge_safety_timer_minutes;
};

union power_supply_propval {
    int intval;
    const char *strval;
};

struct power_supply_resistance_temp_table {
    int temp;
    int resistance;
};

struct power_supply_vbat_ri_table {
    int vbat_uv;
    int ri_uohm;
};

struct pppoe_tag {
    __be16 tag_type;
    __be16 tag_len;
    char tag_data[0];
};

struct pppoe_hdr {
    __u8 type: 4;
    __u8 ver: 4;
    __u8 code;
    __be16 sid;
    __be16 length;
    struct pppoe_tag tag[0];
};

struct pps_bind_args {
    int tsformat;
    int edge;
    int consumer;
};

struct pps_device;

struct pps_source_info {
    char name[32];
    char path[32];
    int mode;
    void (*echo)(struct pps_device *, int, void *);
    struct module *owner;
    struct device *dev;
};

struct pps_ktime {
    __s64 sec;
    __s32 nsec;
    __u32 flags;
};

struct pps_kparams {
    int api_version;
    int mode;
    struct pps_ktime assert_off_tu;
    struct pps_ktime clear_off_tu;
};

struct pps_device {
    struct pps_source_info info;
    struct pps_kparams params;
    __u32 assert_sequence;
    __u32 clear_sequence;
    struct pps_ktime assert_tu;
    struct pps_ktime clear_tu;
    int current_mode;
    unsigned int last_ev;
    wait_queue_head_t queue;
    unsigned int id;
    const void *lookup_cookie;
    struct device dev;
    struct fasync_struct *async_queue;
    spinlock_t lock;
};

struct pps_event_time {
    struct timespec64 ts_real;
};

struct pps_kinfo {
    __u32 assert_sequence;
    __u32 clear_sequence;
    struct pps_ktime assert_tu;
    struct pps_ktime clear_tu;
    int current_mode;
};

struct pps_fdata {
    struct pps_kinfo info;
    struct pps_ktime timeout;
};

struct pptp_gre_header {
    struct gre_base_hdr gre_hd;
    __be16 payload_len;
    __be16 call_id;
    __be32 seq;
    __be32 ack;
};

struct pr_clear {
    __u64 key;
    __u32 flags;
    __u32 __pad;
};

struct pr_cont_work_struct {
    bool comma;
    work_func_t func;
    long int ctr;
};

struct pr_held_reservation {
    u64 key;
    u32 generation;
    enum pr_type type;
};

struct pr_keys {
    u32 generation;
    u32 num_keys;
    u64 keys[0];
};

struct pr_ops {
    int (*pr_register)(struct block_device *, u64, u64, u32);
    int (*pr_reserve)(struct block_device *, u64, enum pr_type, u32);
    int (*pr_release)(struct block_device *, u64, enum pr_type);
    int (*pr_preempt)(struct block_device *, u64, u64, enum pr_type, bool);
    int (*pr_clear)(struct block_device *, u64);
    int (*pr_read_keys)(struct block_device *, struct pr_keys *);
    int (*pr_read_reservation)(struct block_device *, struct pr_held_reservation *);
};

struct pr_preempt {
    __u64 old_key;
    __u64 new_key;
    __u32 type;
    __u32 flags;
};

struct pr_registration {
    __u64 old_key;
    __u64 new_key;
    __u32 flags;
    __u32 __pad;
};

struct pr_reservation {
    __u64 key;
    __u32 type;
    __u32 flags;
};

struct prb_data_blk_lpos {
    long unsigned int begin;
    long unsigned int next;
};

struct prb_data_block {
    long unsigned int id;
    char data[0];
};

struct prb_data_ring {
    unsigned int size_bits;
    char *data;
    atomic_long_t head_lpos;
    atomic_long_t tail_lpos;
};

struct prb_desc {
    atomic_long_t state_var;
    struct prb_data_blk_lpos text_blk_lpos;
};

struct printk_info;

struct prb_desc_ring {
    unsigned int count_bits;
    struct prb_desc *descs;
    struct printk_info *infos;
    atomic_long_t head_id;
    atomic_long_t tail_id;
    atomic_long_t last_finalized_seq;
};

struct printk_ringbuffer;

struct prb_reserved_entry {
    struct printk_ringbuffer *rb;
    long unsigned int irqflags;
    long unsigned int id;
    unsigned int text_space;
};

struct prctl_mm_map {
    __u64 start_code;
    __u64 end_code;
    __u64 start_data;
    __u64 end_data;
    __u64 start_brk;
    __u64 brk;
    __u64 start_stack;
    __u64 arg_start;
    __u64 arg_end;
    __u64 env_start;
    __u64 env_end;
    __u64 *auxv;
    __u32 auxv_size;
    __u32 exe_fd;
};

struct pre_voltage_change_data {
    long unsigned int old_uV;
    long unsigned int min_uV;
    long unsigned int max_uV;
};

struct preempt_ops {
    void (*sched_in)(struct preempt_notifier *, int);
    void (*sched_out)(struct preempt_notifier *, struct task_struct *);
};

struct prefix_cacheinfo {
    __u32 preferred_time;
    __u32 valid_time;
};

struct prefix_info {
    __u8 type;
    __u8 length;
    __u8 prefix_len;
    union {
        __u8 flags;
        struct {
            __u8 reserved: 4;
            __u8 preferpd: 1;
            __u8 routeraddr: 1;
            __u8 autoconf: 1;
            __u8 onlink: 1;
        };
    };
    __be32 valid;
    __be32 prefered;
    __be32 reserved2;
    struct in6_addr prefix;
};

struct prefixmsg {
    unsigned char prefix_family;
    unsigned char prefix_pad1;
    short unsigned int prefix_pad2;
    int prefix_ifindex;
    unsigned char prefix_type;
    unsigned char prefix_len;
    unsigned char prefix_flags;
    unsigned char prefix_pad3;
};

struct prepend_buffer {
    char *buf;
    int len;
};

struct print_entry {
    struct trace_entry ent;
    long unsigned int ip;
    char buf[0];
};

struct printf_spec {
    unsigned char flags;
    unsigned char base;
    short int precision;
    int field_width;
};

struct printk_info {
    u64 seq;
    u64 ts_nsec;
    u16 text_len;
    u8 facility;
    u8 flags: 5;
    u8 level: 3;
    u32 caller_id;
    struct dev_printk_info dev_info;
};

struct printk_message {
    struct printk_buffers *pbufs;
    unsigned int outbuf_len;
    u64 seq;
    long unsigned int dropped;
};

struct printk_record {
    struct printk_info *info;
    char *text_buf;
    unsigned int text_buf_size;
};

struct printk_ringbuffer {
    struct prb_desc_ring desc_ring;
    struct prb_data_ring text_data_ring;
    atomic_long_t fail;
};

struct private_data {
    struct list_head node;
    cpumask_var_t cpus;
    struct device *cpu_dev;
    struct cpufreq_frequency_table *freq_table;
    bool have_static_opps;
    int opp_token;
};

struct privflags_reply_data {
    struct ethnl_reply_data base;
    const char (*priv_flag_names)[32];
    unsigned int n_priv_flags;
    u32 priv_flags;
};

typedef struct kobject *kobj_probe_t(dev_t, int *, void *);

struct probe {
    struct probe *next;
    dev_t dev;
    long unsigned int range;
    struct module *owner;
    kobj_probe_t *get;
    int (*lock)(dev_t, void *);
    void *data;
};

struct probe_arg {
    struct fetch_insn *code;
    bool dynamic;
    unsigned int offset;
    unsigned int count;
    const char *name;
    const char *comm;
    char *fmt;
    const struct fetch_type *type;
};

struct probe_entry_arg {
    struct fetch_insn *code;
    unsigned int size;
};

typedef int (*proc_write_t)(struct file *, char *, size_t);

struct proc_ops;

struct proc_dir_entry {
    atomic_t in_use;
    refcount_t refcnt;
    struct list_head pde_openers;
    spinlock_t pde_unload_lock;
    struct completion *pde_unload_completion;
    const struct inode_operations *proc_iops;
    union {
        const struct proc_ops *proc_ops;
        const struct file_operations *proc_dir_ops;
    };
    const struct dentry_operations *proc_dops;
    union {
        const struct seq_operations *seq_ops;
        int (*single_show)(struct seq_file *, void *);
    };
    proc_write_t write;
    void *data;
    unsigned int state_size;
    unsigned int low_ino;
    nlink_t nlink;
    kuid_t uid;
    kgid_t gid;
    loff_t size;
    struct proc_dir_entry *parent;
    struct rb_root subdir;
    struct rb_node subdir_node;
    char *name;
    umode_t mode;
    u8 flags;
    u8 namelen;
    char inline_name[0];
};

struct proc_fs_context {
    struct pid_namespace *pid_ns;
    unsigned int mask;
    enum proc_hidepid hidepid;
    int gid;
    enum proc_pidonly pidonly;
};

struct proc_fs_info {
    struct pid_namespace *pid_ns;
    struct dentry *proc_self;
    struct dentry *proc_thread_self;
    kgid_t pid_gid;
    enum proc_hidepid hide_pid;
    enum proc_pidonly pidonly;
    struct callback_head rcu;
};

struct proc_fs_opts {
    int flag;
    const char *str;
};

struct proc_inode {
    struct pid *pid;
    unsigned int fd;
    union proc_op op;
    struct proc_dir_entry *pde;
    struct ctl_table_header *sysctl;
    const struct ctl_table *sysctl_entry;
    struct hlist_node sibling_inodes;
    const struct proc_ns_operations *ns_ops;
    struct inode vfs_inode;
};

struct proc_maps_private {
    struct inode *inode;
    struct task_struct *task;
    struct mm_struct *mm;
    struct vma_iterator iter;
};

struct proc_mounts {
    struct mnt_namespace *ns;
    struct path root;
    int (*show)(struct seq_file *, struct vfsmount *);
};

struct proc_ns_operations {
    const char *name;
    const char *real_ns_name;
    int type;
    struct ns_common * (*get)(struct task_struct *);
    void (*put)(struct ns_common *);
    int (*install)(struct nsset *, struct ns_common *);
    struct user_namespace * (*owner)(struct ns_common *);
    struct ns_common * (*get_parent)(struct ns_common *);
};

struct proc_ops {
    unsigned int proc_flags;
    int (*proc_open)(struct inode *, struct file *);
    ssize_t (*proc_read)(struct file *, char *, size_t, loff_t *);
    ssize_t (*proc_read_iter)(struct kiocb *, struct iov_iter *);
    ssize_t (*proc_write)(struct file *, const char *, size_t, loff_t *);
    loff_t (*proc_lseek)(struct file *, loff_t, int);
    int (*proc_release)(struct inode *, struct file *);
    __poll_t (*proc_poll)(struct file *, struct poll_table_struct *);
    long int (*proc_ioctl)(struct file *, unsigned int, long unsigned int);
    long int (*proc_compat_ioctl)(struct file *, unsigned int, long unsigned int);
    int (*proc_mmap)(struct file *, struct vm_area_struct *);
    long unsigned int (*proc_get_unmapped_area)(struct file *, long unsigned int, long unsigned int, long unsigned int, long unsigned int);
};

struct proc_timens_offset {
    int clockid;
    struct timespec64 val;
};

struct process_timer {
    struct timer_list timer;
    struct task_struct *task;
};

struct procmap_query {
    __u64 size;
    __u64 query_flags;
    __u64 query_addr;
    __u64 vma_start;
    __u64 vma_end;
    __u64 vma_flags;
    __u64 vma_page_size;
    __u64 vma_offset;
    __u64 inode;
    __u32 dev_major;
    __u32 dev_minor;
    __u32 vma_name_size;
    __u32 build_id_size;
    __u64 vma_name_addr;
    __u64 build_id_addr;
};

struct profile_fgraph_data {
    long long unsigned int calltime;
    long long unsigned int subtime;
    long long unsigned int sleeptime;
};

struct prog_entry {
    int target;
    int when_to_branch;
    struct filter_pred *pred;
};

struct prog_poke_elem {
    struct list_head list;
    struct bpf_prog_aux *aux;
};

struct prog_test_member1 {
    int a;
};

struct prog_test_member {
    struct prog_test_member1 m;
    int c;
};

struct prog_test_ref_kfunc {
    int a;
    int b;
    struct prog_test_member memb;
    struct prog_test_ref_kfunc *next;
    refcount_t cnt;
};

struct property {
    char *name;
    int length;
    void *value;
    struct property *next;
    long unsigned int _flags;
    struct bin_attribute attr;
};

struct property_entry {
    const char *name;
    size_t length;
    bool is_inline;
    enum dev_prop_type type;
    union {
        const void *pointer;
        union {
            u8 u8_data[8];
            u16 u16_data[4];
            u32 u32_data[2];
            u64 u64_data[1];
            const char *str[1];
        } value;
    };
};

struct prot_inuse {
    int all;
    int val[64];
};

struct smc_hashinfo;

struct proto_accept_arg;

struct sk_psock;

struct timewait_sock_ops;

struct raw_hashinfo;

struct proto {
    void (*close)(struct sock *, long int);
    int (*pre_connect)(struct sock *, struct sockaddr *, int);
    int (*connect)(struct sock *, struct sockaddr *, int);
    int (*disconnect)(struct sock *, int);
    struct sock * (*accept)(struct sock *, struct proto_accept_arg *);
    int (*ioctl)(struct sock *, int, int *);
    int (*init)(struct sock *);
    void (*destroy)(struct sock *);
    void (*shutdown)(struct sock *, int);
    int (*setsockopt)(struct sock *, int, int, sockptr_t, unsigned int);
    int (*getsockopt)(struct sock *, int, int, char *, int *);
    void (*keepalive)(struct sock *, int);
    int (*compat_ioctl)(struct sock *, unsigned int, long unsigned int);
    int (*sendmsg)(struct sock *, struct msghdr *, size_t);
    int (*recvmsg)(struct sock *, struct msghdr *, size_t, int, int *);
    void (*splice_eof)(struct socket *);
    int (*bind)(struct sock *, struct sockaddr *, int);
    int (*bind_add)(struct sock *, struct sockaddr *, int);
    int (*backlog_rcv)(struct sock *, struct sk_buff *);
    bool (*bpf_bypass_getsockopt)(int, int);
    void (*release_cb)(struct sock *);
    int (*hash)(struct sock *);
    void (*unhash)(struct sock *);
    void (*rehash)(struct sock *);
    int (*get_port)(struct sock *, short unsigned int);
    void (*put_port)(struct sock *);
    int (*psock_update_sk_prot)(struct sock *, struct sk_psock *, bool);
    unsigned int inuse_idx;
    int (*forward_alloc_get)(const struct sock *);
    bool (*stream_memory_free)(const struct sock *, int);
    bool (*sock_is_readable)(struct sock *);
    void (*enter_memory_pressure)(struct sock *);
    void (*leave_memory_pressure)(struct sock *);
    atomic_long_t *memory_allocated;
    int *per_cpu_fw_alloc;
    struct percpu_counter *sockets_allocated;
    long unsigned int *memory_pressure;
    long int *sysctl_mem;
    int *sysctl_wmem;
    int *sysctl_rmem;
    u32 sysctl_wmem_offset;
    u32 sysctl_rmem_offset;
    int max_header;
    bool no_autobind;
    struct kmem_cache *slab;
    unsigned int obj_size;
    unsigned int ipv6_pinfo_offset;
    slab_flags_t slab_flags;
    unsigned int useroffset;
    unsigned int usersize;
    unsigned int *orphan_count;
    struct request_sock_ops *rsk_prot;
    struct timewait_sock_ops *twsk_prot;
    union {
        struct inet_hashinfo *hashinfo;
        struct udp_table *udp_table;
        struct raw_hashinfo *raw_hash;
        struct smc_hashinfo *smc_hash;
    } h;
    struct module *owner;
    char name[32];
    struct list_head node;
    int (*diag_destroy)(struct sock *, int);
};

struct proto_accept_arg {
    int flags;
    int err;
    int is_empty;
    bool kern;
};

typedef int (*skb_read_actor_t)(struct sock *, struct sk_buff *);

struct proto_ops {
    int family;
    struct module *owner;
    int (*release)(struct socket *);
    int (*bind)(struct socket *, struct sockaddr *, int);
    int (*connect)(struct socket *, struct sockaddr *, int, int);
    int (*socketpair)(struct socket *, struct socket *);
    int (*accept)(struct socket *, struct socket *, struct proto_accept_arg *);
    int (*getname)(struct socket *, struct sockaddr *, int);
    __poll_t (*poll)(struct file *, struct socket *, struct poll_table_struct *);
    int (*ioctl)(struct socket *, unsigned int, long unsigned int);
    int (*compat_ioctl)(struct socket *, unsigned int, long unsigned int);
    int (*gettstamp)(struct socket *, void *, bool, bool);
    int (*listen)(struct socket *, int);
    int (*shutdown)(struct socket *, int);
    int (*setsockopt)(struct socket *, int, int, sockptr_t, unsigned int);
    int (*getsockopt)(struct socket *, int, int, char *, int *);
    void (*show_fdinfo)(struct seq_file *, struct socket *);
    int (*sendmsg)(struct socket *, struct msghdr *, size_t);
    int (*recvmsg)(struct socket *, struct msghdr *, size_t, int);
    int (*mmap)(struct file *, struct socket *, struct vm_area_struct *);
    ssize_t (*splice_read)(struct socket *, loff_t *, struct pipe_inode_info *, size_t, unsigned int);
    void (*splice_eof)(struct socket *);
    int (*set_peek_off)(struct sock *, int);
    int (*peek_len)(struct socket *);
    int (*read_sock)(struct sock *, read_descriptor_t *, sk_read_actor_t);
    int (*read_skb)(struct sock *, skb_read_actor_t);
    int (*sendmsg_locked)(struct sock *, struct msghdr *, size_t);
    int (*set_rcvlowat)(struct sock *, int);
};

struct psample_group {
    struct list_head list;
    struct net *net;
    u32 group_num;
    u32 refcount;
    u32 seq;
    struct callback_head rcu;
};

struct psched_pktrate {
    u64 rate_pkts_ps;
    u32 mult;
    u8 shift;
};

struct psched_ratecfg {
    u64 rate_bytes_ps;
    u32 mult;
    u16 overhead;
    u16 mpu;
    u8 linklayer;
    u8 shift;
};

struct psci_boot_args {
    atomic_t lock;
    long unsigned int pc;
    long unsigned int r0;
};

struct psci_operations {
    u32 (*get_version)(void);
    int (*cpu_suspend)(u32, long unsigned int);
    int (*cpu_off)(u32);
    int (*cpu_on)(long unsigned int, long unsigned int);
    int (*migrate)(long unsigned int);
    int (*affinity_info)(long unsigned int, long unsigned int);
    int (*migrate_info_type)(void);
};

struct pse_admin_state {
    enum ethtool_podl_pse_admin_state podl_admin_state;
    enum ethtool_c33_pse_admin_state c33_admin_state;
};

struct pse_controller_dev;

struct pse_control {
    struct pse_controller_dev *pcdev;
    struct regulator *ps;
    struct list_head list;
    unsigned int id;
    struct kref refcnt;
};

struct pse_control_config {
    enum ethtool_podl_pse_admin_state podl_admin_control;
    enum ethtool_c33_pse_admin_state c33_admin_control;
};

struct pse_controller_ops;

struct pse_pi;

struct pse_controller_dev {
    const struct pse_controller_ops *ops;
    struct module *owner;
    struct list_head list;
    struct list_head pse_control_head;
    struct device *dev;
    int of_pse_n_cells;
    unsigned int nr_lines;
    struct mutex lock;
    enum ethtool_pse_types types;
    struct pse_pi *pi;
    bool no_of_pse_pi;
};

struct pse_pw_status;

struct pse_ext_state_info;

struct pse_pw_limit_ranges;

struct pse_controller_ops {
    int (*setup_pi_matrix)(struct pse_controller_dev *);
    int (*pi_get_admin_state)(struct pse_controller_dev *, int, struct pse_admin_state *);
    int (*pi_get_pw_status)(struct pse_controller_dev *, int, struct pse_pw_status *);
    int (*pi_get_ext_state)(struct pse_controller_dev *, int, struct pse_ext_state_info *);
    int (*pi_get_pw_class)(struct pse_controller_dev *, int);
    int (*pi_get_actual_pw)(struct pse_controller_dev *, int);
    int (*pi_enable)(struct pse_controller_dev *, int);
    int (*pi_disable)(struct pse_controller_dev *, int);
    int (*pi_get_voltage)(struct pse_controller_dev *, int);
    int (*pi_get_pw_limit)(struct pse_controller_dev *, int);
    int (*pi_set_pw_limit)(struct pse_controller_dev *, int, int);
    int (*pi_get_pw_limit_ranges)(struct pse_controller_dev *, int, struct pse_pw_limit_ranges *);
};

struct pse_ext_state_info {
    struct ethtool_c33_pse_ext_state_info c33_ext_state_info;
};

struct pse_pi_pairset {
    enum pse_pi_pairset_pinout pinout;
    struct device_node *np;
};

struct pse_pi {
    struct pse_pi_pairset pairset[2];
    struct device_node *np;
    struct regulator_dev *rdev;
    bool admin_state_enabled;
};

struct pse_pw_limit_ranges {
    struct ethtool_c33_pse_pw_limit_range *c33_pw_limit_ranges;
};

struct pse_pw_status {
    enum ethtool_podl_pse_pw_d_status podl_pw_status;
    enum ethtool_c33_pse_pw_d_status c33_pw_status;
};

struct pse_reply_data {
    struct ethnl_reply_data base;
    struct ethtool_pse_control_status status;
};

struct super_operations;

struct xattr_handler;

struct pseudo_fs_context {
    const struct super_operations *ops;
    const struct export_operations *eops;
    const struct xattr_handler * const *xattr;
    const struct dentry_operations *dops;
    long unsigned int magic;
};

struct psi_group_cpu;

struct psi_group {
    struct psi_group *parent;
    bool enabled;
    struct mutex avgs_lock;
    struct psi_group_cpu *pcpu;
    u64 avg_total[6];
    u64 avg_last_update;
    u64 avg_next_update;
    struct delayed_work avgs_work;
    struct list_head avg_triggers;
    u32 avg_nr_triggers[6];
    u64 total[12];
    long unsigned int avg[18];
    struct task_struct *rtpoll_task;
    struct timer_list rtpoll_timer;
    wait_queue_head_t rtpoll_wait;
    atomic_t rtpoll_wakeup;
    atomic_t rtpoll_scheduled;
    struct mutex rtpoll_trigger_lock;
    struct list_head rtpoll_triggers;
    u32 rtpoll_nr_triggers[6];
    u32 rtpoll_states;
    u64 rtpoll_min_period;
    u64 rtpoll_total[6];
    u64 rtpoll_next_update;
    u64 rtpoll_until;
};

struct psi_group_cpu {
    seqcount_t seq;
    unsigned int tasks[4];
    u32 state_mask;
    u32 times[7];
    u64 state_start;
    u32 times_prev[14];
    long: 64;
};

struct psi_window {
    u64 size;
    u64 start_time;
    u64 start_value;
    u64 prev_growth;
};

struct psi_trigger {
    enum psi_states state;
    u64 threshold;
    struct list_head node;
    struct psi_group *group;
    wait_queue_head_t event_wait;
    struct kernfs_open_file *of;
    int event;
    struct psi_window win;
    u64 last_event_time;
    bool pending_event;
    enum psi_aggregators aggregator;
};

struct pstore_ftrace_record {
    long unsigned int ip;
    long unsigned int parent_ip;
    u64 ts;
};

struct pstore_ftrace_seq_data {
    const void *ptr;
    size_t off;
    size_t size;
};

struct pstore_record;

struct pstore_info {
    struct module *owner;
    const char *name;
    raw_spinlock_t buf_lock;
    char *buf;
    size_t bufsize;
    struct mutex read_mutex;
    int flags;
    int max_reason;
    void *data;
    int (*open)(struct pstore_info *);
    int (*close)(struct pstore_info *);
    ssize_t (*read)(struct pstore_record *);
    int (*write)(struct pstore_record *);
    int (*write_user)(struct pstore_record *, const char *);
    int (*erase)(struct pstore_record *);
};

struct pstore_private {
    struct list_head list;
    struct dentry *dentry;
    struct pstore_record *record;
    size_t total_size;
};

struct pstore_record {
    struct pstore_info *psi;
    enum pstore_type_id type;
    u64 id;
    struct timespec64 time;
    char *buf;
    ssize_t size;
    ssize_t ecc_notice_size;
    void *priv;
    int count;
    enum kmsg_dump_reason reason;
    unsigned int part;
    bool compressed;
};

struct psy_am_i_supplied_data {
    struct power_supply *psy;
    unsigned int count;
};

struct psy_for_each_psy_cb_data {
    int (*fn)(struct power_supply *, void *);
    void *data;
};

struct psy_get_supplier_prop_data {
    struct power_supply *psy;
    enum power_supply_property psp;
    union power_supply_propval *val;
};

struct pt_regs_offset {
    const char *name;
    int offset;
};

struct ptdesc {
    long unsigned int __page_flags;
    union {
        struct callback_head pt_rcu_head;
        struct list_head pt_list;
        struct {
            long unsigned int _pt_pad_1;
            pgtable_t pmd_huge_pte;
        };
    };
    long unsigned int __page_mapping;
    union {
        long unsigned int pt_index;
        struct mm_struct *pt_mm;
        atomic_t pt_frag_refcount;
        atomic_t pt_share_count;
    };
    union {
        long unsigned int _pt_pad_2;
        spinlock_t ptl;
    };
    unsigned int __page_type;
    atomic_t __page_refcount;
    long unsigned int pt_memcg_data;
};

struct ptdump_info {
    struct mm_struct *mm;
    const struct addr_marker *markers;
    long unsigned int base_addr;
};

struct ptdump_prot_bits;

struct ptdump_pg_level {
    const struct ptdump_prot_bits *bits;
    char name[4];
    int num;
    u64 mask;
};

struct ptdump_range;

struct ptdump_state {
    void (*note_page)(struct ptdump_state *, long unsigned int, int, u64);
    void (*effective_prot)(struct ptdump_state *, int, u64);
    const struct ptdump_range *range;
};

struct ptdump_pg_state {
    struct ptdump_state ptdump;
    struct ptdump_pg_level *pg_level;
    struct seq_file *seq;
    const struct addr_marker *marker;
    const struct mm_struct *mm;
    long unsigned int start_address;
    int level;
    u64 current_prot;
    bool check_wx;
    long unsigned int wx_pages;
    long unsigned int uxn_pages;
};

struct ptdump_prot_bits {
    u64 mask;
    u64 val;
    const char *set;
    const char *clear;
};

struct ptdump_range {
    long unsigned int start;
    long unsigned int end;
};

struct ptp_clock {
    struct posix_clock clock;
    struct device dev;
    struct ptp_clock_info *info;
    dev_t devid;
    int index;
    struct pps_device *pps_source;
    long int dialed_frequency;
    struct list_head tsevqs;
    spinlock_t tsevqs_lock;
    struct mutex pincfg_mux;
    wait_queue_head_t tsev_wq;
    int defunct;
    struct device_attribute *pin_dev_attr;
    struct attribute **pin_attr;
    struct attribute_group pin_attr_group;
    const struct attribute_group *pin_attr_groups[2];
    struct kthread_worker *kworker;
    struct kthread_delayed_work aux_work;
    unsigned int max_vclocks;
    unsigned int n_vclocks;
    int *vclock_index;
    struct mutex n_vclocks_mux;
    bool is_virtual_clock;
    bool has_cycles;
    struct dentry *debugfs_root;
};

struct ptp_clock_caps {
    int max_adj;
    int n_alarm;
    int n_ext_ts;
    int n_per_out;
    int pps;
    int n_pins;
    int cross_timestamping;
    int adjust_phase;
    int max_phase_adj;
    int rsv[11];
};

struct ptp_clock_event {
    int type;
    int index;
    union {
        u64 timestamp;
        s64 offset;
        struct pps_event_time pps_times;
    };
};

struct ptp_extts_request {
    unsigned int index;
    unsigned int flags;
    unsigned int rsv[2];
};

struct ptp_clock_time {
    __s64 sec;
    __u32 nsec;
    __u32 reserved;
};

struct ptp_perout_request {
    union {
        struct ptp_clock_time start;
        struct ptp_clock_time phase;
    };
    struct ptp_clock_time period;
    unsigned int index;
    unsigned int flags;
    union {
        struct ptp_clock_time on;
        unsigned int rsv[4];
    };
};

struct ptp_clock_request {
    enum {
        PTP_CLK_REQ_EXTTS = 0,
        PTP_CLK_REQ_PEROUT = 1,
        PTP_CLK_REQ_PPS = 2,
    } type;
    union {
        struct ptp_extts_request extts;
        struct ptp_perout_request perout;
    };
};

struct ptp_extts_event {
    struct ptp_clock_time t;
    unsigned int index;
    unsigned int flags;
    unsigned int rsv[2];
};

struct ptp_header {
    u8 tsmt;
    u8 ver;
    __be16 message_length;
    u8 domain_number;
    u8 reserved1;
    u8 flag_field[2];
    __be64 correction;
    __be32 reserved2;
    struct port_identity source_port_identity;
    __be16 sequence_id;
    u8 control;
    u8 log_message_interval;
} __attribute__((packed));

struct ptp_sys_offset {
    unsigned int n_samples;
    unsigned int rsv[3];
    struct ptp_clock_time ts[51];
};

struct ptp_sys_offset_extended {
    unsigned int n_samples;
    __kernel_clockid_t clockid;
    unsigned int rsv[2];
    struct ptp_clock_time ts[75];
};

struct ptp_sys_offset_precise {
    struct ptp_clock_time device;
    struct ptp_clock_time sys_realtime;
    struct ptp_clock_time sys_monoraw;
    unsigned int rsv[4];
};

struct ptp_system_timestamp {
    struct timespec64 pre_ts;
    struct timespec64 post_ts;
    clockid_t clockid;
};

struct ptp_vclock {
    struct ptp_clock *pclock;
    struct ptp_clock_info info;
    struct ptp_clock *clock;
    struct hlist_node vclock_hash_node;
    struct cyclecounter cc;
    struct timecounter tc;
    struct mutex lock;
};

struct ptrace_peeksiginfo_args {
    __u64 off;
    __u32 flags;
    __s32 nr;
};

struct ptrace_relation {
    struct task_struct *tracer;
    struct task_struct *tracee;
    bool invalid;
    struct list_head node;
    struct callback_head rcu;
};

struct ptrace_rseq_configuration {
    __u64 rseq_abi_pointer;
    __u32 rseq_abi_size;
    __u32 signature;
    __u32 flags;
    __u32 pad;
};

struct ptrace_syscall_info {
    __u8 op;
    __u8 pad[3];
    __u32 arch;
    __u64 instruction_pointer;
    __u64 stack_pointer;
    union {
        struct {
            __u64 nr;
            __u64 args[6];
        } entry;
        struct {
            __s64 rval;
            __u8 is_error;
        } exit;
        struct {
            __u64 nr;
            __u64 args[6];
            __u32 ret_data;
        } seccomp;
    };
};

struct ptrauth_key {
    long unsigned int lo;
    long unsigned int hi;
};

struct ptrauth_keys_kernel {
    struct ptrauth_key apia;
};

struct ptrauth_keys_user {
    struct ptrauth_key apia;
    struct ptrauth_key apib;
    struct ptrauth_key apda;
    struct ptrauth_key apdb;
    struct ptrauth_key apga;
};

struct pts_mount_opts {
    int setuid;
    int setgid;
    kuid_t uid;
    kgid_t gid;
    umode_t mode;
    umode_t ptmxmode;
    int reserve;
    int max;
};

struct pts_fs_info {
    struct ida allocated_ptys;
    struct pts_mount_opts mount_opts;
    struct super_block *sb;
    struct dentry *ptmx_dentry;
};

struct pubkey_hdr {
    uint8_t version;
    uint32_t timestamp;
    uint8_t algo;
    uint8_t nmpi;
    char mpi[0];
} __attribute__((packed));

struct public_key {
    void *key;
    u32 keylen;
    enum OID algo;
    void *params;
    u32 paramlen;
    bool key_is_private;
    const char *id_type;
    const char *pkey_algo;
    long unsigned int key_eflags;
};

struct public_key_signature {
    struct asymmetric_key_id *auth_ids[3];
    u8 *s;
    u8 *digest;
    u32 s_size;
    u32 digest_size;
    const char *pkey_algo;
    const char *hash_algo;
    const char *encoding;
};

struct pvclock_vcpu_stolen_time;

struct pv_time_stolen_time_region {
    struct pvclock_vcpu_stolen_time *kaddr;
};

struct pvclock_vcpu_stolen_time {
    __le32 revision;
    __le32 attributes;
    __le64 stolen_time;
    u8 padding[48];
};

struct pvm_ftr_bits {
    bool sign;
    u8 shift;
    u8 width;
    u8 max_val;
    bool (*vm_supported)(const struct kvm *);
};

struct pwm_args {
    u64 period;
    enum pwm_polarity polarity;
};

struct pwm_capture {
    unsigned int period;
    unsigned int duty_cycle;
};

struct pwm_chip;

typedef struct pwm_chip *class_pwmchip_t;

struct pwm_state {
    u64 period;
    u64 duty_cycle;
    enum pwm_polarity polarity;
    bool enabled;
    bool usage_power;
};

struct pwm_device {
    const char *label;
    long unsigned int flags;
    unsigned int hwpwm;
    struct pwm_chip *chip;
    struct pwm_args args;
    struct pwm_state state;
    struct pwm_state last;
};

struct pwm_ops;

struct pwm_chip {
    struct device dev;
    const struct pwm_ops *ops;
    struct module *owner;
    unsigned int id;
    unsigned int npwm;
    struct pwm_device * (*of_xlate)(struct pwm_chip *, const struct of_phandle_args *);
    bool atomic;
    bool uses_pwmchip_alloc;
    bool operational;
    union {
        struct mutex nonatomic_lock;
        spinlock_t atomic_lock;
    };
    struct pwm_device pwms[0];
};

struct pwm_export {
    struct device pwm_dev;
    struct pwm_device *pwm;
    struct mutex lock;
    struct pwm_state suspend;
};

struct pwm_lookup {
    struct list_head list;
    const char *provider;
    unsigned int index;
    const char *dev_id;
    const char *con_id;
    unsigned int period;
    enum pwm_polarity polarity;
    const char *module;
};

struct pwm_waveform;

struct pwm_ops {
    int (*request)(struct pwm_chip *, struct pwm_device *);
    void (*free)(struct pwm_chip *, struct pwm_device *);
    int (*capture)(struct pwm_chip *, struct pwm_device *, struct pwm_capture *, long unsigned int);
    size_t sizeof_wfhw;
    int (*round_waveform_tohw)(struct pwm_chip *, struct pwm_device *, const struct pwm_waveform *, void *);
    int (*round_waveform_fromhw)(struct pwm_chip *, struct pwm_device *, const void *, struct pwm_waveform *);
    int (*read_waveform)(struct pwm_chip *, struct pwm_device *, void *);
    int (*write_waveform)(struct pwm_chip *, struct pwm_device *, const void *);
    int (*apply)(struct pwm_chip *, struct pwm_device *, const struct pwm_state *);
    int (*get_state)(struct pwm_chip *, struct pwm_device *, struct pwm_state *);
};

struct pwm_waveform {
    u64 period_length_ns;
    u64 duty_length_ns;
    u64 duty_offset_ns;
};

struct qc_dqblk {
    int d_fieldmask;
    u64 d_spc_hardlimit;
    u64 d_spc_softlimit;
    u64 d_ino_hardlimit;
    u64 d_ino_softlimit;
    u64 d_space;
    u64 d_ino_count;
    s64 d_ino_timer;
    s64 d_spc_timer;
    int d_ino_warns;
    int d_spc_warns;
    u64 d_rt_spc_hardlimit;
    u64 d_rt_spc_softlimit;
    u64 d_rt_space;
    s64 d_rt_spc_timer;
    int d_rt_spc_warns;
};

struct qc_info {
    int i_fieldmask;
    unsigned int i_flags;
    unsigned int i_spc_timelimit;
    unsigned int i_ino_timelimit;
    unsigned int i_rt_spc_timelimit;
    unsigned int i_spc_warnlimit;
    unsigned int i_ino_warnlimit;
    unsigned int i_rt_spc_warnlimit;
};

struct qc_type_state {
    unsigned int flags;
    unsigned int spc_timelimit;
    unsigned int ino_timelimit;
    unsigned int rt_spc_timelimit;
    unsigned int spc_warnlimit;
    unsigned int ino_warnlimit;
    unsigned int rt_spc_warnlimit;
    long long unsigned int ino;
    blkcnt_t blocks;
    blkcnt_t nextents;
};

struct qc_state {
    unsigned int s_incoredqs;
    struct qc_type_state s_state[3];
};

struct qdisc_dump_args {
    struct qdisc_walker w;
    struct sk_buff *skb;
    struct netlink_callback *cb;
};

struct tc_ratespec {
    unsigned char cell_log;
    __u8 linklayer;
    short unsigned int overhead;
    short int cell_align;
    short unsigned int mpu;
    __u32 rate;
};

struct qdisc_rate_table {
    struct tc_ratespec rate;
    u32 data[256];
    struct qdisc_rate_table *next;
    int refcnt;
};

struct tc_sizespec {
    unsigned char cell_log;
    unsigned char size_log;
    short int cell_align;
    int overhead;
    unsigned int linklayer;
    unsigned int mpu;
    unsigned int mtu;
    unsigned int tsize;
};

struct qdisc_size_table {
    struct callback_head rcu;
    struct list_head list;
    struct tc_sizespec szopts;
    int refcnt;
    u16 data[0];
};

struct qdisc_watchdog {
    struct hrtimer timer;
    struct Qdisc *qdisc;
};

struct qnode {
    struct mcs_spinlock mcs;
};

struct queue_limits {
    blk_features_t features;
    blk_flags_t flags;
    long unsigned int seg_boundary_mask;
    long unsigned int virt_boundary_mask;
    unsigned int max_hw_sectors;
    unsigned int max_dev_sectors;
    unsigned int chunk_sectors;
    unsigned int max_sectors;
    unsigned int max_user_sectors;
    unsigned int max_segment_size;
    unsigned int min_segment_size;
    unsigned int physical_block_size;
    unsigned int logical_block_size;
    unsigned int alignment_offset;
    unsigned int io_min;
    unsigned int io_opt;
    unsigned int max_discard_sectors;
    unsigned int max_hw_discard_sectors;
    unsigned int max_user_discard_sectors;
    unsigned int max_secure_erase_sectors;
    unsigned int max_write_zeroes_sectors;
    unsigned int max_hw_zone_append_sectors;
    unsigned int max_zone_append_sectors;
    unsigned int discard_granularity;
    unsigned int discard_alignment;
    unsigned int zone_write_granularity;
    unsigned int atomic_write_hw_max;
    unsigned int atomic_write_max_sectors;
    unsigned int atomic_write_hw_boundary;
    unsigned int atomic_write_boundary_sectors;
    unsigned int atomic_write_hw_unit_min;
    unsigned int atomic_write_unit_min;
    unsigned int atomic_write_hw_unit_max;
    unsigned int atomic_write_unit_max;
    short unsigned int max_segments;
    short unsigned int max_integrity_segments;
    short unsigned int max_discard_segments;
    unsigned int max_open_zones;
    unsigned int max_active_zones;
    unsigned int dma_alignment;
    unsigned int dma_pad_mask;
    struct blk_integrity integrity;
};

struct queue_sysfs_entry {
    struct attribute attr;
    ssize_t (*show)(struct gendisk *, char *);
    ssize_t (*store)(struct gendisk *, const char *, size_t);
    int (*store_limit)(struct gendisk *, const char *, size_t, struct queue_limits *);
    void (*load_module)(struct gendisk *, const char *, size_t);
};

struct quirk_entry {
    u16 vid;
    u16 pid;
    u32 flags;
};

struct quirks_list_struct {
    struct hid_device_id hid_bl_item;
    struct list_head node;
};

struct quota_format_ops {
    int (*check_quota_file)(struct super_block *, int);
    int (*read_file_info)(struct super_block *, int);
    int (*write_file_info)(struct super_block *, int);
    int (*free_file_info)(struct super_block *, int);
    int (*read_dqblk)(struct dquot *);
    int (*commit_dqblk)(struct dquot *);
    int (*release_dqblk)(struct dquot *);
    int (*get_next_id)(struct super_block *, struct kqid *);
};

struct quota_format_type {
    int qf_fmt_id;
    const struct quota_format_ops *qf_ops;
    struct module *qf_owner;
    struct quota_format_type *qf_next;
};

struct quota_id {
    struct rb_node node;
    qid_t id;
    qsize_t bhardlimit;
    qsize_t bsoftlimit;
    qsize_t ihardlimit;
    qsize_t isoftlimit;
};

struct quota_info {
    unsigned int flags;
    struct rw_semaphore dqio_sem;
    struct inode *files[3];
    struct mem_dqinfo info[3];
    const struct quota_format_ops *ops[3];
};

struct quota_module_name {
    int qm_fmt_id;
    char *qm_mod_name;
};

struct quotactl_ops {
    int (*quota_on)(struct super_block *, int, int, const struct path *);
    int (*quota_off)(struct super_block *, int);
    int (*quota_enable)(struct super_block *, unsigned int);
    int (*quota_disable)(struct super_block *, unsigned int);
    int (*quota_sync)(struct super_block *, int);
    int (*set_info)(struct super_block *, int, struct qc_info *);
    int (*get_dqblk)(struct super_block *, struct kqid, struct qc_dqblk *);
    int (*get_nextdqblk)(struct super_block *, struct kqid *, struct qc_dqblk *);
    int (*set_dqblk)(struct super_block *, struct kqid, struct qc_dqblk *);
    int (*get_state)(struct super_block *, struct qc_state *);
    int (*rm_xquota)(struct super_block *, unsigned int);
};

struct ra_msg {
    struct icmp6hdr icmph;
    __be32 reachable_time;
    __be32 retrans_timer;
};

struct xa_node;

struct radix_tree_iter {
    long unsigned int index;
    long unsigned int next_index;
    long unsigned int tags;
    struct xa_node *node;
};

struct radix_tree_preload {
    local_lock_t lock;
    unsigned int nr;
    struct xa_node *nodes;
};

struct ramfs_mount_opts {
    umode_t mode;
};

struct ramfs_fs_info {
    struct ramfs_mount_opts mount_opts;
};

struct rand_data {
    void *hash_state;
    __u64 prev_time;
    __u64 last_delta;
    __s64 last_delta2;
    unsigned int flags;
    unsigned int osr;
    unsigned char *mem;
    unsigned int memlocation;
    unsigned int memblocks;
    unsigned int memblocksize;
    unsigned int memaccessloops;
    unsigned int rct_count;
    unsigned int apt_cutoff;
    unsigned int apt_cutoff_permanent;
    unsigned int apt_observations;
    unsigned int apt_count;
    unsigned int apt_base;
    unsigned int health_failure;
    unsigned int apt_base_set: 1;
};

struct range_node {
    struct rb_node rn_rbnode;
    struct rb_node rb_range_size;
    u32 rn_start;
    u32 rn_last;
    u32 __rn_subtree_last;
};

struct range_trans {
    u32 source_type;
    u32 target_type;
    u32 target_class;
};

struct rank_info {
    int chan_idx;
    struct csrow_info *csrow;
    struct dimm_info *dimm;
    u32 ce_count;
};

struct raspberrypi_clk {
    struct device *dev;
    struct rpi_firmware *firmware;
    struct platform_device *cpufreq;
};

struct raspberrypi_clk_variant;

struct raspberrypi_clk_data {
    struct clk_hw hw;
    unsigned int id;
    struct raspberrypi_clk_variant *variant;
    struct raspberrypi_clk *rpi;
};

struct raspberrypi_clk_variant {
    bool export;
    char *clkdev;
    long unsigned int min_rate;
    bool minimize;
};

struct raspberrypi_firmware_prop {
    __le32 id;
    __le32 val;
    __le32 disable_turbo;
};

struct rate_sample {
    u64 prior_mstamp;
    u32 prior_delivered;
    u32 prior_delivered_ce;
    s32 delivered;
    s32 delivered_ce;
    long int interval_us;
    u32 snd_interval_us;
    u32 rcv_interval_us;
    long int rtt_us;
    int losses;
    u32 acked_sacked;
    u32 prior_in_flight;
    u32 last_end_seq;
    bool is_app_limited;
    bool is_retrans;
    bool is_ack_delayed;
};

struct raw6_frag_vec {
    struct msghdr *msg;
    int hlen;
    char c[4];
};

struct raw6_sock {
    struct inet_sock inet;
    __u32 checksum;
    __u32 offset;
    struct icmp6_filter filter;
    __u32 ip6mr_table;
    struct ipv6_pinfo inet6;
};

struct raw_data_entry {
    struct trace_entry ent;
    unsigned int id;
    char buf[0];
};

struct raw_frag_vec {
    struct msghdr *msg;
    union {
        struct icmphdr icmph;
        char c[1];
    } hdr;
    int hlen;
};

struct raw_hashinfo {
    spinlock_t lock;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    struct hlist_head ht[256];
};

struct raw_iter_state {
    struct seq_net_private p;
    int bucket;
};

struct raw_sock {
    struct inet_sock inet;
    struct icmp_filter filter;
    u32 ipmr_table;
};

struct rawdata_f_data {
    struct aa_loaddata *loaddata;
};

struct rb_augment_callbacks {
    void (*propagate)(struct rb_node *, struct rb_node *);
    void (*copy)(struct rb_node *, struct rb_node *);
    void (*rotate)(struct rb_node *, struct rb_node *);
};

struct rb_event_info {
    u64 ts;
    u64 delta;
    u64 before;
    u64 after;
    long unsigned int length;
    struct buffer_page *tail_page;
    int add_timestamp;
};

struct rb_irq_work {
    struct irq_work work;
    wait_queue_head_t waiters;
    wait_queue_head_t full_waiters;
    atomic_t seq;
    bool waiters_pending;
    bool full_waiters_pending;
    bool wakeup_full;
};

struct rb_list {
    struct rb_root root;
    struct list_head head;
    spinlock_t lock;
};

struct rb_time_struct {
    local64_t time;
};

typedef struct rb_time_struct rb_time_t;

struct rb_wait_data {
    struct rb_irq_work *irq_work;
    int seq;
};

struct rc {
    long int (*fill)(void *, long unsigned int);
    uint8_t *ptr;
    uint8_t *buffer;
    uint8_t *buffer_end;
    long int buffer_size;
    uint32_t code;
    uint32_t range;
    uint32_t bound;
    void (*error)(char *);
};

struct rc_dec {
    uint32_t range;
    uint32_t code;
    uint32_t init_bytes_left;
    const uint8_t *in;
    size_t in_pos;
    size_t in_limit;
};

struct rc_map_table;

struct rc_map {
    struct rc_map_table *scan;
    unsigned int size;
    unsigned int len;
    unsigned int alloc;
    enum rc_proto rc_proto;
    const char *name;
    spinlock_t lock;
};

struct rc_scancode_filter {
    u32 data;
    u32 mask;
};

struct rc_dev {
    struct device dev;
    bool managed_alloc;
    const struct attribute_group *sysfs_groups[5];
    const char *device_name;
    const char *input_phys;
    struct input_id input_id;
    const char *driver_name;
    const char *map_name;
    struct rc_map rc_map;
    struct mutex lock;
    unsigned int minor;
    struct ir_raw_event_ctrl *raw;
    struct input_dev *input_dev;
    enum rc_driver_type driver_type;
    bool idle;
    bool encode_wakeup;
    u64 allowed_protocols;
    u64 enabled_protocols;
    u64 allowed_wakeup_protocols;
    enum rc_proto wakeup_protocol;
    struct rc_scancode_filter scancode_filter;
    struct rc_scancode_filter scancode_wakeup_filter;
    u32 scancode_mask;
    u32 users;
    void *priv;
    spinlock_t keylock;
    bool keypressed;
    long unsigned int keyup_jiffies;
    struct timer_list timer_keyup;
    struct timer_list timer_repeat;
    u32 last_keycode;
    enum rc_proto last_protocol;
    u64 last_scancode;
    u8 last_toggle;
    u32 timeout;
    u32 min_timeout;
    u32 max_timeout;
    u32 rx_resolution;
    struct device lirc_dev;
    struct cdev lirc_cdev;
    ktime_t gap_start;
    spinlock_t lirc_fh_lock;
    struct list_head lirc_fh;
    bool registered;
    int (*change_protocol)(struct rc_dev *, u64 *);
    int (*open)(struct rc_dev *);
    void (*close)(struct rc_dev *);
    int (*s_tx_mask)(struct rc_dev *, u32);
    int (*s_tx_carrier)(struct rc_dev *, u32);
    int (*s_tx_duty_cycle)(struct rc_dev *, u32);
    int (*s_rx_carrier_range)(struct rc_dev *, u32, u32);
    int (*tx_ir)(struct rc_dev *, unsigned int *, unsigned int);
    void (*s_idle)(struct rc_dev *, bool);
    int (*s_wideband_receiver)(struct rc_dev *, int);
    int (*s_carrier_report)(struct rc_dev *, int);
    int (*s_filter)(struct rc_dev *, struct rc_scancode_filter *);
    int (*s_wakeup_filter)(struct rc_dev *, struct rc_scancode_filter *);
    int (*s_timeout)(struct rc_dev *, unsigned int);
};

struct rc_filter_attribute {
    struct device_attribute attr;
    enum rc_filter_type type;
    bool mask;
};

struct rc_map_list {
    struct list_head list;
    struct rc_map map;
};

struct rc_map_table {
    u64 scancode;
    u32 keycode;
};

struct rcec_ea {
    u8 nextbusn;
    u8 lastbusn;
    u32 bitmap;
};

struct rchan_callbacks;

struct rchan_buf;

struct rchan {
    u32 version;
    size_t subbuf_size;
    size_t n_subbufs;
    size_t alloc_size;
    const struct rchan_callbacks *cb;
    struct kref kref;
    void *private_data;
    size_t last_toobig;
    struct rchan_buf **buf;
    int is_global;
    struct list_head list;
    struct dentry *parent;
    int has_base_filename;
    char base_filename[255];
};

struct rchan_buf {
    void *start;
    void *data;
    size_t offset;
    size_t subbufs_produced;
    size_t subbufs_consumed;
    struct rchan *chan;
    wait_queue_head_t read_wait;
    struct irq_work wakeup_work;
    struct dentry *dentry;
    struct kref kref;
    struct page **page_array;
    unsigned int page_count;
    unsigned int finalized;
    size_t *padding;
    size_t prev_padding;
    size_t bytes_consumed;
    size_t early_bytes;
    unsigned int cpu;
    long: 64;
    long: 64;
};

struct rchan_callbacks {
    int (*subbuf_start)(struct rchan_buf *, void *, void *, size_t);
    struct dentry * (*create_buf_file)(const char *, struct dentry *, umode_t, struct rchan_buf *, int *);
    int (*remove_buf_file)(struct dentry *);
};

struct rchan_percpu_buf_dispatcher {
    struct rchan_buf *buf;
    struct dentry *dentry;
};

struct rcu_cblist {
    struct callback_head *head;
    struct callback_head **tail;
    long int len;
};

union rcu_noqs {
    struct {
        u8 norm;
        u8 exp;
    } b;
    u16 s;
};

struct rcu_segcblist {
    struct callback_head *head;
    struct callback_head **tails[4];
    long unsigned int gp_seq[4];
    atomic_long_t len;
    long int seglen[4];
    u8 flags;
};

struct rcu_snap_record {
    long unsigned int gp_seq;
    u64 cputime_irq;
    u64 cputime_softirq;
    u64 cputime_system;
    long unsigned int nr_hardirqs;
    unsigned int nr_softirqs;
    long long unsigned int nr_csw;
    long unsigned int jiffies;
};

struct rcu_node;

struct rcu_data {
    long unsigned int gp_seq;
    long unsigned int gp_seq_needed;
    union rcu_noqs cpu_no_qs;
    bool core_needs_qs;
    bool beenonline;
    bool gpwrap;
    bool cpu_started;
    struct rcu_node *mynode;
    long unsigned int grpmask;
    long unsigned int ticks_this_gp;
    struct irq_work defer_qs_iw;
    bool defer_qs_iw_pending;
    struct work_struct strict_work;
    struct rcu_segcblist cblist;
    long int qlen_last_fqs_check;
    long unsigned int n_cbs_invoked;
    long unsigned int n_force_qs_snap;
    long int blimit;
    int watching_snap;
    bool rcu_need_heavy_qs;
    bool rcu_urgent_qs;
    bool rcu_forced_tick;
    bool rcu_forced_tick_exp;
    long unsigned int barrier_seq_snap;
    struct callback_head barrier_head;
    int exp_watching_snap;
    struct swait_queue_head nocb_cb_wq;
    struct swait_queue_head nocb_state_wq;
    struct task_struct *nocb_gp_kthread;
    raw_spinlock_t nocb_lock;
    int nocb_defer_wakeup;
    struct timer_list nocb_timer;
    long unsigned int nocb_gp_adv_time;
    struct mutex nocb_gp_kthread_mutex;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    raw_spinlock_t nocb_bypass_lock;
    struct rcu_cblist nocb_bypass;
    long unsigned int nocb_bypass_first;
    long unsigned int nocb_nobypass_last;
    int nocb_nobypass_count;
    long: 64;
    raw_spinlock_t nocb_gp_lock;
    u8 nocb_gp_sleep;
    u8 nocb_gp_bypass;
    u8 nocb_gp_gp;
    long unsigned int nocb_gp_seq;
    long unsigned int nocb_gp_loops;
    struct swait_queue_head nocb_gp_wq;
    bool nocb_cb_sleep;
    struct task_struct *nocb_cb_kthread;
    struct list_head nocb_head_rdp;
    struct list_head nocb_entry_rdp;
    struct rcu_data *nocb_toggling_rdp;
    long: 64;
    long: 64;
    long: 64;
    struct rcu_data *nocb_gp_rdp;
    struct task_struct *rcu_cpu_kthread_task;
    unsigned int rcu_cpu_kthread_status;
    char rcu_cpu_has_work;
    long unsigned int rcuc_activity;
    unsigned int softirq_snap;
    struct irq_work rcu_iw;
    bool rcu_iw_pending;
    long unsigned int rcu_iw_gp_seq;
    long unsigned int rcu_ofl_gp_seq;
    short int rcu_ofl_gp_state;
    long unsigned int rcu_onl_gp_seq;
    short int rcu_onl_gp_state;
    long unsigned int last_fqs_resched;
    long unsigned int last_sched_clock;
    struct rcu_snap_record snap_record;
    long int lazy_len;
    int cpu;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
};

struct rcu_exp_work {
    long unsigned int rew_s;
    struct kthread_work rew_work;
};

struct rcu_node {
    raw_spinlock_t lock;
    long unsigned int gp_seq;
    long unsigned int gp_seq_needed;
    long unsigned int completedqs;
    long unsigned int qsmask;
    long unsigned int rcu_gp_init_mask;
    long unsigned int qsmaskinit;
    long unsigned int qsmaskinitnext;
    long unsigned int expmask;
    long unsigned int expmaskinit;
    long unsigned int expmaskinitnext;
    struct kthread_worker *exp_kworker;
    long unsigned int cbovldmask;
    long unsigned int ffmask;
    long unsigned int grpmask;
    int grplo;
    int grphi;
    u8 grpnum;
    u8 level;
    bool wait_blkd_tasks;
    struct rcu_node *parent;
    struct list_head blkd_tasks;
    struct list_head *gp_tasks;
    struct list_head *exp_tasks;
    struct list_head *boost_tasks;
    struct rt_mutex boost_mtx;
    long unsigned int boost_time;
    struct mutex kthread_mutex;
    struct task_struct *boost_kthread_task;
    unsigned int boost_kthread_status;
    long unsigned int n_boosts;
    struct swait_queue_head nocb_gp_wq[2];
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    raw_spinlock_t fqslock;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    spinlock_t exp_lock;
    long unsigned int exp_seq_rq;
    wait_queue_head_t exp_wq[4];
    struct rcu_exp_work rew;
    bool exp_need_flush;
    raw_spinlock_t exp_poll_lock;
    long unsigned int exp_seq_poll_rq;
    struct work_struct exp_poll_wq;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
};

union rcu_special {
    struct {
        u8 blocked;
        u8 need_qs;
        u8 exp_hint;
        u8 need_mb;
    } b;
    u32 s;
};

struct rcu_stall_chk_rdr {
    int nesting;
    union rcu_special rs;
    bool on_blkd_list;
};

struct sr_wait_node {
    atomic_t inuse;
    struct llist_node node;
};

struct rcu_state {
    struct rcu_node node[17];
    struct rcu_node *level[3];
    int ncpus;
    int n_online_cpus;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long unsigned int gp_seq;
    long unsigned int gp_max;
    struct task_struct *gp_kthread;
    struct swait_queue_head gp_wq;
    short int gp_flags;
    short int gp_state;
    long unsigned int gp_wake_time;
    long unsigned int gp_wake_seq;
    long unsigned int gp_seq_polled;
    long unsigned int gp_seq_polled_snap;
    long unsigned int gp_seq_polled_exp_snap;
    struct mutex barrier_mutex;
    atomic_t barrier_cpu_count;
    struct completion barrier_completion;
    long unsigned int barrier_sequence;
    raw_spinlock_t barrier_lock;
    struct mutex exp_mutex;
    struct mutex exp_wake_mutex;
    long unsigned int expedited_sequence;
    atomic_t expedited_need_qs;
    struct swait_queue_head expedited_wq;
    int ncpus_snap;
    u8 cbovld;
    u8 cbovldnext;
    long unsigned int jiffies_force_qs;
    long unsigned int jiffies_kick_kthreads;
    long unsigned int n_force_qs;
    long unsigned int gp_start;
    long unsigned int gp_end;
    long unsigned int gp_activity;
    long unsigned int gp_req_activity;
    long unsigned int jiffies_stall;
    int nr_fqs_jiffies_stall;
    long unsigned int jiffies_resched;
    long unsigned int n_force_qs_gpstart;
    const char *name;
    char abbr;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    arch_spinlock_t ofl_lock;
    struct llist_head srs_next;
    struct llist_node *srs_wait_tail;
    struct llist_node *srs_done_tail;
    struct sr_wait_node srs_wait_nodes[5];
    struct work_struct srs_cleanup_work;
    atomic_t srs_cleanups_pending;
    struct mutex nocb_mutex;
    int nocb_is_setup;
};

struct rcu_synchronize {
    struct callback_head head;
    struct completion completion;
};

struct rcu_tasks;

typedef void (*rcu_tasks_gp_func_t)(struct rcu_tasks *);

typedef void (*pregp_func_t)(struct list_head *);

typedef void (*pertask_func_t)(struct task_struct *, struct list_head *);

typedef void (*postscan_func_t)(struct list_head *);

typedef void (*holdouts_func_t)(struct list_head *, bool, bool *);

typedef void (*postgp_func_t)(struct rcu_tasks *);

typedef void (*rcu_callback_t)(struct callback_head *);

typedef void (*call_rcu_func_t)(struct callback_head *, rcu_callback_t);

struct rcu_tasks_percpu;

struct rcu_tasks {
    struct rcuwait cbs_wait;
    raw_spinlock_t cbs_gbl_lock;
    struct mutex tasks_gp_mutex;
    int gp_state;
    int gp_sleep;
    int init_fract;
    long unsigned int gp_jiffies;
    long unsigned int gp_start;
    long unsigned int tasks_gp_seq;
    long unsigned int n_ipis;
    long unsigned int n_ipis_fails;
    struct task_struct *kthread_ptr;
    long unsigned int lazy_jiffies;
    rcu_tasks_gp_func_t gp_func;
    pregp_func_t pregp_func;
    pertask_func_t pertask_func;
    postscan_func_t postscan_func;
    holdouts_func_t holdouts_func;
    postgp_func_t postgp_func;
    call_rcu_func_t call_func;
    unsigned int wait_state;
    struct rcu_tasks_percpu *rtpcpu;
    struct rcu_tasks_percpu **rtpcp_array;
    int percpu_enqueue_shift;
    int percpu_enqueue_lim;
    int percpu_dequeue_lim;
    long unsigned int percpu_dequeue_gpseq;
    struct mutex barrier_q_mutex;
    atomic_t barrier_q_count;
    struct completion barrier_q_completion;
    long unsigned int barrier_q_seq;
    long unsigned int barrier_q_start;
    char *name;
    char *kname;
};

struct rcu_tasks_percpu {
    struct rcu_segcblist cblist;
    raw_spinlock_t lock;
    long unsigned int rtp_jiffies;
    long unsigned int rtp_n_lock_retries;
    struct timer_list lazy_timer;
    unsigned int urgent_gp;
    struct work_struct rtp_work;
    struct irq_work rtp_irq_work;
    struct callback_head barrier_q_head;
    struct list_head rtp_blkd_tasks;
    struct list_head rtp_exit_list;
    int cpu;
    int index;
    struct rcu_tasks *rtpp;
};

struct rd_msg {
    struct icmp6hdr icmph;
    struct in6_addr target;
    struct in6_addr dest;
    __u8 opt[0];
};

struct rdma_ah_init_attr {
    struct rdma_ah_attr *ah_attr;
    u32 flags;
    struct net_device *xmit_slave;
};

struct rdma_cgroup {
    struct cgroup_subsys_state css;
    struct list_head rpools;
};

struct rdma_counter {
    struct rdma_restrack_entry res;
    struct ib_device *device;
    uint32_t id;
    struct kref kref;
    struct rdma_counter_mode mode;
    struct mutex lock;
    struct rdma_hw_stats *stats;
    u32 port;
};

struct rdma_stat_desc;

struct rdma_hw_stats {
    struct mutex lock;
    long unsigned int timestamp;
    long unsigned int lifespan;
    const struct rdma_stat_desc *descs;
    long unsigned int *is_disabled;
    int num_counters;
    u64 value[0];
};

struct rdma_link_ops {
    struct list_head list;
    const char *type;
    int (*newlink)(const char *, struct net_device *);
};

struct rdma_netdev_alloc_params {
    size_t sizeof_priv;
    unsigned int txqs;
    unsigned int rxqs;
    void *param;
    int (*initialize_rdma_netdev)(struct ib_device *, u32, struct net_device *, void *);
};

struct rdma_stat_desc {
    const char *name;
    unsigned int flags;
    const void *priv;
};

struct rdma_user_mmap_entry {
    struct kref ref;
    struct ib_ucontext *ucontext;
    long unsigned int start_pgoff;
    size_t npages;
    bool driver_removed;
};

struct rdmacg_resource {
    int max;
    int usage;
};

struct rdmacg_resource_pool {
    struct rdmacg_device *device;
    struct rdmacg_resource resources[2];
    struct list_head cg_node;
    struct list_head dev_node;
    u64 usage_sum;
    int num_max_cnt;
};

struct readahead_control {
    struct file *file;
    struct address_space *mapping;
    struct file_ra_state *ra;
    long unsigned int _index;
    unsigned int _nr_pages;
    unsigned int _batch_count;
    bool dropbehind;
    bool _workingset;
    long unsigned int _pflags;
};

struct realm_config {
    union {
        struct {
            long unsigned int ipa_bits;
            long unsigned int hash_algo;
        };
        u8 pad[512];
    };
    union {
        u8 rpv[64];
        u8 pad2[3584];
    };
};

struct reciprocal_value_adv {
    u32 m;
    u8 sh;
    u8 exp;
    bool is_wide_m;
};

struct reclaim_stat {
    unsigned int nr_dirty;
    unsigned int nr_unqueued_dirty;
    unsigned int nr_congested;
    unsigned int nr_writeback;
    unsigned int nr_immediate;
    unsigned int nr_pageout;
    unsigned int nr_activate[2];
    unsigned int nr_ref_keep;
    unsigned int nr_unmap_fail;
    unsigned int nr_lazyfree_fail;
    unsigned int nr_demoted;
};

struct reclaim_state {
    long unsigned int reclaimed;
    struct lru_gen_mm_walk *mm_walk;
};

struct recovery_info {
    tid_t start_transaction;
    tid_t end_transaction;
    long unsigned int head_block;
    int nr_replays;
    int nr_revokes;
    int nr_revoke_hits;
};

struct redist_region {
    void *redist_base;
    phys_addr_t phys_base;
    bool single_redist;
};

struct reg_default {
    unsigned int reg;
    unsigned int def;
};

struct reg_field {
    unsigned int reg;
    unsigned int lsb;
    unsigned int msb;
    unsigned int id_size;
    unsigned int id_offset;
};

struct reg_genl_event {
    char reg_name[32];
    uint64_t event;
};

struct reg_mask_range {
    __u64 addr;
    __u32 range;
    __u32 reserved[13];
};

struct reg_sequence {
    unsigned int reg;
    unsigned int def;
    unsigned int delay_us;
};

struct regcache_ops {
    const char *name;
    enum regcache_type type;
    int (*init)(struct regmap *);
    int (*exit)(struct regmap *);
    void (*debugfs_init)(struct regmap *);
    int (*read)(struct regmap *, unsigned int, unsigned int *);
    int (*write)(struct regmap *, unsigned int, unsigned int);
    int (*sync)(struct regmap *, unsigned int, unsigned int);
    int (*drop)(struct regmap *, unsigned int, unsigned int);
};

struct regcache_rbtree_node;

struct regcache_rbtree_ctx {
    struct rb_root root;
    struct regcache_rbtree_node *cached_rbnode;
};

struct regcache_rbtree_node {
    void *block;
    long unsigned int *cache_present;
    unsigned int base_reg;
    unsigned int blklen;
    struct rb_node node;
};

typedef int (*regex_match_func)(char *, struct regex *, int);

struct regex {
    char pattern[256];
    int len;
    int field_len;
    regex_match_func match;
};

struct region {
    unsigned int start;
    unsigned int off;
    unsigned int group_len;
    unsigned int end;
    unsigned int nbits;
};

struct region_devres {
    struct resource *parent;
    resource_size_t start;
    resource_size_t n;
};

typedef void (*regmap_lock)(void *);

typedef void (*regmap_unlock)(void *);

struct regmap_format {
    size_t buf_size;
    size_t reg_bytes;
    size_t pad_bytes;
    size_t val_bytes;
    s8 reg_shift;
    void (*format_write)(struct regmap *, unsigned int, unsigned int);
    void (*format_reg)(void *, unsigned int, unsigned int);
    void (*format_val)(void *, unsigned int, unsigned int);
    unsigned int (*parse_val)(const void *);
    void (*parse_inplace)(void *);
};

struct hwspinlock;

struct regmap_bus;

struct regmap_access_table;

struct regmap {
    union {
        struct mutex mutex;
        struct {
            spinlock_t spinlock;
            long unsigned int spinlock_flags;
        };
        struct {
            raw_spinlock_t raw_spinlock;
            long unsigned int raw_spinlock_flags;
        };
    };
    struct lock_class_key *lock_key;
    regmap_lock lock;
    regmap_unlock unlock;
    void *lock_arg;
    gfp_t alloc_flags;
    unsigned int reg_base;
    struct device *dev;
    void *work_buf;
    struct regmap_format format;
    const struct regmap_bus *bus;
    void *bus_context;
    const char *name;
    bool async;
    spinlock_t async_lock;
    wait_queue_head_t async_waitq;
    struct list_head async_list;
    struct list_head async_free;
    int async_ret;
    bool debugfs_disable;
    struct dentry *debugfs;
    const char *debugfs_name;
    unsigned int debugfs_reg_len;
    unsigned int debugfs_val_len;
    unsigned int debugfs_tot_len;
    struct list_head debugfs_off_cache;
    struct mutex cache_lock;
    unsigned int max_register;
    bool max_register_is_set;
    bool (*writeable_reg)(struct device *, unsigned int);
    bool (*readable_reg)(struct device *, unsigned int);
    bool (*volatile_reg)(struct device *, unsigned int);
    bool (*precious_reg)(struct device *, unsigned int);
    bool (*writeable_noinc_reg)(struct device *, unsigned int);
    bool (*readable_noinc_reg)(struct device *, unsigned int);
    const struct regmap_access_table *wr_table;
    const struct regmap_access_table *rd_table;
    const struct regmap_access_table *volatile_table;
    const struct regmap_access_table *precious_table;
    const struct regmap_access_table *wr_noinc_table;
    const struct regmap_access_table *rd_noinc_table;
    int (*reg_read)(void *, unsigned int, unsigned int *);
    int (*reg_write)(void *, unsigned int, unsigned int);
    int (*reg_update_bits)(void *, unsigned int, unsigned int, unsigned int);
    int (*read)(void *, const void *, size_t, void *, size_t);
    int (*write)(void *, const void *, size_t);
    bool defer_caching;
    long unsigned int read_flag_mask;
    long unsigned int write_flag_mask;
    int reg_shift;
    int reg_stride;
    int reg_stride_order;
    bool force_write_field;
    const struct regcache_ops *cache_ops;
    enum regcache_type cache_type;
    unsigned int cache_size_raw;
    unsigned int cache_word_size;
    unsigned int num_reg_defaults;
    unsigned int num_reg_defaults_raw;
    bool cache_only;
    bool cache_bypass;
    bool cache_free;
    struct reg_default *reg_defaults;
    const void *reg_defaults_raw;
    void *cache;
    bool cache_dirty;
    bool no_sync_defaults;
    struct reg_sequence *patch;
    int patch_regs;
    bool use_single_read;
    bool use_single_write;
    bool can_multi_write;
    size_t max_raw_read;
    size_t max_raw_write;
    struct rb_root range_tree;
    void *selector_work_buf;
    struct hwspinlock *hwlock;
    bool can_sleep;
};

struct regmap_range;

struct regmap_access_table {
    const struct regmap_range *yes_ranges;
    unsigned int n_yes_ranges;
    const struct regmap_range *no_ranges;
    unsigned int n_no_ranges;
};

struct regmap_async {
    struct list_head list;
    struct regmap *map;
    void *work_buf;
};

typedef int (*regmap_hw_write)(void *, const void *, size_t);

typedef int (*regmap_hw_gather_write)(void *, const void *, size_t, const void *, size_t);

typedef int (*regmap_hw_async_write)(void *, const void *, size_t, const void *, size_t, struct regmap_async *);

typedef int (*regmap_hw_reg_write)(void *, unsigned int, unsigned int);

typedef int (*regmap_hw_reg_noinc_write)(void *, unsigned int, const void *, size_t);

typedef int (*regmap_hw_reg_update_bits)(void *, unsigned int, unsigned int, unsigned int);

typedef int (*regmap_hw_read)(void *, const void *, size_t, void *, size_t);

typedef int (*regmap_hw_reg_read)(void *, unsigned int, unsigned int *);

typedef int (*regmap_hw_reg_noinc_read)(void *, unsigned int, void *, size_t);

typedef void (*regmap_hw_free_context)(void *);

typedef struct regmap_async * (*regmap_hw_async_alloc)(void);

struct regmap_bus {
    bool fast_io;
    bool free_on_exit;
    regmap_hw_write write;
    regmap_hw_gather_write gather_write;
    regmap_hw_async_write async_write;
    regmap_hw_reg_write reg_write;
    regmap_hw_reg_noinc_write reg_noinc_write;
    regmap_hw_reg_update_bits reg_update_bits;
    regmap_hw_read read;
    regmap_hw_reg_read reg_read;
    regmap_hw_reg_noinc_read reg_noinc_read;
    regmap_hw_free_context free_context;
    regmap_hw_async_alloc async_alloc;
    u8 read_flag_mask;
    enum regmap_endian reg_format_endian_default;
    enum regmap_endian val_format_endian_default;
    size_t max_raw_read;
    size_t max_raw_write;
};

struct regmap_range_cfg;

struct regmap_config {
    const char *name;
    int reg_bits;
    int reg_stride;
    int reg_shift;
    unsigned int reg_base;
    int pad_bits;
    int val_bits;
    bool (*writeable_reg)(struct device *, unsigned int);
    bool (*readable_reg)(struct device *, unsigned int);
    bool (*volatile_reg)(struct device *, unsigned int);
    bool (*precious_reg)(struct device *, unsigned int);
    bool (*writeable_noinc_reg)(struct device *, unsigned int);
    bool (*readable_noinc_reg)(struct device *, unsigned int);
    int (*reg_read)(void *, unsigned int, unsigned int *);
    int (*reg_write)(void *, unsigned int, unsigned int);
    int (*reg_update_bits)(void *, unsigned int, unsigned int, unsigned int);
    int (*read)(void *, const void *, size_t, void *, size_t);
    int (*write)(void *, const void *, size_t);
    size_t max_raw_read;
    size_t max_raw_write;
    bool can_sleep;
    bool fast_io;
    bool io_port;
    bool disable_locking;
    regmap_lock lock;
    regmap_unlock unlock;
    void *lock_arg;
    unsigned int max_register;
    bool max_register_is_0;
    const struct regmap_access_table *wr_table;
    const struct regmap_access_table *rd_table;
    const struct regmap_access_table *volatile_table;
    const struct regmap_access_table *precious_table;
    const struct regmap_access_table *wr_noinc_table;
    const struct regmap_access_table *rd_noinc_table;
    const struct reg_default *reg_defaults;
    unsigned int num_reg_defaults;
    enum regcache_type cache_type;
    const void *reg_defaults_raw;
    unsigned int num_reg_defaults_raw;
    long unsigned int read_flag_mask;
    long unsigned int write_flag_mask;
    bool zero_flag_mask;
    bool use_single_read;
    bool use_single_write;
    bool use_relaxed_mmio;
    bool can_multi_write;
    bool use_hwlock;
    bool use_raw_spinlock;
    unsigned int hwlock_id;
    unsigned int hwlock_mode;
    enum regmap_endian reg_format_endian;
    enum regmap_endian val_format_endian;
    const struct regmap_range_cfg *ranges;
    unsigned int num_ranges;
};

struct regmap_debugfs_node {
    struct regmap *map;
    struct list_head link;
};

struct regmap_debugfs_off_cache {
    struct list_head list;
    off_t min;
    off_t max;
    unsigned int base_reg;
    unsigned int max_reg;
};

struct regmap_field {
    struct regmap *regmap;
    unsigned int mask;
    unsigned int shift;
    unsigned int reg;
    unsigned int id_size;
    unsigned int id_offset;
};

struct regmap_irq_type {
    unsigned int type_reg_offset;
    unsigned int type_reg_mask;
    unsigned int type_rising_val;
    unsigned int type_falling_val;
    unsigned int type_level_low_val;
    unsigned int type_level_high_val;
    unsigned int types_supported;
};

struct regmap_irq {
    unsigned int reg_offset;
    unsigned int mask;
    struct regmap_irq_type type;
};

struct regmap_irq_sub_irq_map;

struct regmap_irq_chip_data;

struct regmap_irq_chip {
    const char *name;
    const char *domain_suffix;
    unsigned int main_status;
    unsigned int num_main_status_bits;
    const struct regmap_irq_sub_irq_map *sub_reg_offsets;
    int num_main_regs;
    unsigned int status_base;
    unsigned int mask_base;
    unsigned int unmask_base;
    unsigned int ack_base;
    unsigned int wake_base;
    const unsigned int *config_base;
    unsigned int irq_reg_stride;
    unsigned int init_ack_masked: 1;
    unsigned int mask_unmask_non_inverted: 1;
    unsigned int use_ack: 1;
    unsigned int ack_invert: 1;
    unsigned int clear_ack: 1;
    unsigned int status_invert: 1;
    unsigned int wake_invert: 1;
    unsigned int type_in_mask: 1;
    unsigned int clear_on_unmask: 1;
    unsigned int runtime_pm: 1;
    unsigned int no_status: 1;
    int num_regs;
    const struct regmap_irq *irqs;
    int num_irqs;
    int num_config_bases;
    int num_config_regs;
    int (*handle_pre_irq)(void *);
    int (*handle_post_irq)(void *);
    int (*handle_mask_sync)(int, unsigned int, unsigned int, void *);
    int (*set_type_config)(unsigned int **, unsigned int, const struct regmap_irq *, int, void *);
    unsigned int (*get_irq_reg)(struct regmap_irq_chip_data *, unsigned int, int);
    void *irq_drv_data;
};

struct regmap_irq_chip_data {
    struct mutex lock;
    struct irq_chip irq_chip;
    struct regmap *map;
    const struct regmap_irq_chip *chip;
    int irq_base;
    struct irq_domain *domain;
    int irq;
    int wake_count;
    void *status_reg_buf;
    unsigned int *main_status_buf;
    unsigned int *status_buf;
    unsigned int *mask_buf;
    unsigned int *mask_buf_def;
    unsigned int *wake_buf;
    unsigned int *type_buf;
    unsigned int *type_buf_def;
    unsigned int **config_buf;
    unsigned int irq_reg_stride;
    unsigned int (*get_irq_reg)(struct regmap_irq_chip_data *, unsigned int, int);
    unsigned int clear_status: 1;
};

struct regmap_irq_sub_irq_map {
    unsigned int num_regs;
    unsigned int *offset;
};

struct regmap_mmio_context {
    void *regs;
    unsigned int val_bytes;
    bool big_endian;
    bool attached_clk;
    struct clk *clk;
    void (*reg_write)(struct regmap_mmio_context *, unsigned int, unsigned int);
    unsigned int (*reg_read)(struct regmap_mmio_context *, unsigned int);
};

struct regmap_range {
    unsigned int range_min;
    unsigned int range_max;
};

struct regmap_range_cfg {
    const char *name;
    unsigned int range_min;
    unsigned int range_max;
    unsigned int selector_reg;
    unsigned int selector_mask;
    int selector_shift;
    unsigned int window_start;
    unsigned int window_len;
};

struct regmap_range_node {
    struct rb_node node;
    const char *name;
    struct regmap *map;
    unsigned int range_min;
    unsigned int range_max;
    unsigned int selector_reg;
    unsigned int selector_mask;
    int selector_shift;
    unsigned int window_start;
    unsigned int window_len;
};

struct regulator_voltage {
    int min_uV;
    int max_uV;
};

struct regulator {
    struct device *dev;
    struct list_head list;
    unsigned int always_on: 1;
    unsigned int bypass: 1;
    unsigned int device_link: 1;
    int uA_load;
    unsigned int enable_count;
    unsigned int deferred_disables;
    struct regulator_voltage voltage[5];
    const char *supply_name;
    struct device_attribute dev_attr;
    struct regulator_dev *rdev;
    struct dentry *debugfs;
};

struct regulator_bulk_data {
    const char *supply;
    struct regulator *consumer;
    int init_load_uA;
    int ret;
};

struct regulator_bulk_devres {
    struct regulator_bulk_data *consumers;
    int num_consumers;
};

struct regulator_config {
    struct device *dev;
    const struct regulator_init_data *init_data;
    void *driver_data;
    struct device_node *of_node;
    struct regmap *regmap;
    struct gpio_desc *ena_gpiod;
};

struct regulator_consumer_supply {
    const char *dev_name;
    const char *supply;
};

struct regulator_coupler {
    struct list_head list;
    int (*attach_regulator)(struct regulator_coupler *, struct regulator_dev *);
    int (*detach_regulator)(struct regulator_coupler *, struct regulator_dev *);
    int (*balance_voltage)(struct regulator_coupler *, struct regulator_dev *, suspend_state_t);
};

struct regulator_enable_gpio;

struct regulator_dev {
    const struct regulator_desc *desc;
    int exclusive;
    u32 use_count;
    u32 open_count;
    u32 bypass_count;
    struct list_head list;
    struct list_head consumer_list;
    struct coupling_desc coupling_desc;
    struct blocking_notifier_head notifier;
    struct ww_mutex mutex;
    struct task_struct *mutex_owner;
    int ref_cnt;
    struct module *owner;
    struct device dev;
    struct regulation_constraints *constraints;
    struct regulator *supply;
    const char *supply_name;
    struct regmap *regmap;
    struct delayed_work disable_work;
    void *reg_data;
    struct dentry *debugfs;
    struct regulator_enable_gpio *ena_pin;
    unsigned int ena_gpio_state: 1;
    unsigned int is_switch: 1;
    ktime_t last_off;
    int cached_err;
    bool use_cached_err;
    spinlock_t err_lock;
    int pw_requested_mW;
};

struct regulator_enable_gpio {
    struct list_head list;
    struct gpio_desc *gpiod;
    u32 enable_count;
    u32 request_count;
};

struct regulator_err_state {
    struct regulator_dev *rdev;
    long unsigned int notifs;
    long unsigned int errors;
    int possible_errs;
};

struct regulator_irq_data {
    struct regulator_err_state *states;
    int num_states;
    void *data;
    long int opaque;
};

struct regulator_irq_desc {
    const char *name;
    int fatal_cnt;
    int reread_ms;
    int irq_off_ms;
    bool skip_off;
    bool high_prio;
    void *data;
    int (*die)(struct regulator_irq_data *);
    int (*map_event)(int, struct regulator_irq_data *, long unsigned int *);
    int (*renable)(struct regulator_irq_data *);
};

struct regulator_irq {
    struct regulator_irq_data rdata;
    struct regulator_irq_desc desc;
    int irq;
    int retry_cnt;
    struct delayed_work isr_work;
};

struct regulator_map {
    struct list_head list;
    const char *dev_name;
    const char *supply;
    struct regulator_dev *regulator;
};

struct regulator_notifier_match {
    struct regulator *regulator;
    struct notifier_block *nb;
};

struct regulator_ops {
    int (*list_voltage)(struct regulator_dev *, unsigned int);
    int (*set_voltage)(struct regulator_dev *, int, int, unsigned int *);
    int (*map_voltage)(struct regulator_dev *, int, int);
    int (*set_voltage_sel)(struct regulator_dev *, unsigned int);
    int (*get_voltage)(struct regulator_dev *);
    int (*get_voltage_sel)(struct regulator_dev *);
    int (*set_current_limit)(struct regulator_dev *, int, int);
    int (*get_current_limit)(struct regulator_dev *);
    int (*set_input_current_limit)(struct regulator_dev *, int);
    int (*set_over_current_protection)(struct regulator_dev *, int, int, bool);
    int (*set_over_voltage_protection)(struct regulator_dev *, int, int, bool);
    int (*set_under_voltage_protection)(struct regulator_dev *, int, int, bool);
    int (*set_thermal_protection)(struct regulator_dev *, int, int, bool);
    int (*set_active_discharge)(struct regulator_dev *, bool);
    int (*enable)(struct regulator_dev *);
    int (*disable)(struct regulator_dev *);
    int (*is_enabled)(struct regulator_dev *);
    int (*set_mode)(struct regulator_dev *, unsigned int);
    unsigned int (*get_mode)(struct regulator_dev *);
    int (*get_error_flags)(struct regulator_dev *, unsigned int *);
    int (*enable_time)(struct regulator_dev *);
    int (*set_ramp_delay)(struct regulator_dev *, int);
    int (*set_voltage_time)(struct regulator_dev *, int, int);
    int (*set_voltage_time_sel)(struct regulator_dev *, unsigned int, unsigned int);
    int (*set_soft_start)(struct regulator_dev *);
    int (*get_status)(struct regulator_dev *);
    unsigned int (*get_optimum_mode)(struct regulator_dev *, int, int, int);
    int (*set_load)(struct regulator_dev *, int);
    int (*set_bypass)(struct regulator_dev *, bool);
    int (*get_bypass)(struct regulator_dev *, bool *);
    int (*set_suspend_voltage)(struct regulator_dev *, int);
    int (*set_suspend_enable)(struct regulator_dev *);
    int (*set_suspend_disable)(struct regulator_dev *);
    int (*set_suspend_mode)(struct regulator_dev *, unsigned int);
    int (*resume)(struct regulator_dev *);
    int (*set_pull_down)(struct regulator_dev *);
};

struct regulator_supply_alias {
    struct list_head list;
    struct device *src_dev;
    const char *src_supply;
    struct device *alias_dev;
    const char *alias_supply;
};

struct regulator_supply_alias_match {
    struct device *dev;
    const char *id;
};

struct regulatory_request {
    struct callback_head callback_head;
    int wiphy_idx;
    enum nl80211_reg_initiator initiator;
    enum nl80211_user_reg_hint_type user_reg_hint_type;
    char alpha2[3];
    enum nl80211_dfs_regions dfs_region;
    bool intersect;
    bool processed;
    enum environment_cap country_ie_env;
    struct list_head list;
};

struct remote_event {
    int armed;
    int fired;
    u32 __unused;
};

typedef int (*remote_function_f)(void *);

struct remote_function_call {
    struct task_struct *p;
    remote_function_f func;
    void *info;
    int ret;
};

struct remote_output {
    struct perf_buffer *rb;
    int err;
};

struct renamedata {
    struct mnt_idmap *old_mnt_idmap;
    struct inode *old_dir;
    struct dentry *old_dentry;
    struct mnt_idmap *new_mnt_idmap;
    struct inode *new_dir;
    struct dentry *new_dentry;
    struct inode **delegated_inode;
    unsigned int flags;
};

struct repcodes_s {
    U32 rep[3];
};

typedef struct repcodes_s repcodes_t;

struct reply_func {
    int type;
    int (*cb)(struct net_device *, struct nlmsghdr *, u32, struct nlattr **, struct sk_buff *);
};

struct req {
    struct req *next;
    struct completion done;
    int err;
    const char *name;
    umode_t mode;
    kuid_t uid;
    kgid_t gid;
    struct device *dev;
};

struct req_iterator {
    struct bvec_iter iter;
    struct bio *bio;
};

typedef enum rq_end_io_ret rq_end_io_fn(struct request *, blk_status_t);

struct request {
    struct request_queue *q;
    struct blk_mq_ctx *mq_ctx;
    struct blk_mq_hw_ctx *mq_hctx;
    blk_opf_t cmd_flags;
    req_flags_t rq_flags;
    int tag;
    int internal_tag;
    unsigned int timeout;
    unsigned int __data_len;
    sector_t __sector;
    struct bio *bio;
    struct bio *biotail;
    union {
        struct list_head queuelist;
        struct request *rq_next;
    };
    struct block_device *part;
    u64 start_time_ns;
    u64 io_start_time_ns;
    short unsigned int wbt_flags;
    short unsigned int stats_sectors;
    short unsigned int nr_phys_segments;
    short unsigned int nr_integrity_segments;
    struct bio_crypt_ctx *crypt_ctx;
    struct blk_crypto_keyslot *crypt_keyslot;
    enum mq_rq_state state;
    atomic_t ref;
    long unsigned int deadline;
    union {
        struct hlist_node hash;
        struct llist_node ipi_list;
    };
    union {
        struct rb_node rb_node;
        struct bio_vec special_vec;
    };
    struct {
        struct io_cq *icq;
        void *priv[2];
    } elv;
    struct {
        unsigned int seq;
        rq_end_io_fn *saved_end_io;
    } flush;
    u64 fifo_time;
    rq_end_io_fn *end_io;
    void *end_io_data;
};

struct request_key_auth {
    struct callback_head rcu;
    struct key *target_key;
    struct key *dest_keyring;
    const struct cred *cred;
    void *callout_info;
    size_t callout_len;
    pid_t pid;
    char op[8];
};

struct rq_qos;

struct throtl_data;

struct request_queue {
    void *queuedata;
    struct elevator_queue *elevator;
    const struct blk_mq_ops *mq_ops;
    struct blk_mq_ctx *queue_ctx;
    long unsigned int queue_flags;
    unsigned int rq_timeout;
    unsigned int queue_depth;
    refcount_t refs;
    unsigned int nr_hw_queues;
    struct xarray hctx_table;
    struct percpu_ref q_usage_counter;
    struct lock_class_key io_lock_cls_key;
    struct lockdep_map io_lockdep_map;
    struct lock_class_key q_lock_cls_key;
    struct lockdep_map q_lockdep_map;
    struct request *last_merge;
    spinlock_t queue_lock;
    int quiesce_depth;
    struct gendisk *disk;
    struct kobject *mq_kobj;
    struct queue_limits limits;
    struct device *dev;
    enum rpm_status rpm_status;
    atomic_t pm_only;
    struct blk_queue_stats *stats;
    struct rq_qos *rq_qos;
    struct mutex rq_qos_mutex;
    int id;
    long unsigned int nr_requests;
    struct blk_crypto_profile *crypto_profile;
    struct kobject *crypto_kobject;
    struct timer_list timeout;
    struct work_struct timeout_work;
    atomic_t nr_active_requests_shared_tags;
    struct blk_mq_tags *sched_shared_tags;
    struct list_head icq_list;
    long unsigned int blkcg_pols[1];
    struct blkcg_gq *root_blkg;
    struct list_head blkg_list;
    struct mutex blkcg_mutex;
    int node;
    spinlock_t requeue_lock;
    struct list_head requeue_list;
    struct delayed_work requeue_work;
    struct blk_trace *blk_trace;
    struct blk_flush_queue *fq;
    struct list_head flush_list;
    struct mutex sysfs_lock;
    struct mutex limits_lock;
    struct list_head unused_hctx_list;
    spinlock_t unused_hctx_lock;
    int mq_freeze_depth;
    struct throtl_data *td;
    struct callback_head callback_head;
    wait_queue_head_t mq_freeze_wq;
    struct mutex mq_freeze_lock;
    struct blk_mq_tag_set *tag_set;
    struct list_head tag_set_list;
    struct dentry *debugfs_dir;
    struct dentry *sched_debugfs_dir;
    struct dentry *rqos_debugfs_dir;
    struct mutex debugfs_mutex;
};

struct request_sense {
    __u8 error_code: 7;
    __u8 valid: 1;
    __u8 segment_number;
    __u8 sense_key: 4;
    __u8 reserved2: 1;
    __u8 ili: 1;
    __u8 reserved1: 2;
    __u8 information[4];
    __u8 add_sense_len;
    __u8 command_info[4];
    __u8 asc;
    __u8 ascq;
    __u8 fruc;
    __u8 sks[3];
    __u8 asb[46];
};

struct request_sock__safe_rcu_or_null {
    struct sock *sk;
};

struct request_sock_ops {
    int family;
    unsigned int obj_size;
    struct kmem_cache *slab;
    char *slab_name;
    int (*rtx_syn_ack)(const struct sock *, struct request_sock *);
    void (*send_ack)(const struct sock *, struct sk_buff *, struct request_sock *);
    void (*send_reset)(const struct sock *, struct sk_buff *, enum sk_rst_reason);
    void (*destructor)(struct request_sock *);
    void (*syn_ack_timeout)(const struct request_sock *);
};

struct reserve_mem_table {
    char name[16];
    phys_addr_t start;
    phys_addr_t size;
};

struct reserved_mem_ops;

struct reserved_mem {
    const char *name;
    long unsigned int fdt_node;
    const struct reserved_mem_ops *ops;
    phys_addr_t base;
    phys_addr_t size;
    void *priv;
};

struct reserved_mem_ops {
    int (*device_init)(struct reserved_mem *, struct device *);
    void (*device_release)(struct reserved_mem *, struct device *);
};

struct reset_control {
    struct reset_controller_dev *rcdev;
    struct list_head list;
    unsigned int id;
    struct kref refcnt;
    bool acquired;
    bool shared;
    bool array;
    atomic_t deassert_count;
    atomic_t triggered_count;
};

struct reset_control_array {
    struct reset_control base;
    unsigned int num_rstcs;
    struct reset_control *rstc[0];
};

struct reset_control_bulk_data {
    const char *id;
    struct reset_control *rstc;
};

struct reset_control_bulk_devres {
    int num_rstcs;
    struct reset_control_bulk_data *rstcs;
};

struct reset_control_lookup {
    struct list_head list;
    const char *provider;
    unsigned int index;
    const char *dev_id;
    const char *con_id;
};

struct reset_control_ops {
    int (*reset)(struct reset_controller_dev *, long unsigned int);
    int (*assert)(struct reset_controller_dev *, long unsigned int);
    int (*deassert)(struct reset_controller_dev *, long unsigned int);
    int (*status)(struct reset_controller_dev *, long unsigned int);
};

struct reset_gpio_lookup {
    struct of_phandle_args of_args;
    struct list_head list;
};

struct reset_simple_devdata {
    u32 reg_offset;
    u32 nr_resets;
    bool active_low;
    bool status_active_low;
};

typedef resource_size_t (*resource_alignf)(void *, const struct resource *, resource_size_t, resource_size_t);

struct resource_constraint {
    resource_size_t min;
    resource_size_t max;
    resource_size_t align;
    resource_alignf alignf;
    void *alignf_data;
};

struct resource_entry {
    struct list_head node;
    struct resource *res;
    resource_size_t offset;
    struct resource __res;
};

struct restart_block {
    long unsigned int arch_data;
    long int (*fn)(struct restart_block *);
    union {
        struct {
            u32 *uaddr;
            u32 val;
            u32 flags;
            u32 bitset;
            u64 time;
            u32 *uaddr2;
        } futex;
        struct {
            clockid_t clockid;
            enum timespec_type type;
            union {
                struct __kernel_timespec *rmtp;
                struct old_timespec32 *compat_rmtp;
            };
            u64 expires;
        } nanosleep;
        struct {
            struct pollfd *ufds;
            int nfds;
            int has_timeout;
            long unsigned int tv_sec;
            long unsigned int tv_nsec;
        } poll;
    };
};

struct resv_map {
    struct kref refs;
    spinlock_t lock;
    struct list_head regions;
    long int adds_in_progress;
    struct list_head region_cache;
    long int region_cache_count;
    struct rw_semaphore rw_sema;
    struct page_counter *reservation_counter;
    long unsigned int pages_per_hpage;
    struct cgroup_subsys_state *css;
};

struct return_address_data {
    unsigned int level;
    void *addr;
};

struct return_consumer {
    __u64 cookie;
    __u64 id;
};

struct return_instance {
    struct hprobe hprobe;
    long unsigned int func;
    long unsigned int stack;
    long unsigned int orig_ret_vaddr;
    bool chained;
    int cons_cnt;
    struct return_instance *next;
    struct callback_head rcu;
    struct return_consumer consumer;
    struct return_consumer *extra_consumers;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
};

struct reuseport_array {
    struct bpf_map map;
    struct sock *ptrs[0];
};

struct rgb {
    u8 r;
    u8 g;
    u8 b;
};

struct rhash_lock_head {};

struct rhashtable_compare_arg {
    struct rhashtable *ht;
    const void *key;
};

struct ring_buffer_event {
    u32 type_len: 5;
    u32 time_delta: 27;
    u32 array[0];
};

struct ring_buffer_per_cpu;

struct ring_buffer_iter {
    struct ring_buffer_per_cpu *cpu_buffer;
    long unsigned int head;
    long unsigned int next_event;
    struct buffer_page *head_page;
    struct buffer_page *cache_reader_page;
    long unsigned int cache_read;
    long unsigned int cache_pages_removed;
    u64 read_stamp;
    u64 page_stamp;
    struct ring_buffer_event *event;
    size_t event_size;
    int missed_events;
};

struct ring_buffer_meta {
    int magic;
    int struct_size;
    long unsigned int text_addr;
    long unsigned int data_addr;
    long unsigned int first_buffer;
    long unsigned int head_buffer;
    long unsigned int commit_buffer;
    __u32 subbuf_size;
    __u32 nr_subbufs;
    int buffers[0];
};

struct trace_buffer_meta;

struct ring_buffer_per_cpu {
    int cpu;
    atomic_t record_disabled;
    atomic_t resize_disabled;
    struct trace_buffer *buffer;
    raw_spinlock_t reader_lock;
    arch_spinlock_t lock;
    struct lock_class_key lock_key;
    struct buffer_data_page *free_page;
    long unsigned int nr_pages;
    unsigned int current_context;
    struct list_head *pages;
    long unsigned int cnt;
    struct buffer_page *head_page;
    struct buffer_page *tail_page;
    struct buffer_page *commit_page;
    struct buffer_page *reader_page;
    long unsigned int lost_events;
    long unsigned int last_overrun;
    long unsigned int nest;
    local_t entries_bytes;
    local_t entries;
    local_t overrun;
    local_t commit_overrun;
    local_t dropped_events;
    local_t committing;
    local_t commits;
    local_t pages_touched;
    local_t pages_lost;
    local_t pages_read;
    long int last_pages_touch;
    size_t shortest_full;
    long unsigned int read;
    long unsigned int read_bytes;
    rb_time_t write_stamp;
    rb_time_t before_stamp;
    u64 event_stamp[5];
    u64 read_stamp;
    long unsigned int pages_removed;
    unsigned int mapped;
    unsigned int user_mapped;
    struct mutex mapping_lock;
    long unsigned int *subbuf_ids;
    struct trace_buffer_meta *meta_page;
    struct ring_buffer_meta *ring_meta;
    long int nr_pages_to_update;
    struct list_head new_pages;
    struct work_struct update_pages_work;
    struct completion update_done;
    struct rb_irq_work irq_work;
};

struct rings_reply_data {
    struct ethnl_reply_data base;
    struct ethtool_ringparam ringparam;
    struct kernel_ethtool_ringparam kernel_ringparam;
    u32 supported_ring_params;
};

struct rlimit64 {
    __u64 rlim_cur;
    __u64 rlim_max;
};

struct rmap_walk_arg {
    struct folio *folio;
    bool map_unused_to_zeropage;
};

struct rmap_walk_control {
    void *arg;
    bool try_lock;
    bool contended;
    bool (*rmap_one)(struct folio *, struct vm_area_struct *, long unsigned int, void *);
    int (*done)(struct folio *);
    struct anon_vma * (*anon_lock)(const struct folio *, struct rmap_walk_control *);
    bool (*invalid_vma)(struct vm_area_struct *, void *);
};

struct rmem_assigned_device {
    struct device *dev;
    struct reserved_mem *rmem;
    struct list_head list;
};

struct rnd_state {
    __u32 s1;
    __u32 s2;
    __u32 s3;
    __u32 s4;
};

struct rng_alg {
    int (*generate)(struct crypto_rng *, const u8 *, unsigned int, u8 *, unsigned int);
    int (*seed)(struct crypto_rng *, const u8 *, unsigned int);
    void (*set_ent)(struct crypto_rng *, const u8 *, unsigned int);
    unsigned int seedsize;
    struct crypto_alg base;
};

struct robust_list {
    struct robust_list *next;
};

struct robust_list_head {
    struct robust_list list;
    long int futex_offset;
    struct robust_list *list_op_pending;
};

struct role_allow {
    u32 role;
    u32 new_role;
    struct role_allow *next;
};

struct role_datum {
    u32 value;
    u32 bounds;
    struct ebitmap dominates;
    struct ebitmap types;
};

struct role_trans_datum {
    u32 new_role;
};

struct role_trans_key {
    u32 role;
    u32 type;
    u32 tclass;
};

struct root_device {
    struct device dev;
    struct module *owner;
};

struct root_domain {
    atomic_t refcount;
    atomic_t rto_count;
    struct callback_head rcu;
    cpumask_var_t span;
    cpumask_var_t online;
    bool overloaded;
    bool overutilized;
    cpumask_var_t dlo_mask;
    atomic_t dlo_count;
    struct dl_bw dl_bw;
    struct cpudl cpudl;
    u64 visit_cookie;
    struct irq_work rto_push_work;
    raw_spinlock_t rto_lock;
    int rto_loop;
    int rto_cpu;
    atomic_t rto_loop_next;
    atomic_t rto_loop_start;
    cpumask_var_t rto_mask;
    struct cpupri cpupri;
    struct perf_domain *pd;
};

struct route_info {
    __u8 type;
    __u8 length;
    __u8 prefix_len;
    __u8 reserved_l: 3;
    __u8 route_pref: 2;
    __u8 reserved_h: 3;
    __be32 lifetime;
    __u8 prefix[0];
};

struct rp1_clk_change {
    struct clk_hw *hw;
    long unsigned int new_rate;
};

struct rp1_clockman;

struct rp1_clk_desc {
    struct clk_hw * (*clk_register)(struct rp1_clockman *, const void *);
    const void *data;
};

struct rp1_clock_data;

struct rp1_clock {
    struct clk_hw hw;
    struct rp1_clockman *clockman;
    const struct rp1_clock_data *data;
    long unsigned int cached_rate;
};

struct rp1_clock_data {
    const char *name;
    const char * const parents[16];
    int num_std_parents;
    int num_aux_parents;
    long unsigned int flags;
    u32 oe_mask;
    u32 clk_src_mask;
    u32 ctrl_reg;
    u32 div_int_reg;
    u32 div_frac_reg;
    u32 sel_reg;
    u32 div_int_max;
    long unsigned int max_freq;
    u32 fc0_src;
};

struct rp1_clockman {
    struct device *dev;
    void *regs;
    spinlock_t regs_lock;
    struct clk_hw_onecell_data onecell;
};

struct rp1_dev {
    struct pci_dev *pdev;
    struct device *dev;
    resource_size_t bar_start;
    resource_size_t bar_end;
    struct clk *sys_clk;
    struct irq_domain *domain;
    struct irq_data *pcie_irqds[64];
    void *msix_cfg_regs;
};

struct rp1_iobank_desc {
    int min_gpio;
    int num_gpios;
    int gpio_offset;
    int inte_offset;
    int ints_offset;
    int rio_offset;
    int pads_offset;
};

struct rp1_pin_funcs {
    u8 funcs[9];
};

struct rp1_pin_info {
    u8 num;
    u8 bank;
    u8 offset;
    u8 fsel;
    u8 irq_type;
    void *gpio;
    void *rio;
    void *inte;
    void *ints;
    void *pad;
    void *dummy;
};

struct rp1_pinctrl {
    struct device *dev;
    void *gpio_base;
    void *rio_base;
    void *pads_base;
    void *dummy_base;
    int irq[3];
    struct rp1_pin_info pins[54];
    struct pinctrl_dev *pctl_dev;
    struct gpio_chip gpio_chip;
    struct pinctrl_gpio_range gpio_range;
    raw_spinlock_t irq_lock[3];
};

struct rp1_pll_data;

struct rp1_pll {
    struct clk_hw hw;
    struct clk_divider div;
    struct rp1_clockman *clockman;
    const struct rp1_pll_data *data;
    long unsigned int cached_rate;
};

struct rp1_pll_core_data;

struct rp1_pll_core {
    struct clk_hw hw;
    struct rp1_clockman *clockman;
    const struct rp1_pll_core_data *data;
    long unsigned int cached_rate;
};

struct rp1_pll_core_data {
    const char *name;
    u32 cs_reg;
    u32 pwr_reg;
    u32 fbdiv_int_reg;
    u32 fbdiv_frac_reg;
    long unsigned int flags;
    u32 fc0_src;
};

struct rp1_pll_data {
    const char *name;
    const char *source_pll;
    u32 ctrl_reg;
    long unsigned int flags;
    u32 fc0_src;
};

struct rp1_pll_ph_data;

struct rp1_pll_ph {
    struct clk_hw hw;
    struct rp1_clockman *clockman;
    const struct rp1_pll_ph_data *data;
};

struct rp1_pll_ph_data {
    const char *name;
    const char *source_pll;
    unsigned int phase;
    unsigned int fixed_divider;
    u32 ph_reg;
    long unsigned int flags;
    u32 fc0_src;
};

struct rp1_sdio_clkgen {
    struct device *dev;
    struct clk *src_clk;
    struct clk *base_clk;
    struct clk_hw hw;
    void *regs;
    u32 local_base;
};

struct rp1_varsrc {
    struct clk_hw hw;
    struct rp1_clockman *clockman;
    long unsigned int rate;
};

struct rpc_cred_cache;

struct rpc_authops;

struct rpc_auth {
    unsigned int au_cslack;
    unsigned int au_rslack;
    unsigned int au_verfsize;
    unsigned int au_ralign;
    long unsigned int au_flags;
    const struct rpc_authops *au_ops;
    rpc_authflavor_t au_flavor;
    refcount_t au_count;
    struct rpc_cred_cache *au_credcache;
};

struct rpc_auth_create_args {
    rpc_authflavor_t pseudoflavor;
    const char *target_name;
};

struct rpcsec_gss_info;

struct rpc_authops {
    struct module *owner;
    rpc_authflavor_t au_flavor;
    char *au_name;
    struct rpc_auth * (*create)(const struct rpc_auth_create_args *, struct rpc_clnt *);
    void (*destroy)(struct rpc_auth *);
    int (*hash_cred)(struct auth_cred *, unsigned int);
    struct rpc_cred * (*lookup_cred)(struct rpc_auth *, struct auth_cred *, int);
    struct rpc_cred * (*crcreate)(struct rpc_auth *, struct auth_cred *, int, gfp_t);
    rpc_authflavor_t (*info2flavor)(struct rpcsec_gss_info *);
    int (*flavor2info)(rpc_authflavor_t, struct rpcsec_gss_info *);
    int (*key_timeout)(struct rpc_auth *, struct rpc_cred *);
    int (*ping)(struct rpc_clnt *);
};

struct rpc_call_ops {
    void (*rpc_call_prepare)(struct rpc_task *, void *);
    void (*rpc_call_done)(struct rpc_task *, void *);
    void (*rpc_count_stats)(struct rpc_task *, void *);
    void (*rpc_release)(void *);
};

struct rpc_iostats;

struct rpc_pipe_dir_head {
    struct list_head pdh_entries;
    struct dentry *pdh_dentry;
};

struct rpc_rtt {
    long unsigned int timeo;
    long unsigned int srtt[5];
    long unsigned int sdrtt[5];
    int ntimeouts[5];
};

struct rpc_timeout {
    long unsigned int to_initval;
    long unsigned int to_maxval;
    long unsigned int to_increment;
    unsigned int to_retries;
    unsigned char to_exponential;
};

struct rpc_xprt_switch;

struct rpc_xprt_iter_ops;

struct rpc_xprt_iter {
    struct rpc_xprt_switch *xpi_xpswitch;
    struct rpc_xprt *xpi_cursor;
    const struct rpc_xprt_iter_ops *xpi_ops;
};

struct rpc_stat;

struct rpc_program;

struct rpc_sysfs_client;

struct rpc_clnt {
    refcount_t cl_count;
    unsigned int cl_clid;
    struct list_head cl_clients;
    struct list_head cl_tasks;
    atomic_t cl_pid;
    spinlock_t cl_lock;
    struct rpc_xprt *cl_xprt;
    const struct rpc_procinfo *cl_procinfo;
    u32 cl_prog;
    u32 cl_vers;
    u32 cl_maxproc;
    struct rpc_auth *cl_auth;
    struct rpc_stat *cl_stats;
    struct rpc_iostats *cl_metrics;
    unsigned int cl_softrtry: 1;
    unsigned int cl_softerr: 1;
    unsigned int cl_discrtry: 1;
    unsigned int cl_noretranstimeo: 1;
    unsigned int cl_autobind: 1;
    unsigned int cl_chatty: 1;
    unsigned int cl_shutdown: 1;
    struct xprtsec_parms cl_xprtsec;
    struct rpc_rtt *cl_rtt;
    const struct rpc_timeout *cl_timeout;
    atomic_t cl_swapper;
    int cl_nodelen;
    char cl_nodename[65];
    struct rpc_pipe_dir_head cl_pipedir_objects;
    struct rpc_clnt *cl_parent;
    struct rpc_rtt cl_rtt_default;
    struct rpc_timeout cl_timeout_default;
    const struct rpc_program *cl_program;
    const char *cl_principal;
    struct dentry *cl_debugfs;
    struct rpc_sysfs_client *cl_sysfs;
    union {
        struct rpc_xprt_iter cl_xpi;
        struct work_struct cl_work;
    };
    const struct cred *cl_cred;
    unsigned int cl_max_connect;
    struct super_block *pipefs_sb;
    atomic_t cl_task_count;
};

struct rpc_credops;

struct rpc_cred {
    struct hlist_node cr_hash;
    struct list_head cr_lru;
    struct callback_head cr_rcu;
    struct rpc_auth *cr_auth;
    const struct rpc_credops *cr_ops;
    long unsigned int cr_expire;
    long unsigned int cr_flags;
    refcount_t cr_count;
    const struct cred *cr_cred;
};

struct rpc_credops {
    const char *cr_name;
    int (*cr_init)(struct rpc_auth *, struct rpc_cred *);
    void (*crdestroy)(struct rpc_cred *);
    int (*crmatch)(struct auth_cred *, struct rpc_cred *, int);
    int (*crmarshal)(struct rpc_task *, struct xdr_stream *);
    int (*crrefresh)(struct rpc_task *);
    int (*crvalidate)(struct rpc_task *, struct xdr_stream *);
    int (*crwrap_req)(struct rpc_task *, struct xdr_stream *);
    int (*crunwrap_resp)(struct rpc_task *, struct xdr_stream *);
    int (*crkey_timeout)(struct rpc_cred *);
    char * (*crstringify_acceptor)(struct rpc_cred *);
    bool (*crneed_reencode)(struct rpc_task *);
};

typedef void (*kxdreproc_t)(struct rpc_rqst *, struct xdr_stream *, const void *);

typedef int (*kxdrdproc_t)(struct rpc_rqst *, struct xdr_stream *, void *);

struct rpc_procinfo {
    u32 p_proc;
    kxdreproc_t p_encode;
    kxdrdproc_t p_decode;
    unsigned int p_arglen;
    unsigned int p_replen;
    unsigned int p_timer;
    u32 p_statidx;
    const char *p_name;
};

struct rpc_version;

struct rpc_program {
    const char *name;
    u32 number;
    unsigned int nrvers;
    const struct rpc_version **version;
    struct rpc_stat *stats;
    const char *pipe_dir_name;
};

struct xdr_buf {
    struct kvec head[1];
    struct kvec tail[1];
    struct bio_vec *bvec;
    struct page **pages;
    unsigned int page_base;
    unsigned int page_len;
    unsigned int flags;
    unsigned int buflen;
    unsigned int len;
};

struct rpc_rqst {
    struct rpc_xprt *rq_xprt;
    struct xdr_buf rq_snd_buf;
    struct xdr_buf rq_rcv_buf;
    struct rpc_task *rq_task;
    struct rpc_cred *rq_cred;
    __be32 rq_xid;
    int rq_cong;
    u32 rq_seqno;
    int rq_enc_pages_num;
    struct page **rq_enc_pages;
    void (*rq_release_snd_buf)(struct rpc_rqst *);
    union {
        struct list_head rq_list;
        struct rb_node rq_recv;
    };
    struct list_head rq_xmit;
    struct list_head rq_xmit2;
    void *rq_buffer;
    size_t rq_callsize;
    void *rq_rbuffer;
    size_t rq_rcvsize;
    size_t rq_xmit_bytes_sent;
    size_t rq_reply_bytes_recvd;
    struct xdr_buf rq_private_buf;
    long unsigned int rq_majortimeo;
    long unsigned int rq_minortimeo;
    long unsigned int rq_timeout;
    ktime_t rq_rtt;
    unsigned int rq_retries;
    unsigned int rq_connect_cookie;
    atomic_t rq_pin;
    u32 rq_bytes_sent;
    ktime_t rq_xtime;
    int rq_ntrans;
    struct lwq_node rq_bc_list;
    long unsigned int rq_bc_pa_state;
    struct list_head rq_bc_pa_list;
};

struct rpc_stat {
    const struct rpc_program *program;
    unsigned int netcnt;
    unsigned int netudpcnt;
    unsigned int nettcpcnt;
    unsigned int nettcpconn;
    unsigned int netreconn;
    unsigned int rpccnt;
    unsigned int rpcretrans;
    unsigned int rpcauthrefresh;
    unsigned int rpcgarbage;
};

struct rpc_sysfs_client {
    struct kobject kobject;
    struct net *net;
    struct rpc_clnt *clnt;
    struct rpc_xprt_switch *xprt_switch;
};

struct rpc_version {
    u32 number;
    unsigned int nrprocs;
    const struct rpc_procinfo *procs;
    unsigned int *counts;
};

struct svc_xprt;

struct rpc_sysfs_xprt;

struct rpc_xprt_ops;

struct svc_serv;

struct xprt_class;

struct rpc_xprt {
    struct kref kref;
    const struct rpc_xprt_ops *ops;
    unsigned int id;
    const struct rpc_timeout *timeout;
    struct __kernel_sockaddr_storage addr;
    size_t addrlen;
    int prot;
    long unsigned int cong;
    long unsigned int cwnd;
    size_t max_payload;
    struct rpc_wait_queue binding;
    struct rpc_wait_queue sending;
    struct rpc_wait_queue pending;
    struct rpc_wait_queue backlog;
    struct list_head free;
    unsigned int max_reqs;
    unsigned int min_reqs;
    unsigned int num_reqs;
    long unsigned int state;
    unsigned char resvport: 1;
    unsigned char reuseport: 1;
    atomic_t swapper;
    unsigned int bind_index;
    struct list_head xprt_switch;
    long unsigned int bind_timeout;
    long unsigned int reestablish_timeout;
    struct xprtsec_parms xprtsec;
    unsigned int connect_cookie;
    struct work_struct task_cleanup;
    struct timer_list timer;
    long unsigned int last_used;
    long unsigned int idle_timeout;
    long unsigned int connect_timeout;
    long unsigned int max_reconnect_timeout;
    atomic_long_t queuelen;
    spinlock_t transport_lock;
    spinlock_t reserve_lock;
    spinlock_t queue_lock;
    u32 xid;
    struct rpc_task *snd_task;
    struct list_head xmit_queue;
    atomic_long_t xmit_queuelen;
    struct svc_xprt *bc_xprt;
    struct svc_serv *bc_serv;
    unsigned int bc_alloc_max;
    unsigned int bc_alloc_count;
    atomic_t bc_slot_count;
    spinlock_t bc_pa_lock;
    struct list_head bc_pa_list;
    struct rb_root recv_queue;
    struct {
        long unsigned int bind_count;
        long unsigned int connect_count;
        long unsigned int connect_start;
        long unsigned int connect_time;
        long unsigned int sends;
        long unsigned int recvs;
        long unsigned int bad_xids;
        long unsigned int max_slots;
        long long unsigned int req_u;
        long long unsigned int bklog_u;
        long long unsigned int sending_u;
        long long unsigned int pending_u;
    } stat;
    struct net *xprt_net;
    netns_tracker ns_tracker;
    const char *servername;
    const char *address_strings[6];
    struct dentry *debugfs;
    struct callback_head rcu;
    const struct xprt_class *xprt_class;
    struct rpc_sysfs_xprt *xprt_sysfs;
    bool main;
};

struct rpc_xprt_iter_ops {
    void (*xpi_rewind)(struct rpc_xprt_iter *);
    struct rpc_xprt * (*xpi_xprt)(struct rpc_xprt_iter *);
    struct rpc_xprt * (*xpi_next)(struct rpc_xprt_iter *);
};

struct rpc_xprt_ops {
    void (*set_buffer_size)(struct rpc_xprt *, size_t, size_t);
    int (*reserve_xprt)(struct rpc_xprt *, struct rpc_task *);
    void (*release_xprt)(struct rpc_xprt *, struct rpc_task *);
    void (*alloc_slot)(struct rpc_xprt *, struct rpc_task *);
    void (*free_slot)(struct rpc_xprt *, struct rpc_rqst *);
    void (*rpcbind)(struct rpc_task *);
    void (*set_port)(struct rpc_xprt *, short unsigned int);
    void (*connect)(struct rpc_xprt *, struct rpc_task *);
    int (*get_srcaddr)(struct rpc_xprt *, char *, size_t);
    short unsigned int (*get_srcport)(struct rpc_xprt *);
    int (*buf_alloc)(struct rpc_task *);
    void (*buf_free)(struct rpc_task *);
    int (*prepare_request)(struct rpc_rqst *, struct xdr_buf *);
    int (*send_request)(struct rpc_rqst *);
    void (*abort_send_request)(struct rpc_rqst *);
    void (*wait_for_reply_request)(struct rpc_task *);
    void (*timer)(struct rpc_xprt *, struct rpc_task *);
    void (*release_request)(struct rpc_task *);
    void (*close)(struct rpc_xprt *);
    void (*destroy)(struct rpc_xprt *);
    void (*set_connect_timeout)(struct rpc_xprt *, long unsigned int, long unsigned int);
    void (*print_stats)(struct rpc_xprt *, struct seq_file *);
    int (*enable_swap)(struct rpc_xprt *);
    void (*disable_swap)(struct rpc_xprt *);
    void (*inject_disconnect)(struct rpc_xprt *);
    int (*bc_setup)(struct rpc_xprt *, unsigned int);
    size_t (*bc_maxpayload)(struct rpc_xprt *);
    unsigned int (*bc_num_slots)(struct rpc_xprt *);
    void (*bc_free_rqst)(struct rpc_rqst *);
    void (*bc_destroy)(struct rpc_xprt *, unsigned int);
};

struct rpc_sysfs_xprt_switch;

struct rpc_xprt_switch {
    spinlock_t xps_lock;
    struct kref xps_kref;
    unsigned int xps_id;
    unsigned int xps_nxprts;
    unsigned int xps_nactive;
    unsigned int xps_nunique_destaddr_xprts;
    atomic_long_t xps_queuelen;
    struct list_head xps_xprt_list;
    struct net *xps_net;
    const struct rpc_xprt_iter_ops *xps_iter_ops;
    struct rpc_sysfs_xprt_switch *xps_sysfs;
    struct callback_head xps_rcu;
};

struct rpcsec_gss_info {
    struct rpcsec_gss_oid oid;
    u32 qop;
    u32 service;
};

struct rpi_exp_gpio {
    struct gpio_chip gc;
    struct rpi_firmware *fw;
};

struct rpi_firmware {
    struct mbox_client cl;
    struct mbox_chan *chan;
    struct completion c;
    u32 enabled;
    struct kref consumers;
    u32 get_throttled;
};

struct rpi_firmware_clk_rate_request {
    __le32 id;
    __le32 rate;
};

struct rpi_firmware_get_clocks_response {
    u32 parent;
    u32 id;
};

struct rpi_firmware_property_tag_header {
    u32 tag;
    u32 buf_size;
    u32 req_resp_size;
};

struct rpi_otp_priv {
    struct rpi_firmware *fw;
    u32 block;
};

struct rpi_power_domain {
    u32 domain;
    bool enabled;
    bool old_interface;
    struct generic_pm_domain base;
    struct rpi_firmware *fw;
};

struct rpi_power_domain_packet {
    u32 domain;
    u32 state;
};

struct rpi_power_domains {
    bool has_new_interface;
    struct genpd_onecell_data xlate;
    struct rpi_firmware *fw;
    struct rpi_power_domain domains[23];
};

struct rpi_reset {
    struct reset_controller_dev rcdev;
    struct rpi_firmware *fw;
};

struct rps_dev_flow {
    u16 cpu;
    u16 filter;
    unsigned int last_qtail;
};

struct rps_dev_flow_table {
    unsigned int mask;
    struct callback_head rcu;
    struct rps_dev_flow flows[0];
};

struct rps_map {
    unsigned int len;
    struct callback_head rcu;
    u16 cpus[0];
};

struct rps_sock_flow_table {
    u32 mask;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    u32 ents[0];
};

struct uclamp_bucket {
    long unsigned int value: 11;
    long unsigned int tasks: 53;
};

struct uclamp_rq {
    unsigned int value;
    struct uclamp_bucket bucket[5];
};

struct rt_prio_array {
    long unsigned int bitmap[2];
    struct list_head queue[100];
};

struct rt_rq {
    struct rt_prio_array active;
    unsigned int rt_nr_running;
    unsigned int rr_nr_running;
    struct {
        int curr;
        int next;
    } highest_prio;
    bool overloaded;
    struct plist_head pushable_tasks;
    int rt_queued;
};

struct scx_dispatch_q {
    raw_spinlock_t lock;
    struct list_head list;
    struct rb_root priq;
    u32 nr;
    u32 seq;
    u64 id;
    struct rhash_head hash_node;
    struct llist_node free_node;
    struct callback_head rcu;
};

struct scx_rq {
    struct scx_dispatch_q local_dsq;
    struct list_head runnable_list;
    struct list_head ddsp_deferred_locals;
    long unsigned int ops_qseq;
    u64 extra_enq_flags;
    u32 nr_running;
    u32 cpuperf_target;
    bool cpu_released;
    u32 flags;
    u64 clock;
    cpumask_var_t cpus_to_kick;
    cpumask_var_t cpus_to_kick_if_idle;
    cpumask_var_t cpus_to_preempt;
    cpumask_var_t cpus_to_wait;
    long unsigned int pnt_seq;
    struct balance_callback deferred_bal_cb;
    struct irq_work deferred_irq_work;
    struct irq_work kick_cpus_irq_work;
};

struct sched_dl_entity;

typedef bool (*dl_server_has_tasks_f)(struct sched_dl_entity *);

typedef struct task_struct * (*dl_server_pick_f)(struct sched_dl_entity *);

struct sched_dl_entity {
    struct rb_node rb_node;
    u64 dl_runtime;
    u64 dl_deadline;
    u64 dl_period;
    u64 dl_bw;
    u64 dl_density;
    s64 runtime;
    u64 deadline;
    unsigned int flags;
    unsigned int dl_throttled: 1;
    unsigned int dl_yielded: 1;
    unsigned int dl_non_contending: 1;
    unsigned int dl_overrun: 1;
    unsigned int dl_server: 1;
    unsigned int dl_server_active: 1;
    unsigned int dl_defer: 1;
    unsigned int dl_defer_armed: 1;
    unsigned int dl_defer_running: 1;
    struct hrtimer dl_timer;
    struct hrtimer inactive_timer;
    struct rq *rq;
    dl_server_has_tasks_f server_has_tasks;
    dl_server_pick_f server_pick_task;
    struct sched_dl_entity *pi_se;
};

struct sched_info {
    long unsigned int pcount;
    long long unsigned int run_delay;
    long long unsigned int max_run_delay;
    long long unsigned int min_run_delay;
    long long unsigned int last_arrival;
    long long unsigned int last_queued;
};

struct rq {
    raw_spinlock_t __lock;
    unsigned int nr_running;
    long unsigned int last_blocked_load_update_tick;
    unsigned int has_blocked_load;
    long: 64;
    call_single_data_t nohz_csd;
    unsigned int nohz_tick_stopped;
    atomic_t nohz_flags;
    unsigned int ttwu_pending;
    u64 nr_switches;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    struct uclamp_rq uclamp[2];
    unsigned int uclamp_flags;
    long: 64;
    long: 64;
    long: 64;
    struct cfs_rq cfs;
    struct rt_rq rt;
    struct dl_rq dl;
    struct scx_rq scx;
    struct sched_dl_entity fair_server;
    struct list_head leaf_cfs_rq_list;
    struct list_head *tmp_alone_branch;
    unsigned int nr_uninterruptible;
    union {
        struct task_struct *donor;
        struct task_struct *curr;
    };
    struct sched_dl_entity *dl_server;
    struct task_struct *idle;
    struct task_struct *stop;
    long unsigned int next_balance;
    struct mm_struct *prev_mm;
    unsigned int clock_update_flags;
    u64 clock;
    long: 64;
    long: 64;
    u64 clock_task;
    u64 clock_pelt;
    long unsigned int lost_idle_time;
    u64 clock_pelt_idle;
    u64 clock_idle;
    atomic_t nr_iowait;
    u64 last_seen_need_resched_ns;
    int ticks_without_resched;
    int membarrier_state;
    struct root_domain *rd;
    struct sched_domain *sd;
    long unsigned int cpu_capacity;
    struct balance_callback *balance_callback;
    unsigned char nohz_idle_balance;
    unsigned char idle_balance;
    long unsigned int misfit_task_load;
    int active_balance;
    int push_cpu;
    struct cpu_stop_work active_balance_work;
    int cpu;
    int online;
    struct list_head cfs_tasks;
    struct sched_avg avg_rt;
    struct sched_avg avg_dl;
    struct sched_avg avg_hw;
    u64 idle_stamp;
    u64 avg_idle;
    u64 max_idle_balance_cost;
    u64 prev_steal_time;
    long unsigned int calc_load_update;
    long int calc_load_active;
    long: 64;
    long: 64;
    call_single_data_t hrtick_csd;
    struct hrtimer hrtick_timer;
    ktime_t hrtick_time;
    struct sched_info rq_sched_info;
    long long unsigned int rq_cpu_time;
    unsigned int yld_count;
    unsigned int sched_count;
    unsigned int sched_goidle;
    unsigned int ttwu_count;
    unsigned int ttwu_local;
    struct cpuidle_state *idle_state;
    unsigned int nr_pinned;
    unsigned int push_busy;
    struct cpu_stop_work push_work;
    cpumask_var_t scratch_mask;
    long: 64;
    call_single_data_t cfsb_csd;
    struct list_head cfsb_csd_list;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
};

struct rq_depth {
    unsigned int max_depth;
    int scale_step;
    bool scaled_max;
    unsigned int queue_depth;
    unsigned int default_depth;
};

struct rq_iter_data {
    struct blk_mq_hw_ctx *hctx;
    bool has_rq;
};

struct rq_map_data {
    struct page **pages;
    long unsigned int offset;
    short unsigned int page_order;
    short unsigned int nr_entries;
    bool null_mapped;
    bool from_user;
};

struct rq_qos_ops;

struct rq_qos {
    const struct rq_qos_ops *ops;
    struct gendisk *disk;
    enum rq_qos_id id;
    struct rq_qos *next;
    struct dentry *debugfs_dir;
};

struct rq_qos_ops {
    void (*throttle)(struct rq_qos *, struct bio *);
    void (*track)(struct rq_qos *, struct request *, struct bio *);
    void (*merge)(struct rq_qos *, struct request *, struct bio *);
    void (*issue)(struct rq_qos *, struct request *);
    void (*requeue)(struct rq_qos *, struct request *);
    void (*done)(struct rq_qos *, struct request *);
    void (*done_bio)(struct rq_qos *, struct bio *);
    void (*cleanup)(struct rq_qos *, struct bio *);
    void (*queue_depth_changed)(struct rq_qos *);
    void (*exit)(struct rq_qos *);
    const struct blk_mq_debugfs_attr *debugfs_attrs;
};

struct rq_wait;

typedef bool acquire_inflight_cb_t(struct rq_wait *, void *);

struct rq_qos_wait_data {
    struct wait_queue_entry wq;
    struct task_struct *task;
    struct rq_wait *rqw;
    acquire_inflight_cb_t *cb;
    void *private_data;
    bool got_token;
};

struct rq_wait {
    wait_queue_head_t wait;
    atomic_t inflight;
};

struct rq_wb {
    unsigned int wb_background;
    unsigned int wb_normal;
    short int enable_state;
    unsigned int unknown_cnt;
    u64 win_nsec;
    u64 cur_win_nsec;
    struct blk_stat_callback *cb;
    u64 sync_issue;
    void *sync_cookie;
    long unsigned int last_issue;
    long unsigned int last_comp;
    long unsigned int min_lat_nsec;
    struct rq_qos rqos;
    struct rq_wait rq_wait[3];
    struct rq_depth rq_depth;
};

struct rs_msg {
    struct icmp6hdr icmph;
    __u8 opt[0];
};

struct rsa_key {
    const u8 *n;
    const u8 *e;
    const u8 *d;
    const u8 *p;
    const u8 *q;
    const u8 *dp;
    const u8 *dq;
    const u8 *qinv;
    size_t n_sz;
    size_t e_sz;
    size_t d_sz;
    size_t p_sz;
    size_t q_sz;
    size_t dp_sz;
    size_t dq_sz;
    size_t qinv_sz;
};

struct rsa_mpi_key {
    MPI n;
    MPI e;
    MPI d;
    MPI p;
    MPI q;
    MPI dp;
    MPI dq;
    MPI qinv;
};

struct rsassa_pkcs1_ctx {
    struct crypto_akcipher *child;
    unsigned int key_size;
};

struct rsassa_pkcs1_inst_ctx {
    struct crypto_akcipher_spawn spawn;
    const struct hash_prefix *hash_prefix;
};

struct rseq {
    __u32 cpu_id_start;
    __u32 cpu_id;
    __u64 rseq_cs;
    __u32 flags;
    __u32 node_id;
    __u32 mm_cid;
    char end[0];
};

struct rseq_cs {
    __u32 version;
    __u32 flags;
    __u64 start_ip;
    __u64 post_commit_offset;
    __u64 abort_ip;
};

struct rss_nl_dump_ctx {
    long unsigned int ifindex;
    long unsigned int ctx_idx;
    unsigned int match_ifindex;
    unsigned int start_ctx;
};

struct rss_reply_data {
    struct ethnl_reply_data base;
    bool no_key_fields;
    u32 indir_size;
    u32 hkey_size;
    u32 hfunc;
    u32 input_xfrm;
    u32 *indir_table;
    u8 *hkey;
};

struct rss_req_info {
    struct ethnl_req_info base;
    u32 rss_context;
};

struct rsvd_count {
    int ndelayed;
    bool first_do_lblk_found;
    ext4_lblk_t first_do_lblk;
    ext4_lblk_t last_do_lblk;
    struct extent_status *left_es;
    bool partial;
    ext4_lblk_t lclu;
};

struct rt0_hdr {
    struct ipv6_rt_hdr rt_hdr;
    __u32 reserved;
    struct in6_addr addr[0];
};

struct rt6_exception {
    struct hlist_node hlist;
    struct rt6_info *rt6i;
    long unsigned int stamp;
    struct callback_head rcu;
};

struct rt6_exception_bucket {
    struct hlist_head chain;
    int depth;
};

struct rt6_mtu_change_arg {
    struct net_device *dev;
    unsigned int mtu;
    struct fib6_info *f6i;
};

struct rt6_nh {
    struct fib6_info *fib6_info;
    struct fib6_config r_cfg;
    struct list_head next;
};

struct rt6_rtnl_dump_arg {
    struct sk_buff *skb;
    struct netlink_callback *cb;
    struct net *net;
    struct fib_dump_filter filter;
};

struct rt6_statistics {
    __u32 fib_nodes;
    __u32 fib_route_nodes;
    __u32 fib_rt_entries;
    __u32 fib_rt_cache;
    __u32 fib_discarded_routes;
    atomic_t fib_rt_alloc;
};

struct rt_cache_stat {
    unsigned int in_slow_tot;
    unsigned int in_slow_mc;
    unsigned int in_no_route;
    unsigned int in_brd;
    unsigned int in_martian_dst;
    unsigned int in_martian_src;
    unsigned int out_slow_tot;
    unsigned int out_slow_mc;
};

struct rt_waiter_node {
    struct rb_node entry;
    int prio;
    u64 deadline;
};

struct rt_mutex_waiter {
    struct rt_waiter_node tree;
    struct rt_waiter_node pi_tree;
    struct task_struct *task;
    struct rt_mutex_base *lock;
    unsigned int wake_state;
    struct ww_acquire_ctx *ww_ctx;
};

typedef struct rt_rq *rt_rq_iter_t;

struct sigaltstack {
    void *ss_sp;
    int ss_flags;
    __kernel_size_t ss_size;
};

typedef struct sigaltstack stack_t;

struct sigcontext {
    __u64 fault_address;
    __u64 regs[31];
    __u64 sp;
    __u64 pc;
    __u64 pstate;
    long: 64;
    __u8 __reserved[4096];
};

struct ucontext {
    long unsigned int uc_flags;
    struct ucontext *uc_link;
    stack_t uc_stack;
    sigset_t uc_sigmask;
    __u8 __unused[120];
    long: 64;
    struct sigcontext uc_mcontext;
};

struct rt_sigframe {
    struct siginfo info;
    struct ucontext uc;
};

struct rt_sigframe_user_layout {
    struct rt_sigframe *sigframe;
    struct frame_record *next_frame;
    long unsigned int size;
    long unsigned int limit;
    long unsigned int fpsimd_offset;
    long unsigned int esr_offset;
    long unsigned int gcs_offset;
    long unsigned int sve_offset;
    long unsigned int tpidr2_offset;
    long unsigned int za_offset;
    long unsigned int zt_offset;
    long unsigned int fpmr_offset;
    long unsigned int poe_offset;
    long unsigned int extra_offset;
    long unsigned int end_offset;
};

struct wake_q_node;

struct wake_q_head {
    struct wake_q_node *first;
    struct wake_q_node **lastp;
};

struct rt_wake_q_head {
    struct wake_q_head head;
    struct task_struct *rtlock_task;
};

struct rta_cacheinfo {
    __u32 rta_clntref;
    __u32 rta_lastuse;
    __s32 rta_expires;
    __u32 rta_error;
    __u32 rta_used;
    __u32 rta_id;
    __u32 rta_ts;
    __u32 rta_tsage;
};

struct rta_mfc_stats {
    __u64 mfcs_packets;
    __u64 mfcs_bytes;
    __u64 mfcs_wrong_if;
};

struct rtc_time;

struct rtc_wkalrm;

struct rtc_param;

struct rtc_class_ops {
    int (*ioctl)(struct device *, unsigned int, long unsigned int);
    int (*read_time)(struct device *, struct rtc_time *);
    int (*set_time)(struct device *, struct rtc_time *);
    int (*read_alarm)(struct device *, struct rtc_wkalrm *);
    int (*set_alarm)(struct device *, struct rtc_wkalrm *);
    int (*proc)(struct device *, struct seq_file *);
    int (*alarm_irq_enable)(struct device *, unsigned int);
    int (*read_offset)(struct device *, long int *);
    int (*set_offset)(struct device *, long int);
    int (*param_get)(struct device *, struct rtc_param *);
    int (*param_set)(struct device *, struct rtc_param *);
};

struct rtc_device;

struct rtc_timer {
    struct timerqueue_node node;
    ktime_t period;
    void (*func)(struct rtc_device *);
    struct rtc_device *rtc;
    int enabled;
};

struct rtc_device {
    struct device dev;
    struct module *owner;
    int id;
    const struct rtc_class_ops *ops;
    struct mutex ops_lock;
    struct cdev char_dev;
    long unsigned int flags;
    long unsigned int irq_data;
    spinlock_t irq_lock;
    wait_queue_head_t irq_queue;
    struct fasync_struct *async_queue;
    int irq_freq;
    int max_user_freq;
    struct timerqueue_head timerqueue;
    struct rtc_timer aie_timer;
    struct rtc_timer uie_rtctimer;
    struct hrtimer pie_timer;
    int pie_enabled;
    struct work_struct irqwork;
    long unsigned int set_offset_nsec;
    long unsigned int features[1];
    time64_t range_min;
    timeu64_t range_max;
    timeu64_t alarm_offset_max;
    time64_t start_secs;
    time64_t offset_secs;
    bool set_start_time;
};

struct rtc_param {
    __u64 param;
    union {
        __u64 uvalue;
        __s64 svalue;
        __u64 ptr;
    };
    __u32 index;
    __u32 __pad;
};

struct rtc_time {
    int tm_sec;
    int tm_min;
    int tm_hour;
    int tm_mday;
    int tm_mon;
    int tm_year;
    int tm_wday;
    int tm_yday;
    int tm_isdst;
};

struct rtc_wkalrm {
    unsigned char enabled;
    unsigned char pending;
    struct rtc_time time;
};

struct rtentry {
    long unsigned int rt_pad1;
    struct sockaddr rt_dst;
    struct sockaddr rt_gateway;
    struct sockaddr rt_genmask;
    short unsigned int rt_flags;
    short int rt_pad2;
    long unsigned int rt_pad3;
    void *rt_pad4;
    short int rt_metric;
    char *rt_dev;
    long unsigned int rt_mtu;
    long unsigned int rt_window;
    short unsigned int rt_irtt;
};

struct rtgenmsg {
    unsigned char rtgen_family;
};

struct rtm_dump_res_bucket_ctx;

struct rtm_dump_nexthop_bucket_data {
    struct rtm_dump_res_bucket_ctx *ctx;
    struct nh_dump_filter filter;
};

struct rtm_dump_nh_ctx {
    u32 idx;
};

struct rtm_dump_res_bucket_ctx {
    struct rtm_dump_nh_ctx nh;
    u16 bucket_index;
};

struct rtmsg {
    unsigned char rtm_family;
    unsigned char rtm_dst_len;
    unsigned char rtm_src_len;
    unsigned char rtm_tos;
    unsigned char rtm_table;
    unsigned char rtm_protocol;
    unsigned char rtm_scope;
    unsigned char rtm_type;
    unsigned int rtm_flags;
};

struct rtnexthop {
    short unsigned int rtnh_len;
    unsigned char rtnh_flags;
    unsigned char rtnh_hops;
    int rtnh_ifindex;
};

struct rtnl_af_ops {
    struct list_head list;
    struct srcu_struct srcu;
    int family;
    int (*fill_link_af)(struct sk_buff *, const struct net_device *, u32);
    size_t (*get_link_af_size)(const struct net_device *, u32);
    int (*validate_link_af)(const struct net_device *, const struct nlattr *, struct netlink_ext_ack *);
    int (*set_link_af)(struct net_device *, const struct nlattr *, struct netlink_ext_ack *);
    int (*fill_stats_af)(struct sk_buff *, const struct net_device *);
    size_t (*get_stats_af_size)(const struct net_device *);
};

typedef int (*rtnl_doit_func)(struct sk_buff *, struct nlmsghdr *, struct netlink_ext_ack *);

typedef int (*rtnl_dumpit_func)(struct sk_buff *, struct netlink_callback *);

struct rtnl_link {
    rtnl_doit_func doit;
    rtnl_dumpit_func dumpit;
    struct module *owner;
    unsigned int flags;
    struct callback_head rcu;
};

struct rtnl_link_ifmap {
    __u64 mem_start;
    __u64 mem_end;
    __u64 base_addr;
    __u16 irq;
    __u8 dma;
    __u8 port;
};

struct rtnl_link_ops {
    struct list_head list;
    struct srcu_struct srcu;
    const char *kind;
    size_t priv_size;
    struct net_device * (*alloc)(struct nlattr **, const char *, unsigned char, unsigned int, unsigned int);
    void (*setup)(struct net_device *);
    bool netns_refund;
    const u16 peer_type;
    unsigned int maxtype;
    const struct nla_policy *policy;
    int (*validate)(struct nlattr **, struct nlattr **, struct netlink_ext_ack *);
    int (*newlink)(struct net *, struct net_device *, struct nlattr **, struct nlattr **, struct netlink_ext_ack *);
    int (*changelink)(struct net_device *, struct nlattr **, struct nlattr **, struct netlink_ext_ack *);
    void (*dellink)(struct net_device *, struct list_head *);
    size_t (*get_size)(const struct net_device *);
    int (*fill_info)(struct sk_buff *, const struct net_device *);
    size_t (*get_xstats_size)(const struct net_device *);
    int (*fill_xstats)(struct sk_buff *, const struct net_device *);
    unsigned int (*get_num_tx_queues)(void);
    unsigned int (*get_num_rx_queues)(void);
    unsigned int slave_maxtype;
    const struct nla_policy *slave_policy;
    int (*slave_changelink)(struct net_device *, struct net_device *, struct nlattr **, struct nlattr **, struct netlink_ext_ack *);
    size_t (*get_slave_size)(const struct net_device *, const struct net_device *);
    int (*fill_slave_info)(struct sk_buff *, const struct net_device *, const struct net_device *);
    struct net * (*get_link_net)(const struct net_device *);
    size_t (*get_linkxstats_size)(const struct net_device *, int);
    int (*fill_linkxstats)(struct sk_buff *, const struct net_device *, int *, int);
};

struct rtnl_link_stats {
    __u32 rx_packets;
    __u32 tx_packets;
    __u32 rx_bytes;
    __u32 tx_bytes;
    __u32 rx_errors;
    __u32 tx_errors;
    __u32 rx_dropped;
    __u32 tx_dropped;
    __u32 multicast;
    __u32 collisions;
    __u32 rx_length_errors;
    __u32 rx_over_errors;
    __u32 rx_crc_errors;
    __u32 rx_frame_errors;
    __u32 rx_fifo_errors;
    __u32 rx_missed_errors;
    __u32 tx_aborted_errors;
    __u32 tx_carrier_errors;
    __u32 tx_fifo_errors;
    __u32 tx_heartbeat_errors;
    __u32 tx_window_errors;
    __u32 rx_compressed;
    __u32 tx_compressed;
    __u32 rx_nohandler;
};

struct rtnl_link_stats64 {
    __u64 rx_packets;
    __u64 tx_packets;
    __u64 rx_bytes;
    __u64 tx_bytes;
    __u64 rx_errors;
    __u64 tx_errors;
    __u64 rx_dropped;
    __u64 tx_dropped;
    __u64 multicast;
    __u64 collisions;
    __u64 rx_length_errors;
    __u64 rx_over_errors;
    __u64 rx_crc_errors;
    __u64 rx_frame_errors;
    __u64 rx_fifo_errors;
    __u64 rx_missed_errors;
    __u64 tx_aborted_errors;
    __u64 tx_carrier_errors;
    __u64 tx_fifo_errors;
    __u64 tx_heartbeat_errors;
    __u64 tx_window_errors;
    __u64 rx_compressed;
    __u64 tx_compressed;
    __u64 rx_nohandler;
    __u64 rx_otherhost_dropped;
};

struct rtnl_mdb_dump_ctx {
    long int idx;
};

struct rtnl_msg_handler {
    struct module *owner;
    int protocol;
    int msgtype;
    rtnl_doit_func doit;
    rtnl_dumpit_func dumpit;
    int flags;
};

struct rtnl_net_dump_cb {
    struct net *tgt_net;
    struct net *ref_net;
    struct sk_buff *skb;
    struct net_fill_args fillargs;
    int idx;
    int s_idx;
};

struct rtnl_nets {
    struct net *net[3];
    unsigned char len;
};

struct rtnl_newlink_tbs {
    struct nlattr *tb[67];
    struct nlattr *linkinfo[6];
    struct nlattr *attr[51];
    struct nlattr *slave_attr[45];
};

struct rtnl_offload_xstats_request_used {
    bool request;
    bool used;
};

struct rtnl_stats_dump_filters {
    u32 mask[6];
};

struct rtvia {
    __kernel_sa_family_t rtvia_family;
    __u8 rtvia_addr[0];
};

struct rusage {
    struct __kernel_old_timeval ru_utime;
    struct __kernel_old_timeval ru_stime;
    __kernel_long_t ru_maxrss;
    __kernel_long_t ru_ixrss;
    __kernel_long_t ru_idrss;
    __kernel_long_t ru_isrss;
    __kernel_long_t ru_minflt;
    __kernel_long_t ru_majflt;
    __kernel_long_t ru_nswap;
    __kernel_long_t ru_inblock;
    __kernel_long_t ru_oublock;
    __kernel_long_t ru_msgsnd;
    __kernel_long_t ru_msgrcv;
    __kernel_long_t ru_nsignals;
    __kernel_long_t ru_nvcsw;
    __kernel_long_t ru_nivcsw;
};

typedef struct rw_semaphore *class_rwsem_read_t;

typedef struct rw_semaphore *class_rwsem_write_t;

struct rwsem_waiter {
    struct list_head list;
    struct task_struct *task;
    enum rwsem_waiter_type type;
    long unsigned int timeout;
    bool handoff_set;
};

struct rx_queue_attribute {
    struct attribute attr;
    ssize_t (*show)(struct netdev_rx_queue *, char *);
    ssize_t (*store)(struct netdev_rx_queue *, const char *, size_t);
};

struct s {
    __be32 conv;
};

struct s1_walk_info {
    u64 baddr;
    enum trans_regime regime;
    unsigned int max_oa_bits;
    unsigned int pgshift;
    unsigned int txsz;
    int sl;
    bool hpd;
    bool e0poe;
    bool poe;
    bool pan;
    bool be;
    bool s2;
};

struct s1_walk_result {
    union {
        struct {
            u64 desc;
            u64 pa;
            s8 level;
            u8 APTable;
            bool UXNTable;
            bool PXNTable;
            bool uwxn;
            bool uov;
            bool ur;
            bool uw;
            bool ux;
            bool pwxn;
            bool pov;
            bool pr;
            bool pw;
            bool px;
        };
        struct {
            u8 fst;
            bool ptw;
            bool s2;
        };
    };
    bool failed;
};

struct s2_walk_info {
    int (*read_desc)(phys_addr_t, u64 *, void *);
    void *data;
    u64 baddr;
    unsigned int max_oa_bits;
    unsigned int pgshift;
    unsigned int sl;
    unsigned int t0sz;
    bool be;
};

struct s3_save {
    u32 command;
    u32 dev_nt;
    u64 dcbaa_ptr;
    u32 config_reg;
};

struct s_data {
    struct sched_domain **sd;
    struct root_domain *rd;
};

struct value_name_pair;

struct sa_name_list {
    int opcode;
    const struct value_name_pair *arr;
    int arr_sz;
};

struct saved_alias {
    struct kmem_cache *s;
    const char *name;
    struct saved_alias *next;
};

struct saved_cmdlines_buffer {
    unsigned int map_pid_to_cmdline[32769];
    unsigned int *map_cmdline_to_pid;
    unsigned int cmdline_num;
    int cmdline_idx;
    char saved_cmdlines[0];
};

struct saved_syn {
    u32 mac_hdrlen;
    u32 network_hdrlen;
    u32 tcp_hdrlen;
    u8 data[0];
};

struct sb_writers {
    short unsigned int frozen;
    int freeze_kcount;
    int freeze_ucount;
    struct percpu_rw_semaphore rw_sem[3];
};

struct sbitmap_word {
    long unsigned int word;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long unsigned int cleared;
    raw_spinlock_t swap_lock;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
};

struct sbq_wait {
    struct sbitmap_queue *sbq;
    struct wait_queue_entry wait;
};

struct sbq_wait_state {
    wait_queue_head_t wait;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
};

struct scale_freq_data {
    enum scale_freq_source source;
    void (*set_freq_scale)(void);
};

struct scan_control {
    long unsigned int nr_to_reclaim;
    nodemask_t *nodemask;
    struct mem_cgroup *target_mem_cgroup;
    long unsigned int anon_cost;
    long unsigned int file_cost;
    int *proactive_swappiness;
    unsigned int may_deactivate: 2;
    unsigned int force_deactivate: 1;
    unsigned int skipped_deactivate: 1;
    unsigned int may_writepage: 1;
    unsigned int may_unmap: 1;
    unsigned int may_swap: 1;
    unsigned int no_cache_trim_mode: 1;
    unsigned int cache_trim_mode_failed: 1;
    unsigned int proactive: 1;
    unsigned int memcg_low_reclaim: 1;
    unsigned int memcg_low_skipped: 1;
    unsigned int memcg_full_walk: 1;
    unsigned int hibernation_mode: 1;
    unsigned int compaction_ready: 1;
    unsigned int cache_trim_mode: 1;
    unsigned int file_is_tiny: 1;
    unsigned int no_demotion: 1;
    s8 order;
    s8 priority;
    s8 reclaim_idx;
    gfp_t gfp_mask;
    long unsigned int nr_scanned;
    long unsigned int nr_reclaimed;
    struct {
        unsigned int dirty;
        unsigned int unqueued_dirty;
        unsigned int congested;
        unsigned int writeback;
        unsigned int immediate;
        unsigned int file_taken;
        unsigned int taken;
    } nr;
    struct reclaim_state reclaim_state;
};

struct scatter_walk {
    struct scatterlist *sg;
    unsigned int offset;
};

struct sch_frag_data {
    long unsigned int dst;
    struct qdisc_skb_cb cb;
    __be16 inner_protocol;
    u16 vlan_tci;
    __be16 vlan_proto;
    unsigned int l2_len;
    u8 l2_data[18];
    int (*xmit)(struct sk_buff *);
};

struct sched_attr {
    __u32 size;
    __u32 sched_policy;
    __u64 sched_flags;
    __s32 sched_nice;
    __u32 sched_priority;
    __u64 sched_runtime;
    __u64 sched_deadline;
    __u64 sched_period;
    __u32 sched_util_min;
    __u32 sched_util_max;
};

struct sched_class {
    int uclamp_enabled;
    void (*enqueue_task)(struct rq *, struct task_struct *, int);
    bool (*dequeue_task)(struct rq *, struct task_struct *, int);
    void (*yield_task)(struct rq *);
    bool (*yield_to_task)(struct rq *, struct task_struct *);
    void (*wakeup_preempt)(struct rq *, struct task_struct *, int);
    int (*balance)(struct rq *, struct task_struct *, struct rq_flags *);
    struct task_struct * (*pick_task)(struct rq *);
    struct task_struct * (*pick_next_task)(struct rq *, struct task_struct *);
    void (*put_prev_task)(struct rq *, struct task_struct *, struct task_struct *);
    void (*set_next_task)(struct rq *, struct task_struct *, bool);
    int (*select_task_rq)(struct task_struct *, int, int);
    void (*migrate_task_rq)(struct task_struct *, int);
    void (*task_woken)(struct rq *, struct task_struct *);
    void (*set_cpus_allowed)(struct task_struct *, struct affinity_context *);
    void (*rq_online)(struct rq *);
    void (*rq_offline)(struct rq *);
    struct rq * (*find_lock_rq)(struct task_struct *, struct rq *);
    void (*task_tick)(struct rq *, struct task_struct *, int);
    void (*task_fork)(struct task_struct *);
    void (*task_dead)(struct task_struct *);
    void (*switching_to)(struct rq *, struct task_struct *);
    void (*switched_from)(struct rq *, struct task_struct *);
    void (*switched_to)(struct rq *, struct task_struct *);
    void (*reweight_task)(struct rq *, struct task_struct *, const struct load_weight *);
    void (*prio_changed)(struct rq *, struct task_struct *, int);
    unsigned int (*get_rr_interval)(struct rq *, struct task_struct *);
    void (*update_curr)(struct rq *);
    void (*task_change_group)(struct task_struct *);
};

struct sched_group;

struct sched_domain_shared;

struct sched_domain {
    struct sched_domain *parent;
    struct sched_domain *child;
    struct sched_group *groups;
    long unsigned int min_interval;
    long unsigned int max_interval;
    unsigned int busy_factor;
    unsigned int imbalance_pct;
    unsigned int cache_nice_tries;
    unsigned int imb_numa_nr;
    int nohz_idle;
    int flags;
    int level;
    long unsigned int last_balance;
    unsigned int balance_interval;
    unsigned int nr_balance_failed;
    u64 max_newidle_lb_cost;
    long unsigned int last_decay_max_lb_cost;
    unsigned int lb_count[3];
    unsigned int lb_failed[3];
    unsigned int lb_balanced[3];
    unsigned int lb_imbalance_load[3];
    unsigned int lb_imbalance_util[3];
    unsigned int lb_imbalance_task[3];
    unsigned int lb_imbalance_misfit[3];
    unsigned int lb_gained[3];
    unsigned int lb_hot_gained[3];
    unsigned int lb_nobusyg[3];
    unsigned int lb_nobusyq[3];
    unsigned int alb_count;
    unsigned int alb_failed;
    unsigned int alb_pushed;
    unsigned int sbe_count;
    unsigned int sbe_balanced;
    unsigned int sbe_pushed;
    unsigned int sbf_count;
    unsigned int sbf_balanced;
    unsigned int sbf_pushed;
    unsigned int ttwu_wake_remote;
    unsigned int ttwu_move_affine;
    unsigned int ttwu_move_balance;
    char *name;
    union {
        void *private;
        struct callback_head rcu;
    };
    struct sched_domain_shared *shared;
    unsigned int span_weight;
    long unsigned int span[0];
};

struct sched_domain_attr {
    int relax_domain_level;
};

struct sched_domain_shared {
    atomic_t ref;
    atomic_t nr_busy_cpus;
    int has_idle_cores;
    int nr_idle_scan;
};

typedef const struct cpumask * (*sched_domain_mask_f)(int);

typedef int (*sched_domain_flags_f)(void);

struct sched_group_capacity;

struct sd_data {
    struct sched_domain **sd;
    struct sched_domain_shared **sds;
    struct sched_group **sg;
    struct sched_group_capacity **sgc;
};

struct sched_domain_topology_level {
    sched_domain_mask_f mask;
    sched_domain_flags_f sd_flags;
    int flags;
    int numa_level;
    struct sd_data data;
    char *name;
};

struct sched_enq_and_set_ctx {
    struct task_struct *p;
    int queue_flags;
    bool queued;
    bool running;
};

struct sched_entity {
    struct load_weight load;
    struct rb_node run_node;
    u64 deadline;
    u64 min_vruntime;
    u64 min_slice;
    struct list_head group_node;
    unsigned char on_rq;
    unsigned char sched_delayed;
    unsigned char rel_deadline;
    unsigned char custom_slice;
    u64 exec_start;
    u64 sum_exec_runtime;
    u64 prev_sum_exec_runtime;
    u64 vruntime;
    s64 vlag;
    u64 slice;
    u64 nr_migrations;
    int depth;
    struct sched_entity *parent;
    struct cfs_rq *cfs_rq;
    struct cfs_rq *my_q;
    long unsigned int runnable_weight;
    long: 64;
    struct sched_avg avg;
};

struct sched_statistics {
    u64 wait_start;
    u64 wait_max;
    u64 wait_count;
    u64 wait_sum;
    u64 iowait_count;
    u64 iowait_sum;
    u64 sleep_start;
    u64 sleep_max;
    s64 sum_sleep_runtime;
    u64 block_start;
    u64 block_max;
    s64 sum_block_runtime;
    s64 exec_max;
    u64 slice_max;
    u64 nr_migrations_cold;
    u64 nr_failed_migrations_affine;
    u64 nr_failed_migrations_running;
    u64 nr_failed_migrations_hot;
    u64 nr_forced_migrations;
    u64 nr_wakeups;
    u64 nr_wakeups_sync;
    u64 nr_wakeups_migrate;
    u64 nr_wakeups_local;
    u64 nr_wakeups_remote;
    u64 nr_wakeups_affine;
    u64 nr_wakeups_affine_attempts;
    u64 nr_wakeups_passive;
    u64 nr_wakeups_idle;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
};

struct sched_entity_stats {
    struct sched_entity se;
    struct sched_statistics stats;
};

struct sched_ext_entity {
    struct scx_dispatch_q *dsq;
    struct scx_dsq_list_node dsq_list;
    struct rb_node dsq_priq;
    u32 dsq_seq;
    u32 dsq_flags;
    u32 flags;
    u32 weight;
    s32 sticky_cpu;
    s32 holding_cpu;
    u32 kf_mask;
    struct task_struct *kf_tasks[2];
    atomic_long_t ops_state;
    struct list_head runnable_node;
    long unsigned int runnable_at;
    u64 ddsp_dsq_id;
    u64 ddsp_enq_flags;
    u64 slice;
    u64 dsq_vtime;
    bool disallow;
    struct cgroup *cgrp_moving_from;
    struct list_head tasks_node;
};

struct sched_group {
    struct sched_group *next;
    atomic_t ref;
    unsigned int group_weight;
    unsigned int cores;
    struct sched_group_capacity *sgc;
    int asym_prefer_cpu;
    int flags;
    long unsigned int cpumask[0];
};

struct sched_group_capacity {
    atomic_t ref;
    long unsigned int capacity;
    long unsigned int min_capacity;
    long unsigned int max_capacity;
    long unsigned int next_update;
    int imbalance;
    int id;
    long unsigned int cpumask[0];
};

struct sched_param {
    int sched_priority;
};

struct sched_rt_entity {
    struct list_head run_list;
    long unsigned int timeout;
    long unsigned int watchdog_stamp;
    unsigned int time_slice;
    short unsigned int on_rq;
    short unsigned int on_list;
    struct sched_rt_entity *back;
};

struct scm_fp_list;

struct scm_cookie {
    struct pid *pid;
    struct scm_fp_list *fp;
    struct scm_creds creds;
    u32 secid;
};

struct unix_edge;

struct scm_fp_list {
    short int count;
    short int count_unix;
    short int max;
    bool inflight;
    bool dead;
    struct list_head vertices;
    struct unix_edge *edges;
    struct user_struct *user;
    struct file *fp[253];
};

struct scm_stat {
    atomic_t nr_fds;
    long unsigned int nr_unix_fds;
};

struct scm_timestamping {
    struct __kernel_old_timespec ts[3];
};

struct scm_timestamping64 {
    struct __kernel_timespec ts[3];
};

struct scm_timestamping_internal {
    struct timespec64 ts[3];
};

struct scm_ts_pktinfo {
    __u32 if_index;
    __u32 pkt_length;
    __u32 reserved[2];
};

struct scomp_alg {
    void * (*alloc_ctx)(struct crypto_scomp *);
    void (*free_ctx)(struct crypto_scomp *, void *);
    int (*compress)(struct crypto_scomp *, const u8 *, unsigned int, u8 *, unsigned int *, void *);
    int (*decompress)(struct crypto_scomp *, const u8 *, unsigned int, u8 *, unsigned int *, void *);
    union {
        struct {
            struct crypto_alg base;
        };
        struct comp_alg_common calg;
    };
};

struct scomp_scratch {
    spinlock_t lock;
    void *src;
    void *dst;
};

struct scratches_to_free {
    struct callback_head rcu;
    unsigned int cnt;
    void *scratches[0];
};

struct screen_info {
    __u8 orig_x;
    __u8 orig_y;
    __u16 ext_mem_k;
    __u16 orig_video_page;
    __u8 orig_video_mode;
    __u8 orig_video_cols;
    __u8 flags;
    __u8 unused2;
    __u16 orig_video_ega_bx;
    __u16 unused3;
    __u8 orig_video_lines;
    __u8 orig_video_isVGA;
    __u16 orig_video_points;
    __u16 lfb_width;
    __u16 lfb_height;
    __u16 lfb_depth;
    __u32 lfb_base;
    __u32 lfb_size;
    __u16 cl_magic;
    __u16 cl_offset;
    __u16 lfb_linelength;
    __u8 red_size;
    __u8 red_pos;
    __u8 green_size;
    __u8 green_pos;
    __u8 blue_size;
    __u8 blue_pos;
    __u8 rsvd_size;
    __u8 rsvd_pos;
    __u16 vesapm_seg;
    __u16 vesapm_off;
    __u16 pages;
    __u16 vesa_attributes;
    __u32 capabilities;
    __u32 ext_lfb_base;
    __u8 _reserved[2];
} __attribute__((packed));

struct scsi_data_buffer {
    struct sg_table table;
    unsigned int length;
};

struct scsi_device;

struct scsi_cmnd {
    struct scsi_device *device;
    struct list_head eh_entry;
    struct delayed_work abort_work;
    struct callback_head rcu;
    int eh_eflags;
    int budget_token;
    long unsigned int jiffies_at_alloc;
    int retries;
    int allowed;
    unsigned char prot_op;
    unsigned char prot_type;
    unsigned char prot_flags;
    enum scsi_cmnd_submitter submitter;
    short unsigned int cmd_len;
    enum dma_data_direction sc_data_direction;
    unsigned char cmnd[32];
    struct scsi_data_buffer sdb;
    struct scsi_data_buffer *prot_sdb;
    unsigned int underflow;
    unsigned int transfersize;
    unsigned int resid_len;
    unsigned int sense_len;
    unsigned char *sense_buffer;
    int flags;
    long unsigned int state;
    unsigned int extra_len;
    unsigned char *host_scribble;
    int result;
};

struct scsi_dev_info_list {
    struct list_head dev_info_list;
    char vendor[8];
    char model[16];
    blist_flags_t flags;
    unsigned int compatible;
};

struct scsi_dev_info_list_table {
    struct list_head node;
    struct list_head scsi_dev_info_list;
    const char *name;
    int key;
};

struct scsi_vpd;

struct scsi_target;

struct scsi_device_handler;

struct scsi_device {
    struct Scsi_Host *host;
    struct request_queue *request_queue;
    struct list_head siblings;
    struct list_head same_target_siblings;
    struct sbitmap budget_map;
    atomic_t device_blocked;
    atomic_t restarts;
    spinlock_t list_lock;
    struct list_head starved_entry;
    short unsigned int queue_depth;
    short unsigned int max_queue_depth;
    short unsigned int last_queue_full_depth;
    short unsigned int last_queue_full_count;
    long unsigned int last_queue_full_time;
    long unsigned int queue_ramp_up_period;
    long unsigned int last_queue_ramp_up;
    unsigned int id;
    unsigned int channel;
    u64 lun;
    unsigned int manufacturer;
    unsigned int sector_size;
    void *hostdata;
    unsigned char type;
    char scsi_level;
    char inq_periph_qual;
    struct mutex inquiry_mutex;
    unsigned char inquiry_len;
    unsigned char *inquiry;
    const char *vendor;
    const char *model;
    const char *rev;
    struct scsi_vpd *vpd_pg0;
    struct scsi_vpd *vpd_pg83;
    struct scsi_vpd *vpd_pg80;
    struct scsi_vpd *vpd_pg89;
    struct scsi_vpd *vpd_pgb0;
    struct scsi_vpd *vpd_pgb1;
    struct scsi_vpd *vpd_pgb2;
    struct scsi_vpd *vpd_pgb7;
    struct scsi_target *sdev_target;
    blist_flags_t sdev_bflags;
    unsigned int eh_timeout;
    unsigned int manage_system_start_stop: 1;
    unsigned int manage_runtime_start_stop: 1;
    unsigned int manage_shutdown: 1;
    unsigned int force_runtime_start_on_system_start: 1;
    unsigned int removable: 1;
    unsigned int changed: 1;
    unsigned int busy: 1;
    unsigned int lockable: 1;
    unsigned int locked: 1;
    unsigned int borken: 1;
    unsigned int disconnect: 1;
    unsigned int soft_reset: 1;
    unsigned int sdtr: 1;
    unsigned int wdtr: 1;
    unsigned int ppr: 1;
    unsigned int tagged_supported: 1;
    unsigned int simple_tags: 1;
    unsigned int was_reset: 1;
    unsigned int expecting_cc_ua: 1;
    unsigned int use_10_for_rw: 1;
    unsigned int use_10_for_ms: 1;
    unsigned int set_dbd_for_ms: 1;
    unsigned int read_before_ms: 1;
    unsigned int no_report_opcodes: 1;
    unsigned int no_write_same: 1;
    unsigned int use_16_for_rw: 1;
    unsigned int use_16_for_sync: 1;
    unsigned int skip_ms_page_8: 1;
    unsigned int skip_ms_page_3f: 1;
    unsigned int skip_vpd_pages: 1;
    unsigned int try_vpd_pages: 1;
    unsigned int use_192_bytes_for_3f: 1;
    unsigned int no_start_on_add: 1;
    unsigned int allow_restart: 1;
    unsigned int start_stop_pwr_cond: 1;
    unsigned int no_uld_attach: 1;
    unsigned int select_no_atn: 1;
    unsigned int fix_capacity: 1;
    unsigned int guess_capacity: 1;
    unsigned int retry_hwerror: 1;
    unsigned int last_sector_bug: 1;
    unsigned int no_read_disc_info: 1;
    unsigned int no_read_capacity_16: 1;
    unsigned int try_rc_10_first: 1;
    unsigned int security_supported: 1;
    unsigned int is_visible: 1;
    unsigned int wce_default_on: 1;
    unsigned int no_dif: 1;
    unsigned int broken_fua: 1;
    unsigned int lun_in_cdb: 1;
    unsigned int unmap_limit_for_ws: 1;
    unsigned int rpm_autosuspend: 1;
    unsigned int ignore_media_change: 1;
    unsigned int silence_suspend: 1;
    unsigned int no_vpd_size: 1;
    unsigned int cdl_supported: 1;
    unsigned int cdl_enable: 1;
    unsigned int queue_stopped;
    bool offline_already;
    atomic_t disk_events_disable_depth;
    long unsigned int supported_events[1];
    long unsigned int pending_events[1];
    struct list_head event_list;
    struct work_struct event_work;
    unsigned int max_device_blocked;
    atomic_t iorequest_cnt;
    atomic_t iodone_cnt;
    atomic_t ioerr_cnt;
    atomic_t iotmo_cnt;
    struct device sdev_gendev;
    struct device sdev_dev;
    struct work_struct requeue_work;
    struct scsi_device_handler *handler;
    void *handler_data;
    size_t dma_drain_len;
    void *dma_drain_buf;
    unsigned int sg_timeout;
    unsigned int sg_reserved_size;
    struct bsg_device *bsg_dev;
    unsigned char access_state;
    struct mutex state_mutex;
    enum scsi_device_state sdev_state;
    struct task_struct *quiesced_by;
    long unsigned int sdev_data[0];
};

typedef void (*activate_complete)(void *, int);

struct scsi_device_handler {
    struct list_head list;
    struct module *module;
    const char *name;
    enum scsi_disposition (*check_sense)(struct scsi_device *, struct scsi_sense_hdr *);
    int (*attach)(struct scsi_device *);
    void (*detach)(struct scsi_device *);
    int (*activate)(struct scsi_device *, activate_complete, void *);
    blk_status_t (*prep_fn)(struct scsi_device *, struct request *);
    int (*set_params)(struct scsi_device *, const char *);
    void (*rescan)(struct scsi_device *);
};

struct scsi_dh_blist {
    const char *vendor;
    const char *model;
    const char *driver;
};

struct zoned_disk_info {
    u32 nr_zones;
    u32 zone_blocks;
};

struct scsi_disk {
    struct scsi_device *device;
    struct device disk_dev;
    struct gendisk *disk;
    struct opal_dev *opal_dev;
    struct zoned_disk_info early_zone_info;
    struct zoned_disk_info zone_info;
    u32 zones_optimal_open;
    u32 zones_optimal_nonseq;
    u32 zones_max_open;
    u32 zone_starting_lba_gran;
    atomic_t openers;
    sector_t capacity;
    int max_retries;
    u32 min_xfer_blocks;
    u32 max_xfer_blocks;
    u32 opt_xfer_blocks;
    u32 max_ws_blocks;
    u32 max_unmap_blocks;
    u32 unmap_granularity;
    u32 unmap_alignment;
    u32 max_atomic;
    u32 atomic_alignment;
    u32 atomic_granularity;
    u32 max_atomic_with_boundary;
    u32 max_atomic_boundary;
    u32 index;
    unsigned int physical_block_size;
    unsigned int max_medium_access_timeouts;
    unsigned int medium_access_timed_out;
    u16 permanent_stream_count;
    u8 media_present;
    u8 write_prot;
    u8 protection_type;
    u8 provisioning_mode;
    u8 zeroing_mode;
    u8 nr_actuators;
    bool suspended;
    unsigned int ATO: 1;
    unsigned int cache_override: 1;
    unsigned int WCE: 1;
    unsigned int RCD: 1;
    unsigned int DPOFUA: 1;
    unsigned int first_scan: 1;
    unsigned int lbpme: 1;
    unsigned int lbprz: 1;
    unsigned int lbpu: 1;
    unsigned int lbpws: 1;
    unsigned int lbpws10: 1;
    unsigned int lbpvpd: 1;
    unsigned int ws10: 1;
    unsigned int ws16: 1;
    unsigned int rc_basis: 2;
    unsigned int zoned: 2;
    unsigned int urswrz: 1;
    unsigned int security: 1;
    unsigned int ignore_medium_access_errors: 1;
    unsigned int rscs: 1;
    unsigned int use_atomic_write_boundary: 1;
};

struct scsi_driver {
    struct device_driver gendrv;
    int (*resume)(struct device *);
    void (*rescan)(struct device *);
    blk_status_t (*init_command)(struct scsi_cmnd *);
    void (*uninit_command)(struct scsi_cmnd *);
    int (*done)(struct scsi_cmnd *);
    int (*eh_action)(struct scsi_cmnd *, int);
    void (*eh_reset)(struct scsi_cmnd *);
};

struct scsi_eh_save {
    int result;
    unsigned int resid_len;
    int eh_eflags;
    enum dma_data_direction data_direction;
    unsigned int underflow;
    unsigned char cmd_len;
    unsigned char prot_op;
    unsigned char cmnd[32];
    struct scsi_data_buffer sdb;
    struct scatterlist sense_sgl;
};

struct scsi_event {
    enum scsi_device_event evt_type;
    struct list_head node;
};

struct scsi_failures;

struct scsi_exec_args {
    unsigned char *sense;
    unsigned int sense_len;
    struct scsi_sense_hdr *sshdr;
    blk_mq_req_flags_t req_flags;
    int scmd_flags;
    int *resid;
    struct scsi_failures *failures;
};

struct scsi_failure {
    int result;
    u8 sense;
    u8 asc;
    u8 ascq;
    s8 allowed;
    s8 retries;
};

struct scsi_failures {
    int total_allowed;
    int total_retries;
    struct scsi_failure *failure_definitions;
};

struct scsi_host_busy_iter_data {
    bool (*fn)(struct scsi_cmnd *, void *);
    void *priv;
};

struct scsi_host_template {
    unsigned int cmd_size;
    int (*queuecommand)(struct Scsi_Host *, struct scsi_cmnd *);
    void (*commit_rqs)(struct Scsi_Host *, u16);
    struct module *module;
    const char *name;
    const char * (*info)(struct Scsi_Host *);
    int (*ioctl)(struct scsi_device *, unsigned int, void *);
    int (*compat_ioctl)(struct scsi_device *, unsigned int, void *);
    int (*init_cmd_priv)(struct Scsi_Host *, struct scsi_cmnd *);
    int (*exit_cmd_priv)(struct Scsi_Host *, struct scsi_cmnd *);
    int (*eh_abort_handler)(struct scsi_cmnd *);
    int (*eh_device_reset_handler)(struct scsi_cmnd *);
    int (*eh_target_reset_handler)(struct scsi_cmnd *);
    int (*eh_bus_reset_handler)(struct scsi_cmnd *);
    int (*eh_host_reset_handler)(struct scsi_cmnd *);
    int (*sdev_init)(struct scsi_device *);
    int (*sdev_configure)(struct scsi_device *, struct queue_limits *);
    void (*sdev_destroy)(struct scsi_device *);
    int (*target_alloc)(struct scsi_target *);
    void (*target_destroy)(struct scsi_target *);
    int (*scan_finished)(struct Scsi_Host *, long unsigned int);
    void (*scan_start)(struct Scsi_Host *);
    int (*change_queue_depth)(struct scsi_device *, int);
    void (*map_queues)(struct Scsi_Host *);
    int (*mq_poll)(struct Scsi_Host *, unsigned int);
    bool (*dma_need_drain)(struct request *);
    int (*bios_param)(struct scsi_device *, struct block_device *, sector_t, int *);
    void (*unlock_native_capacity)(struct scsi_device *);
    int (*show_info)(struct seq_file *, struct Scsi_Host *);
    int (*write_info)(struct Scsi_Host *, char *, int);
    enum scsi_timeout_action (*eh_timed_out)(struct scsi_cmnd *);
    bool (*eh_should_retry_cmd)(struct scsi_cmnd *);
    int (*host_reset)(struct Scsi_Host *, int);
    const char *proc_name;
    int can_queue;
    int this_id;
    short unsigned int sg_tablesize;
    short unsigned int sg_prot_tablesize;
    unsigned int max_sectors;
    unsigned int max_segment_size;
    unsigned int dma_alignment;
    long unsigned int dma_boundary;
    long unsigned int virt_boundary_mask;
    short int cmd_per_lun;
    bool tag_alloc_policy_rr: 1;
    unsigned int track_queue_depth: 1;
    unsigned int supported_mode: 2;
    unsigned int emulated: 1;
    unsigned int skip_settle_delay: 1;
    unsigned int no_write_same: 1;
    unsigned int host_tagset: 1;
    unsigned int queuecommand_may_block: 1;
    unsigned int max_host_blocked;
    const struct attribute_group **shost_groups;
    const struct attribute_group **sdev_groups;
    u64 vendor_id;
};

struct scsi_idlun {
    __u32 dev_id;
    __u32 host_unique_id;
};

struct scsi_io_group_descriptor {
    u8 ic_enable: 1;
    u8 cs_enble: 1;
    u8 st_enble: 1;
    u8 reserved1: 3;
    u8 io_advice_hints_mode: 2;
    u8 reserved2[3];
    u8 lbm_descriptor_type: 4;
    u8 rlbsr: 2;
    u8 reserved3: 1;
    u8 acdlu: 1;
    u8 params[2];
    u8 reserved4;
    u8 reserved5[8];
};

struct scsi_ioctl_command {
    unsigned int inlen;
    unsigned int outlen;
    unsigned char data[0];
};

struct scsi_lun {
    __u8 scsi_lun[8];
};

struct scsi_mode_data {
    __u32 length;
    __u16 block_descriptor_length;
    __u8 medium_type;
    __u8 device_specific;
    __u8 header_length;
    __u8 longlba: 1;
};

struct scsi_nl_hdr {
    __u8 version;
    __u8 transport;
    __u16 magic;
    __u16 msgtype;
    __u16 msglen;
};

struct scsi_proc_entry {
    struct list_head entry;
    const struct scsi_host_template *sht;
    struct proc_dir_entry *proc_dir;
    unsigned int present;
};

struct scsi_sense_hdr {
    u8 response_code;
    u8 sense_key;
    u8 asc;
    u8 ascq;
    u8 byte4;
    u8 byte5;
    u8 byte6;
    u8 additional_length;
};

struct scsi_stream_status {
    u8 reserved1: 7;
    u8 perm: 1;
    u8 reserved2;
    __be16 stream_identifier;
    u8 rel_lifetime: 6;
    u8 reserved3: 2;
    u8 reserved4[3];
};

struct scsi_stream_status_header {
    __be32 len;
    u16 reserved;
    __be16 number_of_open_streams;
    struct {
        struct {} __empty_stream_status;
        struct scsi_stream_status stream_status[0];
    };
};

struct scsi_target {
    struct scsi_device *starget_sdev_user;
    struct list_head siblings;
    struct list_head devices;
    struct device dev;
    struct kref reap_ref;
    unsigned int channel;
    unsigned int id;
    unsigned int create: 1;
    unsigned int single_lun: 1;
    unsigned int pdt_1f_for_no_lun: 1;
    unsigned int no_report_luns: 1;
    unsigned int expecting_lun_change: 1;
    atomic_t target_busy;
    atomic_t target_blocked;
    unsigned int can_queue;
    unsigned int max_target_blocked;
    char scsi_level;
    enum scsi_target_state state;
    void *hostdata;
    long unsigned int starget_data[0];
};

struct transport_container {
    struct attribute_container ac;
    const struct attribute_group *statistics;
};

struct scsi_transport_template {
    struct transport_container host_attrs;
    struct transport_container target_attrs;
    struct transport_container device_attrs;
    int (*user_scan)(struct Scsi_Host *, uint, uint, u64);
    int device_size;
    int device_private_offset;
    int target_size;
    int target_private_offset;
    int host_size;
    unsigned int create_work_queue: 1;
    void (*eh_strategy_handler)(struct Scsi_Host *);
};

struct scsi_varlen_cdb_hdr {
    __u8 opcode;
    __u8 control;
    __u8 misc[5];
    __u8 additional_cdb_length;
    __be16 service_action;
};

struct scsi_vpd {
    struct callback_head rcu;
    int len;
    unsigned char data[0];
};

struct sctp_paramhdr {
    __be16 type;
    __be16 length;
};

struct sctp_adaptation_ind_param {
    struct sctp_paramhdr param_hdr;
    __be32 adaptation_ind;
};

struct sctp_addip_param {
    struct sctp_paramhdr param_hdr;
    __be32 crr_id;
};

struct sctp_addiphdr {
    __be32 serial;
};

union sctp_addr {
    struct sockaddr_in v4;
    struct sockaddr_in6 v6;
    struct sockaddr sa;
};

struct sctp_ipv4addr_param {
    struct sctp_paramhdr param_hdr;
    struct in_addr addr;
};

struct sctp_ipv6addr_param {
    struct sctp_paramhdr param_hdr;
    struct in6_addr addr;
};

union sctp_addr_param {
    struct sctp_paramhdr p;
    struct sctp_ipv4addr_param v4;
    struct sctp_ipv6addr_param v6;
};

struct sctp_transport;

struct sctp_sock;

struct sctp_af {
    int (*sctp_xmit)(struct sk_buff *, struct sctp_transport *);
    int (*setsockopt)(struct sock *, int, int, sockptr_t, unsigned int);
    int (*getsockopt)(struct sock *, int, int, char *, int *);
    void (*get_dst)(struct sctp_transport *, union sctp_addr *, struct flowi *, struct sock *);
    void (*get_saddr)(struct sctp_sock *, struct sctp_transport *, struct flowi *);
    void (*copy_addrlist)(struct list_head *, struct net_device *);
    int (*cmp_addr)(const union sctp_addr *, const union sctp_addr *);
    void (*addr_copy)(union sctp_addr *, union sctp_addr *);
    void (*from_skb)(union sctp_addr *, struct sk_buff *, int);
    void (*from_sk)(union sctp_addr *, struct sock *);
    bool (*from_addr_param)(union sctp_addr *, union sctp_addr_param *, __be16, int);
    int (*to_addr_param)(const union sctp_addr *, union sctp_addr_param *);
    int (*addr_valid)(union sctp_addr *, struct sctp_sock *, const struct sk_buff *);
    enum sctp_scope (*scope)(union sctp_addr *);
    void (*inaddr_any)(union sctp_addr *, __be16);
    int (*is_any)(const union sctp_addr *);
    int (*available)(union sctp_addr *, struct sctp_sock *);
    int (*skb_iif)(const struct sk_buff *);
    int (*skb_sdif)(const struct sk_buff *);
    int (*is_ce)(const struct sk_buff *);
    void (*seq_dump_addr)(struct seq_file *, union sctp_addr *);
    void (*ecn_capable)(struct sock *);
    __u16 net_header_len;
    int sockaddr_len;
    int (*ip_options_len)(struct sock *);
    sa_family_t sa_family;
    struct list_head list;
};

struct sctp_chunk;

struct sctp_inq {
    struct list_head in_chunk_list;
    struct sctp_chunk *in_progress;
    struct work_struct immediate;
};

struct sctp_bind_addr {
    __u16 port;
    struct list_head address_list;
};

struct sctp_ep_common {
    enum sctp_endpoint_type type;
    refcount_t refcnt;
    bool dead;
    struct sock *sk;
    struct net *net;
    struct sctp_inq inqueue;
    struct sctp_bind_addr bind_addr;
};

struct sctp_cookie {
    __u32 my_vtag;
    __u32 peer_vtag;
    __u32 my_ttag;
    __u32 peer_ttag;
    ktime_t expiration;
    __u16 sinit_num_ostreams;
    __u16 sinit_max_instreams;
    __u32 initial_tsn;
    union sctp_addr peer_addr;
    __u16 my_port;
    __u8 prsctp_capable;
    __u8 padding;
    __u32 adaptation_ind;
    __u8 auth_random[36];
    __u8 auth_hmacs[10];
    __u8 auth_chunks[20];
    __u32 raw_addr_list_len;
};

struct sctp_tsnmap {
    long unsigned int *tsn_map;
    __u32 base_tsn;
    __u32 cumulative_tsn_ack_point;
    __u32 max_tsn_seen;
    __u16 len;
    __u16 pending_data;
    __u16 num_dup_tsns;
    __be32 dup_tsns[16];
};

struct sctp_inithdr_host {
    __u32 init_tag;
    __u32 a_rwnd;
    __u16 num_outbound_streams;
    __u16 num_inbound_streams;
    __u32 initial_tsn;
};

struct sctp_stream_out_ext;

struct sctp_stream_out {
    union {
        __u32 mid;
        __u16 ssn;
    };
    __u32 mid_uo;
    struct sctp_stream_out_ext *ext;
    __u8 state;
};

struct sctp_stream_in {
    union {
        __u32 mid;
        __u16 ssn;
    };
    __u32 mid_uo;
    __u32 fsn;
    __u32 fsn_uo;
    char pd_mode;
    char pd_mode_uo;
};

struct sctp_stream_interleave;

struct sctp_stream {
    struct {
        struct __genradix tree;
        struct sctp_stream_out type[0];
    } out;
    struct {
        struct __genradix tree;
        struct sctp_stream_in type[0];
    } in;
    __u16 outcnt;
    __u16 incnt;
    struct sctp_stream_out *out_curr;
    union {
        struct {
            struct list_head prio_list;
        };
        struct {
            struct list_head rr_list;
            struct sctp_stream_out_ext *rr_next;
        };
        struct {
            struct list_head fc_list;
        };
    };
    struct sctp_stream_interleave *si;
};

struct sctp_sched_ops;

struct sctp_association;

struct sctp_outq {
    struct sctp_association *asoc;
    struct list_head out_chunk_list;
    struct sctp_sched_ops *sched;
    unsigned int out_qlen;
    unsigned int error;
    struct list_head control_chunk_list;
    struct list_head sacked;
    struct list_head retransmit;
    struct list_head abandoned;
    __u32 outstanding_bytes;
    char fast_rtx;
    char cork;
};

struct sctp_ulpq {
    char pd_mode;
    struct sctp_association *asoc;
    struct sk_buff_head reasm;
    struct sk_buff_head reasm_uo;
    struct sk_buff_head lobby;
};

struct sctp_priv_assoc_stats {
    struct __kernel_sockaddr_storage obs_rto_ipaddr;
    __u64 max_obs_rto;
    __u64 isacks;
    __u64 osacks;
    __u64 opackets;
    __u64 ipackets;
    __u64 rtxchunks;
    __u64 outofseqtsns;
    __u64 idupchunks;
    __u64 gapcnt;
    __u64 ouodchunks;
    __u64 iuodchunks;
    __u64 oodchunks;
    __u64 iodchunks;
    __u64 octrlchunks;
    __u64 ictrlchunks;
};

struct sctp_endpoint;

struct sctp_random_param;

struct sctp_chunks_param;

struct sctp_hmac_algo_param;

struct sctp_auth_bytes;

struct sctp_shared_key;

struct sctp_association {
    struct sctp_ep_common base;
    struct list_head asocs;
    sctp_assoc_t assoc_id;
    struct sctp_endpoint *ep;
    struct sctp_cookie c;
    struct {
        struct list_head transport_addr_list;
        __u32 rwnd;
        __u16 transport_count;
        __u16 port;
        struct sctp_transport *primary_path;
        union sctp_addr primary_addr;
        struct sctp_transport *active_path;
        struct sctp_transport *retran_path;
        struct sctp_transport *last_sent_to;
        struct sctp_transport *last_data_from;
        struct sctp_tsnmap tsn_map;
        __be16 addip_disabled_mask;
        __u16 ecn_capable: 1;
        __u16 ipv4_address: 1;
        __u16 ipv6_address: 1;
        __u16 asconf_capable: 1;
        __u16 prsctp_capable: 1;
        __u16 reconf_capable: 1;
        __u16 intl_capable: 1;
        __u16 auth_capable: 1;
        __u16 sack_needed: 1;
        __u16 sack_generation: 1;
        __u16 zero_window_announced: 1;
        __u32 sack_cnt;
        __u32 adaptation_ind;
        struct sctp_inithdr_host i;
        void *cookie;
        int cookie_len;
        __u32 addip_serial;
        struct sctp_random_param *peer_random;
        struct sctp_chunks_param *peer_chunks;
        struct sctp_hmac_algo_param *peer_hmacs;
    } peer;
    enum sctp_state state;
    int overall_error_count;
    ktime_t cookie_life;
    long unsigned int rto_initial;
    long unsigned int rto_max;
    long unsigned int rto_min;
    int max_burst;
    int max_retrans;
    __u16 pf_retrans;
    __u16 ps_retrans;
    __u16 max_init_attempts;
    __u16 init_retries;
    long unsigned int max_init_timeo;
    long unsigned int hbinterval;
    long unsigned int probe_interval;
    __be16 encap_port;
    __u16 pathmaxrxt;
    __u32 flowlabel;
    __u8 dscp;
    __u8 pmtu_pending;
    __u32 pathmtu;
    __u32 param_flags;
    __u32 sackfreq;
    long unsigned int sackdelay;
    long unsigned int timeouts[12];
    struct timer_list timers[12];
    struct sctp_transport *shutdown_last_sent_to;
    struct sctp_transport *init_last_sent_to;
    int shutdown_retries;
    __u32 next_tsn;
    __u32 ctsn_ack_point;
    __u32 adv_peer_ack_point;
    __u32 highest_sacked;
    __u32 fast_recovery_exit;
    __u8 fast_recovery;
    __u16 unack_data;
    __u32 rtx_data_chunks;
    __u32 rwnd;
    __u32 a_rwnd;
    __u32 rwnd_over;
    __u32 rwnd_press;
    int sndbuf_used;
    atomic_t rmem_alloc;
    wait_queue_head_t wait;
    __u32 frag_point;
    __u32 user_frag;
    int init_err_counter;
    int init_cycle;
    __u16 default_stream;
    __u16 default_flags;
    __u32 default_ppid;
    __u32 default_context;
    __u32 default_timetolive;
    __u32 default_rcv_context;
    struct sctp_stream stream;
    struct sctp_outq outqueue;
    struct sctp_ulpq ulpq;
    __u32 last_ecne_tsn;
    __u32 last_cwr_tsn;
    int numduptsns;
    struct sctp_chunk *addip_last_asconf;
    struct list_head asconf_ack_list;
    struct list_head addip_chunk_list;
    __u32 addip_serial;
    int src_out_of_asoc_ok;
    union sctp_addr *asconf_addr_del_pending;
    struct sctp_transport *new_transport;
    struct list_head endpoint_shared_keys;
    struct sctp_auth_bytes *asoc_shared_key;
    struct sctp_shared_key *shkey;
    __u16 default_hmac_id;
    __u16 active_key_id;
    __u8 need_ecne: 1;
    __u8 temp: 1;
    __u8 pf_expose: 2;
    __u8 force_delay: 1;
    __u8 strreset_enable;
    __u8 strreset_outstanding;
    __u32 strreset_outseq;
    __u32 strreset_inseq;
    __u32 strreset_result[2];
    struct sctp_chunk *strreset_chunk;
    struct sctp_priv_assoc_stats stats;
    int sent_cnt_removable;
    __u16 subscribe;
    __u64 abandoned_unsent[3];
    __u64 abandoned_sent[3];
    u32 secid;
    u32 peer_secid;
    struct callback_head rcu;
};

struct sctp_assocparams {
    sctp_assoc_t sasoc_assoc_id;
    __u16 sasoc_asocmaxrxt;
    __u16 sasoc_number_peer_destinations;
    __u32 sasoc_peer_rwnd;
    __u32 sasoc_local_rwnd;
    __u32 sasoc_cookie_life;
};

struct sctp_auth_bytes {
    refcount_t refcnt;
    __u32 len;
    __u8 data[0];
};

struct sctp_authhdr {
    __be16 shkey_id;
    __be16 hmac_id;
};

struct sctp_bind_bucket {
    short unsigned int port;
    signed char fastreuse;
    signed char fastreuseport;
    kuid_t fastuid;
    struct hlist_node node;
    struct hlist_head owner;
    struct net *net;
};

struct sctp_cookie_preserve_param;

struct sctp_hostname_param;

struct sctp_cookie_param;

struct sctp_supported_addrs_param;

struct sctp_supported_ext_param;

union sctp_params {
    void *v;
    struct sctp_paramhdr *p;
    struct sctp_cookie_preserve_param *life;
    struct sctp_hostname_param *dns;
    struct sctp_cookie_param *cookie;
    struct sctp_supported_addrs_param *sat;
    struct sctp_ipv4addr_param *v4;
    struct sctp_ipv6addr_param *v6;
    union sctp_addr_param *addr;
    struct sctp_adaptation_ind_param *aind;
    struct sctp_supported_ext_param *ext;
    struct sctp_random_param *random;
    struct sctp_chunks_param *chunks;
    struct sctp_hmac_algo_param *hmac_algo;
    struct sctp_addip_param *addip;
};

struct sctp_sndrcvinfo {
    __u16 sinfo_stream;
    __u16 sinfo_ssn;
    __u16 sinfo_flags;
    __u32 sinfo_ppid;
    __u32 sinfo_context;
    __u32 sinfo_timetolive;
    __u32 sinfo_tsn;
    __u32 sinfo_cumtsn;
    sctp_assoc_t sinfo_assoc_id;
};

struct sctp_datahdr;

struct sctp_inithdr;

struct sctp_sackhdr;

struct sctp_heartbeathdr;

struct sctp_sender_hb_info;

struct sctp_shutdownhdr;

struct sctp_signed_cookie;

struct sctp_ecnehdr;

struct sctp_cwrhdr;

struct sctp_errhdr;

struct sctp_fwdtsn_hdr;

struct sctp_idatahdr;

struct sctp_ifwdtsn_hdr;

struct sctp_chunkhdr;

struct sctphdr;

struct sctp_datamsg;

struct sctp_chunk {
    struct list_head list;
    refcount_t refcnt;
    int sent_count;
    union {
        struct list_head transmitted_list;
        struct list_head stream_list;
    };
    struct list_head frag_list;
    struct sk_buff *skb;
    union {
        struct sk_buff *head_skb;
        struct sctp_shared_key *shkey;
    };
    union sctp_params param_hdr;
    union {
        __u8 *v;
        struct sctp_datahdr *data_hdr;
        struct sctp_inithdr *init_hdr;
        struct sctp_sackhdr *sack_hdr;
        struct sctp_heartbeathdr *hb_hdr;
        struct sctp_sender_hb_info *hbs_hdr;
        struct sctp_shutdownhdr *shutdown_hdr;
        struct sctp_signed_cookie *cookie_hdr;
        struct sctp_ecnehdr *ecne_hdr;
        struct sctp_cwrhdr *ecn_cwr_hdr;
        struct sctp_errhdr *err_hdr;
        struct sctp_addiphdr *addip_hdr;
        struct sctp_fwdtsn_hdr *fwdtsn_hdr;
        struct sctp_authhdr *auth_hdr;
        struct sctp_idatahdr *idata_hdr;
        struct sctp_ifwdtsn_hdr *ifwdtsn_hdr;
    } subh;
    __u8 *chunk_end;
    struct sctp_chunkhdr *chunk_hdr;
    struct sctphdr *sctp_hdr;
    struct sctp_sndrcvinfo sinfo;
    struct sctp_association *asoc;
    struct sctp_ep_common *rcvr;
    long unsigned int sent_at;
    union sctp_addr source;
    union sctp_addr dest;
    struct sctp_datamsg *msg;
    struct sctp_transport *transport;
    struct sk_buff *auth_chunk;
    __u16 rtt_in_progress: 1;
    __u16 has_tsn: 1;
    __u16 has_ssn: 1;
    __u16 singleton: 1;
    __u16 end_of_packet: 1;
    __u16 ecn_ce_done: 1;
    __u16 pdiscard: 1;
    __u16 tsn_gap_acked: 1;
    __u16 data_accepted: 1;
    __u16 auth: 1;
    __u16 has_asconf: 1;
    __u16 pmtu_probe: 1;
    __u16 tsn_missing_report: 2;
    __u16 fast_retransmit: 2;
};

struct sctp_chunkhdr {
    __u8 type;
    __u8 flags;
    __be16 length;
};

struct sctp_chunks_param {
    struct sctp_paramhdr param_hdr;
    __u8 chunks[0];
};

struct sctp_cookie_param {
    struct sctp_paramhdr p;
    __u8 body[0];
};

struct sctp_cookie_preserve_param {
    struct sctp_paramhdr param_hdr;
    __be32 lifespan_increment;
};

struct sctp_cwrhdr {
    __be32 lowest_tsn;
};

struct sctp_datahdr {
    __be32 tsn;
    __be16 stream;
    __be16 ssn;
    __u32 ppid;
};

struct sctp_datamsg {
    struct list_head chunks;
    refcount_t refcnt;
    long unsigned int expires_at;
    int send_error;
    u8 send_failed: 1;
    u8 can_delay: 1;
    u8 abandoned: 1;
};

struct sctp_ecnehdr {
    __be32 lowest_tsn;
};

struct sctp_endpoint {
    struct sctp_ep_common base;
    struct hlist_node node;
    int hashent;
    struct list_head asocs;
    __u8 secret_key[32];
    __u8 *digest;
    __u32 sndbuf_policy;
    __u32 rcvbuf_policy;
    struct crypto_shash **auth_hmacs;
    struct sctp_hmac_algo_param *auth_hmacs_list;
    struct sctp_chunks_param *auth_chunk_list;
    struct list_head endpoint_shared_keys;
    __u16 active_key_id;
    __u8 ecn_enable: 1;
    __u8 auth_enable: 1;
    __u8 intl_enable: 1;
    __u8 prsctp_enable: 1;
    __u8 asconf_enable: 1;
    __u8 reconf_enable: 1;
    __u8 strreset_enable;
    struct callback_head rcu;
};

struct sctp_errhdr {
    __be16 cause;
    __be16 length;
};

struct sctp_fwdtsn_hdr {
    __be32 new_cum_tsn;
};

struct sctp_heartbeathdr {
    struct sctp_paramhdr info;
};

struct sctp_hmac_algo_param {
    struct sctp_paramhdr param_hdr;
    __be16 hmac_ids[0];
};

struct sctp_hostname_param {
    struct sctp_paramhdr param_hdr;
    uint8_t hostname[0];
};

struct sctp_idatahdr {
    __be32 tsn;
    __be16 stream;
    __be16 reserved;
    __be32 mid;
    union {
        __u32 ppid;
        __be32 fsn;
    };
    __u8 payload[0];
};

struct sctp_ifwdtsn_hdr {
    __be32 new_cum_tsn;
};

struct sctp_inithdr {
    __be32 init_tag;
    __be32 a_rwnd;
    __be16 num_outbound_streams;
    __be16 num_inbound_streams;
    __be32 initial_tsn;
};

struct sctp_initmsg {
    __u16 sinit_num_ostreams;
    __u16 sinit_max_instreams;
    __u16 sinit_max_attempts;
    __u16 sinit_max_init_timeo;
};

struct sctp_packet {
    __u16 source_port;
    __u16 destination_port;
    __u32 vtag;
    struct list_head chunk_list;
    size_t overhead;
    size_t size;
    size_t max_size;
    struct sctp_transport *transport;
    struct sctp_chunk *auth;
    u8 has_cookie_echo: 1;
    u8 has_sack: 1;
    u8 has_auth: 1;
    u8 has_data: 1;
    u8 ipfragok: 1;
};

struct sctp_paddrparams {
    sctp_assoc_t spp_assoc_id;
    struct __kernel_sockaddr_storage spp_address;
    __u32 spp_hbinterval;
    __u16 spp_pathmaxrxt;
    __u32 spp_pathmtu;
    __u32 spp_sackdelay;
    __u32 spp_flags;
    __u32 spp_ipv6_flowlabel;
    __u8 spp_dscp;
    int: 0;
} __attribute__((packed));

struct sctp_ulpevent;

struct sctp_pf {
    void (*event_msgname)(struct sctp_ulpevent *, char *, int *);
    void (*skb_msgname)(struct sk_buff *, char *, int *);
    int (*af_supported)(sa_family_t, struct sctp_sock *);
    int (*cmp_addr)(const union sctp_addr *, const union sctp_addr *, struct sctp_sock *);
    int (*bind_verify)(struct sctp_sock *, union sctp_addr *);
    int (*send_verify)(struct sctp_sock *, union sctp_addr *);
    int (*supported_addrs)(const struct sctp_sock *, __be16 *);
    struct sock * (*create_accept_sk)(struct sock *, struct sctp_association *, bool);
    int (*addr_to_user)(struct sctp_sock *, union sctp_addr *);
    void (*to_sk_saddr)(union sctp_addr *, struct sock *);
    void (*to_sk_daddr)(union sctp_addr *, struct sock *);
    void (*copy_ip_options)(struct sock *, struct sock *);
    struct sctp_af *af;
};

struct sctp_random_param {
    struct sctp_paramhdr param_hdr;
    __u8 random_val[0];
};

struct sctp_rtoinfo {
    sctp_assoc_t srto_assoc_id;
    __u32 srto_initial;
    __u32 srto_max;
    __u32 srto_min;
};

struct sctp_sackhdr {
    __be32 cum_tsn_ack;
    __be32 a_rwnd;
    __be16 num_gap_ack_blocks;
    __be16 num_dup_tsns;
};

struct sctp_sender_hb_info {
    struct sctp_paramhdr param_hdr;
    union sctp_addr daddr;
    long unsigned int sent_at;
    __u64 hb_nonce;
    __u32 probe_size;
};

struct sctp_shared_key {
    struct list_head key_list;
    struct sctp_auth_bytes *key;
    refcount_t refcnt;
    __u16 key_id;
    __u8 deactivated;
};

struct sctp_shutdownhdr {
    __be32 cum_tsn_ack;
};

struct sctp_signed_cookie {
    __u8 signature[32];
    __u32 __pad;
    struct sctp_cookie c;
} __attribute__((packed));

struct sctp_sock {
    struct inet_sock inet;
    enum sctp_socket_type type;
    struct sctp_pf *pf;
    struct crypto_shash *hmac;
    char *sctp_hmac_alg;
    struct sctp_endpoint *ep;
    struct sctp_bind_bucket *bind_hash;
    __u16 default_stream;
    __u32 default_ppid;
    __u16 default_flags;
    __u32 default_context;
    __u32 default_timetolive;
    __u32 default_rcv_context;
    int max_burst;
    __u32 hbinterval;
    __u32 probe_interval;
    __be16 udp_port;
    __be16 encap_port;
    __u16 pathmaxrxt;
    __u32 flowlabel;
    __u8 dscp;
    __u16 pf_retrans;
    __u16 ps_retrans;
    __u32 pathmtu;
    __u32 sackdelay;
    __u32 sackfreq;
    __u32 param_flags;
    __u32 default_ss;
    struct sctp_rtoinfo rtoinfo;
    struct sctp_paddrparams paddrparam;
    struct sctp_assocparams assocparams;
    __u16 subscribe;
    struct sctp_initmsg initmsg;
    int user_frag;
    __u32 autoclose;
    __u32 adaptation_ind;
    __u32 pd_point;
    __u16 nodelay: 1;
    __u16 pf_expose: 2;
    __u16 reuse: 1;
    __u16 disable_fragments: 1;
    __u16 v4mapped: 1;
    __u16 frag_interleave: 1;
    __u16 recvrcvinfo: 1;
    __u16 recvnxtinfo: 1;
    __u16 data_ready_signalled: 1;
    atomic_t pd_mode;
    struct sk_buff_head pd_lobby;
    struct list_head auto_asconf_list;
    int do_auto_asconf;
};

struct sctp_stream_interleave {
    __u16 data_chunk_len;
    __u16 ftsn_chunk_len;
    struct sctp_chunk * (*make_datafrag)(const struct sctp_association *, const struct sctp_sndrcvinfo *, int, __u8, gfp_t);
    void (*assign_number)(struct sctp_chunk *);
    bool (*validate_data)(struct sctp_chunk *);
    int (*ulpevent_data)(struct sctp_ulpq *, struct sctp_chunk *, gfp_t);
    int (*enqueue_event)(struct sctp_ulpq *, struct sctp_ulpevent *);
    void (*renege_events)(struct sctp_ulpq *, struct sctp_chunk *, gfp_t);
    void (*start_pd)(struct sctp_ulpq *, gfp_t);
    void (*abort_pd)(struct sctp_ulpq *, gfp_t);
    void (*generate_ftsn)(struct sctp_outq *, __u32);
    bool (*validate_ftsn)(struct sctp_chunk *);
    void (*report_ftsn)(struct sctp_ulpq *, __u32);
    void (*handle_ftsn)(struct sctp_ulpq *, struct sctp_chunk *);
};

struct sctp_stream_priorities;

struct sctp_stream_out_ext {
    __u64 abandoned_unsent[3];
    __u64 abandoned_sent[3];
    struct list_head outq;
    union {
        struct {
            struct list_head prio_list;
            struct sctp_stream_priorities *prio_head;
        };
        struct {
            struct list_head rr_list;
        };
        struct {
            struct list_head fc_list;
            __u32 fc_length;
            __u16 fc_weight;
        };
    };
};

struct sctp_stream_priorities {
    struct list_head prio_sched;
    struct list_head active;
    struct sctp_stream_out_ext *next;
    __u16 prio;
    __u16 users;
};

struct sctp_supported_addrs_param {
    struct sctp_paramhdr param_hdr;
    __be16 types[0];
};

struct sctp_supported_ext_param {
    struct sctp_paramhdr param_hdr;
    __u8 chunks[0];
};

struct sctp_transport {
    struct list_head transports;
    struct rhlist_head node;
    refcount_t refcnt;
    __u32 dead: 1;
    __u32 rto_pending: 1;
    __u32 hb_sent: 1;
    __u32 pmtu_pending: 1;
    __u32 dst_pending_confirm: 1;
    __u32 sack_generation: 1;
    u32 dst_cookie;
    struct flowi fl;
    union sctp_addr ipaddr;
    struct sctp_af *af_specific;
    struct sctp_association *asoc;
    long unsigned int rto;
    __u32 rtt;
    __u32 rttvar;
    __u32 srtt;
    __u32 cwnd;
    __u32 ssthresh;
    __u32 partial_bytes_acked;
    __u32 flight_size;
    __u32 burst_limited;
    struct dst_entry *dst;
    union sctp_addr saddr;
    long unsigned int hbinterval;
    long unsigned int probe_interval;
    long unsigned int sackdelay;
    __u32 sackfreq;
    atomic_t mtu_info;
    ktime_t last_time_heard;
    long unsigned int last_time_sent;
    long unsigned int last_time_ecne_reduced;
    __be16 encap_port;
    __u16 pathmaxrxt;
    __u32 flowlabel;
    __u8 dscp;
    __u16 pf_retrans;
    __u16 ps_retrans;
    __u32 pathmtu;
    __u32 param_flags;
    int init_sent_count;
    int state;
    short unsigned int error_count;
    struct timer_list T3_rtx_timer;
    struct timer_list hb_timer;
    struct timer_list proto_unreach_timer;
    struct timer_list reconf_timer;
    struct timer_list probe_timer;
    struct list_head transmitted;
    struct sctp_packet packet;
    struct list_head send_ready;
    struct {
        __u32 next_tsn_at_change;
        char changeover_active;
        char cycling_changeover;
        char cacc_saw_newack;
    } cacc;
    struct {
        __u16 pmtu;
        __u16 probe_size;
        __u16 probe_high;
        __u8 probe_count;
        __u8 state;
    } pl;
    __u64 hb_nonce;
    struct callback_head rcu;
};

struct sctp_ulpevent {
    struct sctp_association *asoc;
    struct sctp_chunk *chunk;
    unsigned int rmem_len;
    union {
        __u32 mid;
        __u16 ssn;
    };
    union {
        __u32 ppid;
        __u32 fsn;
    };
    __u32 tsn;
    __u32 cumtsn;
    __u16 stream;
    __u16 flags;
    __u16 msg_flags;
} __attribute__((packed));

struct sctphdr {
    __be16 source;
    __be16 dest;
    __be32 vtag;
    __le32 checksum;
};

struct scx_bstr_buf {
    u64 data[12];
    char line[1024];
};

struct scx_cgroup_init_args {
    u32 weight;
};

struct scx_cpu_acquire_args {};

struct scx_cpu_release_args {
    enum scx_cpu_preempt_reason reason;
    struct task_struct *task;
};

struct scx_dsp_buf_ent {
    struct task_struct *task;
    long unsigned int qseq;
    u64 dsq_id;
    u64 enq_flags;
};

struct scx_dsp_ctx {
    struct rq *rq;
    u32 cursor;
    u32 nr_tasks;
    struct scx_dsp_buf_ent buf[0];
};

struct scx_dump_ctx {
    enum scx_exit_kind kind;
    s64 exit_code;
    const char *reason;
    u64 at_ns;
    u64 at_jiffies;
};

struct scx_dump_data {
    s32 cpu;
    bool first;
    s32 cursor;
    struct seq_buf *s;
    const char *prefix;
    struct scx_bstr_buf buf;
};

struct scx_exit_info {
    enum scx_exit_kind kind;
    s64 exit_code;
    const char *reason;
    long unsigned int *bt;
    u32 bt_len;
    char *msg;
    char *dump;
};

struct scx_exit_task_args {
    bool cancelled;
};

struct scx_init_task_args {
    bool fork;
    struct cgroup *cgroup;
};

struct scx_task_iter {
    struct sched_ext_entity cursor;
    struct task_struct *locked;
    struct rq *rq;
    struct rq_flags rf;
    u32 cnt;
};

struct sd_app_op_cond_busy_data {
    struct mmc_host *host;
    u32 ocr;
    struct mmc_command *cmd;
};

struct sd_busy_data {
    struct mmc_card *card;
    u8 *reg_buf;
};

struct sd_flag_debug {
    unsigned int meta_flags;
    char *name;
};

struct sd_flow_limit {
    u64 count;
    unsigned int num_buckets;
    unsigned int history_head;
    u16 history[128];
    u8 buckets[0];
};

struct sg_lb_stats {
    long unsigned int avg_load;
    long unsigned int group_load;
    long unsigned int group_capacity;
    long unsigned int group_util;
    long unsigned int group_runnable;
    unsigned int sum_nr_running;
    unsigned int sum_h_nr_running;
    unsigned int idle_cpus;
    unsigned int group_weight;
    enum group_type group_type;
    unsigned int group_asym_packing;
    unsigned int group_smt_balance;
    long unsigned int group_misfit_task_load;
};

struct sd_lb_stats {
    struct sched_group *busiest;
    struct sched_group *local;
    long unsigned int total_load;
    long unsigned int total_capacity;
    long unsigned int avg_load;
    unsigned int prefer_sibling;
    struct sg_lb_stats busiest_stat;
    struct sg_lb_stats local_stat;
};

struct sd_uhs2_wait_active_state_data {
    struct mmc_host *host;
    struct mmc_command *cmd;
};

struct shash_desc {
    struct crypto_shash *tfm;
    void *__ctx[0];
};

struct sdesc {
    struct shash_desc shash;
    char ctx[0];
};

struct sdhci_adma2_64_desc {
    __le16 cmd;
    __le16 len;
    __le32 addr_lo;
    __le32 addr_hi;
};

struct sdhci_ops;

struct sdhci_host {
    const char *hw_name;
    unsigned int quirks;
    unsigned int quirks2;
    int irq;
    void *ioaddr;
    phys_addr_t mapbase;
    char *bounce_buffer;
    dma_addr_t bounce_addr;
    unsigned int bounce_buffer_size;
    const struct sdhci_ops *ops;
    struct mmc_host *mmc;
    struct mmc_host_ops mmc_host_ops;
    u64 dma_mask;
    struct led_classdev led;
    char led_name[32];
    spinlock_t lock;
    int flags;
    unsigned int version;
    unsigned int max_clk;
    unsigned int timeout_clk;
    u8 max_timeout_count;
    unsigned int clk_mul;
    unsigned int clock;
    u8 pwr;
    u8 drv_type;
    bool reinit_uhs;
    bool runtime_suspended;
    bool bus_on;
    bool preset_enabled;
    bool pending_reset;
    bool irq_wake_enabled;
    bool v4_mode;
    bool use_external_dma;
    bool always_defer_done;
    struct mmc_request *mrqs_done[2];
    struct mmc_command *cmd;
    struct mmc_command *data_cmd;
    struct mmc_command *deferred_cmd;
    struct mmc_data *data;
    unsigned int data_early: 1;
    struct sg_mapping_iter sg_miter;
    unsigned int blocks;
    int sg_count;
    int max_adma;
    void *adma_table;
    void *align_buffer;
    size_t adma_table_sz;
    size_t align_buffer_sz;
    dma_addr_t adma_addr;
    dma_addr_t align_addr;
    unsigned int desc_sz;
    unsigned int alloc_desc_sz;
    struct workqueue_struct *complete_wq;
    struct work_struct complete_work;
    struct timer_list timer;
    struct timer_list data_timer;
    void (*complete_work_fn)(struct work_struct *);
    irqreturn_t (*thread_irq_fn)(int, void *);
    u32 caps;
    u32 caps1;
    bool read_caps;
    bool sdhci_core_to_disable_vqmmc;
    unsigned int ocr_avail_sdio;
    unsigned int ocr_avail_sd;
    unsigned int ocr_avail_mmc;
    u32 ocr_mask;
    unsigned int timing;
    u32 thread_isr;
    u32 ier;
    bool cqe_on;
    u32 cqe_ier;
    u32 cqe_err_ier;
    wait_queue_head_t buf_ready_int;
    unsigned int tuning_done;
    unsigned int tuning_count;
    unsigned int tuning_mode;
    unsigned int tuning_err;
    int tuning_delay;
    int tuning_loop_count;
    u32 sdma_boundary;
    u32 adma_table_cnt;
    u64 data_timeout;
    long: 64;
    long unsigned int private[0];
};

struct sdhci_pltfm_data;

struct sdhci_iproc_data {
    const struct sdhci_pltfm_data *pdata;
    u32 caps;
    u32 caps1;
    u32 mmc_caps;
    bool missing_caps;
};

struct sdhci_iproc_host {
    const struct sdhci_iproc_data *data;
    u32 shadow_cmd;
    u32 shadow_blk;
    bool is_cmd_shadowed;
    bool is_blk_shadowed;
};

struct sdhci_ops {
    u32 (*read_l)(struct sdhci_host *, int);
    u16 (*read_w)(struct sdhci_host *, int);
    u8 (*read_b)(struct sdhci_host *, int);
    void (*write_l)(struct sdhci_host *, u32, int);
    void (*write_w)(struct sdhci_host *, u16, int);
    void (*write_b)(struct sdhci_host *, u8, int);
    void (*set_clock)(struct sdhci_host *, unsigned int);
    void (*set_power)(struct sdhci_host *, unsigned char, short unsigned int);
    u32 (*irq)(struct sdhci_host *, u32);
    int (*set_dma_mask)(struct sdhci_host *);
    int (*enable_dma)(struct sdhci_host *);
    unsigned int (*get_max_clock)(struct sdhci_host *);
    unsigned int (*get_min_clock)(struct sdhci_host *);
    unsigned int (*get_timeout_clock)(struct sdhci_host *);
    unsigned int (*get_max_timeout_count)(struct sdhci_host *);
    void (*set_timeout)(struct sdhci_host *, struct mmc_command *);
    void (*set_bus_width)(struct sdhci_host *, int);
    void (*platform_send_init_74_clocks)(struct sdhci_host *, u8);
    unsigned int (*get_ro)(struct sdhci_host *);
    void (*reset)(struct sdhci_host *, u8);
    int (*platform_execute_tuning)(struct sdhci_host *, u32);
    void (*set_uhs_signaling)(struct sdhci_host *, unsigned int);
    void (*hw_reset)(struct sdhci_host *);
    void (*adma_workaround)(struct sdhci_host *, u32);
    void (*card_event)(struct sdhci_host *);
    void (*voltage_switch)(struct sdhci_host *);
    void (*adma_write_desc)(struct sdhci_host *, void **, dma_addr_t, int, unsigned int);
    void (*copy_to_bounce_buffer)(struct sdhci_host *, struct mmc_data *, unsigned int);
    void (*request_done)(struct sdhci_host *, struct mmc_request *);
    void (*dump_vendor_regs)(struct sdhci_host *);
    void (*dump_uhs2_regs)(struct sdhci_host *);
    void (*uhs2_pre_detect_init)(struct sdhci_host *);
    int (*init_sd_express)(struct sdhci_host *, struct mmc_ios *);
};

struct sdhci_pltfm_data {
    const struct sdhci_ops *ops;
    unsigned int quirks;
    unsigned int quirks2;
};

struct sdhci_pltfm_host {
    struct clk *clk;
    struct clk *timeout_clk;
    unsigned int clock;
    u16 xfer_mode_shadow;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long unsigned int private[0];
};

struct sdio_device_id {
    __u8 class;
    __u16 vendor;
    __u16 device;
    kernel_ulong_t driver_data;
};

struct sdio_driver {
    char *name;
    const struct sdio_device_id *id_table;
    int (*probe)(struct sdio_func *, const struct sdio_device_id *);
    void (*remove)(struct sdio_func *);
    struct device_driver drv;
};

typedef void sdio_irq_handler_t(struct sdio_func *);

struct sdio_func {
    struct mmc_card *card;
    struct device dev;
    sdio_irq_handler_t *irq_handler;
    unsigned int num;
    unsigned char class;
    short unsigned int vendor;
    short unsigned int device;
    unsigned int max_blksize;
    unsigned int cur_blksize;
    unsigned int enable_timeout;
    unsigned int state;
    u8 *tmpbuf;
    u8 major_rev;
    u8 minor_rev;
    unsigned int num_info;
    const char **info;
    struct sdio_func_tuple *tuples;
};

struct sdio_func_tuple {
    struct sdio_func_tuple *next;
    unsigned char code;
    unsigned char size;
    unsigned char data[0];
};

struct xfrm_offload {
    struct {
        __u32 low;
        __u32 hi;
    } seq;
    __u32 flags;
    __u32 status;
    __u32 orig_mac_len;
    __u8 proto;
    __u8 inner_ipproto;
};

struct sec_path {
    int len;
    int olen;
    int verified_cnt;
    struct xfrm_state *xvec[6];
    struct xfrm_offload ovec[1];
};

struct seccomp_filter;

struct seccomp {
    int mode;
    atomic_t filter_count;
    struct seccomp_filter *filter;
};

struct seccomp_data {
    int nr;
    __u32 arch;
    __u64 instruction_pointer;
    __u64 args[6];
};

struct seccomp_filter {
    refcount_t refs;
    refcount_t users;
    bool log;
    bool wait_killable_recv;
    struct action_cache cache;
    struct seccomp_filter *prev;
    struct bpf_prog *prog;
    struct notification *notif;
    struct mutex notify_lock;
    wait_queue_head_t wqh;
};

struct seccomp_kaddfd {
    struct file *file;
    int fd;
    unsigned int flags;
    __u32 ioctl_flags;
    union {
        bool setfd;
        int ret;
    };
    struct completion completion;
    struct list_head list;
};

struct seccomp_knotif {
    struct task_struct *task;
    u64 id;
    const struct seccomp_data *data;
    enum notify_state state;
    int error;
    long int val;
    u32 flags;
    struct completion ready;
    struct list_head list;
    struct list_head addfd;
};

struct seccomp_log_name {
    u32 log;
    const char *name;
};

struct seccomp_metadata {
    __u64 filter_off;
    __u64 flags;
};

struct seccomp_notif {
    __u64 id;
    __u32 pid;
    __u32 flags;
    struct seccomp_data data;
};

struct seccomp_notif_addfd {
    __u64 id;
    __u32 flags;
    __u32 srcfd;
    __u32 newfd;
    __u32 newfd_flags;
};

struct seccomp_notif_resp {
    __u64 id;
    __s64 val;
    __s32 error;
    __u32 flags;
};

struct seccomp_notif_sizes {
    __u16 seccomp_notif;
    __u16 seccomp_notif_resp;
    __u16 seccomp_data;
};

struct secondary_data {
    struct task_struct *task;
    long int status;
};

struct section_header {
    char name[8];
    uint32_t virtual_size;
    uint32_t virtual_address;
    uint32_t raw_data_size;
    uint32_t data_addr;
    uint32_t relocs;
    uint32_t line_numbers;
    uint16_t num_relocs;
    uint16_t num_lin_numbers;
    uint32_t flags;
};

struct security_class_mapping {
    const char *name;
    const char *perms[33];
};

struct security_hook_heads {
    struct hlist_head binder_set_context_mgr;
    struct hlist_head binder_transaction;
    struct hlist_head binder_transfer_binder;
    struct hlist_head binder_transfer_file;
    struct hlist_head ptrace_access_check;
    struct hlist_head ptrace_traceme;
    struct hlist_head capget;
    struct hlist_head capset;
    struct hlist_head capable;
    struct hlist_head quotactl;
    struct hlist_head quota_on;
    struct hlist_head syslog;
    struct hlist_head settime;
    struct hlist_head vm_enough_memory;
    struct hlist_head bprm_creds_for_exec;
    struct hlist_head bprm_creds_from_file;
    struct hlist_head bprm_check_security;
    struct hlist_head bprm_committing_creds;
    struct hlist_head bprm_committed_creds;
    struct hlist_head fs_context_submount;
    struct hlist_head fs_context_dup;
    struct hlist_head fs_context_parse_param;
    struct hlist_head sb_alloc_security;
    struct hlist_head sb_delete;
    struct hlist_head sb_free_security;
    struct hlist_head sb_free_mnt_opts;
    struct hlist_head sb_eat_lsm_opts;
    struct hlist_head sb_mnt_opts_compat;
    struct hlist_head sb_remount;
    struct hlist_head sb_kern_mount;
    struct hlist_head sb_show_options;
    struct hlist_head sb_statfs;
    struct hlist_head sb_mount;
    struct hlist_head sb_umount;
    struct hlist_head sb_pivotroot;
    struct hlist_head sb_set_mnt_opts;
    struct hlist_head sb_clone_mnt_opts;
    struct hlist_head move_mount;
    struct hlist_head dentry_init_security;
    struct hlist_head dentry_create_files_as;
    struct hlist_head path_unlink;
    struct hlist_head path_mkdir;
    struct hlist_head path_rmdir;
    struct hlist_head path_mknod;
    struct hlist_head path_post_mknod;
    struct hlist_head path_truncate;
    struct hlist_head path_symlink;
    struct hlist_head path_link;
    struct hlist_head path_rename;
    struct hlist_head path_chmod;
    struct hlist_head path_chown;
    struct hlist_head path_chroot;
    struct hlist_head path_notify;
    struct hlist_head inode_alloc_security;
    struct hlist_head inode_free_security;
    struct hlist_head inode_free_security_rcu;
    struct hlist_head inode_init_security;
    struct hlist_head inode_init_security_anon;
    struct hlist_head inode_create;
    struct hlist_head inode_post_create_tmpfile;
    struct hlist_head inode_link;
    struct hlist_head inode_unlink;
    struct hlist_head inode_symlink;
    struct hlist_head inode_mkdir;
    struct hlist_head inode_rmdir;
    struct hlist_head inode_mknod;
    struct hlist_head inode_rename;
    struct hlist_head inode_readlink;
    struct hlist_head inode_follow_link;
    struct hlist_head inode_permission;
    struct hlist_head inode_setattr;
    struct hlist_head inode_post_setattr;
    struct hlist_head inode_getattr;
    struct hlist_head inode_xattr_skipcap;
    struct hlist_head inode_setxattr;
    struct hlist_head inode_post_setxattr;
    struct hlist_head inode_getxattr;
    struct hlist_head inode_listxattr;
    struct hlist_head inode_removexattr;
    struct hlist_head inode_post_removexattr;
    struct hlist_head inode_set_acl;
    struct hlist_head inode_post_set_acl;
    struct hlist_head inode_get_acl;
    struct hlist_head inode_remove_acl;
    struct hlist_head inode_post_remove_acl;
    struct hlist_head inode_need_killpriv;
    struct hlist_head inode_killpriv;
    struct hlist_head inode_getsecurity;
    struct hlist_head inode_setsecurity;
    struct hlist_head inode_listsecurity;
    struct hlist_head inode_getlsmprop;
    struct hlist_head inode_copy_up;
    struct hlist_head inode_copy_up_xattr;
    struct hlist_head inode_setintegrity;
    struct hlist_head kernfs_init_security;
    struct hlist_head file_permission;
    struct hlist_head file_alloc_security;
    struct hlist_head file_release;
    struct hlist_head file_free_security;
    struct hlist_head file_ioctl;
    struct hlist_head file_ioctl_compat;
    struct hlist_head mmap_addr;
    struct hlist_head mmap_file;
    struct hlist_head file_mprotect;
    struct hlist_head file_lock;
    struct hlist_head file_fcntl;
    struct hlist_head file_set_fowner;
    struct hlist_head file_send_sigiotask;
    struct hlist_head file_receive;
    struct hlist_head file_open;
    struct hlist_head file_post_open;
    struct hlist_head file_truncate;
    struct hlist_head task_alloc;
    struct hlist_head task_free;
    struct hlist_head cred_alloc_blank;
    struct hlist_head cred_free;
    struct hlist_head cred_prepare;
    struct hlist_head cred_transfer;
    struct hlist_head cred_getsecid;
    struct hlist_head cred_getlsmprop;
    struct hlist_head kernel_act_as;
    struct hlist_head kernel_create_files_as;
    struct hlist_head kernel_module_request;
    struct hlist_head kernel_load_data;
    struct hlist_head kernel_post_load_data;
    struct hlist_head kernel_read_file;
    struct hlist_head kernel_post_read_file;
    struct hlist_head task_fix_setuid;
    struct hlist_head task_fix_setgid;
    struct hlist_head task_fix_setgroups;
    struct hlist_head task_setpgid;
    struct hlist_head task_getpgid;
    struct hlist_head task_getsid;
    struct hlist_head current_getlsmprop_subj;
    struct hlist_head task_getlsmprop_obj;
    struct hlist_head task_setnice;
    struct hlist_head task_setioprio;
    struct hlist_head task_getioprio;
    struct hlist_head task_prlimit;
    struct hlist_head task_setrlimit;
    struct hlist_head task_setscheduler;
    struct hlist_head task_getscheduler;
    struct hlist_head task_movememory;
    struct hlist_head task_kill;
    struct hlist_head task_prctl;
    struct hlist_head task_to_inode;
    struct hlist_head userns_create;
    struct hlist_head ipc_permission;
    struct hlist_head ipc_getlsmprop;
    struct hlist_head msg_msg_alloc_security;
    struct hlist_head msg_msg_free_security;
    struct hlist_head msg_queue_alloc_security;
    struct hlist_head msg_queue_free_security;
    struct hlist_head msg_queue_associate;
    struct hlist_head msg_queue_msgctl;
    struct hlist_head msg_queue_msgsnd;
    struct hlist_head msg_queue_msgrcv;
    struct hlist_head shm_alloc_security;
    struct hlist_head shm_free_security;
    struct hlist_head shm_associate;
    struct hlist_head shm_shmctl;
    struct hlist_head shm_shmat;
    struct hlist_head sem_alloc_security;
    struct hlist_head sem_free_security;
    struct hlist_head sem_associate;
    struct hlist_head sem_semctl;
    struct hlist_head sem_semop;
    struct hlist_head netlink_send;
    struct hlist_head d_instantiate;
    struct hlist_head getselfattr;
    struct hlist_head setselfattr;
    struct hlist_head getprocattr;
    struct hlist_head setprocattr;
    struct hlist_head ismaclabel;
    struct hlist_head secid_to_secctx;
    struct hlist_head lsmprop_to_secctx;
    struct hlist_head secctx_to_secid;
    struct hlist_head release_secctx;
    struct hlist_head inode_invalidate_secctx;
    struct hlist_head inode_notifysecctx;
    struct hlist_head inode_setsecctx;
    struct hlist_head inode_getsecctx;
    struct hlist_head post_notification;
    struct hlist_head watch_key;
    struct hlist_head unix_stream_connect;
    struct hlist_head unix_may_send;
    struct hlist_head socket_create;
    struct hlist_head socket_post_create;
    struct hlist_head socket_socketpair;
    struct hlist_head socket_bind;
    struct hlist_head socket_connect;
    struct hlist_head socket_listen;
    struct hlist_head socket_accept;
    struct hlist_head socket_sendmsg;
    struct hlist_head socket_recvmsg;
    struct hlist_head socket_getsockname;
    struct hlist_head socket_getpeername;
    struct hlist_head socket_getsockopt;
    struct hlist_head socket_setsockopt;
    struct hlist_head socket_shutdown;
    struct hlist_head socket_sock_rcv_skb;
    struct hlist_head socket_getpeersec_stream;
    struct hlist_head socket_getpeersec_dgram;
    struct hlist_head sk_alloc_security;
    struct hlist_head sk_free_security;
    struct hlist_head sk_clone_security;
    struct hlist_head sk_getsecid;
    struct hlist_head sock_graft;
    struct hlist_head inet_conn_request;
    struct hlist_head inet_csk_clone;
    struct hlist_head inet_conn_established;
    struct hlist_head secmark_relabel_packet;
    struct hlist_head secmark_refcount_inc;
    struct hlist_head secmark_refcount_dec;
    struct hlist_head req_classify_flow;
    struct hlist_head tun_dev_alloc_security;
    struct hlist_head tun_dev_create;
    struct hlist_head tun_dev_attach_queue;
    struct hlist_head tun_dev_attach;
    struct hlist_head tun_dev_open;
    struct hlist_head sctp_assoc_request;
    struct hlist_head sctp_bind_connect;
    struct hlist_head sctp_sk_clone;
    struct hlist_head sctp_assoc_established;
    struct hlist_head mptcp_add_subflow;
    struct hlist_head xfrm_policy_alloc_security;
    struct hlist_head xfrm_policy_clone_security;
    struct hlist_head xfrm_policy_free_security;
    struct hlist_head xfrm_policy_delete_security;
    struct hlist_head xfrm_state_alloc;
    struct hlist_head xfrm_state_alloc_acquire;
    struct hlist_head xfrm_state_free_security;
    struct hlist_head xfrm_state_delete_security;
    struct hlist_head xfrm_policy_lookup;
    struct hlist_head xfrm_state_pol_flow_match;
    struct hlist_head xfrm_decode_session;
    struct hlist_head key_alloc;
    struct hlist_head key_permission;
    struct hlist_head key_getsecurity;
    struct hlist_head key_post_create_or_update;
    struct hlist_head audit_rule_init;
    struct hlist_head audit_rule_known;
    struct hlist_head audit_rule_match;
    struct hlist_head audit_rule_free;
    struct hlist_head bpf;
    struct hlist_head bpf_map;
    struct hlist_head bpf_prog;
    struct hlist_head bpf_map_create;
    struct hlist_head bpf_map_free;
    struct hlist_head bpf_prog_load;
    struct hlist_head bpf_prog_free;
    struct hlist_head bpf_token_create;
    struct hlist_head bpf_token_free;
    struct hlist_head bpf_token_cmd;
    struct hlist_head bpf_token_capable;
    struct hlist_head locked_down;
    struct hlist_head lock_kernel_down;
    struct hlist_head perf_event_open;
    struct hlist_head perf_event_alloc;
    struct hlist_head perf_event_read;
    struct hlist_head perf_event_write;
    struct hlist_head uring_override_creds;
    struct hlist_head uring_sqpoll;
    struct hlist_head uring_cmd;
    struct hlist_head initramfs_populated;
    struct hlist_head bdev_alloc_security;
    struct hlist_head bdev_free_security;
    struct hlist_head bdev_setintegrity;
};

struct timezone;

struct xattr;

struct sembuf;

struct xfrm_sec_ctx;

struct xfrm_user_sec_ctx;

union security_list_options {
    int (*binder_set_context_mgr)(const struct cred *);
    int (*binder_transaction)(const struct cred *, const struct cred *);
    int (*binder_transfer_binder)(const struct cred *, const struct cred *);
    int (*binder_transfer_file)(const struct cred *, const struct cred *, const struct file *);
    int (*ptrace_access_check)(struct task_struct *, unsigned int);
    int (*ptrace_traceme)(struct task_struct *);
    int (*capget)(const struct task_struct *, kernel_cap_t *, kernel_cap_t *, kernel_cap_t *);
    int (*capset)(struct cred *, const struct cred *, const kernel_cap_t *, const kernel_cap_t *, const kernel_cap_t *);
    int (*capable)(const struct cred *, struct user_namespace *, int, unsigned int);
    int (*quotactl)(int, int, int, const struct super_block *);
    int (*quota_on)(struct dentry *);
    int (*syslog)(int);
    int (*settime)(const struct timespec64 *, const struct timezone *);
    int (*vm_enough_memory)(struct mm_struct *, long int);
    int (*bprm_creds_for_exec)(struct linux_binprm *);
    int (*bprm_creds_from_file)(struct linux_binprm *, const struct file *);
    int (*bprm_check_security)(struct linux_binprm *);
    void (*bprm_committing_creds)(const struct linux_binprm *);
    void (*bprm_committed_creds)(const struct linux_binprm *);
    int (*fs_context_submount)(struct fs_context *, struct super_block *);
    int (*fs_context_dup)(struct fs_context *, struct fs_context *);
    int (*fs_context_parse_param)(struct fs_context *, struct fs_parameter *);
    int (*sb_alloc_security)(struct super_block *);
    void (*sb_delete)(struct super_block *);
    void (*sb_free_security)(struct super_block *);
    void (*sb_free_mnt_opts)(void *);
    int (*sb_eat_lsm_opts)(char *, void **);
    int (*sb_mnt_opts_compat)(struct super_block *, void *);
    int (*sb_remount)(struct super_block *, void *);
    int (*sb_kern_mount)(const struct super_block *);
    int (*sb_show_options)(struct seq_file *, struct super_block *);
    int (*sb_statfs)(struct dentry *);
    int (*sb_mount)(const char *, const struct path *, const char *, long unsigned int, void *);
    int (*sb_umount)(struct vfsmount *, int);
    int (*sb_pivotroot)(const struct path *, const struct path *);
    int (*sb_set_mnt_opts)(struct super_block *, void *, long unsigned int, long unsigned int *);
    int (*sb_clone_mnt_opts)(const struct super_block *, struct super_block *, long unsigned int, long unsigned int *);
    int (*move_mount)(const struct path *, const struct path *);
    int (*dentry_init_security)(struct dentry *, int, const struct qstr *, const char **, struct lsm_context *);
    int (*dentry_create_files_as)(struct dentry *, int, struct qstr *, const struct cred *, struct cred *);
    int (*path_unlink)(const struct path *, struct dentry *);
    int (*path_mkdir)(const struct path *, struct dentry *, umode_t);
    int (*path_rmdir)(const struct path *, struct dentry *);
    int (*path_mknod)(const struct path *, struct dentry *, umode_t, unsigned int);
    void (*path_post_mknod)(struct mnt_idmap *, struct dentry *);
    int (*path_truncate)(const struct path *);
    int (*path_symlink)(const struct path *, struct dentry *, const char *);
    int (*path_link)(struct dentry *, const struct path *, struct dentry *);
    int (*path_rename)(const struct path *, struct dentry *, const struct path *, struct dentry *, unsigned int);
    int (*path_chmod)(const struct path *, umode_t);
    int (*path_chown)(const struct path *, kuid_t, kgid_t);
    int (*path_chroot)(const struct path *);
    int (*path_notify)(const struct path *, u64, unsigned int);
    int (*inode_alloc_security)(struct inode *);
    void (*inode_free_security)(struct inode *);
    void (*inode_free_security_rcu)(void *);
    int (*inode_init_security)(struct inode *, struct inode *, const struct qstr *, struct xattr *, int *);
    int (*inode_init_security_anon)(struct inode *, const struct qstr *, const struct inode *);
    int (*inode_create)(struct inode *, struct dentry *, umode_t);
    void (*inode_post_create_tmpfile)(struct mnt_idmap *, struct inode *);
    int (*inode_link)(struct dentry *, struct inode *, struct dentry *);
    int (*inode_unlink)(struct inode *, struct dentry *);
    int (*inode_symlink)(struct inode *, struct dentry *, const char *);
    int (*inode_mkdir)(struct inode *, struct dentry *, umode_t);
    int (*inode_rmdir)(struct inode *, struct dentry *);
    int (*inode_mknod)(struct inode *, struct dentry *, umode_t, dev_t);
    int (*inode_rename)(struct inode *, struct dentry *, struct inode *, struct dentry *);
    int (*inode_readlink)(struct dentry *);
    int (*inode_follow_link)(struct dentry *, struct inode *, bool);
    int (*inode_permission)(struct inode *, int);
    int (*inode_setattr)(struct mnt_idmap *, struct dentry *, struct iattr *);
    void (*inode_post_setattr)(struct mnt_idmap *, struct dentry *, int);
    int (*inode_getattr)(const struct path *);
    int (*inode_xattr_skipcap)(const char *);
    int (*inode_setxattr)(struct mnt_idmap *, struct dentry *, const char *, const void *, size_t, int);
    void (*inode_post_setxattr)(struct dentry *, const char *, const void *, size_t, int);
    int (*inode_getxattr)(struct dentry *, const char *);
    int (*inode_listxattr)(struct dentry *);
    int (*inode_removexattr)(struct mnt_idmap *, struct dentry *, const char *);
    void (*inode_post_removexattr)(struct dentry *, const char *);
    int (*inode_set_acl)(struct mnt_idmap *, struct dentry *, const char *, struct posix_acl *);
    void (*inode_post_set_acl)(struct dentry *, const char *, struct posix_acl *);
    int (*inode_get_acl)(struct mnt_idmap *, struct dentry *, const char *);
    int (*inode_remove_acl)(struct mnt_idmap *, struct dentry *, const char *);
    void (*inode_post_remove_acl)(struct mnt_idmap *, struct dentry *, const char *);
    int (*inode_need_killpriv)(struct dentry *);
    int (*inode_killpriv)(struct mnt_idmap *, struct dentry *);
    int (*inode_getsecurity)(struct mnt_idmap *, struct inode *, const char *, void **, bool);
    int (*inode_setsecurity)(struct inode *, const char *, const void *, size_t, int);
    int (*inode_listsecurity)(struct inode *, char *, size_t);
    void (*inode_getlsmprop)(struct inode *, struct lsm_prop *);
    int (*inode_copy_up)(struct dentry *, struct cred **);
    int (*inode_copy_up_xattr)(struct dentry *, const char *);
    int (*inode_setintegrity)(const struct inode *, enum lsm_integrity_type, const void *, size_t);
    int (*kernfs_init_security)(struct kernfs_node *, struct kernfs_node *);
    int (*file_permission)(struct file *, int);
    int (*file_alloc_security)(struct file *);
    void (*file_release)(struct file *);
    void (*file_free_security)(struct file *);
    int (*file_ioctl)(struct file *, unsigned int, long unsigned int);
    int (*file_ioctl_compat)(struct file *, unsigned int, long unsigned int);
    int (*mmap_addr)(long unsigned int);
    int (*mmap_file)(struct file *, long unsigned int, long unsigned int, long unsigned int);
    int (*file_mprotect)(struct vm_area_struct *, long unsigned int, long unsigned int);
    int (*file_lock)(struct file *, unsigned int);
    int (*file_fcntl)(struct file *, unsigned int, long unsigned int);
    void (*file_set_fowner)(struct file *);
    int (*file_send_sigiotask)(struct task_struct *, struct fown_struct *, int);
    int (*file_receive)(struct file *);
    int (*file_open)(struct file *);
    int (*file_post_open)(struct file *, int);
    int (*file_truncate)(struct file *);
    int (*task_alloc)(struct task_struct *, long unsigned int);
    void (*task_free)(struct task_struct *);
    int (*cred_alloc_blank)(struct cred *, gfp_t);
    void (*cred_free)(struct cred *);
    int (*cred_prepare)(struct cred *, const struct cred *, gfp_t);
    void (*cred_transfer)(struct cred *, const struct cred *);
    void (*cred_getsecid)(const struct cred *, u32 *);
    void (*cred_getlsmprop)(const struct cred *, struct lsm_prop *);
    int (*kernel_act_as)(struct cred *, u32);
    int (*kernel_create_files_as)(struct cred *, struct inode *);
    int (*kernel_module_request)(char *);
    int (*kernel_load_data)(enum kernel_load_data_id, bool);
    int (*kernel_post_load_data)(char *, loff_t, enum kernel_load_data_id, char *);
    int (*kernel_read_file)(struct file *, enum kernel_read_file_id, bool);
    int (*kernel_post_read_file)(struct file *, char *, loff_t, enum kernel_read_file_id);
    int (*task_fix_setuid)(struct cred *, const struct cred *, int);
    int (*task_fix_setgid)(struct cred *, const struct cred *, int);
    int (*task_fix_setgroups)(struct cred *, const struct cred *);
    int (*task_setpgid)(struct task_struct *, pid_t);
    int (*task_getpgid)(struct task_struct *);
    int (*task_getsid)(struct task_struct *);
    void (*current_getlsmprop_subj)(struct lsm_prop *);
    void (*task_getlsmprop_obj)(struct task_struct *, struct lsm_prop *);
    int (*task_setnice)(struct task_struct *, int);
    int (*task_setioprio)(struct task_struct *, int);
    int (*task_getioprio)(struct task_struct *);
    int (*task_prlimit)(const struct cred *, const struct cred *, unsigned int);
    int (*task_setrlimit)(struct task_struct *, unsigned int, struct rlimit *);
    int (*task_setscheduler)(struct task_struct *);
    int (*task_getscheduler)(struct task_struct *);
    int (*task_movememory)(struct task_struct *);
    int (*task_kill)(struct task_struct *, struct kernel_siginfo *, int, const struct cred *);
    int (*task_prctl)(int, long unsigned int, long unsigned int, long unsigned int, long unsigned int);
    void (*task_to_inode)(struct task_struct *, struct inode *);
    int (*userns_create)(const struct cred *);
    int (*ipc_permission)(struct kern_ipc_perm *, short int);
    void (*ipc_getlsmprop)(struct kern_ipc_perm *, struct lsm_prop *);
    int (*msg_msg_alloc_security)(struct msg_msg *);
    void (*msg_msg_free_security)(struct msg_msg *);
    int (*msg_queue_alloc_security)(struct kern_ipc_perm *);
    void (*msg_queue_free_security)(struct kern_ipc_perm *);
    int (*msg_queue_associate)(struct kern_ipc_perm *, int);
    int (*msg_queue_msgctl)(struct kern_ipc_perm *, int);
    int (*msg_queue_msgsnd)(struct kern_ipc_perm *, struct msg_msg *, int);
    int (*msg_queue_msgrcv)(struct kern_ipc_perm *, struct msg_msg *, struct task_struct *, long int, int);
    int (*shm_alloc_security)(struct kern_ipc_perm *);
    void (*shm_free_security)(struct kern_ipc_perm *);
    int (*shm_associate)(struct kern_ipc_perm *, int);
    int (*shm_shmctl)(struct kern_ipc_perm *, int);
    int (*shm_shmat)(struct kern_ipc_perm *, char *, int);
    int (*sem_alloc_security)(struct kern_ipc_perm *);
    void (*sem_free_security)(struct kern_ipc_perm *);
    int (*sem_associate)(struct kern_ipc_perm *, int);
    int (*sem_semctl)(struct kern_ipc_perm *, int);
    int (*sem_semop)(struct kern_ipc_perm *, struct sembuf *, unsigned int, int);
    int (*netlink_send)(struct sock *, struct sk_buff *);
    void (*d_instantiate)(struct dentry *, struct inode *);
    int (*getselfattr)(unsigned int, struct lsm_ctx *, u32 *, u32);
    int (*setselfattr)(unsigned int, struct lsm_ctx *, u32, u32);
    int (*getprocattr)(struct task_struct *, const char *, char **);
    int (*setprocattr)(const char *, void *, size_t);
    int (*ismaclabel)(const char *);
    int (*secid_to_secctx)(u32, struct lsm_context *);
    int (*lsmprop_to_secctx)(struct lsm_prop *, struct lsm_context *);
    int (*secctx_to_secid)(const char *, u32, u32 *);
    void (*release_secctx)(struct lsm_context *);
    void (*inode_invalidate_secctx)(struct inode *);
    int (*inode_notifysecctx)(struct inode *, void *, u32);
    int (*inode_setsecctx)(struct dentry *, void *, u32);
    int (*inode_getsecctx)(struct inode *, struct lsm_context *);
    int (*post_notification)(const struct cred *, const struct cred *, struct watch_notification *);
    int (*watch_key)(struct key *);
    int (*unix_stream_connect)(struct sock *, struct sock *, struct sock *);
    int (*unix_may_send)(struct socket *, struct socket *);
    int (*socket_create)(int, int, int, int);
    int (*socket_post_create)(struct socket *, int, int, int, int);
    int (*socket_socketpair)(struct socket *, struct socket *);
    int (*socket_bind)(struct socket *, struct sockaddr *, int);
    int (*socket_connect)(struct socket *, struct sockaddr *, int);
    int (*socket_listen)(struct socket *, int);
    int (*socket_accept)(struct socket *, struct socket *);
    int (*socket_sendmsg)(struct socket *, struct msghdr *, int);
    int (*socket_recvmsg)(struct socket *, struct msghdr *, int, int);
    int (*socket_getsockname)(struct socket *);
    int (*socket_getpeername)(struct socket *);
    int (*socket_getsockopt)(struct socket *, int, int);
    int (*socket_setsockopt)(struct socket *, int, int);
    int (*socket_shutdown)(struct socket *, int);
    int (*socket_sock_rcv_skb)(struct sock *, struct sk_buff *);
    int (*socket_getpeersec_stream)(struct socket *, sockptr_t, sockptr_t, unsigned int);
    int (*socket_getpeersec_dgram)(struct socket *, struct sk_buff *, u32 *);
    int (*sk_alloc_security)(struct sock *, int, gfp_t);
    void (*sk_free_security)(struct sock *);
    void (*sk_clone_security)(const struct sock *, struct sock *);
    void (*sk_getsecid)(const struct sock *, u32 *);
    void (*sock_graft)(struct sock *, struct socket *);
    int (*inet_conn_request)(const struct sock *, struct sk_buff *, struct request_sock *);
    void (*inet_csk_clone)(struct sock *, const struct request_sock *);
    void (*inet_conn_established)(struct sock *, struct sk_buff *);
    int (*secmark_relabel_packet)(u32);
    void (*secmark_refcount_inc)(void);
    void (*secmark_refcount_dec)(void);
    void (*req_classify_flow)(const struct request_sock *, struct flowi_common *);
    int (*tun_dev_alloc_security)(void *);
    int (*tun_dev_create)(void);
    int (*tun_dev_attach_queue)(void *);
    int (*tun_dev_attach)(struct sock *, void *);
    int (*tun_dev_open)(void *);
    int (*sctp_assoc_request)(struct sctp_association *, struct sk_buff *);
    int (*sctp_bind_connect)(struct sock *, int, struct sockaddr *, int);
    void (*sctp_sk_clone)(struct sctp_association *, struct sock *, struct sock *);
    int (*sctp_assoc_established)(struct sctp_association *, struct sk_buff *);
    int (*mptcp_add_subflow)(struct sock *, struct sock *);
    int (*xfrm_policy_alloc_security)(struct xfrm_sec_ctx **, struct xfrm_user_sec_ctx *, gfp_t);
    int (*xfrm_policy_clone_security)(struct xfrm_sec_ctx *, struct xfrm_sec_ctx **);
    void (*xfrm_policy_free_security)(struct xfrm_sec_ctx *);
    int (*xfrm_policy_delete_security)(struct xfrm_sec_ctx *);
    int (*xfrm_state_alloc)(struct xfrm_state *, struct xfrm_user_sec_ctx *);
    int (*xfrm_state_alloc_acquire)(struct xfrm_state *, struct xfrm_sec_ctx *, u32);
    void (*xfrm_state_free_security)(struct xfrm_state *);
    int (*xfrm_state_delete_security)(struct xfrm_state *);
    int (*xfrm_policy_lookup)(struct xfrm_sec_ctx *, u32);
    int (*xfrm_state_pol_flow_match)(struct xfrm_state *, struct xfrm_policy *, const struct flowi_common *);
    int (*xfrm_decode_session)(struct sk_buff *, u32 *, int);
    int (*key_alloc)(struct key *, const struct cred *, long unsigned int);
    int (*key_permission)(key_ref_t, const struct cred *, enum key_need_perm);
    int (*key_getsecurity)(struct key *, char **);
    void (*key_post_create_or_update)(struct key *, struct key *, const void *, size_t, long unsigned int, bool);
    int (*audit_rule_init)(u32, u32, char *, void **, gfp_t);
    int (*audit_rule_known)(struct audit_krule *);
    int (*audit_rule_match)(struct lsm_prop *, u32, u32, void *);
    void (*audit_rule_free)(void *);
    int (*bpf)(int, union bpf_attr *, unsigned int);
    int (*bpf_map)(struct bpf_map *, fmode_t);
    int (*bpf_prog)(struct bpf_prog *);
    int (*bpf_map_create)(struct bpf_map *, union bpf_attr *, struct bpf_token *);
    void (*bpf_map_free)(struct bpf_map *);
    int (*bpf_prog_load)(struct bpf_prog *, union bpf_attr *, struct bpf_token *);
    void (*bpf_prog_free)(struct bpf_prog *);
    int (*bpf_token_create)(struct bpf_token *, union bpf_attr *, const struct path *);
    void (*bpf_token_free)(struct bpf_token *);
    int (*bpf_token_cmd)(const struct bpf_token *, enum bpf_cmd);
    int (*bpf_token_capable)(const struct bpf_token *, int);
    int (*locked_down)(enum lockdown_reason);
    int (*lock_kernel_down)(const char *, enum lockdown_reason);
    int (*perf_event_open)(struct perf_event_attr *, int);
    int (*perf_event_alloc)(struct perf_event *);
    int (*perf_event_read)(struct perf_event *);
    int (*perf_event_write)(struct perf_event *);
    int (*uring_override_creds)(const struct cred *);
    int (*uring_sqpoll)(void);
    int (*uring_cmd)(struct io_uring_cmd *);
    void (*initramfs_populated)(void);
    int (*bdev_alloc_security)(struct block_device *);
    void (*bdev_free_security)(struct block_device *);
    int (*bdev_setintegrity)(struct block_device *, enum lsm_integrity_type, const void *, size_t);
};

struct security_hook_list {
    struct hlist_node list;
    struct hlist_head *head;
    union security_list_options hook;
    const struct lsm_id *lsmid;
};

struct seg6_local_lwt;

struct seg6_local_lwtunnel_ops {
    int (*build_state)(struct seg6_local_lwt *, const void *, struct netlink_ext_ack *);
    void (*destroy_state)(struct seg6_local_lwt *);
};

struct seg6_action_desc {
    int action;
    long unsigned int attrs;
    long unsigned int optattrs;
    int (*input)(struct sk_buff *, struct seg6_local_lwt *);
    int static_headroom;
    struct seg6_local_lwtunnel_ops slwt_ops;
};

struct seg6_action_param {
    int (*parse)(struct nlattr **, struct seg6_local_lwt *, struct netlink_ext_ack *);
    int (*put)(struct sk_buff *, struct seg6_local_lwt *);
    int (*cmp)(struct seg6_local_lwt *, struct seg6_local_lwt *);
    void (*destroy)(struct seg6_local_lwt *);
};

struct seg6_bpf_srh_state {
    local_lock_t bh_lock;
    struct ipv6_sr_hdr *srh;
    u16 hdrlen;
    bool valid;
};

struct seg6_end_dt_info {
    enum seg6_end_dt_mode mode;
    struct net *net;
    int vrf_ifindex;
    int vrf_table;
    u16 family;
};

struct seg6_flavors_info {
    __u32 flv_ops;
    __u8 lcblock_bits;
    __u8 lcnode_func_bits;
};

struct seg6_hmac_algo {
    u8 alg_id;
    char name[64];
    struct crypto_shash **tfms;
    struct shash_desc **shashs;
};

struct seg6_hmac_info {
    struct rhash_head node;
    struct callback_head rcu;
    u32 hmackeyid;
    char secret[64];
    u8 slen;
    u8 alg_id;
};

struct seg6_iptunnel_encap {
    int mode;
    struct ipv6_sr_hdr srh[0];
};

struct seg6_local_counters {
    __u64 packets;
    __u64 bytes;
    __u64 errors;
};

struct seg6_local_lwt {
    int action;
    struct ipv6_sr_hdr *srh;
    int table;
    struct in_addr nh4;
    struct in6_addr nh6;
    int iif;
    int oif;
    struct bpf_lwt_prog bpf;
    struct seg6_end_dt_info dt_info;
    struct seg6_flavors_info flv_info;
    struct pcpu_seg6_local_counters *pcpu_counters;
    int headroom;
    struct seg6_action_desc *desc;
    long unsigned int parsed_optattrs;
};

struct seg6_lwt {
    struct dst_cache cache;
    struct seg6_iptunnel_encap tuninfo[0];
};

struct seg6_pernet_data {
    struct mutex lock;
    struct in6_addr *tun_src;
    struct rhashtable hmac_infos;
};

struct sel_netif {
    struct list_head list;
    struct netif_security_struct nsec;
    struct callback_head callback_head;
};

struct sel_netnode {
    struct netnode_security_struct nsec;
    struct list_head list;
    struct callback_head rcu;
};

struct sel_netnode_bkt {
    unsigned int size;
    struct list_head list;
};

struct sel_netport {
    struct netport_security_struct psec;
    struct list_head list;
    struct callback_head rcu;
};

struct sel_netport_bkt {
    int size;
    struct list_head list;
};

struct select_data {
    struct dentry *start;
    union {
        long int found;
        struct dentry *victim;
    };
    struct list_head dispose;
};

struct selinux_audit_data {
    u32 ssid;
    u32 tsid;
    u16 tclass;
    u32 requested;
    u32 audited;
    u32 denied;
    int result;
};

struct selinux_audit_rule {
    u32 au_seqno;
    struct context au_ctxt;
};

struct selinux_avc {
    unsigned int avc_cache_threshold;
    struct avc_cache avc_cache;
};

struct selinux_fs_info {
    struct dentry *bool_dir;
    unsigned int bool_num;
    char **bool_pending_names;
    int *bool_pending_values;
    struct dentry *class_dir;
    long unsigned int last_class_ino;
    bool policy_opened;
    struct dentry *policycap_dir;
    long unsigned int last_ino;
    struct super_block *sb;
};

struct selinux_kernel_status {
    u32 version;
    u32 sequence;
    u32 enforcing;
    u32 policyload;
    u32 deny_unknown;
};

struct selinux_policy;

struct selinux_policy_convert_data;

struct selinux_load_state {
    struct selinux_policy *policy;
    struct selinux_policy_convert_data *convert_data;
};

struct selinux_mapping;

struct selinux_map {
    struct selinux_mapping *mapping;
    u16 size;
};

struct selinux_mapping {
    u16 value;
    u16 num_perms;
    u32 perms[32];
};

struct selinux_mnt_opts {
    u32 fscontext_sid;
    u32 context_sid;
    u32 rootcontext_sid;
    u32 defcontext_sid;
};

struct sidtab;

struct selinux_policy {
    struct sidtab *sidtab;
    struct policydb policydb;
    struct selinux_map map;
    u32 latest_granting;
};

struct sidtab_convert_params {
    struct convert_context_args *args;
    struct sidtab *target;
};

struct selinux_policy_convert_data {
    struct convert_context_args args;
    struct sidtab_convert_params sidtab_params;
};

struct selinux_state {
    bool enforcing;
    bool initialized;
    bool policycap[10];
    struct page *status_page;
    struct mutex status_lock;
    struct selinux_policy *policy;
    struct mutex policy_mutex;
};

struct selnl_msg_policyload {
    __u32 seqno;
};

struct selnl_msg_setenforce {
    __s32 val;
};

struct sem {
    int semval;
    struct pid *sempid;
    spinlock_t lock;
    struct list_head pending_alter;
    struct list_head pending_const;
    time64_t sem_otime;
};

struct sem_array {
    struct kern_ipc_perm sem_perm;
    time64_t sem_ctime;
    struct list_head pending_alter;
    struct list_head pending_const;
    struct list_head list_id;
    int sem_nsems;
    int complex_count;
    unsigned int use_global_lock;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    struct sem sems[0];
};

struct sem_undo;

struct sem_queue {
    struct list_head list;
    struct task_struct *sleeper;
    struct sem_undo *undo;
    struct pid *pid;
    int status;
    struct sembuf *sops;
    struct sembuf *blocking;
    int nsops;
    bool alter;
    bool dupsop;
};

struct sem_undo_list;

struct sem_undo {
    struct list_head list_proc;
    struct callback_head rcu;
    struct sem_undo_list *ulp;
    struct list_head list_id;
    int semid;
    short int semadj[0];
};

struct sem_undo_list {
    refcount_t refcnt;
    spinlock_t lock;
    struct list_head list_proc;
};

struct semaphore_waiter {
    struct list_head list;
    struct task_struct *task;
    bool up;
};

struct sembuf {
    short unsigned int sem_num;
    short int sem_op;
    short int sem_flg;
};

struct semid64_ds {
    struct ipc64_perm sem_perm;
    long int sem_otime;
    long int sem_ctime;
    long unsigned int sem_nsems;
    long unsigned int __unused3;
    long unsigned int __unused4;
};

struct semid_ds {
    struct ipc_perm sem_perm;
    __kernel_old_time_t sem_otime;
    __kernel_old_time_t sem_ctime;
    struct sem *sem_base;
    struct sem_queue *sem_pending;
    struct sem_queue **sem_pending_last;
    struct sem_undo *undo;
    short unsigned int sem_nsems;
};

struct seminfo {
    int semmap;
    int semmni;
    int semmns;
    int semmnu;
    int semmsl;
    int semopm;
    int semume;
    int semusz;
    int semvmx;
    int semaem;
};

struct send_signal_irq_work {
    struct irq_work irq_work;
    struct task_struct *task;
    u32 sig;
    enum pid_type type;
    bool has_siginfo;
    struct kernel_siginfo info;
};

struct seqDef_s {
    U32 offBase;
    U16 litLength;
    U16 mlBase;
};

struct seq_operations {
    void * (*start)(struct seq_file *, loff_t *);
    void (*stop)(struct seq_file *, void *);
    void * (*next)(struct seq_file *, void *, loff_t *);
    int (*show)(struct seq_file *, void *);
};

struct seqcount_rwlock {
    seqcount_t seqcount;
};

typedef struct seqcount_rwlock seqcount_rwlock_t;

struct serdev_device;

struct serdev_controller_ops;

struct serdev_controller {
    struct device dev;
    struct device *host;
    unsigned int nr;
    struct serdev_device *serdev;
    const struct serdev_controller_ops *ops;
};

struct serdev_controller_ops {
    ssize_t (*write_buf)(struct serdev_controller *, const u8 *, size_t);
    void (*write_flush)(struct serdev_controller *);
    int (*write_room)(struct serdev_controller *);
    int (*open)(struct serdev_controller *);
    void (*close)(struct serdev_controller *);
    void (*set_flow_control)(struct serdev_controller *, bool);
    int (*set_parity)(struct serdev_controller *, enum serdev_parity);
    unsigned int (*set_baudrate)(struct serdev_controller *, unsigned int);
    void (*wait_until_sent)(struct serdev_controller *, long int);
    int (*get_tiocm)(struct serdev_controller *);
    int (*set_tiocm)(struct serdev_controller *, unsigned int, unsigned int);
    int (*break_ctl)(struct serdev_controller *, unsigned int);
};

struct serdev_device_ops;

struct serdev_device {
    struct device dev;
    int nr;
    struct serdev_controller *ctrl;
    const struct serdev_device_ops *ops;
    struct completion write_comp;
    struct mutex write_lock;
};

struct serdev_device_driver {
    struct device_driver driver;
    int (*probe)(struct serdev_device *);
    void (*remove)(struct serdev_device *);
};

struct serdev_device_ops {
    size_t (*receive_buf)(struct serdev_device *, const u8 *, size_t);
    void (*write_wakeup)(struct serdev_device *);
};

struct serial8250_config {
    const char *name;
    short unsigned int fifo_size;
    short unsigned int tx_loadsz;
    unsigned char fcr;
    unsigned char rxtrig_bytes[4];
    unsigned int flags;
};

struct serial_ctrl_device {
    struct device dev;
    struct ida port_ida;
};

struct serial_icounter_struct {
    int cts;
    int dsr;
    int rng;
    int dcd;
    int rx;
    int tx;
    int frame;
    int overrun;
    int parity;
    int brk;
    int buf_overrun;
    int reserved[9];
};

struct serial_port_device {
    struct device dev;
    struct uart_port *port;
    unsigned int tx_enabled: 1;
};

struct serial_struct {
    int type;
    int line;
    unsigned int port;
    int irq;
    int flags;
    int xmit_fifo_size;
    int custom_divisor;
    int baud_base;
    short unsigned int close_delay;
    char io_type;
    char reserved_char[1];
    int hub6;
    short unsigned int closing_wait;
    short unsigned int closing_wait2;
    unsigned char *iomem_base;
    short unsigned int iomem_reg_shift;
    unsigned int port_high;
    long unsigned int iomap_base;
};

struct serial_struct32 {
    compat_int_t type;
    compat_int_t line;
    compat_uint_t port;
    compat_int_t irq;
    compat_int_t flags;
    compat_int_t xmit_fifo_size;
    compat_int_t custom_divisor;
    compat_int_t baud_base;
    short unsigned int close_delay;
    char io_type;
    char reserved_char;
    compat_int_t hub6;
    short unsigned int closing_wait;
    short unsigned int closing_wait2;
    compat_uint_t iomem_base;
    short unsigned int iomem_reg_shift;
    unsigned int port_high;
    compat_int_t reserved;
};

struct serport {
    struct tty_port *port;
    struct tty_struct *tty;
    struct tty_driver *tty_drv;
    int tty_idx;
    long unsigned int flags;
};

struct service_data_struct {
    int fourcc;
    int clientid;
    int use_count;
};

struct service_stats_struct {
    int quota_stalls;
    int slot_stalls;
    int bulk_stalls;
    int error_count;
    int ctrl_tx_count;
    int ctrl_rx_count;
    int bulk_tx_count;
    int bulk_rx_count;
    int bulk_aborted_count;
    u64 ctrl_tx_bytes;
    u64 ctrl_rx_bytes;
    u64 bulk_tx_bytes;
    u64 bulk_rx_bytes;
};

struct set_affinity_pending {
    refcount_t refs;
    unsigned int stop_pending;
    struct completion done;
    struct cpu_stop_work stop_work;
    struct migration_arg arg;
};

struct set_config_request {
    struct usb_device *udev;
    int config;
    struct work_struct work;
    struct list_head node;
};

struct set_event_iter {
    enum set_event_iter_type type;
    union {
        struct trace_event_file *file;
        struct event_mod_load *event_mod;
    };
};

struct set_perm_data {
    const efi_memory_desc_t *md;
    bool has_bti;
};

struct setid_rule {
    struct hlist_node next;
    kid_t src_id;
    kid_t dst_id;
    enum setid_type type;
};

struct setid_ruleset {
    struct hlist_head rules[256];
    char *policy_str;
    struct callback_head rcu;
    enum setid_type type;
};

struct sfp;

struct sfp_socket_ops;

struct sfp_quirk;

struct sfp_upstream_ops;

struct sfp_bus {
    struct kref kref;
    struct list_head node;
    const struct fwnode_handle *fwnode;
    const struct sfp_socket_ops *socket_ops;
    struct device *sfp_dev;
    struct sfp *sfp;
    const struct sfp_quirk *sfp_quirk;
    const struct sfp_upstream_ops *upstream_ops;
    void *upstream;
    struct phy_device *phydev;
    bool registered;
    bool started;
};

struct sfp_eeprom_base {
    u8 phys_id;
    u8 phys_ext_id;
    u8 connector;
    u8 if_1x_copper_passive: 1;
    u8 if_1x_copper_active: 1;
    u8 if_1x_lx: 1;
    u8 if_1x_sx: 1;
    u8 e10g_base_sr: 1;
    u8 e10g_base_lr: 1;
    u8 e10g_base_lrm: 1;
    u8 e10g_base_er: 1;
    u8 sonet_oc3_short_reach: 1;
    u8 sonet_oc3_smf_intermediate_reach: 1;
    u8 sonet_oc3_smf_long_reach: 1;
    u8 unallocated_5_3: 1;
    u8 sonet_oc12_short_reach: 1;
    u8 sonet_oc12_smf_intermediate_reach: 1;
    u8 sonet_oc12_smf_long_reach: 1;
    u8 unallocated_5_7: 1;
    u8 sonet_oc48_short_reach: 1;
    u8 sonet_oc48_intermediate_reach: 1;
    u8 sonet_oc48_long_reach: 1;
    u8 sonet_reach_bit2: 1;
    u8 sonet_reach_bit1: 1;
    u8 sonet_oc192_short_reach: 1;
    u8 escon_smf_1310_laser: 1;
    u8 escon_mmf_1310_led: 1;
    u8 e1000_base_sx: 1;
    u8 e1000_base_lx: 1;
    u8 e1000_base_cx: 1;
    u8 e1000_base_t: 1;
    u8 e100_base_lx: 1;
    u8 e100_base_fx: 1;
    u8 e_base_bx10: 1;
    u8 e_base_px: 1;
    u8 fc_tech_electrical_inter_enclosure: 1;
    u8 fc_tech_lc: 1;
    u8 fc_tech_sa: 1;
    u8 fc_ll_m: 1;
    u8 fc_ll_l: 1;
    u8 fc_ll_i: 1;
    u8 fc_ll_s: 1;
    u8 fc_ll_v: 1;
    u8 unallocated_8_0: 1;
    u8 unallocated_8_1: 1;
    u8 sfp_ct_passive: 1;
    u8 sfp_ct_active: 1;
    u8 fc_tech_ll: 1;
    u8 fc_tech_sl: 1;
    u8 fc_tech_sn: 1;
    u8 fc_tech_electrical_intra_enclosure: 1;
    u8 fc_media_sm: 1;
    u8 unallocated_9_1: 1;
    u8 fc_media_m5: 1;
    u8 fc_media_m6: 1;
    u8 fc_media_tv: 1;
    u8 fc_media_mi: 1;
    u8 fc_media_tp: 1;
    u8 fc_media_tw: 1;
    u8 fc_speed_100: 1;
    u8 unallocated_10_1: 1;
    u8 fc_speed_200: 1;
    u8 fc_speed_3200: 1;
    u8 fc_speed_400: 1;
    u8 fc_speed_1600: 1;
    u8 fc_speed_800: 1;
    u8 fc_speed_1200: 1;
    u8 encoding;
    u8 br_nominal;
    u8 rate_id;
    u8 link_len[6];
    char vendor_name[16];
    u8 extended_cc;
    char vendor_oui[3];
    char vendor_pn[16];
    char vendor_rev[4];
    union {
        __be16 optical_wavelength;
        __be16 cable_compliance;
        struct {
            u8 sff8431_app_e: 1;
            u8 fc_pi_4_app_h: 1;
            u8 reserved60_2: 6;
            u8 reserved61: 8;
        } passive;
        struct {
            u8 sff8431_app_e: 1;
            u8 fc_pi_4_app_h: 1;
            u8 sff8431_lim: 1;
            u8 fc_pi_4_lim: 1;
            u8 reserved60_4: 4;
            u8 reserved61: 8;
        } active;
    };
    u8 reserved62;
    u8 cc_base;
};

struct sfp_eeprom_ext {
    __be16 options;
    u8 br_max;
    u8 br_min;
    char vendor_sn[16];
    char datecode[8];
    u8 diagmon;
    u8 enhopts;
    u8 sff8472_compliance;
    u8 cc_ext;
};

struct sfp_eeprom_id {
    struct sfp_eeprom_base base;
    struct sfp_eeprom_ext ext;
};

struct sfp_quirk {
    const char *vendor;
    const char *part;
    void (*modes)(const struct sfp_eeprom_id *, long unsigned int *, long unsigned int *);
    void (*fixup)(struct sfp *);
};

struct sfp_socket_ops {
    void (*attach)(struct sfp *);
    void (*detach)(struct sfp *);
    void (*start)(struct sfp *);
    void (*stop)(struct sfp *);
    void (*set_signal_rate)(struct sfp *, unsigned int);
    int (*module_info)(struct sfp *, struct ethtool_modinfo *);
    int (*module_eeprom)(struct sfp *, struct ethtool_eeprom *, u8 *);
    int (*module_eeprom_by_page)(struct sfp *, const struct ethtool_module_eeprom *, struct netlink_ext_ack *);
};

struct sfp_upstream_ops {
    void (*attach)(void *, struct sfp_bus *);
    void (*detach)(void *, struct sfp_bus *);
    int (*module_insert)(void *, const struct sfp_eeprom_id *);
    void (*module_remove)(void *);
    int (*module_start)(void *);
    void (*module_stop)(void *);
    void (*link_down)(void *);
    void (*link_up)(void *);
    int (*connect_phy)(void *, struct phy_device *);
    void (*disconnect_phy)(void *, struct phy_device *);
};

struct sg {
    struct ext4_group_info info;
    ext4_grpblk_t counters[18];
};

struct sg_append_table {
    struct sg_table sgt;
    struct scatterlist *prv;
    unsigned int total_nents;
};

struct sg_device {
    struct scsi_device *device;
    wait_queue_head_t open_wait;
    struct mutex open_rel_lock;
    int sg_tablesize;
    u32 index;
    struct list_head sfds;
    rwlock_t sfd_lock;
    atomic_t detaching;
    bool exclude;
    int open_cnt;
    char sgdebug;
    char name[32];
    struct cdev *cdev;
    struct kref d_ref;
};

typedef struct sg_device Sg_device;

struct sg_dma_page_iter {
    struct sg_page_iter base;
};

struct sg_scatter_hold {
    short unsigned int k_use_sg;
    unsigned int sglist_len;
    unsigned int bufflen;
    struct page **pages;
    int page_order;
    char dio_in_use;
    unsigned char cmd_opcode;
};

typedef struct sg_scatter_hold Sg_scatter_hold;

struct sg_io_hdr {
    int interface_id;
    int dxfer_direction;
    unsigned char cmd_len;
    unsigned char mx_sb_len;
    short unsigned int iovec_count;
    unsigned int dxfer_len;
    void *dxferp;
    unsigned char *cmdp;
    void *sbp;
    unsigned int timeout;
    unsigned int flags;
    int pack_id;
    void *usr_ptr;
    unsigned char status;
    unsigned char masked_status;
    unsigned char msg_status;
    unsigned char sb_len_wr;
    short unsigned int host_status;
    short unsigned int driver_status;
    int resid;
    unsigned int duration;
    unsigned int info;
};

typedef struct sg_io_hdr sg_io_hdr_t;

struct sg_fd;

struct sg_request {
    struct list_head entry;
    struct sg_fd *parentfp;
    Sg_scatter_hold data;
    sg_io_hdr_t header;
    unsigned char sense_b[96];
    char res_used;
    char orphan;
    char sg_io_owned;
    char done;
    struct request *rq;
    struct bio *bio;
    struct execute_work ew;
};

typedef struct sg_request Sg_request;

struct sg_fd {
    struct list_head sfd_siblings;
    struct sg_device *parentdp;
    wait_queue_head_t read_wait;
    rwlock_t rq_list_lock;
    struct mutex f_mutex;
    int timeout;
    int timeout_user;
    Sg_scatter_hold reserve;
    struct list_head rq_list;
    struct fasync_struct *async_qp;
    Sg_request req_arr[16];
    char force_packid;
    char cmd_q;
    unsigned char next_cmd_len;
    char keep_orphan;
    char mmap_called;
    char res_in_use;
    struct kref f_ref;
    struct execute_work ew;
};

typedef struct sg_fd Sg_fd;

struct sg_header {
    int pack_len;
    int reply_len;
    int pack_id;
    int result;
    unsigned int twelve_byte: 1;
    unsigned int target_status: 5;
    unsigned int host_status: 8;
    unsigned int driver_status: 8;
    unsigned int other_flags: 10;
    unsigned char sense_buffer[16];
};

struct sg_io_v4 {
    __s32 guard;
    __u32 protocol;
    __u32 subprotocol;
    __u32 request_len;
    __u64 request;
    __u64 request_tag;
    __u32 request_attr;
    __u32 request_priority;
    __u32 request_extra;
    __u32 max_response_len;
    __u64 response;
    __u32 dout_iovec_count;
    __u32 dout_xfer_len;
    __u32 din_iovec_count;
    __u32 din_xfer_len;
    __u64 dout_xferp;
    __u64 din_xferp;
    __u32 timeout;
    __u32 flags;
    __u64 usr_ptr;
    __u32 spare_in;
    __u32 driver_status;
    __u32 transport_status;
    __u32 device_status;
    __u32 retry_delay;
    __u32 info;
    __u32 duration;
    __u32 response_len;
    __s32 din_resid;
    __s32 dout_resid;
    __u64 generated_tag;
    __u32 spare_out;
    __u32 padding;
};

struct sg_pool {
    size_t size;
    char *name;
    struct kmem_cache *slab;
    mempool_t *pool;
};

struct sg_proc_deviter {
    loff_t index;
    size_t max;
};

struct sg_req_info {
    char req_state;
    char orphan;
    char sg_io_owned;
    char problem;
    int pack_id;
    void *usr_ptr;
    unsigned int duration;
    int unused;
};

typedef struct sg_req_info sg_req_info_t;

struct sg_scsi_id {
    int host_no;
    int channel;
    int scsi_id;
    int lun;
    int scsi_type;
    short int h_cmd_per_lun;
    short int d_queue_depth;
    int unused[2];
};

typedef struct sg_scsi_id sg_scsi_id_t;

struct sha1_state {
    u32 state[5];
    u64 count;
    u8 buffer[64];
};

struct sha256_state {
    u32 state[8];
    u64 count;
    u8 buf[64];
};

struct sha3_state {
    u64 st[25];
    unsigned int rsiz;
    unsigned int rsizw;
    unsigned int partial;
    u8 buf[144];
};

struct sha512_state {
    u64 state[8];
    u64 count[2];
    u8 buf[128];
};

struct shared_policy {};

struct shash_alg {
    int (*init)(struct shash_desc *);
    int (*update)(struct shash_desc *, const u8 *, unsigned int);
    int (*final)(struct shash_desc *, u8 *);
    int (*finup)(struct shash_desc *, const u8 *, unsigned int, u8 *);
    int (*digest)(struct shash_desc *, const u8 *, unsigned int, u8 *);
    int (*export)(struct shash_desc *, void *);
    int (*import)(struct shash_desc *, const void *);
    int (*setkey)(struct crypto_shash *, const u8 *, unsigned int);
    int (*init_tfm)(struct crypto_shash *);
    void (*exit_tfm)(struct crypto_shash *);
    int (*clone_tfm)(struct crypto_shash *, struct crypto_shash *);
    unsigned int descsize;
    union {
        struct {
            unsigned int digestsize;
            unsigned int statesize;
            struct crypto_alg base;
        };
        struct hash_alg_common halg;
    };
};

struct shash_instance {
    void (*free)(struct shash_instance *);
    union {
        struct {
            char head[104];
            struct crypto_instance base;
        } s;
        struct shash_alg alg;
    };
};

struct shift_out_of_bounds_data {
    struct source_location location;
    struct type_descriptor *lhs_type;
    struct type_descriptor *rhs_type;
};

struct shm_file_data {
    int id;
    struct ipc_namespace *ns;
    struct file *file;
    const struct vm_operations_struct *vm_ops;
};

struct shm_info {
    int used_ids;
    __kernel_ulong_t shm_tot;
    __kernel_ulong_t shm_rss;
    __kernel_ulong_t shm_swp;
    __kernel_ulong_t swap_attempts;
    __kernel_ulong_t swap_successes;
};

struct shmem_falloc {
    wait_queue_head_t *waitq;
    long unsigned int start;
    long unsigned int next;
    long unsigned int nr_falloced;
    long unsigned int nr_unswapped;
};

struct shmem_inode_info {
    spinlock_t lock;
    unsigned int seals;
    long unsigned int flags;
    long unsigned int alloced;
    long unsigned int swapped;
    union {
        struct offset_ctx dir_offsets;
        struct {
            struct list_head shrinklist;
            struct list_head swaplist;
        };
    };
    struct timespec64 i_crtime;
    struct shared_policy policy;
    struct simple_xattrs xattrs;
    long unsigned int fallocend;
    unsigned int fsflags;
    atomic_t stop_eviction;
    struct dquot *i_dquot[3];
    struct inode vfs_inode;
};

struct shmem_quota_limits {
    qsize_t usrquota_bhardlimit;
    qsize_t usrquota_ihardlimit;
    qsize_t grpquota_bhardlimit;
    qsize_t grpquota_ihardlimit;
};

struct unicode_map;

struct shmem_options {
    long long unsigned int blocks;
    long long unsigned int inodes;
    struct mempolicy *mpol;
    kuid_t uid;
    kgid_t gid;
    umode_t mode;
    bool full_inums;
    int huge;
    int seen;
    bool noswap;
    short unsigned int quota_types;
    struct shmem_quota_limits qlimits;
    struct unicode_map *encoding;
    bool strict_encoding;
};

struct shmem_sb_info {
    long unsigned int max_blocks;
    struct percpu_counter used_blocks;
    long unsigned int max_inodes;
    long unsigned int free_ispace;
    raw_spinlock_t stat_lock;
    umode_t mode;
    unsigned char huge;
    kuid_t uid;
    kgid_t gid;
    bool full_inums;
    bool noswap;
    ino_t next_ino;
    ino_t *ino_batch;
    struct mempolicy *mpol;
    spinlock_t shrinklist_lock;
    struct list_head shrinklist;
    long unsigned int shrinklist_len;
    struct shmem_quota_limits qlimits;
};

struct shmid64_ds {
    struct ipc64_perm shm_perm;
    __kernel_size_t shm_segsz;
    long int shm_atime;
    long int shm_dtime;
    long int shm_ctime;
    __kernel_pid_t shm_cpid;
    __kernel_pid_t shm_lpid;
    long unsigned int shm_nattch;
    long unsigned int __unused4;
    long unsigned int __unused5;
};

struct shmid_ds {
    struct ipc_perm shm_perm;
    int shm_segsz;
    __kernel_old_time_t shm_atime;
    __kernel_old_time_t shm_dtime;
    __kernel_old_time_t shm_ctime;
    __kernel_ipc_pid_t shm_cpid;
    __kernel_ipc_pid_t shm_lpid;
    short unsigned int shm_nattch;
    short unsigned int shm_unused;
    void *shm_unused2;
    void *shm_unused3;
};

struct shmid_kernel {
    struct kern_ipc_perm shm_perm;
    struct file *shm_file;
    long unsigned int shm_nattch;
    long unsigned int shm_segsz;
    time64_t shm_atim;
    time64_t shm_dtim;
    time64_t shm_ctim;
    struct pid *shm_cprid;
    struct pid *shm_lprid;
    struct ucounts *mlock_ucounts;
    struct task_struct *shm_creator;
    struct list_head shm_clist;
    struct ipc_namespace *ns;
    long: 64;
    long: 64;
    long: 64;
};

struct shminfo {
    int shmmax;
    int shmmin;
    int shmmni;
    int shmseg;
    int shmall;
};

struct shminfo64 {
    long unsigned int shmmax;
    long unsigned int shmmin;
    long unsigned int shmmni;
    long unsigned int shmseg;
    long unsigned int shmall;
    long unsigned int __unused1;
    long unsigned int __unused2;
    long unsigned int __unused3;
    long unsigned int __unused4;
};

struct shortname_info {
    unsigned char lower: 1;
    unsigned char upper: 1;
    unsigned char valid: 1;
};

struct show_busy_params {
    struct seq_file *m;
    struct blk_mq_hw_ctx *hctx;
};

struct shrink_control {
    gfp_t gfp_mask;
    int nid;
    long unsigned int nr_to_scan;
    long unsigned int nr_scanned;
    struct mem_cgroup *memcg;
};

struct shrinker {
    long unsigned int (*count_objects)(struct shrinker *, struct shrink_control *);
    long unsigned int (*scan_objects)(struct shrinker *, struct shrink_control *);
    long int batch;
    int seeks;
    unsigned int flags;
    refcount_t refcount;
    struct completion done;
    struct callback_head rcu;
    void *private_data;
    struct list_head list;
    int id;
    atomic_long_t *nr_deferred;
};

struct shrinker_info_unit;

struct shrinker_info {
    struct callback_head rcu;
    int map_nr_max;
    struct shrinker_info_unit *unit[0];
};

struct shrinker_info_unit {
    atomic_long_t nr_deferred[64];
    long unsigned int map[1];
};

struct sidtab_node_inner;

struct sidtab_node_leaf;

union sidtab_entry_inner {
    struct sidtab_node_inner *ptr_inner;
    struct sidtab_node_leaf *ptr_leaf;
};

struct sidtab_str_cache;

struct sidtab_entry {
    u32 sid;
    u32 hash;
    struct context context;
    struct sidtab_str_cache *cache;
    struct hlist_node list;
};

struct sidtab_isid_entry {
    int set;
    struct sidtab_entry entry;
};

struct sidtab {
    union sidtab_entry_inner roots[4];
    u32 count;
    struct sidtab_convert_params *convert;
    bool frozen;
    spinlock_t lock;
    u32 cache_free_slots;
    struct list_head cache_lru_list;
    spinlock_t cache_lock;
    struct sidtab_isid_entry isids[27];
    struct hlist_head context_to_sid[512];
};

struct sidtab_node_inner {
    union sidtab_entry_inner entries[512];
};

struct sidtab_node_leaf {
    struct sidtab_entry entries[39];
};

struct sidtab_str_cache {
    struct callback_head rcu_member;
    struct list_head lru_member;
    struct sidtab_entry *parent;
    u32 len;
    char str[0];
};

struct sig_alg {
    int (*sign)(struct crypto_sig *, const void *, unsigned int, void *, unsigned int);
    int (*verify)(struct crypto_sig *, const void *, unsigned int, const void *, unsigned int);
    int (*set_pub_key)(struct crypto_sig *, const void *, unsigned int);
    int (*set_priv_key)(struct crypto_sig *, const void *, unsigned int);
    unsigned int (*key_size)(struct crypto_sig *);
    unsigned int (*digest_size)(struct crypto_sig *);
    unsigned int (*max_size)(struct crypto_sig *);
    int (*init)(struct crypto_sig *);
    void (*exit)(struct crypto_sig *);
    struct crypto_alg base;
};

struct sig_instance {
    void (*free)(struct sig_instance *);
    union {
        struct {
            char head[72];
            struct crypto_instance base;
        };
        struct sig_alg alg;
    };
};

typedef struct sigevent sigevent_t;

struct sighand_struct {
    spinlock_t siglock;
    refcount_t count;
    wait_queue_head_t signalfd_wqh;
    struct k_sigaction action[64];
};

struct sigpending {
    struct list_head list;
    sigset_t signal;
};

struct task_cputime_atomic {
    atomic64_t utime;
    atomic64_t stime;
    atomic64_t sum_exec_runtime;
};

struct thread_group_cputimer {
    struct task_cputime_atomic cputime_atomic;
};

struct task_io_accounting {
    u64 rchar;
    u64 wchar;
    u64 syscr;
    u64 syscw;
    u64 read_bytes;
    u64 write_bytes;
    u64 cancelled_write_bytes;
};

struct taskstats;

struct tty_audit_buf;

struct signal_struct {
    refcount_t sigcnt;
    atomic_t live;
    int nr_threads;
    int quick_threads;
    struct list_head thread_head;
    wait_queue_head_t wait_chldexit;
    struct task_struct *curr_target;
    struct sigpending shared_pending;
    struct hlist_head multiprocess;
    int group_exit_code;
    int notify_count;
    struct task_struct *group_exec_task;
    int group_stop_count;
    unsigned int flags;
    struct core_state *core_state;
    unsigned int is_child_subreaper: 1;
    unsigned int has_child_subreaper: 1;
    unsigned int next_posix_timer_id;
    struct hlist_head posix_timers;
    struct hlist_head ignored_posix_timers;
    struct hrtimer real_timer;
    ktime_t it_real_incr;
    struct cpu_itimer it[2];
    struct thread_group_cputimer cputimer;
    struct posix_cputimers posix_cputimers;
    struct pid *pids[4];
    atomic_t tick_dep_mask;
    struct pid *tty_old_pgrp;
    int leader;
    struct tty_struct *tty;
    struct autogroup *autogroup;
    seqlock_t stats_lock;
    u64 utime;
    u64 stime;
    u64 cutime;
    u64 cstime;
    u64 gtime;
    u64 cgtime;
    struct prev_cputime prev_cputime;
    long unsigned int nvcsw;
    long unsigned int nivcsw;
    long unsigned int cnvcsw;
    long unsigned int cnivcsw;
    long unsigned int min_flt;
    long unsigned int maj_flt;
    long unsigned int cmin_flt;
    long unsigned int cmaj_flt;
    long unsigned int inblock;
    long unsigned int oublock;
    long unsigned int cinblock;
    long unsigned int coublock;
    long unsigned int maxrss;
    long unsigned int cmaxrss;
    struct task_io_accounting ioac;
    long long unsigned int sum_sched_runtime;
    struct rlimit rlim[16];
    struct pacct_struct pacct;
    struct taskstats *stats;
    unsigned int audit_tty;
    struct tty_audit_buf *tty_audit_buf;
    bool oom_flag_origin;
    short int oom_score_adj;
    short int oom_score_adj_min;
    struct mm_struct *oom_mm;
    struct mutex cred_guard_mutex;
    struct rw_semaphore exec_update_lock;
};

struct signalfd_ctx {
    sigset_t sigmask;
};

struct signalfd_siginfo {
    __u32 ssi_signo;
    __s32 ssi_errno;
    __s32 ssi_code;
    __u32 ssi_pid;
    __u32 ssi_uid;
    __s32 ssi_fd;
    __u32 ssi_tid;
    __u32 ssi_band;
    __u32 ssi_overrun;
    __u32 ssi_trapno;
    __s32 ssi_status;
    __s32 ssi_int;
    __u64 ssi_ptr;
    __u64 ssi_utime;
    __u64 ssi_stime;
    __u64 ssi_addr;
    __u16 ssi_addr_lsb;
    __u16 __pad2;
    __s32 ssi_syscall;
    __u64 ssi_call_addr;
    __u32 ssi_arch;
    __u8 __pad[28];
};

struct signature_hdr {
    uint8_t version;
    uint32_t timestamp;
    uint8_t algo;
    uint8_t hash;
    uint8_t keyid[8];
    uint8_t nmpi;
    char mpi[0];
} __attribute__((packed));

struct signature_v2_hdr {
    uint8_t type;
    uint8_t version;
    uint8_t hash_algo;
    __be32 keyid;
    __be16 sig_size;
    uint8_t sig[0];
} __attribute__((packed));

struct sigpool_entry {
    struct crypto_ahash *hash;
    const char *alg;
    struct kref kref;
    uint16_t needs_key: 1;
    uint16_t reserved: 15;
};

struct sigpool_scratch {
    local_lock_t bh_lock;
    void *pad;
};

struct sigset_argpack {
    sigset_t *p;
    size_t size;
};

struct simple_attr {
    int (*get)(void *, u64 *);
    int (*set)(void *, u64);
    char get_buf[24];
    char set_buf[24];
    void *data;
    const char *fmt;
    struct mutex mutex;
};

struct simple_pm_bus {
    struct clk_bulk_data *clks;
    int num_clks;
};

struct simple_transaction_argresp {
    ssize_t size;
    char data[0];
};

struct simple_xattr {
    struct rb_node rb_node;
    char *name;
    size_t size;
    char value[0];
};

struct simplefb_format {
    const char *name;
    u32 bits_per_pixel;
    struct fb_bitfield red;
    struct fb_bitfield green;
    struct fb_bitfield blue;
    struct fb_bitfield transp;
    u32 fourcc;
};

struct simplefb_par {
    u32 palette[16];
    resource_size_t base;
    resource_size_t size;
    struct resource *mem;
    bool clks_enabled;
    unsigned int clk_count;
    struct clk **clks;
    unsigned int num_genpds;
    struct device **genpds;
    struct device_link **genpd_links;
    bool regulators_enabled;
    u32 regulator_count;
    struct regulator **regulators;
};

struct simplefb_params {
    u32 width;
    u32 height;
    u32 stride;
    struct simplefb_format *format;
    struct resource memory;
};

struct simplefb_platform_data {
    u32 width;
    u32 height;
    u32 stride;
    const char *format;
};

struct sioc_mif_req6 {
    mifi_t mifi;
    long unsigned int icount;
    long unsigned int ocount;
    long unsigned int ibytes;
    long unsigned int obytes;
};

struct sioc_sg_req {
    struct in_addr src;
    struct in_addr grp;
    long unsigned int pktcnt;
    long unsigned int bytecnt;
    long unsigned int wrong_if;
};

struct sioc_sg_req6 {
    struct sockaddr_in6 src;
    struct sockaddr_in6 grp;
    long unsigned int pktcnt;
    long unsigned int bytecnt;
    long unsigned int wrong_if;
};

struct sioc_vif_req {
    vifi_t vifi;
    long unsigned int icount;
    long unsigned int ocount;
    long unsigned int ibytes;
    long unsigned int obytes;
};

struct sk_buff__safe_rcu_or_null {
    struct sock *sk;
};

struct sk_buff_fclones {
    struct sk_buff skb1;
    struct sk_buff skb2;
    refcount_t fclone_ref;
};

struct sk_filter {
    refcount_t refcnt;
    struct callback_head rcu;
    struct bpf_prog *prog;
};

struct sk_psock_work_state {
    u32 len;
    u32 off;
};

struct sk_psock {
    struct sock *sk;
    struct sock *sk_redir;
    u32 apply_bytes;
    u32 cork_bytes;
    u32 eval;
    bool redir_ingress;
    struct sk_msg *cork;
    struct sk_psock_progs progs;
    struct strparser strp;
    u32 copied_seq;
    u32 ingress_bytes;
    struct sk_buff_head ingress_skb;
    struct list_head ingress_msg;
    spinlock_t ingress_lock;
    long unsigned int state;
    struct list_head link;
    spinlock_t link_lock;
    refcount_t refcnt;
    void (*saved_unhash)(struct sock *);
    void (*saved_destroy)(struct sock *);
    void (*saved_close)(struct sock *, long int);
    void (*saved_write_space)(struct sock *);
    void (*saved_data_ready)(struct sock *);
    int (*psock_update_sk_prot)(struct sock *, struct sk_psock *, bool);
    struct proto *sk_proto;
    struct mutex work_mutex;
    struct sk_psock_work_state work_state;
    struct delayed_work work;
    struct sock *sk_pair;
    struct rcu_work rwork;
};

struct sk_psock_link {
    struct list_head list;
    struct bpf_map *map;
    void *link_raw;
};

struct sk_security_struct {
    enum {
        NLBL_UNSET = 0,
        NLBL_REQUIRE = 1,
        NLBL_LABELED = 2,
        NLBL_REQSKB = 3,
        NLBL_CONNLABELED = 4,
    } nlbl_state;
    struct netlbl_lsm_secattr *nlbl_secattr;
    u32 sid;
    u32 peer_sid;
    u16 sclass;
    enum {
        SCTP_ASSOC_UNSET = 0,
        SCTP_ASSOC_SET = 1,
    } sctp_assoc_state;
};

struct tls_msg {
    u8 control;
};

struct sk_skb_cb {
    unsigned char data[20];
    unsigned char pad[4];
    struct _strp_msg strp;
    struct tls_msg tls;
    u64 temp_reg;
};

struct skb_checksum_ops {
    __wsum (*update)(const void *, int, __wsum);
    __wsum (*combine)(__wsum, __wsum, int, int);
};

struct skb_data {
    struct urb *urb;
    struct lan78xx_net *dev;
    enum skb_state state;
    size_t length;
    int num_of_packet;
};

struct skb_data___2 {
    struct urb *urb;
    struct usbnet *dev;
    enum skb_state state;
    long int length;
    long unsigned int packets;
};

struct skb_ext {
    refcount_t refcnt;
    u8 offset[3];
    u8 chunks;
    char data[0];
};

struct skb_frag {
    netmem_ref netmem;
    unsigned int len;
    unsigned int offset;
};

typedef struct skb_frag skb_frag_t;

struct skb_free_array {
    unsigned int skb_count;
    void *skb_array[16];
};

struct skb_gso_cb {
    union {
        int mac_offset;
        int data_offset;
    };
    int encap_level;
    __wsum csum;
    __u16 csum_start;
};

struct skb_seq_state {
    __u32 lower_offset;
    __u32 upper_offset;
    __u32 frag_idx;
    __u32 stepped_offset;
    struct sk_buff *root_skb;
    struct sk_buff *cur_skb;
    __u8 *frag_data;
    __u32 frag_off;
};

struct skb_shared_hwtstamps {
    union {
        ktime_t hwtstamp;
        void *netdev_data;
    };
};

struct xsk_tx_metadata_compl {
    __u64 *tx_timestamp;
};

struct skb_shared_info {
    __u8 flags;
    __u8 meta_len;
    __u8 nr_frags;
    __u8 tx_flags;
    short unsigned int gso_size;
    short unsigned int gso_segs;
    struct sk_buff *frag_list;
    union {
        struct skb_shared_hwtstamps hwtstamps;
        struct xsk_tx_metadata_compl xsk_meta;
    };
    unsigned int gso_type;
    u32 tskey;
    atomic_t dataref;
    union {
        struct {
            u32 xdp_frags_size;
            u32 xdp_frags_truesize;
        };
        void *destructor_arg;
    };
    skb_frag_t frags[17];
};

struct skcipher_alg {
    int (*setkey)(struct crypto_skcipher *, const u8 *, unsigned int);
    int (*encrypt)(struct skcipher_request *);
    int (*decrypt)(struct skcipher_request *);
    int (*export)(struct skcipher_request *, void *);
    int (*import)(struct skcipher_request *, const void *);
    int (*init)(struct crypto_skcipher *);
    void (*exit)(struct crypto_skcipher *);
    unsigned int walksize;
    union {
        struct {
            unsigned int min_keysize;
            unsigned int max_keysize;
            unsigned int ivsize;
            unsigned int chunksize;
            unsigned int statesize;
            struct crypto_alg base;
        };
        struct skcipher_alg_common co;
    };
};

struct skcipher_ctx_simple {
    struct crypto_cipher *cipher;
};

struct skcipher_instance {
    void (*free)(struct skcipher_instance *);
    union {
        struct {
            char head[88];
            struct crypto_instance base;
        } s;
        struct skcipher_alg alg;
    };
};

struct skcipher_walk {
    union {
        struct {
            void *addr;
        } virt;
    } src;
    union {
        struct {
            void *addr;
        } virt;
    } dst;
    struct scatter_walk in;
    unsigned int nbytes;
    struct scatter_walk out;
    unsigned int total;
    u8 *page;
    u8 *buffer;
    u8 *oiv;
    void *iv;
    unsigned int ivsize;
    int flags;
    unsigned int blocksize;
    unsigned int stride;
    unsigned int alignmask;
};

struct slab {
    long unsigned int __page_flags;
    struct kmem_cache *slab_cache;
    union {
        struct {
            union {
                struct list_head slab_list;
                struct {
                    struct slab *next;
                    int slabs;
                };
            };
            union {
                struct {
                    void *freelist;
                    union {
                        long unsigned int counters;
                        struct {
                            unsigned int inuse: 16;
                            unsigned int objects: 15;
                            unsigned int frozen: 1;
                        };
                    };
                };
                freelist_aba_t freelist_counter;
            };
        };
        struct callback_head callback_head;
    };
    unsigned int __page_type;
    atomic_t __page_refcount;
    long unsigned int obj_exts;
};

struct slab_attribute {
    struct attribute attr;
    ssize_t (*show)(struct kmem_cache *, char *);
    ssize_t (*store)(struct kmem_cache *, const char *, size_t);
};

struct slabinfo {
    long unsigned int active_objs;
    long unsigned int num_objs;
    long unsigned int active_slabs;
    long unsigned int num_slabs;
    long unsigned int shared_avail;
    unsigned int limit;
    unsigned int batchcount;
    unsigned int shared;
    unsigned int objects_per_slab;
    unsigned int cache_order;
};

struct slabobj_ext {
    struct obj_cgroup *objcg;
};

struct sleep_stack_data {
    struct cpu_suspend_ctx system_regs;
    long unsigned int callee_saved_regs[12];
};

struct slub_flush_work {
    struct work_struct work;
    struct kmem_cache *s;
    bool skip;
};

struct smack_audit_data {
    const char *function;
    char *subject;
    char *object;
    char *request;
    int result;
};

struct smack_known {
    struct list_head list;
    struct hlist_node smk_hashed;
    char *smk_known;
    u32 smk_secid;
    struct netlbl_lsm_secattr smk_netlabel;
    struct list_head smk_rules;
    struct mutex smk_rules_lock;
};

struct smack_known_list_elem {
    struct list_head list;
    struct smack_known *smk_label;
};

struct smack_mnt_opts {
    const char *fsdefault;
    const char *fsfloor;
    const char *fshat;
    const char *fsroot;
    const char *fstransmute;
};

struct smack_parsed_rule {
    struct smack_known *smk_subject;
    struct smack_known *smk_object;
    int smk_access1;
    int smk_access2;
};

struct smack_rule {
    struct list_head list;
    struct smack_known *smk_subject;
    struct smack_known *smk_object;
    int smk_access;
};

struct smk_audit_info {
    struct common_audit_data a;
    struct smack_audit_data sad;
};

struct smk_net4addr {
    struct list_head list;
    struct in_addr smk_host;
    struct in_addr smk_mask;
    int smk_masks;
    struct smack_known *smk_label;
};

struct smk_net6addr {
    struct list_head list;
    struct in6_addr smk_host;
    struct in6_addr smk_mask;
    int smk_masks;
    struct smack_known *smk_label;
};

struct smp_call_on_cpu_struct {
    struct work_struct work;
    struct completion done;
    int (*func)(void *);
    void *data;
    int ret;
    int cpu;
};

struct smp_hotplug_thread {
    struct task_struct **store;
    struct list_head list;
    int (*thread_should_run)(unsigned int);
    void (*thread_fn)(unsigned int);
    void (*create)(unsigned int);
    void (*setup)(unsigned int);
    void (*cleanup)(unsigned int, bool);
    void (*park)(unsigned int);
    void (*unpark)(unsigned int);
    bool selfparking;
    const char *thread_comm;
};

struct smpboot_thread_data {
    unsigned int cpu;
    unsigned int status;
    struct smp_hotplug_thread *ht;
};

struct smsc95xx_priv {
    u32 mac_cr;
    u32 hash_hi;
    u32 hash_lo;
    u32 wolopts;
    spinlock_t mac_cr_lock;
    u8 features;
    u8 suspend_flags;
    bool is_internal_phy;
    struct irq_chip irqchip;
    struct irq_domain *irqdomain;
    struct fwnode_handle *irqfwnode;
    struct mii_bus *mdiobus;
    struct phy_device *phydev;
    struct task_struct *pm_task;
};

struct smsc_hw_stat {
    const char *string;
    u8 reg;
    u8 bits;
};

struct smsc_phy_priv {
    unsigned int edpd_enable: 1;
    unsigned int edpd_mode_set_by_user: 1;
    unsigned int edpd_max_wait_ms;
    bool wol_arp;
};

struct snapshot_context {
    struct tracing_map_elt *elt;
    void *key;
};

struct snmp_mib {
    const char *name;
    int entry;
};

struct so_timestamping {
    int flags;
    int bind_phc;
};

struct soc_device_attribute;

struct soc_device {
    struct device dev;
    struct soc_device_attribute *attr;
    int soc_dev_num;
};

struct soc_device_attribute {
    const char *machine;
    const char *family;
    const char *revision;
    const char *serial_number;
    const char *soc_id;
    const void *data;
    const struct attribute_group *custom_attr_group;
};

struct sock_bh_locked {
    struct sock *sock;
    local_lock_t bh_lock;
};

struct sock_diag_handler {
    struct module *owner;
    __u8 family;
    int (*dump)(struct sk_buff *, struct nlmsghdr *);
    int (*get_info)(struct sk_buff *, struct sock *);
    int (*destroy)(struct sk_buff *, struct nlmsghdr *);
};

struct sock_diag_inet_compat {
    struct module *owner;
    int (*fn)(struct sk_buff *, struct nlmsghdr *);
};

struct sock_diag_req {
    __u8 sdiag_family;
    __u8 sdiag_protocol;
};

struct sock_ee_data_rfc4884 {
    __u16 len;
    __u8 flags;
    __u8 reserved;
};

struct sock_extended_err {
    __u32 ee_errno;
    __u8 ee_origin;
    __u8 ee_type;
    __u8 ee_code;
    __u8 ee_pad;
    __u32 ee_info;
    union {
        __u32 ee_data;
        struct sock_ee_data_rfc4884 ee_rfc4884;
    };
};

struct sock_exterr_skb {
    union {
        struct inet_skb_parm h4;
        struct inet6_skb_parm h6;
    } header;
    struct sock_extended_err ee;
    u16 addr_offset;
    __be16 port;
    u8 opt_stats: 1;
    u8 unused: 7;
};

struct sock_fprog {
    short unsigned int len;
    struct sock_filter *filter;
};

struct sock_fprog_kern {
    u16 len;
    struct sock_filter *filter;
};

struct sock_hash_seq_info {
    struct bpf_map *map;
    struct bpf_shtab *htab;
    u32 bucket_id;
};

struct sock_map_seq_info {
    struct bpf_map *map;
    struct sock *sk;
    u32 index;
};

struct sock_reuseport {
    struct callback_head rcu;
    u16 max_socks;
    u16 num_socks;
    u16 num_closed_socks;
    u16 incoming_cpu;
    unsigned int synq_overflow_ts;
    unsigned int reuseport_id;
    unsigned int bind_inany: 1;
    unsigned int has_conns: 1;
    struct bpf_prog *prog;
    struct sock *socks[0];
};

struct sock_skb_cb {
    u32 dropcount;
};

struct sock_txtime {
    __kernel_clockid_t clockid;
    __u32 flags;
};

struct sockaddr_nl {
    __kernel_sa_family_t nl_family;
    short unsigned int nl_pad;
    __u32 nl_pid;
    __u32 nl_groups;
};

struct sockaddr_un {
    __kernel_sa_family_t sun_family;
    char sun_path[108];
};

struct sockaddr_xdp {
    __u16 sxdp_family;
    __u16 sxdp_flags;
    __u32 sxdp_ifindex;
    __u32 sxdp_queue_id;
    __u32 sxdp_shared_umem_fd;
};

struct socket_wq {
    wait_queue_head_t wait;
    struct fasync_struct *fasync_list;
    long unsigned int flags;
    struct callback_head rcu;
    long: 64;
};

struct socket {
    socket_state state;
    short int type;
    long unsigned int flags;
    struct file *file;
    struct sock *sk;
    const struct proto_ops *ops;
    long: 64;
    long: 64;
    long: 64;
    struct socket_wq wq;
};

struct socket__safe_trusted_or_null {
    struct sock *sk;
};

struct socket_alloc {
    struct socket socket;
    struct inode vfs_inode;
    long: 64;
    long: 64;
    long: 64;
};

struct socket_smack {
    struct smack_known *smk_out;
    struct smack_known *smk_in;
    struct smack_known *smk_packet;
    int smk_state;
};

struct sockmap_link {
    struct bpf_link link;
    struct bpf_map *map;
    enum bpf_attach_type attach_type;
};

struct softirq_action {
    void (*action)(void);
};

struct softnet_data {
    struct list_head poll_list;
    struct sk_buff_head process_queue;
    local_lock_t process_queue_bh_lock;
    unsigned int processed;
    unsigned int time_squeeze;
    struct softnet_data *rps_ipi_list;
    unsigned int received_rps;
    bool in_net_rx_action;
    bool in_napi_threaded_poll;
    struct sd_flow_limit *flow_limit;
    struct Qdisc *output_queue;
    struct Qdisc **output_queue_tailp;
    struct sk_buff *completion_queue;
    struct sk_buff_head xfrm_backlog;
    struct netdev_xmit xmit;
    long: 0;
    unsigned int input_queue_head;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    call_single_data_t csd;
    struct softnet_data *rps_ipi_next;
    unsigned int cpu;
    unsigned int input_queue_tail;
    struct sk_buff_head input_pkt_queue;
    struct napi_struct backlog;
    long: 64;
    atomic_t dropped;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    spinlock_t defer_lock;
    int defer_count;
    int defer_ipi_scheduled;
    struct sk_buff *defer_list;
    long: 64;
    call_single_data_t defer_csd;
};

struct software_node {
    const char *name;
    const struct software_node *parent;
    const struct property_entry *properties;
};

struct software_node_ref_args {
    const struct software_node *node;
    unsigned int nargs;
    u64 args[16];
};

struct solaris_x86_slice {
    __le16 s_tag;
    __le16 s_flag;
    __le32 s_start;
    __le32 s_size;
};

struct solaris_x86_vtoc {
    unsigned int v_bootinfo[3];
    __le32 v_sanity;
    __le32 v_version;
    char v_volume[8];
    __le16 v_sectorsz;
    __le16 v_nparts;
    unsigned int v_reserved[10];
    struct solaris_x86_slice v_slice[16];
    unsigned int timestamp[16];
    char v_asciilabel[128];
};

struct sound_unit {
    int unit_minor;
    const struct file_operations *unit_fops;
    struct sound_unit *next;
    char name[32];
};

struct sp804_clkevt {
    void *base;
    void *load;
    void *load_h;
    void *value;
    void *value_h;
    void *ctrl;
    void *intclr;
    void *ris;
    void *mis;
    void *bgload;
    void *bgload_h;
    long unsigned int reload;
    int width;
};

struct sp804_timer {
    int load;
    int load_h;
    int value;
    int value_h;
    int ctrl;
    int intclr;
    int ris;
    int mis;
    int bgload;
    int bgload_h;
    int timer_base[2];
    int width;
};

struct space_resv {
    __s16 l_type;
    __s16 l_whence;
    __s64 l_start;
    __s64 l_len;
    __s32 l_sysid;
    __u32 l_pid;
    __s32 l_pad[4];
};

struct spectre_v4_param {
    const char *str;
    enum spectre_v4_policy policy;
};

struct spi_device;

struct spi_message;

struct spi_transfer;

struct spi_controller_mem_ops;

struct spi_controller_mem_caps;

struct spi_statistics;

struct spi_controller {
    struct device dev;
    struct list_head list;
    s16 bus_num;
    u16 num_chipselect;
    u16 dma_alignment;
    u32 mode_bits;
    u32 buswidth_override_bits;
    u32 bits_per_word_mask;
    u32 min_speed_hz;
    u32 max_speed_hz;
    u16 flags;
    bool devm_allocated;
    union {
        bool slave;
        bool target;
    };
    size_t (*max_transfer_size)(struct spi_device *);
    size_t (*max_message_size)(struct spi_device *);
    struct mutex io_mutex;
    struct mutex add_lock;
    spinlock_t bus_lock_spinlock;
    struct mutex bus_lock_mutex;
    bool bus_lock_flag;
    int (*setup)(struct spi_device *);
    int (*set_cs_timing)(struct spi_device *);
    int (*transfer)(struct spi_device *, struct spi_message *);
    void (*cleanup)(struct spi_device *);
    bool (*can_dma)(struct spi_controller *, struct spi_device *, struct spi_transfer *);
    struct device *dma_map_dev;
    struct device *cur_rx_dma_dev;
    struct device *cur_tx_dma_dev;
    bool queued;
    struct kthread_worker *kworker;
    struct kthread_work pump_messages;
    spinlock_t queue_lock;
    struct list_head queue;
    struct spi_message *cur_msg;
    struct completion cur_msg_completion;
    bool cur_msg_incomplete;
    bool cur_msg_need_completion;
    bool busy;
    bool running;
    bool rt;
    bool auto_runtime_pm;
    bool fallback;
    bool last_cs_mode_high;
    s8 last_cs[16];
    u32 last_cs_index_mask: 16;
    struct completion xfer_completion;
    size_t max_dma_len;
    int (*optimize_message)(struct spi_message *);
    int (*unoptimize_message)(struct spi_message *);
    int (*prepare_transfer_hardware)(struct spi_controller *);
    int (*transfer_one_message)(struct spi_controller *, struct spi_message *);
    int (*unprepare_transfer_hardware)(struct spi_controller *);
    int (*prepare_message)(struct spi_controller *, struct spi_message *);
    int (*unprepare_message)(struct spi_controller *, struct spi_message *);
    int (*target_abort)(struct spi_controller *);
    void (*set_cs)(struct spi_device *, bool);
    int (*transfer_one)(struct spi_controller *, struct spi_device *, struct spi_transfer *);
    void (*handle_err)(struct spi_controller *, struct spi_message *);
    const struct spi_controller_mem_ops *mem_ops;
    const struct spi_controller_mem_caps *mem_caps;
    struct gpio_desc **cs_gpiods;
    bool use_gpio_descriptors;
    s8 unused_native_cs;
    s8 max_native_cs;
    struct spi_statistics *pcpu_statistics;
    struct dma_chan *dma_tx;
    struct dma_chan *dma_rx;
    void *dummy_rx;
    void *dummy_tx;
    int (*fw_translate_cs)(struct spi_controller *, unsigned int);
    bool ptp_sts_supported;
    long unsigned int irq_flags;
    bool queue_empty;
    bool must_async;
    bool defer_optimize_message;
};

struct spi_controller_mem_caps {
    bool dtr;
    bool ecc;
    bool swap16;
    bool per_op_freq;
};

struct spi_mem;

struct spi_mem_op;

struct spi_mem_dirmap_desc;

struct spi_controller_mem_ops {
    int (*adjust_op_size)(struct spi_mem *, struct spi_mem_op *);
    bool (*supports_op)(struct spi_mem *, const struct spi_mem_op *);
    int (*exec_op)(struct spi_mem *, const struct spi_mem_op *);
    const char * (*get_name)(struct spi_mem *);
    int (*dirmap_create)(struct spi_mem_dirmap_desc *);
    void (*dirmap_destroy)(struct spi_mem_dirmap_desc *);
    ssize_t (*dirmap_read)(struct spi_mem_dirmap_desc *, u64, size_t, void *);
    ssize_t (*dirmap_write)(struct spi_mem_dirmap_desc *, u64, size_t, const void *);
    int (*poll_status)(struct spi_mem *, const struct spi_mem_op *, u16, u16, long unsigned int, long unsigned int, long unsigned int);
};

struct spi_delay {
    u16 value;
    u8 unit;
};

struct spi_device {
    struct device dev;
    struct spi_controller *controller;
    u32 max_speed_hz;
    u8 chip_select[16];
    u8 bits_per_word;
    bool rt;
    u32 mode;
    int irq;
    void *controller_state;
    void *controller_data;
    char modalias[32];
    const char *driver_override;
    struct gpio_desc *cs_gpiod[16];
    struct spi_delay word_delay;
    struct spi_delay cs_setup;
    struct spi_delay cs_hold;
    struct spi_delay cs_inactive;
    struct spi_statistics *pcpu_statistics;
    u32 cs_index_mask: 16;
};

struct spi_device_id {
    char name[32];
    kernel_ulong_t driver_data;
};

struct spi_driver {
    const struct spi_device_id *id_table;
    int (*probe)(struct spi_device *);
    void (*remove)(struct spi_device *);
    void (*shutdown)(struct spi_device *);
    struct device_driver driver;
};

struct spi_mem {
    struct spi_device *spi;
    void *drvpriv;
    const char *name;
};

struct spi_mem_op {
    struct {
        u8 nbytes;
        u8 buswidth;
        u8 dtr: 1;
        u8 __pad: 7;
        u16 opcode;
    } cmd;
    struct {
        u8 nbytes;
        u8 buswidth;
        u8 dtr: 1;
        u8 __pad: 7;
        u64 val;
    } addr;
    struct {
        u8 nbytes;
        u8 buswidth;
        u8 dtr: 1;
        u8 __pad: 7;
    } dummy;
    struct {
        u8 buswidth;
        u8 dtr: 1;
        u8 ecc: 1;
        u8 swap16: 1;
        u8 __pad: 5;
        enum spi_mem_data_dir dir;
        unsigned int nbytes;
        union {
            void *in;
            const void *out;
        } buf;
    } data;
    unsigned int max_freq;
};

struct spi_mem_dirmap_info {
    struct spi_mem_op op_tmpl;
    u64 offset;
    u64 length;
};

struct spi_mem_dirmap_desc {
    struct spi_mem *mem;
    struct spi_mem_dirmap_info info;
    unsigned int nodirmap;
    void *priv;
};

struct spi_mem_driver {
    struct spi_driver spidrv;
    int (*probe)(struct spi_mem *);
    int (*remove)(struct spi_mem *);
    void (*shutdown)(struct spi_mem *);
};

struct spi_message {
    struct list_head transfers;
    struct spi_device *spi;
    bool pre_optimized;
    bool optimized;
    bool prepared;
    int status;
    void (*complete)(void *);
    void *context;
    unsigned int frame_length;
    unsigned int actual_length;
    struct list_head queue;
    void *state;
    void *opt_state;
    struct list_head resources;
};

struct spi_replaced_transfers;

typedef void (*spi_replaced_release_t)(struct spi_controller *, struct spi_message *, struct spi_replaced_transfers *);

struct spi_transfer {
    const void *tx_buf;
    void *rx_buf;
    unsigned int len;
    u16 error;
    bool tx_sg_mapped;
    bool rx_sg_mapped;
    struct sg_table tx_sg;
    struct sg_table rx_sg;
    dma_addr_t tx_dma;
    dma_addr_t rx_dma;
    unsigned int dummy_data: 1;
    unsigned int cs_off: 1;
    unsigned int cs_change: 1;
    unsigned int tx_nbits: 4;
    unsigned int rx_nbits: 4;
    unsigned int timestamped: 1;
    u8 bits_per_word;
    struct spi_delay delay;
    struct spi_delay cs_change_delay;
    struct spi_delay word_delay;
    u32 speed_hz;
    u32 effective_speed_hz;
    unsigned int ptp_sts_word_pre;
    unsigned int ptp_sts_word_post;
    struct ptp_system_timestamp *ptp_sts;
    struct list_head transfer_list;
};

struct spi_replaced_transfers {
    spi_replaced_release_t release;
    void *extradata;
    struct list_head replaced_transfers;
    struct list_head *replaced_after;
    size_t inserted;
    struct spi_transfer inserted_transfers[0];
};

typedef void (*spi_res_release_t)(struct spi_controller *, struct spi_message *, void *);

struct spi_res {
    struct list_head entry;
    spi_res_release_t release;
    long long unsigned int data[0];
};

struct spi_statistics {
    struct u64_stats_sync syncp;
    u64_stats_t messages;
    u64_stats_t transfers;
    u64_stats_t errors;
    u64_stats_t timedout;
    u64_stats_t spi_sync;
    u64_stats_t spi_sync_immediate;
    u64_stats_t spi_async;
    u64_stats_t bytes;
    u64_stats_t bytes_rx;
    u64_stats_t bytes_tx;
    u64_stats_t transfer_bytes_histo[17];
    u64_stats_t transfers_split_maxsize;
};

struct splice_desc {
    size_t total_len;
    unsigned int len;
    unsigned int flags;
    union {
        void *userptr;
        struct file *file;
        void *data;
    } u;
    void (*splice_eof)(struct splice_desc *);
    loff_t pos;
    loff_t *opos;
    size_t num_spliced;
    bool need_wakeup;
};

struct splice_pipe_desc {
    struct page **pages;
    struct partial_page *partial;
    int nr_pages;
    unsigned int nr_pages_max;
    const struct pipe_buf_operations *ops;
    void (*spd_release)(struct splice_pipe_desc *, unsigned int);
};

struct squashfs_base_inode {
    __le16 inode_type;
    __le16 mode;
    __le16 uid;
    __le16 guid;
    __le32 mtime;
    __le32 inode_number;
};

struct squashfs_cache_entry;

struct squashfs_cache {
    char *name;
    int entries;
    int curr_blk;
    int next_blk;
    int num_waiters;
    int unused;
    int block_size;
    int pages;
    spinlock_t lock;
    wait_queue_head_t wait_queue;
    struct squashfs_cache_entry *entry;
};

struct squashfs_page_actor;

struct squashfs_cache_entry {
    u64 block;
    int length;
    int refcount;
    u64 next_index;
    int pending;
    int error;
    int num_waiters;
    wait_queue_head_t wait_queue;
    struct squashfs_cache *cache;
    void **data;
    struct squashfs_page_actor *actor;
};

struct squashfs_sb_info;

struct squashfs_decompressor {
    void * (*init)(struct squashfs_sb_info *, void *);
    void * (*comp_opts)(struct squashfs_sb_info *, void *, int);
    void (*free)(void *);
    int (*decompress)(struct squashfs_sb_info *, void *, struct bio *, int, int, struct squashfs_page_actor *);
    int id;
    char *name;
    int alloc_buffer;
    int supported;
};

struct squashfs_decompressor_thread_ops {
    void * (*create)(struct squashfs_sb_info *, void *);
    void (*destroy)(struct squashfs_sb_info *);
    int (*decompress)(struct squashfs_sb_info *, struct bio *, int, int, struct squashfs_page_actor *);
    int (*max_decompressors)(void);
};

struct squashfs_dev_inode {
    __le16 inode_type;
    __le16 mode;
    __le16 uid;
    __le16 guid;
    __le32 mtime;
    __le32 inode_number;
    __le32 nlink;
    __le32 rdev;
};

struct squashfs_dir_entry {
    __le16 offset;
    __le16 inode_number;
    __le16 type;
    __le16 size;
    char name[0];
};

struct squashfs_dir_header {
    __le32 count;
    __le32 start_block;
    __le32 inode_number;
};

struct squashfs_dir_index {
    __le32 index;
    __le32 start_block;
    __le32 size;
    unsigned char name[0];
};

struct squashfs_dir_inode {
    __le16 inode_type;
    __le16 mode;
    __le16 uid;
    __le16 guid;
    __le32 mtime;
    __le32 inode_number;
    __le32 start_block;
    __le32 nlink;
    __le16 file_size;
    __le16 offset;
    __le32 parent_inode;
};

struct squashfs_fragment_entry {
    __le64 start_block;
    __le32 size;
    unsigned int unused;
};

struct squashfs_ldev_inode {
    __le16 inode_type;
    __le16 mode;
    __le16 uid;
    __le16 guid;
    __le32 mtime;
    __le32 inode_number;
    __le32 nlink;
    __le32 rdev;
    __le32 xattr;
};

struct squashfs_symlink_inode {
    __le16 inode_type;
    __le16 mode;
    __le16 uid;
    __le16 guid;
    __le32 mtime;
    __le32 inode_number;
    __le32 nlink;
    __le32 symlink_size;
    char symlink[0];
};

struct squashfs_reg_inode {
    __le16 inode_type;
    __le16 mode;
    __le16 uid;
    __le16 guid;
    __le32 mtime;
    __le32 inode_number;
    __le32 start_block;
    __le32 fragment;
    __le32 offset;
    __le32 file_size;
    __le16 block_list[0];
};

struct squashfs_lreg_inode {
    __le16 inode_type;
    __le16 mode;
    __le16 uid;
    __le16 guid;
    __le32 mtime;
    __le32 inode_number;
    __le64 start_block;
    __le64 file_size;
    __le64 sparse;
    __le32 nlink;
    __le32 fragment;
    __le32 offset;
    __le32 xattr;
    __le16 block_list[0];
};

struct squashfs_ldir_inode {
    __le16 inode_type;
    __le16 mode;
    __le16 uid;
    __le16 guid;
    __le32 mtime;
    __le32 inode_number;
    __le32 nlink;
    __le32 file_size;
    __le32 start_block;
    __le32 parent_inode;
    __le16 i_count;
    __le16 offset;
    __le32 xattr;
    struct squashfs_dir_index index[0];
};

struct squashfs_ipc_inode {
    __le16 inode_type;
    __le16 mode;
    __le16 uid;
    __le16 guid;
    __le32 mtime;
    __le32 inode_number;
    __le32 nlink;
};

struct squashfs_lipc_inode {
    __le16 inode_type;
    __le16 mode;
    __le16 uid;
    __le16 guid;
    __le32 mtime;
    __le32 inode_number;
    __le32 nlink;
    __le32 xattr;
};

union squashfs_inode {
    struct squashfs_base_inode base;
    struct squashfs_dev_inode dev;
    struct squashfs_ldev_inode ldev;
    struct squashfs_symlink_inode symlink;
    struct squashfs_reg_inode reg;
    struct squashfs_lreg_inode lreg;
    struct squashfs_dir_inode dir;
    struct squashfs_ldir_inode ldir;
    struct squashfs_ipc_inode ipc;
    struct squashfs_lipc_inode lipc;
};

struct squashfs_inode_info {
    u64 start;
    int offset;
    u64 xattr;
    unsigned int xattr_size;
    int xattr_count;
    union {
        struct {
            u64 fragment_block;
            int fragment_size;
            int fragment_offset;
            u64 block_list_start;
        };
        struct {
            u64 dir_idx_start;
            int dir_idx_offset;
            int dir_idx_cnt;
            int parent;
        };
    };
    struct inode vfs_inode;
};

struct squashfs_lz4 {
    void *input;
    void *output;
};

struct squashfs_lzo {
    void *input;
    void *output;
};

struct squashfs_mount_opts {
    enum Opt_errors errors;
    const struct squashfs_decompressor_thread_ops *thread_ops;
    int thread_num;
};

struct squashfs_page_actor {
    union {
        void **buffer;
        struct page **page;
    };
    void *pageaddr;
    void *tmp_buffer;
    void * (*squashfs_first_page)(struct squashfs_page_actor *);
    void * (*squashfs_next_page)(struct squashfs_page_actor *);
    void (*squashfs_finish_page)(struct squashfs_page_actor *);
    struct page *last_page;
    int pages;
    int length;
    int next_page;
    int alloc_buffer;
    int returned_pages;
    long unsigned int next_index;
};

struct squashfs_sb_info {
    const struct squashfs_decompressor *decompressor;
    int devblksize;
    int devblksize_log2;
    struct squashfs_cache *block_cache;
    struct squashfs_cache *fragment_cache;
    struct squashfs_cache *read_page;
    struct address_space *cache_mapping;
    int next_meta_index;
    __le64 *id_table;
    __le64 *fragment_index;
    __le64 *xattr_id_table;
    struct mutex meta_index_mutex;
    struct meta_index *meta_index;
    void *stream;
    __le64 *inode_lookup_table;
    u64 inode_table;
    u64 directory_table;
    u64 xattr_table;
    unsigned int block_size;
    short unsigned int block_log;
    long long int bytes_used;
    unsigned int inodes;
    unsigned int fragments;
    unsigned int xattr_ids;
    unsigned int ids;
    bool panic_on_errors;
    const struct squashfs_decompressor_thread_ops *thread_ops;
    int max_thread_num;
};

struct squashfs_stream {
    void *comp_opts;
    struct list_head strm_list;
    struct mutex mutex;
    int avail_decomp;
    wait_queue_head_t wait;
};

struct squashfs_stream___2 {
    void *stream;
    local_lock_t lock;
};

struct squashfs_stream___3 {
    void *stream;
    struct mutex mutex;
};

struct squashfs_super_block {
    __le32 s_magic;
    __le32 inodes;
    __le32 mkfs_time;
    __le32 block_size;
    __le32 fragments;
    __le16 compression;
    __le16 block_log;
    __le16 flags;
    __le16 no_ids;
    __le16 s_major;
    __le16 s_minor;
    __le64 root_inode;
    __le64 bytes_used;
    __le64 id_table_start;
    __le64 xattr_id_table_start;
    __le64 inode_table_start;
    __le64 directory_table_start;
    __le64 fragment_table_start;
    __le64 lookup_table_start;
};

struct squashfs_xattr_entry {
    __le16 type;
    __le16 size;
    char data[0];
};

struct squashfs_xattr_id {
    __le64 xattr;
    __le32 count;
    __le32 size;
};

struct squashfs_xattr_id_table {
    __le64 xattr_table_start;
    __le32 xattr_ids;
    __le32 unused;
};

struct squashfs_xattr_val {
    __le32 vsize;
    char value[0];
};

struct xz_buf {
    const uint8_t *in;
    size_t in_pos;
    size_t in_size;
    uint8_t *out;
    size_t out_pos;
    size_t out_size;
};

struct xz_dec;

struct squashfs_xz {
    struct xz_dec *state;
    struct xz_buf buf;
};

struct sr6_tlv {
    __u8 type;
    __u8 len;
    __u8 data[0];
};

struct sr6_tlv_hmac {
    struct sr6_tlv tlvhdr;
    __u16 reserved;
    __be32 hmackeyid;
    __u8 hmac[32];
};

struct srcu_data {
    atomic_long_t srcu_lock_count[2];
    atomic_long_t srcu_unlock_count[2];
    int srcu_reader_flavor;
    long: 64;
    long: 64;
    long: 64;
    spinlock_t lock;
    struct rcu_segcblist srcu_cblist;
    long unsigned int srcu_gp_seq_needed;
    long unsigned int srcu_gp_seq_needed_exp;
    bool srcu_cblist_invoking;
    struct timer_list delay_work;
    struct work_struct work;
    struct callback_head srcu_barrier_head;
    struct srcu_node *mynode;
    long unsigned int grpmask;
    int cpu;
    struct srcu_struct *ssp;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
};

struct srcu_node {
    spinlock_t lock;
    long unsigned int srcu_have_cbs[4];
    long unsigned int srcu_data_have_cbs[4];
    long unsigned int srcu_gp_seq_needed_exp;
    struct srcu_node *srcu_parent;
    int grplo;
    int grphi;
};

struct stack_entry {
    struct trace_entry ent;
    int size;
    long unsigned int caller[0];
};

struct stack_map_bucket {
    struct pcpu_freelist_node fnode;
    u32 hash;
    u32 nr;
    u64 data[0];
};

struct stack_record {
    struct list_head hash_list;
    u32 hash;
    u32 size;
    union handle_parts handle;
    refcount_t count;
    union {
        long unsigned int entries[64];
        struct {
            struct list_head free_list;
            long unsigned int rcu_state;
        };
    };
};

struct stacktrace_cookie {
    long unsigned int *store;
    unsigned int size;
    unsigned int skip;
    unsigned int len;
};

struct stage2_age_data {
    bool mkold;
    bool young;
};

struct stage2_attr_data {
    kvm_pte_t attr_set;
    kvm_pte_t attr_clr;
    kvm_pte_t pte;
    s8 level;
};

struct stage2_map_data {
    const u64 phys;
    kvm_pte_t attr;
    u8 owner_id;
    kvm_pte_t *anchor;
    kvm_pte_t *childp;
    struct kvm_s2_mmu *mmu;
    void *memcache;
    bool force_pte;
    bool annotation;
};

struct stashed_operations {
    void (*put_data)(void *);
    int (*init_inode)(struct inode *, void *);
};

struct stat {
    long unsigned int st_dev;
    long unsigned int st_ino;
    unsigned int st_mode;
    unsigned int st_nlink;
    unsigned int st_uid;
    unsigned int st_gid;
    long unsigned int st_rdev;
    long unsigned int __pad1;
    long int st_size;
    int st_blksize;
    int __pad2;
    long int st_blocks;
    long int st_atime;
    long unsigned int st_atime_nsec;
    long int st_mtime;
    long unsigned int st_mtime_nsec;
    long int st_ctime;
    long unsigned int st_ctime_nsec;
    unsigned int __unused4;
    unsigned int __unused5;
};

struct stat64 {
    compat_u64 st_dev;
    unsigned char __pad0[4];
    compat_ulong_t __st_ino;
    compat_uint_t st_mode;
    compat_uint_t st_nlink;
    compat_ulong_t st_uid;
    compat_ulong_t st_gid;
    compat_u64 st_rdev;
    unsigned char __pad3[4];
    compat_s64 st_size;
    compat_ulong_t st_blksize;
    compat_u64 st_blocks;
    compat_ulong_t st_atime;
    compat_ulong_t st_atime_nsec;
    compat_ulong_t st_mtime;
    compat_ulong_t st_mtime_nsec;
    compat_ulong_t st_ctime;
    compat_ulong_t st_ctime_nsec;
    compat_u64 st_ino;
};

struct stat_node {
    struct rb_node node;
    void *stat;
};

struct stat_session {
    struct list_head session_list;
    struct tracer_stat *ts;
    struct rb_root stat_root;
    struct mutex stat_mutex;
    struct dentry *file;
};

struct state_stats_struct {
    int slot_stalls;
    int data_stalls;
    int ctrl_tx_count;
    int ctrl_rx_count;
    int error_count;
};

struct statfs {
    __kernel_long_t f_type;
    __kernel_long_t f_bsize;
    __kernel_long_t f_blocks;
    __kernel_long_t f_bfree;
    __kernel_long_t f_bavail;
    __kernel_long_t f_files;
    __kernel_long_t f_ffree;
    __kernel_fsid_t f_fsid;
    __kernel_long_t f_namelen;
    __kernel_long_t f_frsize;
    __kernel_long_t f_flags;
    __kernel_long_t f_spare[4];
};

struct statfs64 {
    __kernel_long_t f_type;
    __kernel_long_t f_bsize;
    __u64 f_blocks;
    __u64 f_bfree;
    __u64 f_bavail;
    __u64 f_files;
    __u64 f_ffree;
    __kernel_fsid_t f_fsid;
    __kernel_long_t f_namelen;
    __kernel_long_t f_frsize;
    __kernel_long_t f_flags;
    __kernel_long_t f_spare[4];
};

struct static_call_key {
    void *func;
};

struct static_key_deferred {
    struct static_key key;
    long unsigned int timeout;
    struct delayed_work work;
};

struct static_key_false_deferred {
    struct static_key_false key;
    long unsigned int timeout;
    struct delayed_work work;
};

struct static_key_mod {
    struct static_key_mod *next;
    struct jump_entry *entries;
    struct module *mod;
};

struct static_tree_desc_s {
    const ct_data *static_tree;
    const int *extra_bits;
    int extra_base;
    int elems;
    int max_length;
};

struct stats_reply_data {
    struct ethnl_reply_data base;
    union {
        struct {
            struct ethtool_eth_phy_stats phy_stats;
            struct ethtool_eth_mac_stats mac_stats;
            struct ethtool_eth_ctrl_stats ctrl_stats;
            struct ethtool_rmon_stats rmon_stats;
            struct ethtool_phy_stats phydev_stats;
        };
        struct {
            struct ethtool_eth_phy_stats phy_stats;
            struct ethtool_eth_mac_stats mac_stats;
            struct ethtool_eth_ctrl_stats ctrl_stats;
            struct ethtool_rmon_stats rmon_stats;
            struct ethtool_phy_stats phydev_stats;
        } stats;
    };
    const struct ethtool_rmon_hist_range *rmon_ranges;
};

struct stats_req_info {
    struct ethnl_req_info base;
    long unsigned int stat_mask[1];
    enum ethtool_mac_stats_src src;
};

struct status_64 {
    u32 length_status;
    u32 ext_status;
    u32 rx_csum;
    u32 unused1[9];
    u32 tx_csum_info;
    u32 unused2[3];
};

struct statx_timestamp {
    __s64 tv_sec;
    __u32 tv_nsec;
    __s32 __reserved;
};

struct statx {
    __u32 stx_mask;
    __u32 stx_blksize;
    __u64 stx_attributes;
    __u32 stx_nlink;
    __u32 stx_uid;
    __u32 stx_gid;
    __u16 stx_mode;
    __u16 __spare0[1];
    __u64 stx_ino;
    __u64 stx_size;
    __u64 stx_blocks;
    __u64 stx_attributes_mask;
    struct statx_timestamp stx_atime;
    struct statx_timestamp stx_btime;
    struct statx_timestamp stx_ctime;
    struct statx_timestamp stx_mtime;
    __u32 stx_rdev_major;
    __u32 stx_rdev_minor;
    __u32 stx_dev_major;
    __u32 stx_dev_minor;
    __u64 stx_mnt_id;
    __u32 stx_dio_mem_align;
    __u32 stx_dio_offset_align;
    __u64 stx_subvol;
    __u32 stx_atomic_write_unit_min;
    __u32 stx_atomic_write_unit_max;
    __u32 stx_atomic_write_segments_max;
    __u32 stx_dio_read_offset_align;
    __u64 __spare3[9];
};

struct step_hook {
    struct list_head node;
    int (*fn)(struct pt_regs *, long unsigned int);
};

struct stereo_mandatory_mode {
    int width;
    int height;
    int vrefresh;
    unsigned int flags;
};

struct stmpe_client_info;

struct stmpe_variant_info;

struct stmpe_platform_data;

struct stmpe {
    struct regulator *vcc;
    struct regulator *vio;
    struct mutex lock;
    struct mutex irq_lock;
    struct device *dev;
    struct irq_domain *domain;
    void *client;
    struct stmpe_client_info *ci;
    enum stmpe_partnum partnum;
    struct stmpe_variant_info *variant;
    const u8 *regs;
    int irq;
    int num_gpios;
    u8 ier[2];
    u8 oldier[2];
    struct stmpe_platform_data *pdata;
    u8 sample_time;
    u8 mod_12b;
    u8 ref_sel;
    u8 adc_freq;
};

struct stmpe_client_info {
    void *data;
    int irq;
    void *client;
    struct device *dev;
    int (*read_byte)(struct stmpe *, u8);
    int (*write_byte)(struct stmpe *, u8, u8);
    int (*read_block)(struct stmpe *, u8, u8, u8 *);
    int (*write_block)(struct stmpe *, u8, u8, const u8 *);
    void (*init)(struct stmpe *);
};

struct stmpe_platform_data {
    int id;
    unsigned int blocks;
    unsigned int irq_trigger;
    bool autosleep;
    int autosleep_timeout;
};

struct stmpe_variant_block {
    const struct mfd_cell *cell;
    int irq;
    enum stmpe_block block;
};

struct stmpe_variant_info {
    const char *name;
    u16 id_val;
    u16 id_mask;
    int num_gpios;
    int af_bits;
    const u8 *regs;
    struct stmpe_variant_block *blocks;
    int num_blocks;
    int num_irqs;
    int (*enable)(struct stmpe *, unsigned int, bool);
    int (*get_altfunc)(struct stmpe *, enum stmpe_block);
    int (*enable_autosleep)(struct stmpe *, int);
};

struct stop_event_data {
    struct perf_event *event;
    unsigned int restart;
};

struct stored_match_addr {
    union {
        struct sockaddr addr;
        struct sockaddr_in addr4;
        struct sockaddr_in6 addr6;
    };
    int addrlen;
    struct match_addr maddr;
};

struct strarray {
    char **array;
    size_t n;
};

struct strset_info {
    bool per_dev;
    bool free_strings;
    unsigned int count;
    const char (*strings)[32];
};

struct strset_reply_data {
    struct ethnl_reply_data base;
    struct strset_info sets[23];
};

struct strset_req_info {
    struct ethnl_req_info base;
    u32 req_ids;
    bool counts_only;
};

struct subdev_regulators {
    unsigned int num_supplies;
    struct regulator_bulk_data supplies[0];
};

struct subflow_send_info {
    struct sock *ssk;
    u64 linger_time;
};

struct subprocess_info {
    struct work_struct work;
    struct completion *complete;
    const char *path;
    char **argv;
    char **envp;
    int wait;
    int retval;
    int (*init)(struct subprocess_info *, struct cred *);
    void (*cleanup)(struct subprocess_info *);
    void *data;
};

struct subsys_dev_iter {
    struct klist_iter ki;
    const struct device_type *type;
};

struct subsys_interface {
    const char *name;
    const struct bus_type *subsys;
    struct list_head node;
    int (*add_dev)(struct device *, struct subsys_interface *);
    void (*remove_dev)(struct device *, struct subsys_interface *);
};

struct subsys_private {
    struct kset subsys;
    struct kset *devices_kset;
    struct list_head interfaces;
    struct mutex mutex;
    struct kset *drivers_kset;
    struct klist klist_devices;
    struct klist klist_drivers;
    struct blocking_notifier_head bus_notifier;
    unsigned int drivers_autoprobe: 1;
    const struct bus_type *bus;
    struct device *dev_root;
    struct kset glue_dirs;
    const struct class *class;
    struct lock_class_key lock_key;
};

struct sugov_policy;

struct sugov_cpu {
    struct update_util_data update_util;
    struct sugov_policy *sg_policy;
    unsigned int cpu;
    bool iowait_boost_pending;
    unsigned int iowait_boost;
    u64 last_update;
    long unsigned int util;
    long unsigned int bw_min;
    long unsigned int saved_idle_calls;
};

struct sugov_tunables;

struct sugov_policy {
    struct cpufreq_policy *policy;
    struct sugov_tunables *tunables;
    struct list_head tunables_hook;
    raw_spinlock_t update_lock;
    u64 last_freq_update_time;
    s64 freq_update_delay_ns;
    unsigned int next_freq;
    unsigned int cached_raw_freq;
    struct irq_work irq_work;
    struct kthread_work work;
    struct mutex work_lock;
    struct kthread_worker worker;
    struct task_struct *thread;
    bool work_in_progress;
    bool limits_changed;
    bool need_freq_update;
};

struct sugov_tunables {
    struct gov_attr_set attr_set;
    unsigned int rate_limit_us;
};

struct summary_data {
    struct seq_file *s;
    struct regulator_dev *parent;
    int level;
};

struct summary_lock_data {
    struct ww_acquire_ctx *ww_ctx;
    struct regulator_dev **new_contended_rdev;
    struct regulator_dev **old_contended_rdev;
};

struct mtd_info;

struct super_block {
    struct list_head s_list;
    dev_t s_dev;
    unsigned char s_blocksize_bits;
    long unsigned int s_blocksize;
    loff_t s_maxbytes;
    struct file_system_type *s_type;
    const struct super_operations *s_op;
    const struct dquot_operations *dq_op;
    const struct quotactl_ops *s_qcop;
    const struct export_operations *s_export_op;
    long unsigned int s_flags;
    long unsigned int s_iflags;
    long unsigned int s_magic;
    struct dentry *s_root;
    struct rw_semaphore s_umount;
    int s_count;
    atomic_t s_active;
    void *s_security;
    const struct xattr_handler * const *s_xattr;
    const struct fscrypt_operations *s_cop;
    struct fscrypt_keyring *s_master_keys;
    struct unicode_map *s_encoding;
    __u16 s_encoding_flags;
    struct hlist_bl_head s_roots;
    struct list_head s_mounts;
    struct block_device *s_bdev;
    struct file *s_bdev_file;
    struct backing_dev_info *s_bdi;
    struct mtd_info *s_mtd;
    struct hlist_node s_instances;
    unsigned int s_quota_types;
    struct quota_info s_dquot;
    struct sb_writers s_writers;
    void *s_fs_info;
    u32 s_time_gran;
    time64_t s_time_min;
    time64_t s_time_max;
    u32 s_fsnotify_mask;
    struct fsnotify_sb_info *s_fsnotify_info;
    char s_id[32];
    uuid_t s_uuid;
    u8 s_uuid_len;
    char s_sysfs_name[37];
    unsigned int s_max_links;
    struct mutex s_vfs_rename_mutex;
    const char *s_subtype;
    const struct dentry_operations *s_d_op;
    struct shrinker *s_shrink;
    atomic_long_t s_remove_count;
    int s_readonly_remount;
    errseq_t s_wb_err;
    struct workqueue_struct *s_dio_done_wq;
    struct hlist_head s_pins;
    struct user_namespace *s_user_ns;
    struct list_lru s_dentry_lru;
    struct list_lru s_inode_lru;
    struct callback_head rcu;
    struct work_struct destroy_work;
    struct mutex s_sync_lock;
    int s_stack_depth;
    long: 64;
    long: 64;
    spinlock_t s_inode_list_lock;
    struct list_head s_inodes;
    spinlock_t s_inode_wblist_lock;
    struct list_head s_inodes_wb;
    long: 64;
    long: 64;
};

struct super_operations {
    struct inode * (*alloc_inode)(struct super_block *);
    void (*destroy_inode)(struct inode *);
    void (*free_inode)(struct inode *);
    void (*dirty_inode)(struct inode *, int);
    int (*write_inode)(struct inode *, struct writeback_control *);
    int (*drop_inode)(struct inode *);
    void (*evict_inode)(struct inode *);
    void (*put_super)(struct super_block *);
    int (*sync_fs)(struct super_block *, int);
    int (*freeze_super)(struct super_block *, enum freeze_holder);
    int (*freeze_fs)(struct super_block *);
    int (*thaw_super)(struct super_block *, enum freeze_holder);
    int (*unfreeze_fs)(struct super_block *);
    int (*statfs)(struct dentry *, struct kstatfs *);
    int (*remount_fs)(struct super_block *, int *, char *);
    void (*umount_begin)(struct super_block *);
    int (*show_options)(struct seq_file *, struct dentry *);
    int (*show_devname)(struct seq_file *, struct dentry *);
    int (*show_path)(struct seq_file *, struct dentry *);
    int (*show_stats)(struct seq_file *, struct dentry *);
    ssize_t (*quota_read)(struct super_block *, int, char *, size_t, loff_t);
    ssize_t (*quota_write)(struct super_block *, int, const char *, size_t, loff_t);
    struct dquot ** (*get_dquots)(struct inode *);
    long int (*nr_cached_objects)(struct super_block *, struct shrink_control *);
    long int (*free_cached_objects)(struct super_block *, struct shrink_control *);
    void (*shutdown)(struct super_block *);
};

struct superblock_security_struct {
    u32 sid;
    u32 def_sid;
    u32 mntpoint_sid;
    short unsigned int behavior;
    short unsigned int flags;
    struct mutex lock;
    struct list_head isec_head;
    spinlock_t isec_lock;
};

struct superblock_smack {
    struct smack_known *smk_root;
    struct smack_known *smk_floor;
    struct smack_known *smk_hat;
    struct smack_known *smk_default;
    int smk_flags;
};

struct supplier_bindings {
    struct device_node * (*parse_prop)(struct device_node *, const char *, int);
    struct device_node * (*get_con_dev)(struct device_node *);
    bool optional;
    u8 fwlink_flags;
};

struct svc_cred {
    kuid_t cr_uid;
    kgid_t cr_gid;
    struct group_info *cr_group_info;
    u32 cr_flavor;
    char *cr_raw_principal;
    char *cr_principal;
    char *cr_targ_princ;
    struct gss_api_mech *cr_gss_mech;
};

struct svc_deferred_req {
    u32 prot;
    struct svc_xprt *xprt;
    struct __kernel_sockaddr_storage addr;
    size_t addrlen;
    struct __kernel_sockaddr_storage daddr;
    size_t daddrlen;
    void *xprt_ctxt;
    struct cache_deferred_req handle;
    int argslen;
    __be32 args[0];
};

struct svc_pool {
    unsigned int sp_id;
    struct lwq sp_xprts;
    unsigned int sp_nrthreads;
    struct list_head sp_all_threads;
    struct llist_head sp_idle_threads;
    struct percpu_counter sp_messages_arrived;
    struct percpu_counter sp_sockets_queued;
    struct percpu_counter sp_threads_woken;
    long unsigned int sp_flags;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
};

struct svc_procedure {
    __be32 (*pc_func)(struct svc_rqst *);
    bool (*pc_decode)(struct svc_rqst *, struct xdr_stream *);
    bool (*pc_encode)(struct svc_rqst *, struct xdr_stream *);
    void (*pc_release)(struct svc_rqst *);
    unsigned int pc_argsize;
    unsigned int pc_argzero;
    unsigned int pc_ressize;
    unsigned int pc_cachetype;
    unsigned int pc_xdrressize;
    const char *pc_name;
};

struct svc_process_info {
    union {
        int (*dispatch)(struct svc_rqst *);
        struct {
            unsigned int lovers;
            unsigned int hivers;
        } mismatch;
    };
};

struct svc_version;

struct svc_program {
    u32 pg_prog;
    unsigned int pg_lovers;
    unsigned int pg_hivers;
    unsigned int pg_nvers;
    const struct svc_version **pg_vers;
    char *pg_name;
    char *pg_class;
    enum svc_auth_status (*pg_authenticate)(struct svc_rqst *);
    __be32 (*pg_init_request)(struct svc_rqst *, const struct svc_program *, struct svc_process_info *);
    int (*pg_rpcbind_set)(struct net *, const struct svc_program *, u32, int, short unsigned int, short unsigned int);
};

struct xdr_stream {
    __be32 *p;
    struct xdr_buf *buf;
    __be32 *end;
    struct kvec *iov;
    struct kvec scratch;
    struct page **page_ptr;
    void *page_kaddr;
    unsigned int nwords;
    struct rpc_rqst *rqst;
};

struct svc_rqst {
    struct list_head rq_all;
    struct llist_node rq_idle;
    struct callback_head rq_rcu_head;
    struct svc_xprt *rq_xprt;
    struct __kernel_sockaddr_storage rq_addr;
    size_t rq_addrlen;
    struct __kernel_sockaddr_storage rq_daddr;
    size_t rq_daddrlen;
    struct svc_serv *rq_server;
    struct svc_pool *rq_pool;
    const struct svc_procedure *rq_procinfo;
    struct auth_ops *rq_authop;
    struct svc_cred rq_cred;
    void *rq_xprt_ctxt;
    struct svc_deferred_req *rq_deferred;
    struct xdr_buf rq_arg;
    struct xdr_stream rq_arg_stream;
    struct xdr_stream rq_res_stream;
    struct page *rq_scratch_page;
    struct xdr_buf rq_res;
    struct page *rq_pages[260];
    struct page **rq_respages;
    struct page **rq_next_page;
    struct page **rq_page_end;
    struct folio_batch rq_fbatch;
    struct kvec rq_vec[259];
    struct bio_vec rq_bvec[259];
    __be32 rq_xid;
    u32 rq_prog;
    u32 rq_vers;
    u32 rq_proc;
    u32 rq_prot;
    int rq_cachetype;
    long unsigned int rq_flags;
    ktime_t rq_qtime;
    void *rq_argp;
    void *rq_resp;
    __be32 *rq_accept_statp;
    void *rq_auth_data;
    __be32 rq_auth_stat;
    int rq_auth_slack;
    int rq_reserved;
    ktime_t rq_stime;
    struct cache_req rq_chandle;
    struct auth_domain *rq_client;
    struct auth_domain *rq_gssclient;
    struct task_struct *rq_task;
    struct net *rq_bc_net;
    int rq_err;
    long unsigned int bc_to_initval;
    unsigned int bc_to_retries;
    void **rq_lease_breaker;
    unsigned int rq_status_counter;
};

struct svc_stat;

struct svc_serv {
    struct svc_program *sv_programs;
    struct svc_stat *sv_stats;
    spinlock_t sv_lock;
    unsigned int sv_nprogs;
    unsigned int sv_nrthreads;
    unsigned int sv_max_payload;
    unsigned int sv_max_mesg;
    unsigned int sv_xdrsize;
    struct list_head sv_permsocks;
    struct list_head sv_tempsocks;
    int sv_tmpcnt;
    struct timer_list sv_temptimer;
    char *sv_name;
    unsigned int sv_nrpools;
    bool sv_is_pooled;
    struct svc_pool *sv_pools;
    int (*sv_threadfn)(void *);
    struct lwq sv_cb_list;
    bool sv_bc_enabled;
};

struct svc_stat {
    struct svc_program *program;
    unsigned int netcnt;
    unsigned int netudpcnt;
    unsigned int nettcpcnt;
    unsigned int nettcpconn;
    unsigned int rpccnt;
    unsigned int rpcbadfmt;
    unsigned int rpcbadauth;
    unsigned int rpcbadclnt;
};

struct svc_version {
    u32 vs_vers;
    u32 vs_nproc;
    const struct svc_procedure *vs_proc;
    long unsigned int *vs_count;
    u32 vs_xdrsize;
    bool vs_hidden;
    bool vs_rpcb_optnl;
    bool vs_need_cong_ctrl;
    int (*vs_dispatch)(struct svc_rqst *);
};

struct sve_context {
    struct _aarch64_ctx head;
    __u16 vl;
    __u16 flags;
    __u16 __reserved[2];
};

struct sve_state_reg_region {
    unsigned int koffset;
    unsigned int klen;
    unsigned int upad;
};

struct swait_queue {
    struct task_struct *task;
    struct list_head task_list;
};

struct swap_cgroup {
    atomic_t ids;
};

struct swap_cgroup_ctrl {
    struct swap_cgroup *map;
};

struct swap_cluster_info {
    spinlock_t lock;
    u16 count;
    u8 flags;
    u8 order;
    struct list_head list;
};

struct swap_extent {
    struct rb_node rb_node;
    long unsigned int start_page;
    long unsigned int nr_pages;
    sector_t start_block;
};

union swap_header {
    struct {
        char reserved[4086];
        char magic[10];
    } magic;
    struct {
        char bootbits[1024];
        __u32 version;
        __u32 last_page;
        __u32 nr_badpages;
        unsigned char sws_uuid[16];
        unsigned char sws_volume[16];
        __u32 padding[117];
        __u32 badpages[1];
    } info;
};

struct swap_info_struct {
    struct percpu_ref users;
    long unsigned int flags;
    short int prio;
    struct plist_node list;
    signed char type;
    unsigned int max;
    unsigned char *swap_map;
    long unsigned int *zeromap;
    struct swap_cluster_info *cluster_info;
    struct list_head free_clusters;
    struct list_head full_clusters;
    struct list_head nonfull_clusters[10];
    struct list_head frag_clusters[10];
    atomic_long_t frag_cluster_nr[10];
    unsigned int pages;
    atomic_long_t inuse_pages;
    struct percpu_cluster *percpu_cluster;
    struct percpu_cluster *global_cluster;
    spinlock_t global_cluster_lock;
    struct rb_root swap_extent_root;
    struct block_device *bdev;
    struct file *swap_file;
    struct completion comp;
    spinlock_t lock;
    spinlock_t cont_lock;
    struct work_struct discard_work;
    struct work_struct reclaim_work;
    struct list_head discard_clusters;
    struct plist_node avail_lists[0];
};

struct swap_iocb {
    struct kiocb iocb;
    struct bio_vec bvec[32];
    int pages;
    int len;
};

struct swap_slots_cache {
    bool lock_initialized;
    struct mutex alloc_lock;
    swp_entry_t *slots;
    int nr;
    int cur;
    int n_ret;
};

struct swevent_hlist {
    struct hlist_head heads[256];
    struct callback_head callback_head;
};

struct swevent_htable {
    struct swevent_hlist *swevent_hlist;
    struct mutex hlist_mutex;
    int hlist_refcount;
};

struct switchdev_mst_state {
    u16 msti;
    u8 state;
};

struct switchdev_brport_flags {
    long unsigned int val;
    long unsigned int mask;
};

struct switchdev_vlan_msti {
    u16 vid;
    u16 msti;
};

struct switchdev_attr {
    struct net_device *orig_dev;
    enum switchdev_attr_id id;
    u32 flags;
    void *complete_priv;
    void (*complete)(struct net_device *, int, void *);
    union {
        u8 stp_state;
        struct switchdev_mst_state mst_state;
        struct switchdev_brport_flags brport_flags;
        bool mrouter;
        clock_t ageing_time;
        bool vlan_filtering;
        u16 vlan_protocol;
        bool mst;
        bool mc_disabled;
        u8 mrp_port_role;
        struct switchdev_vlan_msti vlan_msti;
    } u;
};

struct switchdev_brport {
    struct net_device *dev;
    const void *ctx;
    struct notifier_block *atomic_nb;
    struct notifier_block *blocking_nb;
    bool tx_fwd_offload;
};

typedef void switchdev_deferred_func_t(struct net_device *, const void *);

struct switchdev_deferred_item {
    struct list_head list;
    struct net_device *dev;
    netdevice_tracker dev_tracker;
    switchdev_deferred_func_t *func;
    long unsigned int data[0];
};

struct switchdev_nested_priv {
    bool (*check_cb)(const struct net_device *);
    bool (*foreign_dev_check_cb)(const struct net_device *, const struct net_device *);
    const struct net_device *dev;
    struct net_device *lower_dev;
};

struct switchdev_notifier_info {
    struct net_device *dev;
    struct netlink_ext_ack *extack;
    const void *ctx;
};

struct switchdev_notifier_brport_info {
    struct switchdev_notifier_info info;
    const struct switchdev_brport brport;
};

struct switchdev_notifier_fdb_info {
    struct switchdev_notifier_info info;
    const unsigned char *addr;
    u16 vid;
    u8 added_by_user: 1;
    u8 is_local: 1;
    u8 locked: 1;
    u8 offloaded: 1;
};

struct switchdev_notifier_port_attr_info {
    struct switchdev_notifier_info info;
    const struct switchdev_attr *attr;
    bool handled;
};

struct switchdev_obj;

struct switchdev_notifier_port_obj_info {
    struct switchdev_notifier_info info;
    const struct switchdev_obj *obj;
    bool handled;
};

struct switchdev_obj {
    struct list_head list;
    struct net_device *orig_dev;
    enum switchdev_obj_id id;
    u32 flags;
    void *complete_priv;
    void (*complete)(struct net_device *, int, void *);
};

struct switchdev_obj_mrp {
    struct switchdev_obj obj;
    struct net_device *p_port;
    struct net_device *s_port;
    u32 ring_id;
    u16 prio;
};

struct switchdev_obj_port_mdb {
    struct switchdev_obj obj;
    unsigned char addr[6];
    u16 vid;
};

struct switchdev_obj_port_vlan {
    struct switchdev_obj obj;
    u16 flags;
    u16 vid;
    bool changed;
};

struct switchdev_obj_ring_role_mrp {
    struct switchdev_obj obj;
    u8 ring_role;
    u32 ring_id;
    u8 sw_backup;
};

struct swmii_regs {
    u16 bmsr;
    u16 lpa;
    u16 lpagb;
    u16 estat;
};

struct swnode {
    struct kobject kobj;
    struct fwnode_handle fwnode;
    const struct software_node *node;
    int id;
    struct ida child_ids;
    struct list_head entry;
    struct list_head children;
    struct swnode *parent;
    unsigned int allocated: 1;
    unsigned int managed: 1;
};

struct sym_count_ctx {
    unsigned int count;
    const char *name;
};

struct symsearch {
    const struct kernel_symbol *start;
    const struct kernel_symbol *stop;
    const u32 *crcs;
    enum mod_license license;
};

struct sync_fence_info {
    char obj_name[32];
    char driver_name[32];
    __s32 status;
    __u32 flags;
    __u64 timestamp_ns;
};

struct sync_file {
    struct file *file;
    char user_name[32];
    struct list_head sync_file_list;
    wait_queue_head_t wq;
    long unsigned int flags;
    struct dma_fence *fence;
    struct dma_fence_cb cb;
};

struct sync_file_info {
    char name[32];
    __s32 status;
    __u32 flags;
    __u32 num_fences;
    __u32 pad;
    __u64 sync_fence_info;
};

struct sync_merge_data {
    char name[32];
    __s32 fd2;
    __s32 fence;
    __u32 flags;
    __u32 pad;
};

struct sync_set_deadline {
    __u64 deadline_ns;
    __u64 pad;
};

struct syncobj_eventfd_entry {
    struct list_head node;
    struct dma_fence *fence;
    struct dma_fence_cb fence_cb;
    struct drm_syncobj *syncobj;
    struct eventfd_ctx *ev_fd_ctx;
    u64 point;
    u32 flags;
};

struct syncobj_wait_entry {
    struct list_head node;
    struct task_struct *task;
    struct dma_fence *fence;
    struct dma_fence_cb fence_cb;
    u64 point;
};

struct trace_event_fields;

struct trace_event_class {
    const char *system;
    void *probe;
    void *perf_probe;
    int (*reg)(struct trace_event_call *, enum trace_reg, void *);
    struct trace_event_fields *fields_array;
    struct list_head * (*get_fields)(struct trace_event_call *);
    struct list_head fields;
    int (*raw_init)(struct trace_event_call *);
};

struct trace_event_functions;

struct trace_event {
    struct hlist_node node;
    int type;
    struct trace_event_functions *funcs;
};

struct trace_event_call {
    struct list_head list;
    struct trace_event_class *class;
    union {
        const char *name;
        struct tracepoint *tp;
    };
    struct trace_event event;
    char *print_fmt;
    union {
        void *module;
        atomic_t refcnt;
    };
    void *data;
    int flags;
    int perf_refcount;
    struct hlist_head *perf_events;
    struct bpf_prog_array *prog_array;
    int (*perf_perm)(struct trace_event_call *, struct perf_event *);
};

struct synth_field;

struct synth_event {
    struct dyn_event devent;
    int ref;
    char *name;
    struct synth_field **fields;
    unsigned int n_fields;
    struct synth_field **dynamic_fields;
    unsigned int n_dynamic_fields;
    unsigned int n_u64;
    struct trace_event_class class;
    struct trace_event_call call;
    struct tracepoint *tp;
    struct module *mod;
};

struct trace_event_buffer {
    struct trace_buffer *buffer;
    struct ring_buffer_event *event;
    struct trace_event_file *trace_file;
    void *entry;
    unsigned int trace_ctx;
    struct pt_regs *regs;
};

struct synth_trace_event;

struct synth_event_trace_state {
    struct trace_event_buffer fbuffer;
    struct synth_trace_event *entry;
    struct trace_buffer *buffer;
    struct synth_event *event;
    unsigned int cur_field;
    unsigned int n_u64;
    bool disabled;
    bool add_next;
    bool add_name;
};

struct synth_field {
    char *type;
    char *name;
    size_t size;
    unsigned int offset;
    unsigned int field_pos;
    bool is_signed;
    bool is_string;
    bool is_dynamic;
    bool is_stack;
};

struct synth_field_desc {
    const char *type;
    const char *name;
};

struct trace_dynamic_info {
    u16 offset;
    u16 len;
};

union trace_synth_field {
    u8 as_u8;
    u16 as_u16;
    u32 as_u32;
    u64 as_u64;
    struct trace_dynamic_info as_dynamic;
};

struct synth_trace_event {
    struct trace_entry ent;
    union trace_synth_field fields[0];
};

struct sys64_hook {
    long unsigned int esr_mask;
    long unsigned int esr_val;
    void (*handler)(long unsigned int, struct pt_regs *);
};

struct sys_off_data {
    int mode;
    void *cb_data;
    const char *cmd;
    struct device *dev;
};

struct sys_off_handler {
    struct notifier_block nb;
    int (*sys_off_cb)(struct sys_off_data *);
    void *cb_data;
    enum sys_off_mode mode;
    bool blocking;
    void *list;
    struct device *dev;
};

struct sys_reg_params;

struct sys_reg_desc {
    const char *name;
    enum {
        AA32_DIRECT = 0,
        AA32_LO = 1,
        AA32_HI = 2,
    } aarch32_map;
    u8 Op0;
    u8 Op1;
    u8 CRn;
    u8 CRm;
    u8 Op2;
    bool (*access)(struct kvm_vcpu *, struct sys_reg_params *, const struct sys_reg_desc *);
    u64 (*reset)(struct kvm_vcpu *, const struct sys_reg_desc *);
    int reg;
    u64 val;
    int (*__get_user)(struct kvm_vcpu *, const struct sys_reg_desc *, u64 *);
    int (*set_user)(struct kvm_vcpu *, const struct sys_reg_desc *, u64);
    unsigned int (*visibility)(const struct kvm_vcpu *, const struct sys_reg_desc *);
};

struct sys_reg_params {
    u8 Op0;
    u8 Op1;
    u8 CRn;
    u8 CRm;
    u8 Op2;
    u64 regval;
    bool is_write;
};

struct syscall_info {
    __u64 sp;
    struct seccomp_data data;
};

struct syscall_metadata {
    const char *name;
    int syscall_nr;
    int nb_args;
    const char **types;
    const char **args;
    struct list_head enter_fields;
    struct trace_event_call *enter_event;
    struct trace_event_call *exit_event;
};

struct syscall_tp_t {
    struct trace_entry ent;
    int syscall_nr;
    long unsigned int ret;
};

struct syscall_tp_t___2 {
    struct trace_entry ent;
    int syscall_nr;
    long unsigned int args[6];
};

struct syscall_trace_enter {
    struct trace_entry ent;
    int nr;
    long unsigned int args[0];
};

struct syscall_trace_exit {
    struct trace_entry ent;
    int nr;
    long int ret;
};

struct syscall_user_dispatch {};

struct syscon {
    struct device_node *np;
    struct regmap *regmap;
    struct reset_control *reset;
    struct list_head list;
};

struct syscore_ops {
    struct list_head node;
    int (*suspend)(void);
    void (*resume)(void);
    void (*shutdown)(void);
};

struct sysctl_alias {
    const char *kernel_param;
    const char *sysctl_param;
};

struct sysfs_ops {
    ssize_t (*show)(struct kobject *, struct attribute *, char *);
    ssize_t (*store)(struct kobject *, struct attribute *, const char *, size_t);
};

struct sysinfo {
    __kernel_long_t uptime;
    __kernel_ulong_t loads[3];
    __kernel_ulong_t totalram;
    __kernel_ulong_t freeram;
    __kernel_ulong_t sharedram;
    __kernel_ulong_t bufferram;
    __kernel_ulong_t totalswap;
    __kernel_ulong_t freeswap;
    __u16 procs;
    __u16 pad;
    __kernel_ulong_t totalhigh;
    __kernel_ulong_t freehigh;
    __u32 mem_unit;
    char _f[0];
};

struct sysrq_key_op {
    void (* const handler)(u8);
    const char * const help_msg;
    const char * const action_msg;
    const int enable_mask;
};

struct sysrq_state {
    struct input_handle handle;
    struct work_struct reinject_work;
    long unsigned int key_down[12];
    unsigned int alt;
    unsigned int alt_use;
    unsigned int shift;
    unsigned int shift_use;
    bool active;
    bool need_reinject;
    bool reinjecting;
    bool reset_canceled;
    bool reset_requested;
    long unsigned int reset_keybit[12];
    int reset_seq_len;
    int reset_seq_cnt;
    int reset_seq_version;
    struct timer_list keyreset_timer;
};

struct system_counterval_t {
    u64 cycles;
    enum clocksource_ids cs_id;
    bool use_nsecs;
};

struct system_device_crosststamp {
    ktime_t device;
    ktime_t sys_realtime;
    ktime_t sys_monoraw;
};

struct system_heap_buffer {
    struct dma_heap *heap;
    struct list_head attachments;
    struct mutex lock;
    long unsigned int len;
    struct sg_table sg_table;
    int vmap_cnt;
    void *vaddr;
};

struct system_time_snapshot {
    u64 cycles;
    ktime_t real;
    ktime_t boot;
    ktime_t raw;
    enum clocksource_ids cs_id;
    unsigned int clock_was_set_seq;
    u8 cs_was_changed_seq;
};

struct sysv_sem {
    struct sem_undo_list *undo_list;
};

struct sysv_shm {
    struct list_head shm_clist;
};

struct t10_pi_tuple {
    __be16 guard_tag;
    __be16 app_tag;
    __be32 ref_tag;
};

struct table_header {
    u16 td_id;
    u16 td_flags;
    u32 td_hilen;
    u32 td_lolen;
    char td_data[0];
};

struct taint_flag {
    char c_true;
    char c_false;
    bool module;
    const char *desc;
};

struct target {
    struct device_node *np;
    bool in_livetree;
};

struct task_delay_info {
    raw_spinlock_t lock;
    u64 blkio_start;
    u64 blkio_delay_max;
    u64 blkio_delay_min;
    u64 blkio_delay;
    u64 swapin_start;
    u64 swapin_delay_max;
    u64 swapin_delay_min;
    u64 swapin_delay;
    u32 blkio_count;
    u32 swapin_count;
    u64 freepages_start;
    u64 freepages_delay_max;
    u64 freepages_delay_min;
    u64 freepages_delay;
    u64 thrashing_start;
    u64 thrashing_delay_max;
    u64 thrashing_delay_min;
    u64 thrashing_delay;
    u64 compact_start;
    u64 compact_delay_max;
    u64 compact_delay_min;
    u64 compact_delay;
    u64 wpcopy_start;
    u64 wpcopy_delay_max;
    u64 wpcopy_delay_min;
    u64 wpcopy_delay;
    u64 irq_delay_max;
    u64 irq_delay_min;
    u64 irq_delay;
    u32 freepages_count;
    u32 thrashing_count;
    u32 compact_count;
    u32 wpcopy_count;
    u32 irq_count;
};

struct task_group {
    struct cgroup_subsys_state css;
    int idle;
    struct sched_entity **se;
    struct cfs_rq **cfs_rq;
    long unsigned int shares;
    long: 64;
    long: 64;
    atomic_long_t load_avg;
    u32 scx_flags;
    u32 scx_weight;
    struct callback_head rcu;
    struct list_head list;
    struct task_group *parent;
    struct list_head siblings;
    struct list_head children;
    struct autogroup *autogroup;
    struct cfs_bandwidth cfs_bandwidth;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
};

struct task_security_struct {
    u32 osid;
    u32 sid;
    u32 exec_sid;
    u32 create_sid;
    u32 keycreate_sid;
    u32 sockcreate_sid;
};

struct task_smack {
    struct smack_known *smk_task;
    struct smack_known *smk_forked;
    struct smack_known *smk_transmuted;
    struct list_head smk_rules;
    struct mutex smk_rules_lock;
    struct list_head smk_relabel;
};

typedef struct task_struct *class_find_get_task_t;

typedef struct task_struct *class_task_lock_t;

struct thread_info {
    long unsigned int flags;
    u64 ttbr0;
    union {
        u64 preempt_count;
        struct {
            u32 count;
            u32 need_resched;
        } preempt;
    };
    u32 cpu;
};

struct uclamp_se {
    unsigned int value: 11;
    unsigned int bucket_id: 3;
    unsigned int active: 1;
    unsigned int user_defined: 1;
};

struct vtime {
    seqcount_t seqcount;
    long long unsigned int starttime;
    enum vtime_state state;
    unsigned int cpu;
    u64 utime;
    u64 stime;
    u64 gtime;
};

struct wake_q_node {
    struct wake_q_node *next;
};

struct tlbflush_unmap_batch {
    struct arch_tlbflush_unmap_batch arch;
    bool flush_required;
    bool writable;
};

struct thread_struct {
    struct cpu_context cpu_context;
    long: 64;
    struct {
        long unsigned int tp_value;
        long unsigned int tp2_value;
        u64 fpmr;
        long unsigned int pad;
        struct user_fpsimd_state fpsimd_state;
    } uw;
    enum fp_type fp_type;
    unsigned int fpsimd_cpu;
    void *sve_state;
    void *sme_state;
    unsigned int vl[2];
    unsigned int vl_onexec[2];
    long unsigned int fault_address;
    long unsigned int fault_code;
    struct debug_info debug;
    long: 64;
    struct user_fpsimd_state kernel_fpsimd_state;
    unsigned int kernel_fpsimd_cpu;
    struct ptrauth_keys_user keys_user;
    struct ptrauth_keys_kernel keys_kernel;
    u64 mte_ctrl;
    u64 sctlr_user;
    u64 svcr;
    u64 tpidr2_el0;
    u64 por_el0;
};

struct uprobe_task;

struct user_event_mm;

struct task_struct {
    struct thread_info thread_info;
    unsigned int __state;
    unsigned int saved_state;
    void *stack;
    refcount_t usage;
    unsigned int flags;
    unsigned int ptrace;
    int on_cpu;
    struct __call_single_node wake_entry;
    unsigned int wakee_flips;
    long unsigned int wakee_flip_decay_ts;
    struct task_struct *last_wakee;
    int recent_used_cpu;
    int wake_cpu;
    int on_rq;
    int prio;
    int static_prio;
    int normal_prio;
    unsigned int rt_priority;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    struct sched_entity se;
    struct sched_rt_entity rt;
    struct sched_dl_entity dl;
    struct sched_dl_entity *dl_server;
    struct sched_ext_entity scx;
    const struct sched_class *sched_class;
    struct task_group *sched_task_group;
    struct uclamp_se uclamp_req[2];
    struct uclamp_se uclamp[2];
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    struct sched_statistics stats;
    struct hlist_head preempt_notifiers;
    unsigned int btrace_seq;
    unsigned int policy;
    long unsigned int max_allowed_capacity;
    int nr_cpus_allowed;
    const cpumask_t *cpus_ptr;
    cpumask_t *user_cpus_ptr;
    cpumask_t cpus_mask;
    void *migration_pending;
    short unsigned int migration_disabled;
    short unsigned int migration_flags;
    int rcu_read_lock_nesting;
    union rcu_special rcu_read_unlock_special;
    struct list_head rcu_node_entry;
    struct rcu_node *rcu_blocked_node;
    long unsigned int rcu_tasks_nvcsw;
    u8 rcu_tasks_holdout;
    u8 rcu_tasks_idx;
    int rcu_tasks_idle_cpu;
    struct list_head rcu_tasks_holdout_list;
    int rcu_tasks_exit_cpu;
    struct list_head rcu_tasks_exit_list;
    int trc_reader_nesting;
    int trc_ipi_to_cpu;
    union rcu_special trc_reader_special;
    struct list_head trc_holdout_list;
    struct list_head trc_blkd_node;
    int trc_blkd_cpu;
    struct sched_info sched_info;
    struct list_head tasks;
    struct plist_node pushable_tasks;
    struct rb_node pushable_dl_tasks;
    struct mm_struct *mm;
    struct mm_struct *active_mm;
    struct address_space *faults_disabled_mapping;
    int exit_state;
    int exit_code;
    int exit_signal;
    int pdeath_signal;
    long unsigned int jobctl;
    unsigned int personality;
    unsigned int sched_reset_on_fork: 1;
    unsigned int sched_contributes_to_load: 1;
    unsigned int sched_migrated: 1;
    unsigned int sched_task_hot: 1;
    long: 28;
    unsigned int sched_remote_wakeup: 1;
    unsigned int sched_rt_mutex: 1;
    unsigned int in_execve: 1;
    unsigned int in_iowait: 1;
    unsigned int in_lru_fault: 1;
    unsigned int no_cgroup_migration: 1;
    unsigned int frozen: 1;
    unsigned int use_memdelay: 1;
    unsigned int in_memstall: 1;
    unsigned int in_eventfd: 1;
    unsigned int in_thrashing: 1;
    long unsigned int atomic_flags;
    struct restart_block restart_block;
    pid_t pid;
    pid_t tgid;
    long unsigned int stack_canary;
    struct task_struct *real_parent;
    struct task_struct *parent;
    struct list_head children;
    struct list_head sibling;
    struct task_struct *group_leader;
    struct list_head ptraced;
    struct list_head ptrace_entry;
    struct pid *thread_pid;
    struct hlist_node pid_links[4];
    struct list_head thread_node;
    struct completion *vfork_done;
    int *set_child_tid;
    int *clear_child_tid;
    void *worker_private;
    u64 utime;
    u64 stime;
    u64 gtime;
    struct prev_cputime prev_cputime;
    struct vtime vtime;
    atomic_t tick_dep_mask;
    long unsigned int nvcsw;
    long unsigned int nivcsw;
    u64 start_time;
    u64 start_boottime;
    long unsigned int min_flt;
    long unsigned int maj_flt;
    struct posix_cputimers posix_cputimers;
    struct posix_cputimers_work posix_cputimers_work;
    const struct cred *ptracer_cred;
    const struct cred *real_cred;
    const struct cred *cred;
    struct key *cached_requested_key;
    char comm[16];
    struct nameidata *nameidata;
    struct sysv_sem sysvsem;
    struct sysv_shm sysvshm;
    long unsigned int last_switch_count;
    long unsigned int last_switch_time;
    struct fs_struct *fs;
    struct files_struct *files;
    struct io_uring_task *io_uring;
    struct nsproxy *nsproxy;
    struct signal_struct *signal;
    struct sighand_struct *sighand;
    sigset_t blocked;
    sigset_t real_blocked;
    sigset_t saved_sigmask;
    struct sigpending pending;
    long unsigned int sas_ss_sp;
    size_t sas_ss_size;
    unsigned int sas_ss_flags;
    struct callback_head *task_works;
    struct audit_context *audit_context;
    kuid_t loginuid;
    unsigned int sessionid;
    struct seccomp seccomp;
    struct syscall_user_dispatch syscall_dispatch;
    u64 parent_exec_id;
    u64 self_exec_id;
    spinlock_t alloc_lock;
    raw_spinlock_t pi_lock;
    struct wake_q_node wake_q;
    struct rb_root_cached pi_waiters;
    struct task_struct *pi_top_task;
    struct rt_mutex_waiter *pi_blocked_on;
    struct irqtrace_events irqtrace;
    unsigned int hardirq_threaded;
    u64 hardirq_chain_key;
    int softirqs_enabled;
    int softirq_context;
    int irq_config;
    unsigned int in_ubsan;
    void *journal_info;
    struct bio_list *bio_list;
    struct blk_plug *plug;
    struct reclaim_state *reclaim_state;
    struct io_context *io_context;
    struct capture_control *capture_control;
    long unsigned int ptrace_message;
    kernel_siginfo_t *last_siginfo;
    struct task_io_accounting ioac;
    unsigned int psi_flags;
    u64 acct_rss_mem1;
    u64 acct_vm_mem1;
    u64 acct_timexpd;
    nodemask_t mems_allowed;
    seqcount_spinlock_t mems_allowed_seq;
    int cpuset_mem_spread_rotor;
    struct css_set *cgroups;
    struct list_head cg_list;
    struct robust_list_head *robust_list;
    struct compat_robust_list_head *compat_robust_list;
    struct list_head pi_state_list;
    struct futex_pi_state *pi_state_cache;
    struct mutex futex_exit_mutex;
    unsigned int futex_state;
    u8 perf_recursion[4];
    struct perf_event_context *perf_event_ctxp;
    struct mutex perf_event_mutex;
    struct list_head perf_event_list;
    struct perf_ctx_data *perf_ctx_data;
    struct rseq *rseq;
    u32 rseq_len;
    u32 rseq_sig;
    long unsigned int rseq_event_mask;
    int mm_cid;
    int last_mm_cid;
    int migrate_from_cpu;
    int mm_cid_active;
    struct callback_head cid_work;
    struct tlbflush_unmap_batch tlb_ubc;
    struct pipe_inode_info *splice_pipe;
    struct page_frag task_frag;
    struct task_delay_info *delays;
    int nr_dirtied;
    int nr_dirtied_pause;
    long unsigned int dirty_paused_when;
    int latency_record_count;
    struct latency_record latency_record[32];
    u64 timer_slack_ns;
    u64 default_timer_slack_ns;
    int curr_ret_stack;
    int curr_ret_depth;
    long unsigned int *ret_stack;
    long long unsigned int ftrace_timestamp;
    long long unsigned int ftrace_sleeptime;
    atomic_t trace_overrun;
    atomic_t tracing_graph_pause;
    long unsigned int trace_recursion;
    unsigned int memcg_nr_pages_over_high;
    struct mem_cgroup *active_memcg;
    struct obj_cgroup *objcg;
    struct gendisk *throttle_disk;
    struct uprobe_task *utask;
    unsigned int sequential_io;
    unsigned int sequential_io_avg;
    struct kmap_ctrl kmap_ctrl;
    struct callback_head rcu;
    refcount_t rcu_users;
    int pagefault_disabled;
    struct task_struct *oom_reaper_list;
    struct timer_list oom_reaper_timer;
    struct vm_struct *stack_vm_area;
    refcount_t stack_refcount;
    void *security;
    struct bpf_local_storage *bpf_storage;
    struct bpf_run_ctx *bpf_ctx;
    struct bpf_net_context *bpf_net_context;
    struct llist_head kretprobe_instances;
    struct user_event_mm *user_event_mm;
    long: 64;
    struct thread_struct thread;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
};

struct task_struct__safe_rcu {
    const cpumask_t *cpus_ptr;
    struct css_set *cgroups;
    struct task_struct *real_parent;
    struct task_struct *group_leader;
};

struct tasklet_head {
    struct tasklet_struct *head;
    struct tasklet_struct **tail;
};

struct taskstats {
    __u16 version;
    __u32 ac_exitcode;
    __u8 ac_flag;
    __u8 ac_nice;
    __u64 cpu_count;
    __u64 cpu_delay_total;
    __u64 cpu_delay_max;
    __u64 cpu_delay_min;
    __u64 blkio_count;
    __u64 blkio_delay_total;
    __u64 blkio_delay_max;
    __u64 blkio_delay_min;
    __u64 swapin_count;
    __u64 swapin_delay_total;
    __u64 swapin_delay_max;
    __u64 swapin_delay_min;
    __u64 cpu_run_real_total;
    __u64 cpu_run_virtual_total;
    char ac_comm[32];
    __u8 ac_sched;
    __u8 ac_pad[3];
    long: 0;
    __u32 ac_uid;
    __u32 ac_gid;
    __u32 ac_pid;
    __u32 ac_ppid;
    __u32 ac_btime;
    __u64 ac_etime;
    __u64 ac_utime;
    __u64 ac_stime;
    __u64 ac_minflt;
    __u64 ac_majflt;
    __u64 coremem;
    __u64 virtmem;
    __u64 hiwater_rss;
    __u64 hiwater_vm;
    __u64 read_char;
    __u64 write_char;
    __u64 read_syscalls;
    __u64 write_syscalls;
    __u64 read_bytes;
    __u64 write_bytes;
    __u64 cancelled_write_bytes;
    __u64 nvcsw;
    __u64 nivcsw;
    __u64 ac_utimescaled;
    __u64 ac_stimescaled;
    __u64 cpu_scaled_run_real_total;
    __u64 freepages_count;
    __u64 freepages_delay_total;
    __u64 freepages_delay_max;
    __u64 freepages_delay_min;
    __u64 thrashing_count;
    __u64 thrashing_delay_total;
    __u64 thrashing_delay_max;
    __u64 thrashing_delay_min;
    __u64 ac_btime64;
    __u64 compact_count;
    __u64 compact_delay_total;
    __u64 compact_delay_max;
    __u64 compact_delay_min;
    __u32 ac_tgid;
    __u64 ac_tgetime;
    __u64 ac_exe_dev;
    __u64 ac_exe_inode;
    __u64 wpcopy_count;
    __u64 wpcopy_delay_total;
    __u64 wpcopy_delay_max;
    __u64 wpcopy_delay_min;
    __u64 irq_count;
    __u64 irq_delay_total;
    __u64 irq_delay_max;
    __u64 irq_delay_min;
};

struct tc_act_pernet_id {
    struct list_head list;
    unsigned int id;
};

struct tcf_t {
    __u64 install;
    __u64 lastuse;
    __u64 expires;
    __u64 firstuse;
};

struct tc_action_ops;

struct tcf_idrinfo;

struct tc_cookie;

struct tcf_chain;

struct tc_action {
    const struct tc_action_ops *ops;
    __u32 type;
    struct tcf_idrinfo *idrinfo;
    u32 tcfa_index;
    refcount_t tcfa_refcnt;
    atomic_t tcfa_bindcnt;
    int tcfa_action;
    struct tcf_t tcfa_tm;
    long: 64;
    struct gnet_stats_basic_sync tcfa_bstats;
    struct gnet_stats_basic_sync tcfa_bstats_hw;
    struct gnet_stats_queue tcfa_qstats;
    struct net_rate_estimator *tcfa_rate_est;
    spinlock_t tcfa_lock;
    struct gnet_stats_basic_sync *cpu_bstats;
    struct gnet_stats_basic_sync *cpu_bstats_hw;
    struct gnet_stats_queue *cpu_qstats;
    struct tc_cookie *user_cookie;
    struct tcf_chain *goto_chain;
    u32 tcfa_flags;
    u8 hw_stats;
    u8 used_hw_stats;
    bool used_hw_stats_valid;
    u32 in_hw_count;
};

struct tc_action_net {
    struct tcf_idrinfo *idrinfo;
    const struct tc_action_ops *ops;
};

typedef void (*tc_action_priv_destructor)(void *);

struct tcf_result;

struct tc_action_ops {
    struct list_head head;
    char kind[16];
    enum tca_id id;
    unsigned int net_id;
    size_t size;
    struct module *owner;
    int (*act)(struct sk_buff *, const struct tc_action *, struct tcf_result *);
    int (*dump)(struct sk_buff *, struct tc_action *, int, int);
    void (*cleanup)(struct tc_action *);
    int (*lookup)(struct net *, struct tc_action **, u32);
    int (*init)(struct net *, struct nlattr *, struct nlattr *, struct tc_action **, struct tcf_proto *, u32, struct netlink_ext_ack *);
    int (*walk)(struct net *, struct sk_buff *, struct netlink_callback *, int, const struct tc_action_ops *, struct netlink_ext_ack *);
    void (*stats_update)(struct tc_action *, u64, u64, u64, u64, bool);
    size_t (*get_fill_size)(const struct tc_action *);
    struct net_device * (*get_dev)(const struct tc_action *, tc_action_priv_destructor *);
    struct psample_group * (*get_psample_group)(const struct tc_action *, tc_action_priv_destructor *);
    int (*offload_act_setup)(struct tc_action *, void *, u32 *, bool, struct netlink_ext_ack *);
};

struct tc_bind_class_args {
    struct qdisc_walker w;
    long unsigned int new_cl;
    u32 portid;
    u32 clid;
};

struct tc_cookie {
    u8 *data;
    u32 len;
    struct callback_head rcu;
};

struct tc_fifo_qopt {
    __u32 limit;
};

struct tc_qopt_offload_stats {
    struct gnet_stats_basic_sync *bstats;
    struct gnet_stats_queue *qstats;
};

struct tc_fifo_qopt_offload {
    enum tc_fifo_command command;
    u32 handle;
    u32 parent;
    union {
        struct tc_qopt_offload_stats stats;
    };
};

struct tc_mq_opt_offload_graft_params {
    long unsigned int queue;
    u32 child_handle;
};

struct tc_mq_qopt_offload {
    enum tc_mq_command command;
    u32 handle;
    union {
        struct tc_qopt_offload_stats stats;
        struct tc_mq_opt_offload_graft_params graft_params;
    };
};

struct tc_pedit_key {
    __u32 mask;
    __u32 val;
    __u32 off;
    __u32 at;
    __u32 offmask;
    __u32 shift;
};

struct tc_prio_qopt {
    int bands;
    __u8 priomap[16];
};

struct tc_query_caps_base {
    enum tc_setup_type type;
    void *caps;
};

struct tc_root_qopt_offload {
    enum tc_root_command command;
    u32 handle;
    bool ingress;
};

struct tc_skb_cb {
    struct qdisc_skb_cb qdisc_cb;
    u32 drop_reason;
    u16 zone;
    u16 mru;
    u8 post_ct: 1;
    u8 post_ct_snat: 1;
    u8 post_ct_dnat: 1;
};

struct tcamsg {
    unsigned char tca_family;
    unsigned char tca__pad1;
    short unsigned int tca__pad2;
};

struct tcf_walker {
    int stop;
    int skip;
    int count;
    bool nonempty;
    long unsigned int cookie;
    int (*fn)(struct tcf_proto *, void *, struct tcf_walker *);
};

struct tcf_bind_args {
    struct tcf_walker w;
    long unsigned int base;
    long unsigned int cl;
    u32 classid;
};

struct tcf_block {
    struct xarray ports;
    struct mutex lock;
    struct list_head chain_list;
    u32 index;
    u32 classid;
    refcount_t refcnt;
    struct net *net;
    struct Qdisc *q;
    struct rw_semaphore cb_lock;
    struct flow_block flow_block;
    struct list_head owner_list;
    bool keep_dst;
    atomic_t useswcnt;
    atomic_t offloadcnt;
    unsigned int nooffloaddevcnt;
    unsigned int lockeddevcnt;
    struct {
        struct tcf_chain *chain;
        struct list_head filter_chain_list;
    } chain0;
    struct callback_head rcu;
    struct hlist_head proto_destroy_ht[128];
    struct mutex proto_destroy_lock;
};

typedef void tcf_chain_head_change_t(struct tcf_proto *, void *);

struct tcf_block_ext_info {
    enum flow_block_binder_type binder_type;
    tcf_chain_head_change_t *chain_head_change;
    void *chain_head_change_priv;
    u32 block_index;
};

struct tcf_block_owner_item {
    struct list_head list;
    struct Qdisc *q;
    enum flow_block_binder_type binder_type;
};

struct tcf_proto_ops;

struct tcf_chain {
    struct mutex filter_chain_lock;
    struct tcf_proto *filter_chain;
    struct list_head list;
    struct tcf_block *block;
    u32 index;
    unsigned int refcnt;
    unsigned int action_refcnt;
    bool explicitly_created;
    bool flushing;
    const struct tcf_proto_ops *tmplt_ops;
    void *tmplt_priv;
    struct callback_head rcu;
};

struct tcf_chain_info {
    struct tcf_proto **pprev;
    struct tcf_proto *next;
};

struct tcf_dump_args {
    struct tcf_walker w;
    struct sk_buff *skb;
    struct netlink_callback *cb;
    struct tcf_block *block;
    struct Qdisc *q;
    u32 parent;
    bool terse_dump;
};

struct tcf_ematch_ops;

struct tcf_ematch {
    struct tcf_ematch_ops *ops;
    long unsigned int data;
    unsigned int datalen;
    u16 matchid;
    u16 flags;
    struct net *net;
};

struct tcf_ematch_hdr {
    __u16 matchid;
    __u16 kind;
    __u16 flags;
    __u16 pad;
};

struct tcf_pkt_info;

struct tcf_ematch_ops {
    int kind;
    int datalen;
    int (*change)(struct net *, void *, int, struct tcf_ematch *);
    int (*match)(struct sk_buff *, struct tcf_ematch *, struct tcf_pkt_info *);
    void (*destroy)(struct tcf_ematch *);
    int (*dump)(struct sk_buff *, struct tcf_ematch *);
    struct module *owner;
    struct list_head link;
};

struct tcf_ematch_tree_hdr {
    __u16 nmatches;
    __u16 progid;
};

struct tcf_ematch_tree {
    struct tcf_ematch_tree_hdr hdr;
    struct tcf_ematch *matches;
};

struct tcf_exts_miss_cookie_node;

struct tcf_exts {
    __u32 type;
    int nr_actions;
    struct tc_action **actions;
    struct net *net;
    netns_tracker ns_tracker;
    struct tcf_exts_miss_cookie_node *miss_cookie_node;
    int action;
    int police;
};

union tcf_exts_miss_cookie {
    struct {
        u32 miss_cookie_base;
        u32 act_index;
    };
    u64 miss_cookie;
};

struct tcf_exts_miss_cookie_node {
    const struct tcf_chain *chain;
    const struct tcf_proto *tp;
    const struct tcf_exts *exts;
    u32 chain_index;
    u32 tp_prio;
    u32 handle;
    u32 miss_cookie_base;
    struct callback_head rcu;
};

struct tcf_filter_chain_list_item {
    struct list_head list;
    tcf_chain_head_change_t *chain_head_change;
    void *chain_head_change_priv;
};

struct tcf_idrinfo {
    struct mutex lock;
    struct idr action_idr;
    struct net *net;
};

struct tcf_net {
    spinlock_t idr_lock;
    struct idr idr;
};

struct tcf_pedit_parms;

struct tcf_pedit {
    struct tc_action common;
    struct tcf_pedit_parms *parms;
    long: 64;
};

struct tcf_pedit_key_ex {
    enum pedit_header_type htype;
    enum pedit_cmd cmd;
};

struct tcf_pedit_parms {
    struct tc_pedit_key *tcfp_keys;
    struct tcf_pedit_key_ex *tcfp_keys_ex;
    u32 tcfp_off_max_hint;
    unsigned char tcfp_nkeys;
    unsigned char tcfp_flags;
    struct callback_head rcu;
};

struct tcf_pkt_info {
    unsigned char *ptr;
    int nexthdr;
};

struct tcf_proto {
    struct tcf_proto *next;
    void *root;
    int (*classify)(struct sk_buff *, const struct tcf_proto *, struct tcf_result *);
    __be16 protocol;
    u32 prio;
    void *data;
    const struct tcf_proto_ops *ops;
    struct tcf_chain *chain;
    spinlock_t lock;
    bool deleting;
    bool counted;
    bool usesw;
    refcount_t refcnt;
    struct callback_head rcu;
    struct hlist_node destroy_ht_node;
};

struct tcf_proto_ops {
    struct list_head head;
    char kind[16];
    int (*classify)(struct sk_buff *, const struct tcf_proto *, struct tcf_result *);
    int (*init)(struct tcf_proto *);
    void (*destroy)(struct tcf_proto *, bool, struct netlink_ext_ack *);
    void * (*get)(struct tcf_proto *, u32);
    void (*put)(struct tcf_proto *, void *);
    int (*change)(struct net *, struct sk_buff *, struct tcf_proto *, long unsigned int, u32, struct nlattr **, void **, u32, struct netlink_ext_ack *);
    int (*delete)(struct tcf_proto *, void *, bool *, bool, struct netlink_ext_ack *);
    bool (*delete_empty)(struct tcf_proto *);
    void (*walk)(struct tcf_proto *, struct tcf_walker *, bool);
    int (*reoffload)(struct tcf_proto *, bool, flow_setup_cb_t *, void *, struct netlink_ext_ack *);
    void (*hw_add)(struct tcf_proto *, void *);
    void (*hw_del)(struct tcf_proto *, void *);
    void (*bind_class)(void *, u32, long unsigned int, void *, long unsigned int);
    void * (*tmplt_create)(struct net *, struct tcf_chain *, struct nlattr **, struct netlink_ext_ack *);
    void (*tmplt_destroy)(void *);
    void (*tmplt_reoffload)(struct tcf_chain *, bool, flow_setup_cb_t *, void *);
    struct tcf_exts * (*get_exts)(const struct tcf_proto *, u32);
    int (*dump)(struct net *, struct tcf_proto *, void *, struct sk_buff *, struct tcmsg *, bool);
    int (*terse_dump)(struct net *, struct tcf_proto *, void *, struct sk_buff *, struct tcmsg *, bool);
    int (*tmplt_dump)(struct sk_buff *, struct net *, void *);
    struct module *owner;
    int flags;
};

struct tcf_qevent {
    struct tcf_block *block;
    struct tcf_block_ext_info info;
    struct tcf_proto *filter_chain;
};

struct tcf_result {
    union {
        struct {
            long unsigned int class;
            u32 classid;
        };
        const struct tcf_proto *goto_tp;
    };
};

struct tcg_efi_specid_event_algs {
    u16 alg_id;
    u16 digest_size;
};

struct tcg_efi_specid_event_head {
    u8 signature[16];
    u32 platform_class;
    u8 spec_version_minor;
    u8 spec_version_major;
    u8 spec_errata;
    u8 uintnsize;
    u32 num_algs;
    struct tcg_efi_specid_event_algs digest_sizes[0];
};

struct tcg_event_field {
    u32 event_size;
    u8 event[0];
};

struct tcg_pcr_event {
    u32 pcr_idx;
    u32 event_type;
    u8 digest[20];
    u32 event_size;
    u8 event[0];
};

struct tpm_digest {
    u16 alg_id;
    u8 digest[64];
};

struct tcg_pcr_event2_head {
    u32 pcr_idx;
    u32 event_type;
    u32 count;
    struct tpm_digest digests[0];
};

struct tcmsg {
    unsigned char tcm_family;
    unsigned char tcm__pad1;
    short unsigned int tcm__pad2;
    int tcm_ifindex;
    __u32 tcm_handle;
    __u32 tcm_parent;
    __u32 tcm_info;
};

struct tcp4_pseudohdr {
    __be32 saddr;
    __be32 daddr;
    __u8 pad;
    __u8 protocol;
    __be16 len;
};

struct tcp6_pseudohdr {
    struct in6_addr saddr;
    struct in6_addr daddr;
    __be32 len;
    __be32 protocol;
};

struct tcp_options_received {
    int ts_recent_stamp;
    u32 ts_recent;
    u32 rcv_tsval;
    u32 rcv_tsecr;
    u16 saw_tstamp: 1;
    u16 tstamp_ok: 1;
    u16 dsack: 1;
    u16 wscale_ok: 1;
    u16 sack_ok: 3;
    u16 smc_ok: 1;
    u16 snd_wscale: 4;
    u16 rcv_wscale: 4;
    u8 saw_unknown: 1;
    u8 unused: 7;
    u8 num_sacks;
    u16 user_mss;
    u16 mss_clamp;
};

struct tcp_rack {
    u64 mstamp;
    u32 rtt_us;
    u32 end_seq;
    u32 last_delivered;
    u8 reo_wnd_steps;
    u8 reo_wnd_persist: 5;
    u8 dsack_seen: 1;
    u8 advanced: 1;
};

struct tcp_sack_block {
    u32 start_seq;
    u32 end_seq;
};

struct tcp_sock_af_ops;

struct tcp_md5sig_info;

struct tcp_ao_info;

struct tcp_fastopen_request;

struct tcp_sock {
    struct inet_connection_sock inet_conn;
    __u8 __cacheline_group_begin__tcp_sock_read_tx[0];
    u32 max_window;
    u32 rcv_ssthresh;
    u32 reordering;
    u32 notsent_lowat;
    u16 gso_segs;
    struct sk_buff *lost_skb_hint;
    struct sk_buff *retransmit_skb_hint;
    __u8 __cacheline_group_end__tcp_sock_read_tx[0];
    __u8 __cacheline_group_begin__tcp_sock_read_txrx[0];
    u32 tsoffset;
    u32 snd_wnd;
    u32 mss_cache;
    u32 snd_cwnd;
    u32 prr_out;
    u32 lost_out;
    u32 sacked_out;
    u16 tcp_header_len;
    u8 scaling_ratio;
    u8 chrono_type: 2;
    u8 repair: 1;
    u8 tcp_usec_ts: 1;
    u8 is_sack_reneg: 1;
    u8 is_cwnd_limited: 1;
    __u8 __cacheline_group_end__tcp_sock_read_txrx[0];
    __u8 __cacheline_group_begin__tcp_sock_read_rx[0];
    u32 copied_seq;
    u32 rcv_tstamp;
    u32 snd_wl1;
    u32 tlp_high_seq;
    u32 rttvar_us;
    u32 retrans_out;
    u16 advmss;
    u16 urg_data;
    u32 lost;
    struct minmax rtt_min;
    struct rb_root out_of_order_queue;
    u32 snd_ssthresh;
    u8 recvmsg_inq: 1;
    __u8 __cacheline_group_end__tcp_sock_read_rx[0];
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    __u8 __cacheline_group_begin__tcp_sock_write_tx[0];
    u32 segs_out;
    u32 data_segs_out;
    u64 bytes_sent;
    u32 snd_sml;
    u32 chrono_start;
    u32 chrono_stat[3];
    u32 write_seq;
    u32 pushed_seq;
    u32 lsndtime;
    u32 mdev_us;
    u32 rtt_seq;
    u64 tcp_wstamp_ns;
    struct list_head tsorted_sent_queue;
    struct sk_buff *highest_sack;
    u8 ecn_flags;
    __u8 __cacheline_group_end__tcp_sock_write_tx[0];
    __u8 __cacheline_group_begin__tcp_sock_write_txrx[0];
    __be32 pred_flags;
    u64 tcp_clock_cache;
    u64 tcp_mstamp;
    u32 rcv_nxt;
    u32 snd_nxt;
    u32 snd_una;
    u32 window_clamp;
    u32 srtt_us;
    u32 packets_out;
    u32 snd_up;
    u32 delivered;
    u32 delivered_ce;
    u32 app_limited;
    u32 rcv_wnd;
    struct tcp_options_received rx_opt;
    u8 nonagle: 4;
    u8 rate_app_limited: 1;
    __u8 __cacheline_group_end__tcp_sock_write_txrx[0];
    long: 0;
    __u8 __cacheline_group_begin__tcp_sock_write_rx[0];
    u64 bytes_received;
    u32 segs_in;
    u32 data_segs_in;
    u32 rcv_wup;
    u32 max_packets_out;
    u32 cwnd_usage_seq;
    u32 rate_delivered;
    u32 rate_interval_us;
    u32 rcv_rtt_last_tsecr;
    u64 first_tx_mstamp;
    u64 delivered_mstamp;
    u64 bytes_acked;
    struct {
        u32 rtt_us;
        u32 seq;
        u64 time;
    } rcv_rtt_est;
    struct {
        u32 space;
        u32 seq;
        u64 time;
    } rcvq_space;
    __u8 __cacheline_group_end__tcp_sock_write_rx[0];
    u32 dsack_dups;
    u32 compressed_ack_rcv_nxt;
    struct list_head tsq_node;
    struct tcp_rack rack;
    u8 compressed_ack;
    u8 dup_ack_counter: 2;
    u8 tlp_retrans: 1;
    u8 unused: 5;
    u8 thin_lto: 1;
    u8 fastopen_connect: 1;
    u8 fastopen_no_cookie: 1;
    u8 fastopen_client_fail: 2;
    u8 frto: 1;
    u8 repair_queue;
    u8 save_syn: 2;
    u8 syn_data: 1;
    u8 syn_fastopen: 1;
    u8 syn_fastopen_exp: 1;
    u8 syn_fastopen_ch: 1;
    u8 syn_data_acked: 1;
    u8 keepalive_probes;
    u32 tcp_tx_delay;
    u32 mdev_max_us;
    u32 reord_seen;
    u32 snd_cwnd_cnt;
    u32 snd_cwnd_clamp;
    u32 snd_cwnd_used;
    u32 snd_cwnd_stamp;
    u32 prior_cwnd;
    u32 prr_delivered;
    u32 last_oow_ack_time;
    struct hrtimer pacing_timer;
    struct hrtimer compressed_ack_timer;
    struct sk_buff *ooo_last_skb;
    struct tcp_sack_block duplicate_sack[1];
    struct tcp_sack_block selective_acks[4];
    struct tcp_sack_block recv_sack_cache[4];
    int lost_cnt_hint;
    u32 prior_ssthresh;
    u32 high_seq;
    u32 retrans_stamp;
    u32 undo_marker;
    int undo_retrans;
    u64 bytes_retrans;
    u32 total_retrans;
    u32 rto_stamp;
    u16 total_rto;
    u16 total_rto_recoveries;
    u32 total_rto_time;
    u32 urg_seq;
    unsigned int keepalive_time;
    unsigned int keepalive_intvl;
    int linger2;
    u8 bpf_sock_ops_cb_flags;
    u8 bpf_chg_cc_inprogress: 1;
    u16 timeout_rehash;
    u32 rcv_ooopack;
    struct {
        u32 probe_seq_start;
        u32 probe_seq_end;
    } mtu_probe;
    u32 plb_rehash;
    u32 mtu_info;
    bool is_mptcp;
    bool syn_smc;
    bool (*smc_hs_congested)(const struct sock *);
    const struct tcp_sock_af_ops *af_specific;
    struct tcp_md5sig_info *md5sig_info;
    struct tcp_ao_info *ao_info;
    struct tcp_fastopen_request *fastopen_req;
    struct request_sock *fastopen_rsk;
    struct saved_syn *saved_syn;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
};

struct tcp6_sock {
    struct tcp_sock tcp;
    struct ipv6_pinfo inet6;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
};

struct tcp_ao_add {
    struct __kernel_sockaddr_storage addr;
    char alg_name[64];
    __s32 ifindex;
    __u32 set_current: 1;
    __u32 set_rnext: 1;
    __u32 reserved: 30;
    __u16 reserved2;
    __u8 prefix;
    __u8 sndid;
    __u8 rcvid;
    __u8 maclen;
    __u8 keyflags;
    __u8 keylen;
    __u8 key[80];
};

union tcp_ao_addr {
    struct in_addr a4;
    struct in6_addr a6;
};

struct tcp_ao_counters {
    atomic64_t pkt_good;
    atomic64_t pkt_bad;
    atomic64_t key_not_found;
    atomic64_t ao_required;
    atomic64_t dropped_icmp;
};

struct tcp_ao_del {
    struct __kernel_sockaddr_storage addr;
    __s32 ifindex;
    __u32 set_current: 1;
    __u32 set_rnext: 1;
    __u32 del_async: 1;
    __u32 reserved: 29;
    __u16 reserved2;
    __u8 prefix;
    __u8 sndid;
    __u8 rcvid;
    __u8 current_key;
    __u8 rnext;
    __u8 keyflags;
};

struct tcp_ao_getsockopt {
    struct __kernel_sockaddr_storage addr;
    char alg_name[64];
    __u8 key[80];
    __u32 nkeys;
    __u16 is_current: 1;
    __u16 is_rnext: 1;
    __u16 get_all: 1;
    __u16 reserved: 13;
    __u8 sndid;
    __u8 rcvid;
    __u8 prefix;
    __u8 maclen;
    __u8 keyflags;
    __u8 keylen;
    __s32 ifindex;
    __u64 pkt_good;
    __u64 pkt_bad;
};

struct tcp_ao_hdr {
    u8 kind;
    u8 length;
    u8 keyid;
    u8 rnext_keyid;
};

struct tcp_ao_key;

struct tcp_ao_info {
    struct hlist_head head;
    struct tcp_ao_key *current_key;
    struct tcp_ao_key *rnext_key;
    struct tcp_ao_counters counters;
    u32 ao_required: 1;
    u32 accept_icmps: 1;
    u32 __unused: 30;
    __be32 lisn;
    __be32 risn;
    u32 snd_sne;
    u32 rcv_sne;
    refcount_t refcnt;
    struct callback_head rcu;
};

struct tcp_ao_info_opt {
    __u32 set_current: 1;
    __u32 set_rnext: 1;
    __u32 ao_required: 1;
    __u32 set_counters: 1;
    __u32 accept_icmps: 1;
    __u32 reserved: 27;
    __u16 reserved2;
    __u8 current_key;
    __u8 rnext;
    __u64 pkt_good;
    __u64 pkt_bad;
    __u64 pkt_key_not_found;
    __u64 pkt_ao_required;
    __u64 pkt_dropped_icmp;
};

struct tcp_ao_key {
    struct hlist_node node;
    union tcp_ao_addr addr;
    u8 key[80];
    unsigned int tcp_sigpool_id;
    unsigned int digest_size;
    int l3index;
    u8 prefixlen;
    u8 family;
    u8 keylen;
    u8 keyflags;
    u8 sndid;
    u8 rcvid;
    u8 maclen;
    struct callback_head rcu;
    atomic64_t pkt_good;
    atomic64_t pkt_bad;
    u8 traffic_keys[0];
};

struct tcp_ao_repair {
    __be32 snt_isn;
    __be32 rcv_isn;
    __u32 snd_sne;
    __u32 rcv_sne;
};

struct tcp_bbr_info {
    __u32 bbr_bw_lo;
    __u32 bbr_bw_hi;
    __u32 bbr_min_rtt;
    __u32 bbr_pacing_gain;
    __u32 bbr_cwnd_gain;
};

struct tcpvegas_info {
    __u32 tcpv_enabled;
    __u32 tcpv_rttcnt;
    __u32 tcpv_rtt;
    __u32 tcpv_minrtt;
};

struct tcp_dctcp_info {
    __u16 dctcp_enabled;
    __u16 dctcp_ce_state;
    __u32 dctcp_alpha;
    __u32 dctcp_ab_ecn;
    __u32 dctcp_ab_tot;
};

union tcp_cc_info {
    struct tcpvegas_info vegas;
    struct tcp_dctcp_info dctcp;
    struct tcp_bbr_info bbr;
};

struct tcp_fastopen_context {
    siphash_key_t key[2];
    int num;
    struct callback_head rcu;
};

struct tcp_fastopen_cookie {
    __le64 val[2];
    s8 len;
    bool exp;
};

struct tcp_fastopen_metrics {
    u16 mss;
    u16 syn_loss: 10;
    u16 try_exp: 2;
    long unsigned int last_syn_loss;
    struct tcp_fastopen_cookie cookie;
};

struct tcp_fastopen_request {
    struct tcp_fastopen_cookie cookie;
    struct msghdr *data;
    size_t size;
    int copied;
    struct ubuf_info *uarg;
};

struct tcp_info {
    __u8 tcpi_state;
    __u8 tcpi_ca_state;
    __u8 tcpi_retransmits;
    __u8 tcpi_probes;
    __u8 tcpi_backoff;
    __u8 tcpi_options;
    __u8 tcpi_snd_wscale: 4;
    __u8 tcpi_rcv_wscale: 4;
    __u8 tcpi_delivery_rate_app_limited: 1;
    __u8 tcpi_fastopen_client_fail: 2;
    __u32 tcpi_rto;
    __u32 tcpi_ato;
    __u32 tcpi_snd_mss;
    __u32 tcpi_rcv_mss;
    __u32 tcpi_unacked;
    __u32 tcpi_sacked;
    __u32 tcpi_lost;
    __u32 tcpi_retrans;
    __u32 tcpi_fackets;
    __u32 tcpi_last_data_sent;
    __u32 tcpi_last_ack_sent;
    __u32 tcpi_last_data_recv;
    __u32 tcpi_last_ack_recv;
    __u32 tcpi_pmtu;
    __u32 tcpi_rcv_ssthresh;
    __u32 tcpi_rtt;
    __u32 tcpi_rttvar;
    __u32 tcpi_snd_ssthresh;
    __u32 tcpi_snd_cwnd;
    __u32 tcpi_advmss;
    __u32 tcpi_reordering;
    __u32 tcpi_rcv_rtt;
    __u32 tcpi_rcv_space;
    __u32 tcpi_total_retrans;
    __u64 tcpi_pacing_rate;
    __u64 tcpi_max_pacing_rate;
    __u64 tcpi_bytes_acked;
    __u64 tcpi_bytes_received;
    __u32 tcpi_segs_out;
    __u32 tcpi_segs_in;
    __u32 tcpi_notsent_bytes;
    __u32 tcpi_min_rtt;
    __u32 tcpi_data_segs_in;
    __u32 tcpi_data_segs_out;
    __u64 tcpi_delivery_rate;
    __u64 tcpi_busy_time;
    __u64 tcpi_rwnd_limited;
    __u64 tcpi_sndbuf_limited;
    __u32 tcpi_delivered;
    __u32 tcpi_delivered_ce;
    __u64 tcpi_bytes_sent;
    __u64 tcpi_bytes_retrans;
    __u32 tcpi_dsack_dups;
    __u32 tcpi_reord_seen;
    __u32 tcpi_rcv_ooopack;
    __u32 tcpi_snd_wnd;
    __u32 tcpi_rcv_wnd;
    __u32 tcpi_rehash;
    __u16 tcpi_total_rto;
    __u16 tcpi_total_rto_recoveries;
    __u32 tcpi_total_rto_time;
};

struct tcp_md5sig_key;

struct tcp_key {
    union {
        struct {
            struct tcp_ao_key *ao_key;
            char *traffic_key;
            u32 sne;
            u8 rcv_next;
        };
        struct tcp_md5sig_key *md5_key;
    };
    enum {
        TCP_KEY_NONE = 0,
        TCP_KEY_MD5 = 1,
        TCP_KEY_AO = 2,
    } type;
};

struct tcp_md5sig {
    struct __kernel_sockaddr_storage tcpm_addr;
    __u8 tcpm_flags;
    __u8 tcpm_prefixlen;
    __u16 tcpm_keylen;
    int tcpm_ifindex;
    __u8 tcpm_key[80];
};

struct tcp_md5sig_info {
    struct hlist_head head;
    struct callback_head rcu;
};

struct tcp_md5sig_key {
    struct hlist_node node;
    u8 keylen;
    u8 family;
    u8 prefixlen;
    u8 flags;
    union tcp_ao_addr addr;
    int l3index;
    u8 key[80];
    struct callback_head rcu;
};

struct tcp_metrics_block {
    struct tcp_metrics_block *tcpm_next;
    struct net *tcpm_net;
    struct inetpeer_addr tcpm_saddr;
    struct inetpeer_addr tcpm_daddr;
    long unsigned int tcpm_stamp;
    u32 tcpm_lock;
    u32 tcpm_vals[5];
    struct tcp_fastopen_metrics tcpm_fastopen;
    struct callback_head callback_head;
};

struct tcp_mib {
    long unsigned int mibs[16];
};

struct tcp_out_options {
    u16 options;
    u16 mss;
    u8 ws;
    u8 num_sack_blocks;
    u8 hash_size;
    u8 bpf_opt_len;
    __u8 *hash_location;
    __u32 tsval;
    __u32 tsecr;
    struct tcp_fastopen_cookie *fastopen_cookie;
    struct mptcp_out_options mptcp;
};

struct tcp_plb_state {
    u8 consec_cong_rounds: 5;
    u8 unused: 3;
    u32 pause_until;
};

struct tcp_repair_opt {
    __u32 opt_code;
    __u32 opt_val;
};

struct tcp_repair_window {
    __u32 snd_wl1;
    __u32 snd_wnd;
    __u32 max_window;
    __u32 rcv_wnd;
    __u32 rcv_wup;
};

struct tcp_request_sock_ops {
    u16 mss_clamp;
    struct tcp_md5sig_key * (*req_md5_lookup)(const struct sock *, const struct sock *);
    int (*calc_md5_hash)(char *, const struct tcp_md5sig_key *, const struct sock *, const struct sk_buff *);
    struct tcp_ao_key * (*ao_lookup)(const struct sock *, struct request_sock *, int, int);
    int (*ao_calc_key)(struct tcp_ao_key *, u8 *, struct request_sock *);
    int (*ao_synack_hash)(char *, struct tcp_ao_key *, struct request_sock *, const struct sk_buff *, int, u32);
    __u32 (*cookie_init_seq)(const struct sk_buff *, __u16 *);
    struct dst_entry * (*route_req)(const struct sock *, struct sk_buff *, struct flowi *, struct request_sock *, u32);
    u32 (*init_seq)(const struct sk_buff *);
    u32 (*init_ts_off)(const struct net *, const struct sk_buff *);
    int (*send_synack)(const struct sock *, struct dst_entry *, struct flowi *, struct request_sock *, struct tcp_fastopen_cookie *, enum tcp_synack_type, struct sk_buff *);
};

struct tcp_sack_block_wire {
    __be32 start_seq;
    __be32 end_seq;
};

struct tcp_sacktag_state {
    u64 first_sackt;
    u64 last_sackt;
    u32 reord;
    u32 sack_delivered;
    int flag;
    unsigned int mss_now;
    struct rate_sample *rate;
};

struct tcp_seq_afinfo {
    sa_family_t family;
};

struct tcp_sigpool {
    void *scratch;
    struct ahash_request *req;
};

struct tcp_skb_cb {
    __u32 seq;
    __u32 end_seq;
    union {
        struct {
            u16 tcp_gso_segs;
            u16 tcp_gso_size;
        };
    };
    __u8 tcp_flags;
    __u8 sacked;
    __u8 ip_dsfield;
    __u8 txstamp_ack: 1;
    __u8 eor: 1;
    __u8 has_rxtstamp: 1;
    __u8 unused: 5;
    __u32 ack_seq;
    union {
        struct {
            __u32 is_app_limited: 1;
            __u32 delivered_ce: 20;
            __u32 unused: 11;
            __u32 delivered;
            u64 first_tx_mstamp;
            u64 delivered_mstamp;
        } tx;
        union {
            struct inet_skb_parm h4;
            struct inet6_skb_parm h6;
        } header;
    };
};

struct tcp_sock_af_ops {
    struct tcp_md5sig_key * (*md5_lookup)(const struct sock *, const struct sock *);
    int (*calc_md5_hash)(char *, const struct tcp_md5sig_key *, const struct sock *, const struct sk_buff *);
    int (*md5_parse)(struct sock *, int, sockptr_t, int);
    int (*ao_parse)(struct sock *, int, sockptr_t, int);
    struct tcp_ao_key * (*ao_lookup)(const struct sock *, struct sock *, int, int);
    int (*ao_calc_key_sk)(struct tcp_ao_key *, u8 *, const struct sock *, __be32, __be32, bool);
    int (*calc_ao_hash)(char *, struct tcp_ao_key *, const struct sock *, const struct sk_buff *, const u8 *, int, u32);
};

struct tcp_splice_state {
    struct pipe_inode_info *pipe;
    size_t len;
    unsigned int flags;
};

struct tcp_timewait_sock {
    struct inet_timewait_sock tw_sk;
    u32 tw_rcv_wnd;
    u32 tw_ts_offset;
    u32 tw_ts_recent;
    u32 tw_last_oow_ack_time;
    int tw_ts_recent_stamp;
    u32 tw_tx_delay;
    struct tcp_md5sig_key *tw_md5_key;
    struct tcp_ao_info *ao_info;
};

struct tcp_ulp_ops {
    struct list_head list;
    int (*init)(struct sock *);
    void (*update)(struct sock *, struct proto *, void (*)(struct sock *));
    void (*release)(struct sock *);
    int (*get_info)(struct sock *, struct sk_buff *);
    size_t (*get_info_size)(const struct sock *);
    void (*clone)(const struct request_sock *, struct sock *, const gfp_t);
    char name[16];
    struct module *owner;
};

struct tcphdr {
    __be16 source;
    __be16 dest;
    __be32 seq;
    __be32 ack_seq;
    __u16 res1: 4;
    __u16 doff: 4;
    __u16 fin: 1;
    __u16 syn: 1;
    __u16 rst: 1;
    __u16 psh: 1;
    __u16 ack: 1;
    __u16 urg: 1;
    __u16 ece: 1;
    __u16 cwr: 1;
    __be16 window;
    __sum16 check;
    __be16 urg_ptr;
};

union tcp_word_hdr {
    struct tcphdr hdr;
    __be32 words[5];
};

struct tcp_xa_pool {
    u8 max;
    u8 idx;
    __u32 tokens[17];
    netmem_ref netmems[17];
};

struct tcp_zerocopy_receive {
    __u64 address;
    __u32 length;
    __u32 recv_skip_hint;
    __u32 inq;
    __s32 err;
    __u64 copybuf_address;
    __s32 copybuf_len;
    __u32 flags;
    __u64 msg_control;
    __u64 msg_controllen;
    __u32 msg_flags;
    __u32 reserved;
};

struct tcpa_event {
    u32 pcr_index;
    u32 event_type;
    u8 pcr_value[20];
    u32 event_size;
    u8 event_data[0];
};

struct tcpa_pc_event {
    u32 event_id;
    u32 event_size;
    u8 event_data[0];
};

struct tcpm_hash_bucket {
    struct tcp_metrics_block *chain;
};

struct tcx_entry {
    struct mini_Qdisc *miniq;
    struct bpf_mprog_bundle bundle;
    u32 miniq_active;
    struct callback_head rcu;
};

struct tcx_link {
    struct bpf_link link;
    struct net_device *dev;
    u32 location;
};

struct teo_bin {
    unsigned int intercepts;
    unsigned int hits;
};

struct teo_cpu {
    s64 sleep_length_ns;
    struct teo_bin state_bins[10];
    unsigned int total;
    unsigned int tick_intercepts;
    unsigned int short_idles;
    bool artificial_wakeup;
};

struct termio {
    short unsigned int c_iflag;
    short unsigned int c_oflag;
    short unsigned int c_cflag;
    short unsigned int c_lflag;
    unsigned char c_line;
    unsigned char c_cc[8];
};

struct termios {
    tcflag_t c_iflag;
    tcflag_t c_oflag;
    tcflag_t c_cflag;
    tcflag_t c_lflag;
    cc_t c_line;
    cc_t c_cc[19];
};

struct termios2 {
    tcflag_t c_iflag;
    tcflag_t c_oflag;
    tcflag_t c_cflag;
    tcflag_t c_lflag;
    cc_t c_line;
    cc_t c_cc[19];
    speed_t c_ispeed;
    speed_t c_ospeed;
};

struct tgid_iter {
    unsigned int tgid;
    struct task_struct *task;
};

struct thermal_attr {
    struct device_attribute attr;
    char name[20];
};

typedef struct thermal_cooling_device *class_cooling_dev_t;

struct thermal_cooling_device {
    int id;
    const char *type;
    long unsigned int max_state;
    struct device device;
    struct device_node *np;
    void *devdata;
    void *stats;
    const struct thermal_cooling_device_ops *ops;
    bool updated;
    struct mutex lock;
    struct list_head thermal_instances;
    struct list_head node;
};

struct thermal_genl_cpu_caps {
    int cpu;
    int performance;
    int efficiency;
};

struct thermal_genl_notify {
    int mcgrp;
};

struct thermal_trip;

struct thermal_governor {
    const char *name;
    int (*bind_to_tz)(struct thermal_zone_device *);
    void (*unbind_from_tz)(struct thermal_zone_device *);
    void (*trip_crossed)(struct thermal_zone_device *, const struct thermal_trip *, bool);
    void (*manage)(struct thermal_zone_device *);
    void (*update_tz)(struct thermal_zone_device *, enum thermal_notify_event);
    struct list_head governor_list;
};

struct thermal_hwmon_attr {
    struct device_attribute attr;
    char name[16];
};

struct thermal_hwmon_device {
    char type[20];
    struct device *device;
    int count;
    struct list_head tz_list;
    struct list_head node;
};

struct thermal_hwmon_temp {
    struct list_head hwmon_node;
    struct thermal_zone_device *tz;
    struct thermal_hwmon_attr temp_input;
    struct thermal_hwmon_attr temp_crit;
};

struct thermal_instance {
    int id;
    char name[20];
    struct thermal_cooling_device *cdev;
    const struct thermal_trip *trip;
    bool initialized;
    long unsigned int upper;
    long unsigned int lower;
    long unsigned int target;
    char attr_name[20];
    struct device_attribute attr;
    char weight_attr_name[20];
    struct device_attribute weight_attr;
    struct list_head trip_node;
    struct list_head cdev_node;
    unsigned int weight;
    bool upper_no_limit;
};

struct thermal_trip {
    int temperature;
    int hysteresis;
    enum thermal_trip_type type;
    u8 flags;
    void *priv;
};

struct thermal_trip_attrs {
    struct thermal_attr type;
    struct thermal_attr temp;
    struct thermal_attr hyst;
};

struct thermal_trip_desc {
    struct thermal_trip trip;
    struct thermal_trip_attrs trip_attrs;
    struct list_head list_node;
    struct list_head thermal_instances;
    int threshold;
};

typedef struct thermal_zone_device *class_thermal_zone_get_by_id_t;

typedef struct thermal_zone_device *class_thermal_zone_reverse_t;

typedef struct thermal_zone_device *class_thermal_zone_t;

struct thermal_zone_device_ops {
    bool (*should_bind)(struct thermal_zone_device *, const struct thermal_trip *, struct thermal_cooling_device *, struct cooling_spec *);
    int (*get_temp)(struct thermal_zone_device *, int *);
    int (*set_trips)(struct thermal_zone_device *, int, int);
    int (*change_mode)(struct thermal_zone_device *, enum thermal_device_mode);
    int (*set_trip_temp)(struct thermal_zone_device *, const struct thermal_trip *, int);
    int (*get_crit_temp)(struct thermal_zone_device *, int *);
    int (*set_emul_temp)(struct thermal_zone_device *, int);
    int (*get_trend)(struct thermal_zone_device *, const struct thermal_trip *, enum thermal_trend *);
    void (*hot)(struct thermal_zone_device *);
    void (*critical)(struct thermal_zone_device *);
};

struct thermal_zone_params;

struct thermal_zone_device {
    int id;
    char type[20];
    struct device device;
    struct completion removal;
    struct completion resume;
    struct attribute_group trips_attribute_group;
    struct list_head trips_high;
    struct list_head trips_reached;
    struct list_head trips_invalid;
    enum thermal_device_mode mode;
    void *devdata;
    int num_trips;
    long unsigned int passive_delay_jiffies;
    long unsigned int polling_delay_jiffies;
    long unsigned int recheck_delay_jiffies;
    int temperature;
    int last_temperature;
    int emul_temperature;
    int passive;
    int prev_low_trip;
    int prev_high_trip;
    struct thermal_zone_device_ops ops;
    struct thermal_zone_params *tzp;
    struct thermal_governor *governor;
    void *governor_data;
    struct ida ida;
    struct mutex lock;
    struct list_head node;
    struct delayed_work poll_queue;
    enum thermal_notify_event notify_event;
    u8 state;
    struct list_head user_thresholds;
    struct thermal_trip_desc trips[0];
};

struct thermal_zone_params {
    const char *governor_name;
    bool no_hwmon;
    u32 sustainable_power;
    s32 k_po;
    s32 k_pu;
    s32 k_i;
    s32 k_d;
    s32 integral_cutoff;
    int slope;
    int offset;
};

struct thpsize {
    struct kobject kobj;
    struct list_head node;
    int order;
};

struct throtl_service_queue {
    struct throtl_service_queue *parent_sq;
    struct list_head queued[2];
    unsigned int nr_queued[2];
    struct rb_root_cached pending_tree;
    unsigned int nr_pending;
    long unsigned int first_pending_disptime;
    struct timer_list pending_timer;
};

struct throtl_data {
    struct throtl_service_queue service_queue;
    struct request_queue *queue;
    unsigned int nr_queued[2];
    unsigned int throtl_slice;
    struct work_struct dispatch_work;
    bool track_bio_latency;
};

struct throtl_grp;

struct throtl_qnode {
    struct list_head node;
    struct bio_list bios;
    struct throtl_grp *tg;
};

struct throtl_grp {
    struct blkg_policy_data pd;
    struct rb_node rb_node;
    struct throtl_data *td;
    struct throtl_service_queue service_queue;
    struct throtl_qnode qnode_on_self[2];
    struct throtl_qnode qnode_on_parent[2];
    long unsigned int disptime;
    unsigned int flags;
    bool has_rules_bps[2];
    bool has_rules_iops[2];
    uint64_t bps[2];
    unsigned int iops[2];
    uint64_t bytes_disp[2];
    unsigned int io_disp[2];
    uint64_t last_bytes_disp[2];
    unsigned int last_io_disp[2];
    long long int carryover_bytes[2];
    int carryover_ios[2];
    long unsigned int last_check_time;
    long unsigned int slice_start[2];
    long unsigned int slice_end[2];
    struct blkg_rwstat stat_bytes;
    struct blkg_rwstat stat_ios;
};

struct tick_device {
    struct clock_event_device *evtdev;
    enum tick_device_mode mode;
};

struct tick_sched {
    long unsigned int flags;
    unsigned int stalled_jiffies;
    long unsigned int last_tick_jiffies;
    struct hrtimer sched_timer;
    ktime_t last_tick;
    ktime_t next_tick;
    long unsigned int idle_jiffies;
    ktime_t idle_waketime;
    unsigned int got_idle_tick;
    seqcount_t idle_sleeptime_seq;
    ktime_t idle_entrytime;
    long unsigned int last_jiffies;
    u64 timer_expires_base;
    u64 timer_expires;
    u64 next_timer;
    ktime_t idle_expires;
    long unsigned int idle_calls;
    long unsigned int idle_sleeps;
    ktime_t idle_exittime;
    ktime_t idle_sleeptime;
    ktime_t iowait_sleeptime;
    atomic_t tick_dep_mask;
    long unsigned int check_clocks;
};

struct tick_work {
    int cpu;
    atomic_t state;
    struct delayed_work work;
};

struct timens_offsets {
    struct timespec64 monotonic;
    struct timespec64 boottime;
};

struct time_namespace {
    struct user_namespace *user_ns;
    struct ucounts *ucounts;
    struct ns_common ns;
    struct timens_offsets offsets;
    struct page *vvar_page;
    bool frozen_offsets;
};

struct tk_read_base {
    struct clocksource *clock;
    u64 mask;
    u64 cycle_last;
    u32 mult;
    u32 shift;
    u64 xtime_nsec;
    ktime_t base;
    u64 base_real;
};

struct timekeeper {
    struct tk_read_base tkr_mono;
    u64 xtime_sec;
    long unsigned int ktime_sec;
    struct timespec64 wall_to_monotonic;
    ktime_t offs_real;
    ktime_t offs_boot;
    ktime_t offs_tai;
    u32 coarse_nsec;
    struct tk_read_base tkr_raw;
    u64 raw_sec;
    unsigned int clock_was_set_seq;
    u8 cs_was_changed_seq;
    struct timespec64 monotonic_to_boot;
    u64 cycle_interval;
    u64 xtime_interval;
    s64 xtime_remainder;
    u64 raw_interval;
    ktime_t next_leap_ktime;
    u64 ntp_tick;
    s64 ntp_error;
    u32 ntp_error_shift;
    u32 ntp_err_mult;
    u32 skip_second_overflow;
    s32 tai_offset;
};

struct timens_offset {
    s64 sec;
    u64 nsec;
};

struct timer_base {
    raw_spinlock_t lock;
    struct timer_list *running_timer;
    long unsigned int clk;
    long unsigned int next_expiry;
    unsigned int cpu;
    bool next_expiry_recalc;
    bool is_idle;
    bool timers_pending;
    long unsigned int pending_map[9];
    struct hlist_head vectors[576];
    long: 64;
    long: 64;
};

struct timer_events {
    u64 local;
    u64 global;
};

struct timer_list_iter {
    int cpu;
    bool second_pass;
    u64 now;
};

struct timer_map {
    struct arch_timer_context *direct_vtimer;
    struct arch_timer_context *direct_ptimer;
    struct arch_timer_context *emul_vtimer;
    struct arch_timer_context *emul_ptimer;
};

struct timer_of {
    unsigned int flags;
    struct device_node *np;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    struct clock_event_device clkevt;
    struct of_timer_base of_base;
    struct of_timer_irq of_irq;
    struct of_timer_clk of_clk;
    void *private_data;
    long: 64;
    long: 64;
    long: 64;
};

struct timer_rand_state {
    long unsigned int last_time;
    long int last_delta;
    long int last_delta2;
};

struct timerfd_ctx {
    union {
        struct hrtimer tmr;
        struct alarm alarm;
    } t;
    ktime_t tintv;
    ktime_t moffs;
    wait_queue_head_t wqh;
    u64 ticks;
    int clockid;
    short unsigned int expired;
    short unsigned int settime_flags;
    struct callback_head rcu;
    struct list_head clist;
    spinlock_t cancel_lock;
    bool might_cancel;
};

struct timerlat_entry {
    struct trace_entry ent;
    unsigned int seqnum;
    int context;
    u64 timer_latency;
};

struct timers_private {
    struct pid *pid;
    struct task_struct *task;
    struct sighand_struct *sighand;
    struct pid_namespace *ns;
    long unsigned int flags;
};

struct timestamp_event_queue {
    struct ptp_extts_event buf[128];
    int head;
    int tail;
    spinlock_t lock;
    struct list_head qlist;
    long unsigned int *mask;
    struct dentry *debugfs_instance;
    struct debugfs_u32_array dfs_bitmap;
};

struct timewait_sock_ops {
    struct kmem_cache *twsk_slab;
    char *twsk_slab_name;
    unsigned int twsk_obj_size;
    void (*twsk_destructor)(struct sock *);
};

struct timezone {
    int tz_minuteswest;
    int tz_dsttime;
};

struct tiocl_selection {
    short unsigned int xs;
    short unsigned int ys;
    short unsigned int xe;
    short unsigned int ye;
    short unsigned int sel_mode;
};

struct tipc_basic_hdr {
    __be32 w[4];
};

struct tk_data {
    seqcount_raw_spinlock_t seq;
    struct timekeeper timekeeper;
    struct timekeeper shadow_timekeeper;
    raw_spinlock_t lock;
};

struct tk_fast {
    seqcount_latch_t seq;
    struct tk_read_base base[2];
};

struct tlb_inv_context {
    struct kvm_s2_mmu *mmu;
    long unsigned int flags;
    u64 tcr;
    u64 sctlr;
};

struct tlb_inv_context___2 {
    struct kvm_s2_mmu *mmu;
    u64 tcr;
    u64 sctlr;
};

union tlbi_info {
    struct {
        u64 start;
        u64 size;
    } range;
    struct {
        u64 addr;
    } ipa;
    struct {
        u64 addr;
        u32 encoding;
    } va;
};

struct tls_crypto_info {
    __u16 version;
    __u16 cipher_type;
};

struct tls12_crypto_info_aes_gcm_128 {
    struct tls_crypto_info info;
    unsigned char iv[8];
    unsigned char key[16];
    unsigned char salt[4];
    unsigned char rec_seq[8];
};

struct tls12_crypto_info_aes_gcm_256 {
    struct tls_crypto_info info;
    unsigned char iv[8];
    unsigned char key[32];
    unsigned char salt[4];
    unsigned char rec_seq[8];
};

struct tls12_crypto_info_chacha20_poly1305 {
    struct tls_crypto_info info;
    unsigned char iv[12];
    unsigned char key[32];
    unsigned char salt[0];
    unsigned char rec_seq[8];
};

struct tls12_crypto_info_sm4_ccm {
    struct tls_crypto_info info;
    unsigned char iv[8];
    unsigned char key[16];
    unsigned char salt[4];
    unsigned char rec_seq[8];
};

struct tls12_crypto_info_sm4_gcm {
    struct tls_crypto_info info;
    unsigned char iv[8];
    unsigned char key[16];
    unsigned char salt[4];
    unsigned char rec_seq[8];
};

struct tls_prot_info {
    u16 version;
    u16 cipher_type;
    u16 prepend_size;
    u16 tag_size;
    u16 overhead_size;
    u16 iv_size;
    u16 salt_size;
    u16 rec_seq_size;
    u16 aad_size;
    u16 tail_size;
};

union tls_crypto_context {
    struct tls_crypto_info info;
    union {
        struct tls12_crypto_info_aes_gcm_128 aes_gcm_128;
        struct tls12_crypto_info_aes_gcm_256 aes_gcm_256;
        struct tls12_crypto_info_chacha20_poly1305 chacha20_poly1305;
        struct tls12_crypto_info_sm4_gcm sm4_gcm;
        struct tls12_crypto_info_sm4_ccm sm4_ccm;
    };
};

struct tls_context {
    struct tls_prot_info prot_info;
    u8 tx_conf: 3;
    u8 rx_conf: 3;
    u8 zerocopy_sendfile: 1;
    u8 rx_no_pad: 1;
    int (*push_pending_record)(struct sock *, int);
    void (*sk_write_space)(struct sock *);
    void *priv_ctx_tx;
    void *priv_ctx_rx;
    struct net_device *netdev;
    struct cipher_context tx;
    struct cipher_context rx;
    struct scatterlist *partially_sent_record;
    u16 partially_sent_offset;
    bool splicing_pages;
    bool pending_open_record_frags;
    struct mutex tx_lock;
    long unsigned int flags;
    struct proto *sk_proto;
    struct sock *sk;
    void (*sk_destruct)(struct sock *);
    union tls_crypto_context crypto_send;
    union tls_crypto_context crypto_recv;
    struct list_head list;
    refcount_t refcount;
    struct callback_head rcu;
};

typedef void (*tls_done_func_t)(void *, int, key_serial_t);

struct tls_handshake_args {
    struct socket *ta_sock;
    tls_done_func_t ta_done;
    void *ta_data;
    const char *ta_peername;
    unsigned int ta_timeout_ms;
    key_serial_t ta_keyring;
    key_serial_t ta_my_cert;
    key_serial_t ta_my_privkey;
    unsigned int ta_num_peerids;
    key_serial_t ta_my_peerids[5];
};

struct tls_handshake_req {
    void (*th_consumer_done)(void *, int, key_serial_t);
    void *th_consumer_data;
    int th_type;
    unsigned int th_timeout_ms;
    int th_auth_mode;
    const char *th_peername;
    key_serial_t th_keyring;
    key_serial_t th_certificate;
    key_serial_t th_privkey;
    unsigned int th_num_peerids;
    key_serial_t th_peerid[5];
};

struct tls_strparser {
    struct sock *sk;
    u32 mark: 8;
    u32 stopped: 1;
    u32 copy_mode: 1;
    u32 mixed_decrypted: 1;
    bool msg_ready;
    struct strp_msg stm;
    struct sk_buff *anchor;
    struct work_struct work;
};

struct tls_sw_context_rx {
    struct crypto_aead *aead_recv;
    struct crypto_wait async_wait;
    struct sk_buff_head rx_list;
    void (*saved_data_ready)(struct sock *);
    u8 reader_present;
    u8 async_capable: 1;
    u8 zc_capable: 1;
    u8 reader_contended: 1;
    bool key_update_pending;
    struct tls_strparser strp;
    atomic_t decrypt_pending;
    struct sk_buff_head async_hold;
    struct wait_queue_head wq;
};

struct tx_work {
    struct delayed_work work;
    struct sock *sk;
};

struct tls_rec;

struct tls_sw_context_tx {
    struct crypto_aead *aead_send;
    struct crypto_wait async_wait;
    struct tx_work tx_work;
    struct tls_rec *open_rec;
    struct list_head tx_list;
    atomic_t encrypt_pending;
    u8 async_capable: 1;
    long unsigned int tx_bitmask;
};

struct tlsdev_ops {
    int (*tls_dev_add)(struct net_device *, struct sock *, enum tls_offload_ctx_dir, struct tls_crypto_info *, u32);
    void (*tls_dev_del)(struct net_device *, struct tls_context *, enum tls_offload_ctx_dir);
    int (*tls_dev_resync)(struct net_device *, struct sock *, u32, u8 *, enum tls_offload_ctx_dir);
};

struct tm {
    int tm_sec;
    int tm_min;
    int tm_hour;
    int tm_mday;
    int tm_mon;
    long int tm_year;
    int tm_wday;
    int tm_yday;
};

struct tmigr_event {
    struct timerqueue_node nextevt;
    unsigned int cpu;
    bool ignore;
};

struct tmigr_group;

struct tmigr_cpu {
    raw_spinlock_t lock;
    bool online;
    bool idle;
    bool remote;
    struct tmigr_group *tmgroup;
    u8 groupmask;
    u64 wakeup;
    struct tmigr_event cpuevt;
};

struct tmigr_group {
    raw_spinlock_t lock;
    struct tmigr_group *parent;
    struct tmigr_event groupevt;
    u64 next_expiry;
    struct timerqueue_head events;
    atomic_t migr_state;
    unsigned int level;
    int numa_node;
    unsigned int num_children;
    u8 groupmask;
    struct list_head list;
};

union tmigr_state {
    u32 state;
    struct {
        u8 active;
        u8 migrator;
        u16 seq;
    };
};

struct tmigr_walk {
    u64 nextexp;
    u64 firstexp;
    struct tmigr_event *evt;
    u8 childmask;
    bool remote;
    long unsigned int basej;
    u64 now;
    bool check;
    bool tmc_active;
};

struct tmpmasks {
    cpumask_var_t addmask;
    cpumask_var_t delmask;
    cpumask_var_t new_cpus;
};

struct tms {
    __kernel_clock_t tms_utime;
    __kernel_clock_t tms_stime;
    __kernel_clock_t tms_cutime;
    __kernel_clock_t tms_cstime;
};

struct tnode {
    struct callback_head rcu;
    t_key empty_children;
    t_key full_children;
    struct key_vector *parent;
    struct key_vector kv[1];
};

struct token_bucket {
    spinlock_t lock;
    int chain_len;
    struct hlist_nulls_head req_chain;
    struct hlist_nulls_head msk_chain;
};

struct tomoyo_acl_head {
    struct list_head list;
    s8 is_deleted;
} __attribute__((packed));

struct tomoyo_condition;

struct tomoyo_acl_info {
    struct list_head list;
    struct tomoyo_condition *cond;
    s8 is_deleted;
    u8 type;
} __attribute__((packed));

struct tomoyo_policy_namespace;

struct tomoyo_acl_param {
    char *data;
    struct list_head *list;
    struct tomoyo_policy_namespace *ns;
    bool is_delete;
};

struct tomoyo_inet_addr_info {
    __be16 port;
    const __be32 *address;
    bool is_ipv6;
};

struct tomoyo_unix_addr_info {
    u8 *addr;
    unsigned int addr_len;
};

struct tomoyo_addr_info {
    u8 protocol;
    u8 operation;
    struct tomoyo_inet_addr_info inet;
    struct tomoyo_unix_addr_info unix0;
};

struct tomoyo_group;

struct tomoyo_ipaddr_union {
    struct in6_addr ip[2];
    struct tomoyo_group *group;
    bool is_ipv6;
};

struct tomoyo_address_group {
    struct tomoyo_acl_head head;
    struct tomoyo_ipaddr_union address;
};

struct tomoyo_path_info;

struct tomoyo_aggregator {
    struct tomoyo_acl_head head;
    const struct tomoyo_path_info *original_name;
    const struct tomoyo_path_info *aggregated_name;
};

struct tomoyo_argv {
    long unsigned int index;
    const struct tomoyo_path_info *value;
    bool is_not;
};

struct tomoyo_shared_acl_head {
    struct list_head list;
    atomic_t users;
} __attribute__((packed));

struct tomoyo_condition {
    struct tomoyo_shared_acl_head head;
    u32 size;
    u16 condc;
    u16 numbers_count;
    u16 names_count;
    u16 argc;
    u16 envc;
    u8 grant_log;
    const struct tomoyo_path_info *transit;
};

struct tomoyo_condition_element {
    u8 left;
    u8 right;
    bool equals;
};

struct tomoyo_domain_info {
    struct list_head list;
    struct list_head acl_info_list;
    const struct tomoyo_path_info *domainname;
    struct tomoyo_policy_namespace *ns;
    long unsigned int group[4];
    u8 profile;
    bool is_deleted;
    bool flags[2];
    atomic_t users;
};

struct tomoyo_env_acl {
    struct tomoyo_acl_info head;
    const struct tomoyo_path_info *env;
};

struct tomoyo_envp {
    const struct tomoyo_path_info *name;
    const struct tomoyo_path_info *value;
    bool is_not;
};

struct tomoyo_obj_info;

struct tomoyo_execve;

struct tomoyo_request_info {
    struct tomoyo_obj_info *obj;
    struct tomoyo_execve *ee;
    struct tomoyo_domain_info *domain;
    union {
        struct {
            const struct tomoyo_path_info *filename;
            const struct tomoyo_path_info *matched_path;
            u8 operation;
        } path;
        struct {
            const struct tomoyo_path_info *filename1;
            const struct tomoyo_path_info *filename2;
            u8 operation;
        } path2;
        struct {
            const struct tomoyo_path_info *filename;
            unsigned int mode;
            unsigned int major;
            unsigned int minor;
            u8 operation;
        } mkdev;
        struct {
            const struct tomoyo_path_info *filename;
            long unsigned int number;
            u8 operation;
        } path_number;
        struct {
            const struct tomoyo_path_info *name;
        } environ;
        struct {
            const __be32 *address;
            u16 port;
            u8 protocol;
            u8 operation;
            bool is_ipv6;
        } inet_network;
        struct {
            const struct tomoyo_path_info *address;
            u8 protocol;
            u8 operation;
        } unix_network;
        struct {
            const struct tomoyo_path_info *type;
            const struct tomoyo_path_info *dir;
            const struct tomoyo_path_info *dev;
            long unsigned int flags;
            int need_dev;
        } mount;
        struct {
            const struct tomoyo_path_info *domainname;
        } task;
    } param;
    struct tomoyo_acl_info *matched_acl;
    u8 param_type;
    bool granted;
    u8 retry;
    u8 profile;
    u8 mode;
    u8 type;
};

struct tomoyo_mini_stat {
    kuid_t uid;
    kgid_t gid;
    ino_t ino;
    umode_t mode;
    dev_t dev;
    dev_t rdev;
};

struct tomoyo_obj_info {
    bool validate_done;
    bool stat_valid[4];
    struct path path1;
    struct path path2;
    struct tomoyo_mini_stat stat[4];
    struct tomoyo_path_info *symlink_target;
};

struct tomoyo_page_dump {
    struct page *page;
    char *data;
};

struct tomoyo_execve {
    struct tomoyo_request_info r;
    struct tomoyo_obj_info obj;
    struct linux_binprm *bprm;
    const struct tomoyo_path_info *transition;
    struct tomoyo_page_dump dump;
    char *tmp;
};

struct tomoyo_group {
    struct tomoyo_shared_acl_head head;
    const struct tomoyo_path_info *group_name;
    struct list_head member_list;
};

struct tomoyo_number_union {
    long unsigned int values[2];
    struct tomoyo_group *group;
    u8 value_type[2];
};

struct tomoyo_inet_acl {
    struct tomoyo_acl_info head;
    u8 protocol;
    u8 perm;
    struct tomoyo_ipaddr_union address;
    struct tomoyo_number_union port;
};

struct tomoyo_io_buffer {
    void (*read)(struct tomoyo_io_buffer *);
    int (*write)(struct tomoyo_io_buffer *);
    __poll_t (*poll)(struct file *, poll_table *);
    struct mutex io_sem;
    char *read_user_buf;
    size_t read_user_buf_avail;
    struct {
        struct list_head *ns;
        struct list_head *domain;
        struct list_head *group;
        struct list_head *acl;
        size_t avail;
        unsigned int step;
        unsigned int query_index;
        u16 index;
        u16 cond_index;
        u8 acl_group_index;
        u8 cond_step;
        u8 bit;
        u8 w_pos;
        bool eof;
        bool print_this_domain_only;
        bool print_transition_related_only;
        bool print_cond_part;
        const char *w[64];
    } r;
    struct {
        struct tomoyo_policy_namespace *ns;
        struct tomoyo_domain_info *domain;
        size_t avail;
        bool is_delete;
    } w;
    char *read_buf;
    size_t readbuf_size;
    char *write_buf;
    size_t writebuf_size;
    enum tomoyo_securityfs_interface_index type;
    u8 users;
    struct list_head list;
};

struct tomoyo_log {
    struct list_head list;
    char *log;
    int size;
};

struct tomoyo_manager {
    struct tomoyo_acl_head head;
    const struct tomoyo_path_info *manager;
};

struct tomoyo_name_union {
    const struct tomoyo_path_info *filename;
    struct tomoyo_group *group;
};

struct tomoyo_mkdev_acl {
    struct tomoyo_acl_info head;
    u8 perm;
    struct tomoyo_name_union name;
    struct tomoyo_number_union mode;
    struct tomoyo_number_union major;
    struct tomoyo_number_union minor;
};

struct tomoyo_mount_acl {
    struct tomoyo_acl_info head;
    struct tomoyo_name_union dev_name;
    struct tomoyo_name_union dir_name;
    struct tomoyo_name_union fs_type;
    struct tomoyo_number_union flags;
};

struct tomoyo_path_info {
    const char *name;
    u32 hash;
    u16 const_len;
    bool is_dir;
    bool is_patterned;
};

struct tomoyo_name {
    struct tomoyo_shared_acl_head head;
    struct tomoyo_path_info entry;
};

struct tomoyo_number_group {
    struct tomoyo_acl_head head;
    struct tomoyo_number_union number;
};

struct tomoyo_path2_acl {
    struct tomoyo_acl_info head;
    u8 perm;
    struct tomoyo_name_union name1;
    struct tomoyo_name_union name2;
};

struct tomoyo_path_acl {
    struct tomoyo_acl_info head;
    u16 perm;
    struct tomoyo_name_union name;
};

struct tomoyo_path_group {
    struct tomoyo_acl_head head;
    const struct tomoyo_path_info *member_name;
};

struct tomoyo_path_number_acl {
    struct tomoyo_acl_info head;
    u8 perm;
    struct tomoyo_name_union name;
    struct tomoyo_number_union number;
};

struct tomoyo_profile;

struct tomoyo_policy_namespace {
    struct tomoyo_profile *profile_ptr[256];
    struct list_head group_list[3];
    struct list_head policy_list[11];
    struct list_head acl_group[256];
    struct list_head namespace_list;
    unsigned int profile_version;
    const char *name;
};

struct tomoyo_preference {
    unsigned int learning_max_entry;
    bool enforcing_verbose;
    bool learning_verbose;
    bool permissive_verbose;
};

struct tomoyo_profile {
    const struct tomoyo_path_info *comment;
    struct tomoyo_preference *learning;
    struct tomoyo_preference *permissive;
    struct tomoyo_preference *enforcing;
    struct tomoyo_preference preference;
    u8 default_config;
    u8 config[42];
    unsigned int pref[2];
};

struct tomoyo_query {
    struct list_head list;
    struct tomoyo_domain_info *domain;
    char *query;
    size_t query_len;
    unsigned int serial;
    u8 timer;
    u8 answer;
    u8 retry;
};

struct tomoyo_task {
    struct tomoyo_domain_info *domain_info;
    struct tomoyo_domain_info *old_domain_info;
};

struct tomoyo_task_acl {
    struct tomoyo_acl_info head;
    const struct tomoyo_path_info *domainname;
};

struct tomoyo_time {
    u16 year;
    u8 month;
    u8 day;
    u8 hour;
    u8 min;
    u8 sec;
};

struct tomoyo_transition_control {
    struct tomoyo_acl_head head;
    u8 type;
    bool is_last_name;
    const struct tomoyo_path_info *domainname;
    const struct tomoyo_path_info *program;
};

struct tomoyo_unix_acl {
    struct tomoyo_acl_info head;
    u8 protocol;
    u8 perm;
    struct tomoyo_name_union name;
};

struct touchscreen_properties {
    unsigned int max_x;
    unsigned int max_y;
    bool invert_x;
    bool invert_y;
    bool swap_x_y;
};

struct tp_module {
    struct list_head list;
    struct module *mod;
};

struct tracepoint_func {
    void *func;
    void *data;
    int prio;
};

struct tp_probes {
    struct callback_head rcu;
    struct tracepoint_func probes[0];
};

struct tp_transition_snapshot {
    long unsigned int rcu;
    bool ongoing;
};

struct tpacket2_hdr {
    __u32 tp_status;
    __u32 tp_len;
    __u32 tp_snaplen;
    __u16 tp_mac;
    __u16 tp_net;
    __u32 tp_sec;
    __u32 tp_nsec;
    __u16 tp_vlan_tci;
    __u16 tp_vlan_tpid;
    __u8 tp_padding[4];
};

struct tpacket_hdr_variant1 {
    __u32 tp_rxhash;
    __u32 tp_vlan_tci;
    __u16 tp_vlan_tpid;
    __u16 tp_padding;
};

struct tpacket3_hdr {
    __u32 tp_next_offset;
    __u32 tp_sec;
    __u32 tp_nsec;
    __u32 tp_snaplen;
    __u32 tp_len;
    __u32 tp_status;
    __u16 tp_mac;
    __u16 tp_net;
    union {
        struct tpacket_hdr_variant1 hv1;
    };
    __u8 tp_padding[8];
};

struct tpacket_auxdata {
    __u32 tp_status;
    __u32 tp_len;
    __u32 tp_snaplen;
    __u16 tp_mac;
    __u16 tp_net;
    __u16 tp_vlan_tci;
    __u16 tp_vlan_tpid;
};

struct tpacket_bd_ts {
    unsigned int ts_sec;
    union {
        unsigned int ts_usec;
        unsigned int ts_nsec;
    };
};

struct tpacket_hdr_v1 {
    __u32 block_status;
    __u32 num_pkts;
    __u32 offset_to_first_pkt;
    __u32 blk_len;
    __u64 seq_num;
    struct tpacket_bd_ts ts_first_pkt;
    struct tpacket_bd_ts ts_last_pkt;
};

union tpacket_bd_header_u {
    struct tpacket_hdr_v1 bh1;
};

struct tpacket_block_desc {
    __u32 version;
    __u32 offset_to_priv;
    union tpacket_bd_header_u hdr;
};

struct tpacket_hdr {
    long unsigned int tp_status;
    unsigned int tp_len;
    unsigned int tp_snaplen;
    short unsigned int tp_mac;
    short unsigned int tp_net;
    unsigned int tp_sec;
    unsigned int tp_usec;
};

struct tpacket_req {
    unsigned int tp_block_size;
    unsigned int tp_block_nr;
    unsigned int tp_frame_size;
    unsigned int tp_frame_nr;
};

struct tpacket_req3 {
    unsigned int tp_block_size;
    unsigned int tp_block_nr;
    unsigned int tp_frame_size;
    unsigned int tp_frame_nr;
    unsigned int tp_retire_blk_tov;
    unsigned int tp_sizeof_priv;
    unsigned int tp_feature_req_word;
};

union tpacket_req_u {
    struct tpacket_req req;
    struct tpacket_req3 req3;
};

struct tpacket_rollover_stats {
    __u64 tp_all;
    __u64 tp_huge;
    __u64 tp_failed;
};

union tpacket_uhdr {
    struct tpacket_hdr *h1;
    struct tpacket2_hdr *h2;
    struct tpacket3_hdr *h3;
    void *raw;
};

struct tpidr2_context {
    struct _aarch64_ctx head;
    __u64 tpidr2;
};

struct tpm1_get_random_out {
    __be32 rng_data_len;
    u8 rng_data[128];
};

struct tpm2_auth {
    u32 handle;
    u32 session;
    u8 our_nonce[32];
    u8 tpm_nonce[32];
    union {
        u8 salt[32];
        u8 scratch[32];
    };
    u8 session_key[32];
    u8 passphrase[32];
    int passphrase_len;
    struct crypto_aes_ctx aes_ctx;
    u8 attrs;
    __be32 ordinal;
    u32 name_h[3];
    u8 name[198];
};

struct tpm2_cap_handles {
    u8 more_data;
    __be32 capability;
    __be32 count;
    __be32 handles[0];
} __attribute__((packed));

struct tpm2_context {
    __be64 sequence;
    __be32 saved_handle;
    __be32 hierarchy;
    __be16 blob_size;
} __attribute__((packed));

struct tpm2_get_cap_out {
    u8 more_data;
    __be32 subcap_id;
    __be32 property_cnt;
    __be32 property_id;
    __be32 value;
} __attribute__((packed));

struct tpm2_get_random_out {
    __be16 size;
    u8 buffer[128];
};

struct tpm2_hash {
    unsigned int crypto_id;
    unsigned int tpm_id;
};

struct tpm2_key_context {
    u32 parent;
    const u8 *pub;
    u32 pub_len;
    const u8 *priv;
    u32 priv_len;
};

struct tpm2_pcr_read_out {
    __be32 update_cnt;
    __be32 pcr_selects_cnt;
    __be16 hash_alg;
    u8 pcr_select_size;
    u8 pcr_select[3];
    __be32 digests_cnt;
    __be16 digest_size;
    u8 digest[0];
} __attribute__((packed));

struct tpm2_pcr_selection {
    __be16 hash_alg;
    u8 size_of_select;
    u8 pcr_select[3];
};

struct tpm_bank_info {
    u16 alg_id;
    u16 digest_size;
    u16 crypto_id;
};

struct tpm_bios_log {
    void *bios_event_log;
    void *bios_event_log_end;
};

struct tpm_buf {
    u32 flags;
    u32 length;
    u8 *data;
    u8 handles;
};

struct tpm_chip_seqops {
    struct tpm_chip *chip;
    const struct seq_operations *seqops;
};

struct tpm_space {
    u32 context_tbl[3];
    u8 *context_buf;
    u32 session_tbl[3];
    u8 *session_buf;
    u32 buf_size;
};

struct tpm_class_ops;

struct tpm_chip {
    struct device dev;
    struct device devs;
    struct cdev cdev;
    struct cdev cdevs;
    struct rw_semaphore ops_sem;
    const struct tpm_class_ops *ops;
    struct tpm_bios_log log;
    struct tpm_chip_seqops bin_log_seqops;
    struct tpm_chip_seqops ascii_log_seqops;
    unsigned int flags;
    int dev_num;
    long unsigned int is_open;
    char hwrng_name[64];
    struct hwrng hwrng;
    struct mutex tpm_mutex;
    long unsigned int timeout_a;
    long unsigned int timeout_b;
    long unsigned int timeout_c;
    long unsigned int timeout_d;
    bool timeout_adjusted;
    long unsigned int duration[4];
    bool duration_adjusted;
    struct dentry *bios_dir[3];
    const struct attribute_group *groups[8];
    unsigned int groups_cnt;
    u32 nr_allocated_banks;
    struct tpm_bank_info *allocated_banks;
    struct tpm_space work_space;
    u32 last_cc;
    u32 nr_commands;
    u32 *cc_attrs_tbl;
    int locality;
};

struct tpm_class_ops {
    unsigned int flags;
    const u8 req_complete_mask;
    const u8 req_complete_val;
    bool (*req_canceled)(struct tpm_chip *, u8);
    int (*recv)(struct tpm_chip *, u8 *, size_t);
    int (*send)(struct tpm_chip *, u8 *, size_t);
    void (*cancel)(struct tpm_chip *);
    u8 (*status)(struct tpm_chip *);
    void (*update_timeouts)(struct tpm_chip *, long unsigned int *);
    void (*update_durations)(struct tpm_chip *, long unsigned int *);
    int (*go_idle)(struct tpm_chip *);
    int (*cmd_ready)(struct tpm_chip *);
    int (*request_locality)(struct tpm_chip *, int);
    int (*relinquish_locality)(struct tpm_chip *, int);
    void (*clk_enable)(struct tpm_chip *, bool);
};

struct tpm_digests {
    unsigned char encauth[20];
    unsigned char pubauth[20];
    unsigned char xorwork[40];
    unsigned char xorhash[20];
    unsigned char nonceodd[20];
};

struct tpm_header {
    __be16 tag;
    __be32 length;
    union {
        __be32 ordinal;
        __be32 return_code;
    };
} __attribute__((packed));

struct tpm_pcr_attr {
    int alg_id;
    int pcr;
    struct device_attribute attr;
};

struct tpm_readpubek_out {
    u8 algorithm[4];
    u8 encscheme[2];
    u8 sigscheme[2];
    __be32 paramsize;
    u8 parameters[12];
    __be32 keysize;
    u8 modulus[256];
    u8 checksum[20];
};

struct tpmrm_priv {
    struct file_priv priv;
    struct tpm_space space;
};

struct trace_pid_list;

struct trace_options;

struct trace_func_repeats;

struct trace_array {
    struct list_head list;
    char *name;
    struct array_buffer array_buffer;
    struct array_buffer max_buffer;
    bool allocated_snapshot;
    spinlock_t snapshot_trigger_lock;
    unsigned int snapshot;
    long unsigned int max_latency;
    struct dentry *d_max_latency;
    struct work_struct fsnotify_work;
    struct irq_work fsnotify_irqwork;
    unsigned int mapped;
    long unsigned int range_addr_start;
    long unsigned int range_addr_size;
    long int text_delta;
    long int data_delta;
    struct trace_pid_list *filtered_pids;
    struct trace_pid_list *filtered_no_pids;
    arch_spinlock_t max_lock;
    int buffer_disabled;
    int sys_refcount_enter;
    int sys_refcount_exit;
    struct trace_event_file *enter_syscall_files[467];
    struct trace_event_file *exit_syscall_files[467];
    int stop_count;
    int clock_id;
    int nr_topts;
    bool clear_trace;
    int buffer_percent;
    unsigned int n_err_log_entries;
    struct tracer *current_trace;
    unsigned int trace_flags;
    unsigned char trace_flags_index[32];
    unsigned int flags;
    raw_spinlock_t start_lock;
    const char *system_names;
    struct list_head err_log;
    struct dentry *dir;
    struct dentry *options;
    struct dentry *percpu_dir;
    struct eventfs_inode *event_dir;
    struct trace_options *topts;
    struct list_head systems;
    struct list_head events;
    struct trace_event_file *trace_marker_file;
    cpumask_var_t tracing_cpumask;
    cpumask_var_t pipe_cpumask;
    int ref;
    int trace_ref;
    struct list_head mod_events;
    struct ftrace_ops *ops;
    struct trace_pid_list *function_pids;
    struct trace_pid_list *function_no_pids;
    struct fgraph_ops *gops;
    struct list_head func_probes;
    struct list_head mod_trace;
    struct list_head mod_notrace;
    int function_enabled;
    int no_filter_buffering_ref;
    struct list_head hist_vars;
    struct cond_snapshot *cond_snapshot;
    struct trace_func_repeats *last_func_repeats;
    bool ring_buffer_expanded;
};

struct trace_array_cpu {
    atomic_t disabled;
    void *buffer_page;
    long unsigned int entries;
    long unsigned int saved_latency;
    long unsigned int critical_start;
    long unsigned int critical_end;
    long unsigned int critical_sequence;
    long unsigned int nice;
    long unsigned int policy;
    long unsigned int rt_priority;
    long unsigned int skipped_entries;
    u64 preempt_timestamp;
    pid_t pid;
    kuid_t uid;
    char comm[16];
    int ftrace_ignore_pid;
    bool ignore_pid;
};

struct trace_bprintk_fmt {
    struct list_head list;
    const char *fmt;
};

struct trace_buffer {
    unsigned int flags;
    int cpus;
    atomic_t record_disabled;
    atomic_t resizing;
    cpumask_var_t cpumask;
    struct lock_class_key *reader_lock_key;
    struct mutex mutex;
    struct ring_buffer_per_cpu **buffers;
    struct hlist_node node;
    u64 (*clock)(void);
    struct rb_irq_work irq_work;
    bool time_stamp_abs;
    long unsigned int range_addr_start;
    long unsigned int range_addr_end;
    long int last_text_delta;
    long int last_data_delta;
    unsigned int subbuf_size;
    unsigned int subbuf_order;
    unsigned int max_data_size;
};

struct trace_buffer_meta {
    __u32 meta_page_size;
    __u32 meta_struct_len;
    __u32 subbuf_size;
    __u32 nr_subbufs;
    struct {
        __u64 lost_events;
        __u32 id;
        __u32 read;
    } reader;
    __u64 flags;
    __u64 entries;
    __u64 overrun;
    __u64 read;
    __u64 Reserved1;
    __u64 Reserved2;
};

struct trace_buffer_struct {
    int nesting;
    char buffer[4096];
};

struct trace_probe_event;

struct trace_probe {
    struct list_head list;
    struct trace_probe_event *event;
    ssize_t size;
    unsigned int nr_args;
    struct probe_entry_arg *entry_arg;
    struct probe_arg args[0];
};

struct trace_eprobe {
    const char *event_system;
    const char *event_name;
    char *filter_str;
    struct trace_event_call *event;
    struct dyn_event devent;
    struct trace_probe tp;
};

struct trace_eval_map {
    const char *system;
    const char *eval_string;
    long unsigned int eval_value;
};

struct trace_event_data_offsets_ack_update_msk {};

struct trace_event_data_offsets_aer_event {
    u32 dev_name;
    const void *dev_name_ptr_;
};

struct trace_event_data_offsets_alarm_class {};

struct trace_event_data_offsets_alarmtimer_suspend {};

struct trace_event_data_offsets_alloc_vmap_area {};

struct trace_event_data_offsets_arm_event {};

struct trace_event_data_offsets_balance_dirty_pages {};

struct trace_event_data_offsets_bdi_dirty_ratelimit {};

struct trace_event_data_offsets_block_bio {};

struct trace_event_data_offsets_block_bio_complete {};

struct trace_event_data_offsets_block_bio_remap {};

struct trace_event_data_offsets_block_buffer {};

struct trace_event_data_offsets_block_plug {};

struct trace_event_data_offsets_block_rq {
    u32 cmd;
    const void *cmd_ptr_;
};

struct trace_event_data_offsets_block_rq_completion {
    u32 cmd;
    const void *cmd_ptr_;
};

struct trace_event_data_offsets_block_rq_remap {};

struct trace_event_data_offsets_block_rq_requeue {
    u32 cmd;
    const void *cmd_ptr_;
};

struct trace_event_data_offsets_block_split {};

struct trace_event_data_offsets_block_unplug {};

struct trace_event_data_offsets_bpf_test_finish {};

struct trace_event_data_offsets_bpf_trace_printk {
    u32 bpf_string;
    const void *bpf_string_ptr_;
};

struct trace_event_data_offsets_bpf_trigger_tp {};

struct trace_event_data_offsets_bpf_xdp_link_attach_failed {
    u32 msg;
    const void *msg_ptr_;
};

struct trace_event_data_offsets_br_fdb_add {
    u32 dev;
    const void *dev_ptr_;
};

struct trace_event_data_offsets_br_fdb_external_learn_add {
    u32 br_dev;
    const void *br_dev_ptr_;
    u32 dev;
    const void *dev_ptr_;
};

struct trace_event_data_offsets_br_fdb_update {
    u32 br_dev;
    const void *br_dev_ptr_;
    u32 dev;
    const void *dev_ptr_;
};

struct trace_event_data_offsets_br_mdb_full {
    u32 dev;
    const void *dev_ptr_;
};

struct trace_event_data_offsets_cap_capable {};

struct trace_event_data_offsets_cdev_update {
    u32 type;
    const void *type_ptr_;
};

struct trace_event_data_offsets_cgroup {
    u32 path;
    const void *path_ptr_;
};

struct trace_event_data_offsets_cgroup_event {
    u32 path;
    const void *path_ptr_;
};

struct trace_event_data_offsets_cgroup_migrate {
    u32 dst_path;
    const void *dst_path_ptr_;
    u32 comm;
    const void *comm_ptr_;
};

struct trace_event_data_offsets_cgroup_root {
    u32 name;
    const void *name_ptr_;
};

struct trace_event_data_offsets_cgroup_rstat {};

struct trace_event_data_offsets_clk {
    u32 name;
    const void *name_ptr_;
};

struct trace_event_data_offsets_clk_duty_cycle {
    u32 name;
    const void *name_ptr_;
};

struct trace_event_data_offsets_clk_parent {
    u32 name;
    const void *name_ptr_;
    u32 pname;
    const void *pname_ptr_;
};

struct trace_event_data_offsets_clk_phase {
    u32 name;
    const void *name_ptr_;
};

struct trace_event_data_offsets_clk_rate {
    u32 name;
    const void *name_ptr_;
};

struct trace_event_data_offsets_clk_rate_range {
    u32 name;
    const void *name_ptr_;
};

struct trace_event_data_offsets_clk_rate_request {
    u32 name;
    const void *name_ptr_;
    u32 pname;
    const void *pname_ptr_;
};

struct trace_event_data_offsets_clock {
    u32 name;
    const void *name_ptr_;
};

struct trace_event_data_offsets_cma_alloc_busy_retry {
    u32 name;
    const void *name_ptr_;
};

struct trace_event_data_offsets_cma_alloc_finish {
    u32 name;
    const void *name_ptr_;
};

struct trace_event_data_offsets_cma_alloc_start {
    u32 name;
    const void *name_ptr_;
};

struct trace_event_data_offsets_cma_release {
    u32 name;
    const void *name_ptr_;
};

struct trace_event_data_offsets_compact_retry {};

struct trace_event_data_offsets_console {
    u32 msg;
    const void *msg_ptr_;
};

struct trace_event_data_offsets_consume_skb {};

struct trace_event_data_offsets_contention_begin {};

struct trace_event_data_offsets_contention_end {};

struct trace_event_data_offsets_context_tracking_user {};

struct trace_event_data_offsets_cpu {};

struct trace_event_data_offsets_cpu_frequency_limits {};

struct trace_event_data_offsets_cpu_idle_miss {};

struct trace_event_data_offsets_cpu_latency_qos_request {};

struct trace_event_data_offsets_cpuhp_enter {};

struct trace_event_data_offsets_cpuhp_exit {};

struct trace_event_data_offsets_cpuhp_multi_enter {};

struct trace_event_data_offsets_csd_function {};

struct trace_event_data_offsets_csd_queue_cpu {};

struct trace_event_data_offsets_ctime {};

struct trace_event_data_offsets_ctime_ns_xchg {};

struct trace_event_data_offsets_dev_pm_qos_request {
    u32 name;
    const void *name_ptr_;
};

struct trace_event_data_offsets_devfreq_frequency {
    u32 dev_name;
    const void *dev_name_ptr_;
};

struct trace_event_data_offsets_devfreq_monitor {
    u32 dev_name;
    const void *dev_name_ptr_;
};

struct trace_event_data_offsets_device_pm_callback_end {
    u32 device;
    const void *device_ptr_;
    u32 driver;
    const void *driver_ptr_;
};

struct trace_event_data_offsets_device_pm_callback_start {
    u32 device;
    const void *device_ptr_;
    u32 driver;
    const void *driver_ptr_;
    u32 parent;
    const void *parent_ptr_;
    u32 pm_ops;
    const void *pm_ops_ptr_;
};

struct trace_event_data_offsets_devlink_health_recover_aborted {
    u32 bus_name;
    const void *bus_name_ptr_;
    u32 dev_name;
    const void *dev_name_ptr_;
    u32 driver_name;
    const void *driver_name_ptr_;
    u32 reporter_name;
    const void *reporter_name_ptr_;
};

struct trace_event_data_offsets_devlink_health_report {
    u32 bus_name;
    const void *bus_name_ptr_;
    u32 dev_name;
    const void *dev_name_ptr_;
    u32 driver_name;
    const void *driver_name_ptr_;
    u32 reporter_name;
    const void *reporter_name_ptr_;
    u32 msg;
    const void *msg_ptr_;
};

struct trace_event_data_offsets_devlink_health_reporter_state_update {
    u32 bus_name;
    const void *bus_name_ptr_;
    u32 dev_name;
    const void *dev_name_ptr_;
    u32 driver_name;
    const void *driver_name_ptr_;
    u32 reporter_name;
    const void *reporter_name_ptr_;
};

struct trace_event_data_offsets_devlink_hwerr {
    u32 bus_name;
    const void *bus_name_ptr_;
    u32 dev_name;
    const void *dev_name_ptr_;
    u32 driver_name;
    const void *driver_name_ptr_;
    u32 msg;
    const void *msg_ptr_;
};

struct trace_event_data_offsets_devlink_hwmsg {
    u32 bus_name;
    const void *bus_name_ptr_;
    u32 dev_name;
    const void *dev_name_ptr_;
    u32 driver_name;
    const void *driver_name_ptr_;
    u32 buf;
    const void *buf_ptr_;
};

struct trace_event_data_offsets_devlink_trap_report {
    u32 bus_name;
    const void *bus_name_ptr_;
    u32 dev_name;
    const void *dev_name_ptr_;
    u32 driver_name;
    const void *driver_name_ptr_;
    u32 trap_name;
    const void *trap_name_ptr_;
    u32 trap_group_name;
    const void *trap_group_name_ptr_;
};

struct trace_event_data_offsets_devres {
    u32 devname;
    const void *devname_ptr_;
    u32 name;
    const void *name_ptr_;
};

struct trace_event_data_offsets_dma_alloc_class {
    u32 device;
    const void *device_ptr_;
};

struct trace_event_data_offsets_dma_alloc_sgt {
    u32 device;
    const void *device_ptr_;
    u32 phys_addrs;
    const void *phys_addrs_ptr_;
};

struct trace_event_data_offsets_dma_fence {
    u32 driver;
    const void *driver_ptr_;
    u32 timeline;
    const void *timeline_ptr_;
};

struct trace_event_data_offsets_dma_free_class {
    u32 device;
    const void *device_ptr_;
};

struct trace_event_data_offsets_dma_free_sgt {
    u32 device;
    const void *device_ptr_;
    u32 phys_addrs;
    const void *phys_addrs_ptr_;
};

struct trace_event_data_offsets_dma_map {
    u32 device;
    const void *device_ptr_;
};

struct trace_event_data_offsets_dma_map_sg {
    u32 device;
    const void *device_ptr_;
    u32 phys_addrs;
    const void *phys_addrs_ptr_;
    u32 dma_addrs;
    const void *dma_addrs_ptr_;
    u32 lengths;
    const void *lengths_ptr_;
};

struct trace_event_data_offsets_dma_map_sg_err {
    u32 device;
    const void *device_ptr_;
    u32 phys_addrs;
    const void *phys_addrs_ptr_;
};

struct trace_event_data_offsets_dma_sync_sg {
    u32 device;
    const void *device_ptr_;
    u32 dma_addrs;
    const void *dma_addrs_ptr_;
    u32 lengths;
    const void *lengths_ptr_;
};

struct trace_event_data_offsets_dma_sync_single {
    u32 device;
    const void *device_ptr_;
};

struct trace_event_data_offsets_dma_unmap {
    u32 device;
    const void *device_ptr_;
};

struct trace_event_data_offsets_dma_unmap_sg {
    u32 device;
    const void *device_ptr_;
    u32 addrs;
    const void *addrs_ptr_;
};

struct trace_event_data_offsets_dql_stall_detected {};

struct trace_event_data_offsets_drm_vblank_event {};

struct trace_event_data_offsets_drm_vblank_event_delivered {};

struct trace_event_data_offsets_drm_vblank_event_queued {};

struct trace_event_data_offsets_error_report_template {};

struct trace_event_data_offsets_exit_mmap {};

struct trace_event_data_offsets_ext4__bitmap_load {};

struct trace_event_data_offsets_ext4__es_extent {};

struct trace_event_data_offsets_ext4__es_shrink_enter {};

struct trace_event_data_offsets_ext4__fallocate_mode {};

struct trace_event_data_offsets_ext4__folio_op {};

struct trace_event_data_offsets_ext4__map_blocks_enter {};

struct trace_event_data_offsets_ext4__map_blocks_exit {};

struct trace_event_data_offsets_ext4__mb_new_pa {};

struct trace_event_data_offsets_ext4__mballoc {};

struct trace_event_data_offsets_ext4__trim {};

struct trace_event_data_offsets_ext4__truncate {};

struct trace_event_data_offsets_ext4__write_begin {};

struct trace_event_data_offsets_ext4__write_end {};

struct trace_event_data_offsets_ext4_alloc_da_blocks {};

struct trace_event_data_offsets_ext4_allocate_blocks {};

struct trace_event_data_offsets_ext4_allocate_inode {};

struct trace_event_data_offsets_ext4_begin_ordered_truncate {};

struct trace_event_data_offsets_ext4_collapse_range {};

struct trace_event_data_offsets_ext4_da_release_space {};

struct trace_event_data_offsets_ext4_da_reserve_space {};

struct trace_event_data_offsets_ext4_da_update_reserve_space {};

struct trace_event_data_offsets_ext4_da_write_pages {};

struct trace_event_data_offsets_ext4_da_write_pages_extent {};

struct trace_event_data_offsets_ext4_discard_blocks {};

struct trace_event_data_offsets_ext4_discard_preallocations {};

struct trace_event_data_offsets_ext4_drop_inode {};

struct trace_event_data_offsets_ext4_error {};

struct trace_event_data_offsets_ext4_es_find_extent_range_enter {};

struct trace_event_data_offsets_ext4_es_find_extent_range_exit {};

struct trace_event_data_offsets_ext4_es_insert_delayed_extent {};

struct trace_event_data_offsets_ext4_es_lookup_extent_enter {};

struct trace_event_data_offsets_ext4_es_lookup_extent_exit {};

struct trace_event_data_offsets_ext4_es_remove_extent {};

struct trace_event_data_offsets_ext4_es_shrink {};

struct trace_event_data_offsets_ext4_es_shrink_scan_exit {};

struct trace_event_data_offsets_ext4_evict_inode {};

struct trace_event_data_offsets_ext4_ext_convert_to_initialized_enter {};

struct trace_event_data_offsets_ext4_ext_convert_to_initialized_fastpath {};

struct trace_event_data_offsets_ext4_ext_handle_unwritten_extents {};

struct trace_event_data_offsets_ext4_ext_load_extent {};

struct trace_event_data_offsets_ext4_ext_remove_space {};

struct trace_event_data_offsets_ext4_ext_remove_space_done {};

struct trace_event_data_offsets_ext4_ext_rm_idx {};

struct trace_event_data_offsets_ext4_ext_rm_leaf {};

struct trace_event_data_offsets_ext4_ext_show_extent {};

struct trace_event_data_offsets_ext4_fallocate_exit {};

struct trace_event_data_offsets_ext4_fc_cleanup {};

struct trace_event_data_offsets_ext4_fc_commit_start {};

struct trace_event_data_offsets_ext4_fc_commit_stop {};

struct trace_event_data_offsets_ext4_fc_replay {};

struct trace_event_data_offsets_ext4_fc_replay_scan {};

struct trace_event_data_offsets_ext4_fc_stats {};

struct trace_event_data_offsets_ext4_fc_track_dentry {};

struct trace_event_data_offsets_ext4_fc_track_inode {};

struct trace_event_data_offsets_ext4_fc_track_range {};

struct trace_event_data_offsets_ext4_forget {};

struct trace_event_data_offsets_ext4_free_blocks {};

struct trace_event_data_offsets_ext4_free_inode {};

struct trace_event_data_offsets_ext4_fsmap_class {};

struct trace_event_data_offsets_ext4_get_implied_cluster_alloc_exit {};

struct trace_event_data_offsets_ext4_getfsmap_class {};

struct trace_event_data_offsets_ext4_insert_range {};

struct trace_event_data_offsets_ext4_invalidate_folio_op {};

struct trace_event_data_offsets_ext4_journal_start_inode {};

struct trace_event_data_offsets_ext4_journal_start_reserved {};

struct trace_event_data_offsets_ext4_journal_start_sb {};

struct trace_event_data_offsets_ext4_lazy_itable_init {};

struct trace_event_data_offsets_ext4_load_inode {};

struct trace_event_data_offsets_ext4_mark_inode_dirty {};

struct trace_event_data_offsets_ext4_mb_discard_preallocations {};

struct trace_event_data_offsets_ext4_mb_release_group_pa {};

struct trace_event_data_offsets_ext4_mb_release_inode_pa {};

struct trace_event_data_offsets_ext4_mballoc_alloc {};

struct trace_event_data_offsets_ext4_mballoc_prealloc {};

struct trace_event_data_offsets_ext4_nfs_commit_metadata {};

struct trace_event_data_offsets_ext4_other_inode_update_time {};

struct trace_event_data_offsets_ext4_prefetch_bitmaps {};

struct trace_event_data_offsets_ext4_read_block_bitmap_load {};

struct trace_event_data_offsets_ext4_remove_blocks {};

struct trace_event_data_offsets_ext4_request_blocks {};

struct trace_event_data_offsets_ext4_request_inode {};

struct trace_event_data_offsets_ext4_shutdown {};

struct trace_event_data_offsets_ext4_sync_file_enter {};

struct trace_event_data_offsets_ext4_sync_file_exit {};

struct trace_event_data_offsets_ext4_sync_fs {};

struct trace_event_data_offsets_ext4_unlink_enter {};

struct trace_event_data_offsets_ext4_unlink_exit {};

struct trace_event_data_offsets_ext4_update_sb {};

struct trace_event_data_offsets_ext4_writepages {};

struct trace_event_data_offsets_ext4_writepages_result {};

struct trace_event_data_offsets_fdb_delete {
    u32 br_dev;
    const void *br_dev_ptr_;
    u32 dev;
    const void *dev_ptr_;
};

struct trace_event_data_offsets_fib6_table_lookup {};

struct trace_event_data_offsets_fib_table_lookup {};

struct trace_event_data_offsets_file_check_and_advance_wb_err {};

struct trace_event_data_offsets_filelock_lease {};

struct trace_event_data_offsets_filelock_lock {};

struct trace_event_data_offsets_filemap_set_wb_err {};

struct trace_event_data_offsets_fill_mg_cmtime {};

struct trace_event_data_offsets_finish_task_reaping {};

struct trace_event_data_offsets_flush_foreign {};

struct trace_event_data_offsets_free_vmap_area_noflush {};

struct trace_event_data_offsets_generic_add_lease {};

struct trace_event_data_offsets_global_dirty_state {};

struct trace_event_data_offsets_gpio_direction {};

struct trace_event_data_offsets_gpio_value {};

struct trace_event_data_offsets_guest_halt_poll_ns {};

struct trace_event_data_offsets_handshake_alert_class {};

struct trace_event_data_offsets_handshake_complete {};

struct trace_event_data_offsets_handshake_error_class {};

struct trace_event_data_offsets_handshake_event_class {};

struct trace_event_data_offsets_handshake_fd_class {};

struct trace_event_data_offsets_hrtimer_class {};

struct trace_event_data_offsets_hrtimer_expire_entry {};

struct trace_event_data_offsets_hrtimer_init {};

struct trace_event_data_offsets_hrtimer_start {};

struct trace_event_data_offsets_hugepage_set {};

struct trace_event_data_offsets_hugepage_update {};

struct trace_event_data_offsets_hugetlbfs__inode {};

struct trace_event_data_offsets_hugetlbfs_alloc_inode {};

struct trace_event_data_offsets_hugetlbfs_fallocate {};

struct trace_event_data_offsets_hugetlbfs_setattr {
    u32 d_name;
    const void *d_name_ptr_;
};

struct trace_event_data_offsets_hw_pressure_update {};

struct trace_event_data_offsets_hwmon_attr_class {
    u32 attr_name;
    const void *attr_name_ptr_;
};

struct trace_event_data_offsets_hwmon_attr_show_string {
    u32 attr_name;
    const void *attr_name_ptr_;
    u32 label;
    const void *label_ptr_;
};

struct trace_event_data_offsets_i2c_read {};

struct trace_event_data_offsets_i2c_reply {
    u32 buf;
    const void *buf_ptr_;
};

struct trace_event_data_offsets_i2c_result {};

struct trace_event_data_offsets_i2c_slave {};

struct trace_event_data_offsets_i2c_write {
    u32 buf;
    const void *buf_ptr_;
};

struct trace_event_data_offsets_icmp_send {};

struct trace_event_data_offsets_inet_sk_error_report {};

struct trace_event_data_offsets_inet_sock_set_state {};

struct trace_event_data_offsets_initcall_finish {};

struct trace_event_data_offsets_initcall_level {
    u32 level;
    const void *level_ptr_;
};

struct trace_event_data_offsets_initcall_start {};

struct trace_event_data_offsets_inode_foreign_history {};

struct trace_event_data_offsets_inode_switch_wbs {};

struct trace_event_data_offsets_instruction_emulation {
    u32 instr;
    const void *instr_ptr_;
};

struct trace_event_data_offsets_io_uring_complete {};

struct trace_event_data_offsets_io_uring_cqe_overflow {};

struct trace_event_data_offsets_io_uring_cqring_wait {};

struct trace_event_data_offsets_io_uring_create {};

struct trace_event_data_offsets_io_uring_defer {
    u32 op_str;
    const void *op_str_ptr_;
};

struct trace_event_data_offsets_io_uring_fail_link {
    u32 op_str;
    const void *op_str_ptr_;
};

struct trace_event_data_offsets_io_uring_file_get {};

struct trace_event_data_offsets_io_uring_link {};

struct trace_event_data_offsets_io_uring_local_work_run {};

struct trace_event_data_offsets_io_uring_poll_arm {
    u32 op_str;
    const void *op_str_ptr_;
};

struct trace_event_data_offsets_io_uring_queue_async_work {
    u32 op_str;
    const void *op_str_ptr_;
};

struct trace_event_data_offsets_io_uring_register {};

struct trace_event_data_offsets_io_uring_req_failed {
    u32 op_str;
    const void *op_str_ptr_;
};

struct trace_event_data_offsets_io_uring_short_write {};

struct trace_event_data_offsets_io_uring_submit_req {
    u32 op_str;
    const void *op_str_ptr_;
};

struct trace_event_data_offsets_io_uring_task_add {
    u32 op_str;
    const void *op_str_ptr_;
};

struct trace_event_data_offsets_io_uring_task_work_run {};

struct trace_event_data_offsets_iomap_class {};

struct trace_event_data_offsets_iomap_dio_complete {};

struct trace_event_data_offsets_iomap_dio_rw_begin {};

struct trace_event_data_offsets_iomap_iter {};

struct trace_event_data_offsets_iomap_range_class {};

struct trace_event_data_offsets_iomap_readpage_class {};

struct trace_event_data_offsets_iomap_writepage_map {};

struct trace_event_data_offsets_iommu_device_event {
    u32 device;
    const void *device_ptr_;
};

struct trace_event_data_offsets_iommu_error {
    u32 device;
    const void *device_ptr_;
    u32 driver;
    const void *driver_ptr_;
};

struct trace_event_data_offsets_iommu_group_event {
    u32 device;
    const void *device_ptr_;
};

struct trace_event_data_offsets_ipi_handler {};

struct trace_event_data_offsets_ipi_raise {
    u32 target_cpus;
    const void *target_cpus_ptr_;
};

struct trace_event_data_offsets_ipi_send_cpu {};

struct trace_event_data_offsets_ipi_send_cpumask {
    u32 cpumask;
    const void *cpumask_ptr_;
};

struct trace_event_data_offsets_irq_handler_entry {
    u32 name;
    const void *name_ptr_;
};

struct trace_event_data_offsets_irq_handler_exit {};

struct trace_event_data_offsets_itimer_expire {};

struct trace_event_data_offsets_itimer_state {};

struct trace_event_data_offsets_jbd2_checkpoint {};

struct trace_event_data_offsets_jbd2_checkpoint_stats {};

struct trace_event_data_offsets_jbd2_commit {};

struct trace_event_data_offsets_jbd2_end_commit {};

struct trace_event_data_offsets_jbd2_handle_extend {};

struct trace_event_data_offsets_jbd2_handle_start_class {};

struct trace_event_data_offsets_jbd2_handle_stats {};

struct trace_event_data_offsets_jbd2_journal_shrink {};

struct trace_event_data_offsets_jbd2_lock_buffer_stall {};

struct trace_event_data_offsets_jbd2_run_stats {};

struct trace_event_data_offsets_jbd2_shrink_checkpoint_list {};

struct trace_event_data_offsets_jbd2_shrink_scan_exit {};

struct trace_event_data_offsets_jbd2_submit_inode_data {};

struct trace_event_data_offsets_jbd2_update_log_tail {};

struct trace_event_data_offsets_jbd2_write_superblock {};

struct trace_event_data_offsets_kcompactd_wake_template {};

struct trace_event_data_offsets_kfree {};

struct trace_event_data_offsets_kfree_skb {};

struct trace_event_data_offsets_kmalloc {};

struct trace_event_data_offsets_kmem_cache_alloc {};

struct trace_event_data_offsets_kmem_cache_free {
    u32 name;
    const void *name_ptr_;
};

struct trace_event_data_offsets_kvm_access_fault {};

struct trace_event_data_offsets_kvm_ack_irq {};

struct trace_event_data_offsets_kvm_age_hva {};

struct trace_event_data_offsets_kvm_arm_set_dreg32 {};

struct trace_event_data_offsets_kvm_dirty_ring_exit {};

struct trace_event_data_offsets_kvm_dirty_ring_push {};

struct trace_event_data_offsets_kvm_dirty_ring_reset {};

struct trace_event_data_offsets_kvm_entry {};

struct trace_event_data_offsets_kvm_exit {};

struct trace_event_data_offsets_kvm_forward_sysreg_trap {};

struct trace_event_data_offsets_kvm_fpu {};

struct trace_event_data_offsets_kvm_get_timer_map {};

struct trace_event_data_offsets_kvm_guest_fault {};

struct trace_event_data_offsets_kvm_halt_poll_ns {};

struct trace_event_data_offsets_kvm_handle_sys_reg {};

struct trace_event_data_offsets_kvm_hvc_arm64 {};

struct trace_event_data_offsets_kvm_inject_nested_exception {};

struct trace_event_data_offsets_kvm_iocsr {};

struct trace_event_data_offsets_kvm_irq_line {};

struct trace_event_data_offsets_kvm_mmio {};

struct trace_event_data_offsets_kvm_mmio_emulate {};

struct trace_event_data_offsets_kvm_mmio_nisv {};

struct trace_event_data_offsets_kvm_nested_eret {};

struct trace_event_data_offsets_kvm_set_guest_debug {};

struct trace_event_data_offsets_kvm_set_irq {};

struct trace_event_data_offsets_kvm_set_way_flush {};

struct trace_event_data_offsets_kvm_sys_access {};

struct trace_event_data_offsets_kvm_test_age_hva {};

struct trace_event_data_offsets_kvm_timer_emulate {};

struct trace_event_data_offsets_kvm_timer_hrtimer_expire {};

struct trace_event_data_offsets_kvm_timer_restore_state {};

struct trace_event_data_offsets_kvm_timer_save_state {};

struct trace_event_data_offsets_kvm_timer_update_irq {};

struct trace_event_data_offsets_kvm_toggle_cache {};

struct trace_event_data_offsets_kvm_unmap_hva_range {};

struct trace_event_data_offsets_kvm_userspace_exit {};

struct trace_event_data_offsets_kvm_vcpu_wakeup {};

struct trace_event_data_offsets_kvm_wfx_arm64 {};

struct trace_event_data_offsets_leases_conflict {};

struct trace_event_data_offsets_locks_get_lock_context {};

struct trace_event_data_offsets_ma_op {};

struct trace_event_data_offsets_ma_read {};

struct trace_event_data_offsets_ma_write {};

struct trace_event_data_offsets_map {};

struct trace_event_data_offsets_mark_victim {
    u32 comm;
    const void *comm_ptr_;
};

struct trace_event_data_offsets_mc_event {
    u32 msg;
    const void *msg_ptr_;
    u32 label;
    const void *label_ptr_;
    u32 driver_detail;
    const void *driver_detail_ptr_;
};

struct trace_event_data_offsets_mdio_access {};

struct trace_event_data_offsets_mem_connect {};

struct trace_event_data_offsets_mem_disconnect {};

struct trace_event_data_offsets_mem_return_failed {};

struct trace_event_data_offsets_memcg_flush_stats {};

struct trace_event_data_offsets_memcg_rstat_events {};

struct trace_event_data_offsets_memcg_rstat_stats {};

struct trace_event_data_offsets_migration_pmd {};

struct trace_event_data_offsets_migration_pte {};

struct trace_event_data_offsets_mm_alloc_contig_migrate_range_info {};

struct trace_event_data_offsets_mm_collapse_huge_page {};

struct trace_event_data_offsets_mm_collapse_huge_page_isolate {};

struct trace_event_data_offsets_mm_collapse_huge_page_swapin {};

struct trace_event_data_offsets_mm_compaction_begin {};

struct trace_event_data_offsets_mm_compaction_defer_template {};

struct trace_event_data_offsets_mm_compaction_end {};

struct trace_event_data_offsets_mm_compaction_isolate_template {};

struct trace_event_data_offsets_mm_compaction_kcompactd_sleep {};

struct trace_event_data_offsets_mm_compaction_migratepages {};

struct trace_event_data_offsets_mm_compaction_suitable_template {};

struct trace_event_data_offsets_mm_compaction_try_to_compact_pages {};

struct trace_event_data_offsets_mm_filemap_fault {};

struct trace_event_data_offsets_mm_filemap_op_page_cache {};

struct trace_event_data_offsets_mm_filemap_op_page_cache_range {};

struct trace_event_data_offsets_mm_khugepaged_collapse_file {
    u32 filename;
    const void *filename_ptr_;
};

struct trace_event_data_offsets_mm_khugepaged_scan_file {
    u32 filename;
    const void *filename_ptr_;
};

struct trace_event_data_offsets_mm_khugepaged_scan_pmd {};

struct trace_event_data_offsets_mm_lru_activate {};

struct trace_event_data_offsets_mm_lru_insertion {};

struct trace_event_data_offsets_mm_migrate_pages {};

struct trace_event_data_offsets_mm_migrate_pages_start {};

struct trace_event_data_offsets_mm_page {};

struct trace_event_data_offsets_mm_page_alloc {};

struct trace_event_data_offsets_mm_page_alloc_extfrag {};

struct trace_event_data_offsets_mm_page_free {};

struct trace_event_data_offsets_mm_page_free_batched {};

struct trace_event_data_offsets_mm_page_pcpu_drain {};

struct trace_event_data_offsets_mm_shrink_slab_end {};

struct trace_event_data_offsets_mm_shrink_slab_start {};

struct trace_event_data_offsets_mm_vmscan_direct_reclaim_begin_template {};

struct trace_event_data_offsets_mm_vmscan_direct_reclaim_end_template {};

struct trace_event_data_offsets_mm_vmscan_kswapd_sleep {};

struct trace_event_data_offsets_mm_vmscan_kswapd_wake {};

struct trace_event_data_offsets_mm_vmscan_lru_isolate {};

struct trace_event_data_offsets_mm_vmscan_lru_shrink_active {};

struct trace_event_data_offsets_mm_vmscan_lru_shrink_inactive {};

struct trace_event_data_offsets_mm_vmscan_node_reclaim_begin {};

struct trace_event_data_offsets_mm_vmscan_reclaim_pages {};

struct trace_event_data_offsets_mm_vmscan_throttled {};

struct trace_event_data_offsets_mm_vmscan_wakeup_kswapd {};

struct trace_event_data_offsets_mm_vmscan_write_folio {};

struct trace_event_data_offsets_mmap_lock {};

struct trace_event_data_offsets_mmap_lock_acquire_returned {};

struct trace_event_data_offsets_mmc_request_done {
    u32 name;
    const void *name_ptr_;
};

struct trace_event_data_offsets_mmc_request_start {
    u32 name;
    const void *name_ptr_;
};

struct trace_event_data_offsets_module_free {
    u32 name;
    const void *name_ptr_;
};

struct trace_event_data_offsets_module_load {
    u32 name;
    const void *name_ptr_;
};

struct trace_event_data_offsets_module_refcnt {
    u32 name;
    const void *name_ptr_;
};

struct trace_event_data_offsets_module_request {
    u32 name;
    const void *name_ptr_;
};

struct trace_event_data_offsets_mptcp_dump_mpext {};

struct trace_event_data_offsets_mptcp_subflow_get_send {};

struct trace_event_data_offsets_napi_poll {
    u32 dev_name;
    const void *dev_name_ptr_;
};

struct trace_event_data_offsets_neigh__update {
    u32 dev;
    const void *dev_ptr_;
};

struct trace_event_data_offsets_neigh_create {
    u32 dev;
    const void *dev_ptr_;
};

struct trace_event_data_offsets_neigh_update {
    u32 dev;
    const void *dev_ptr_;
};

struct trace_event_data_offsets_net_dev_rx_exit_template {};

struct trace_event_data_offsets_net_dev_rx_verbose_template {
    u32 name;
    const void *name_ptr_;
};

struct trace_event_data_offsets_net_dev_start_xmit {
    u32 name;
    const void *name_ptr_;
};

struct trace_event_data_offsets_net_dev_template {
    u32 name;
    const void *name_ptr_;
};

struct trace_event_data_offsets_net_dev_xmit {
    u32 name;
    const void *name_ptr_;
};

struct trace_event_data_offsets_net_dev_xmit_timeout {
    u32 name;
    const void *name_ptr_;
    u32 driver;
    const void *driver_ptr_;
};

struct trace_event_data_offsets_netlink_extack {
    u32 msg;
    const void *msg_ptr_;
};

struct trace_event_data_offsets_non_standard_event {
    u32 fru_text;
    const void *fru_text_ptr_;
    u32 buf;
    const void *buf_ptr_;
};

struct trace_event_data_offsets_notifier_info {};

struct trace_event_data_offsets_oom_score_adj_update {};

struct trace_event_data_offsets_page_pool_release {};

struct trace_event_data_offsets_page_pool_state_hold {};

struct trace_event_data_offsets_page_pool_state_release {};

struct trace_event_data_offsets_page_pool_update_nid {};

struct trace_event_data_offsets_percpu_alloc_percpu {};

struct trace_event_data_offsets_percpu_alloc_percpu_fail {};

struct trace_event_data_offsets_percpu_create_chunk {};

struct trace_event_data_offsets_percpu_destroy_chunk {};

struct trace_event_data_offsets_percpu_free_percpu {};

struct trace_event_data_offsets_pm_qos_update {};

struct trace_event_data_offsets_power_domain {
    u32 name;
    const void *name_ptr_;
};

struct trace_event_data_offsets_powernv_throttle {
    u32 reason;
    const void *reason_ptr_;
};

struct trace_event_data_offsets_preemptirq_template {};

struct trace_event_data_offsets_pstate_sample {};

struct trace_event_data_offsets_purge_vmap_area_lazy {};

struct trace_event_data_offsets_pwm {};

struct trace_event_data_offsets_pwm_read_waveform {};

struct trace_event_data_offsets_pwm_round_waveform_fromhw {};

struct trace_event_data_offsets_pwm_round_waveform_tohw {};

struct trace_event_data_offsets_pwm_write_waveform {};

struct trace_event_data_offsets_qdisc_create {
    u32 dev;
    const void *dev_ptr_;
    u32 kind;
    const void *kind_ptr_;
};

struct trace_event_data_offsets_qdisc_dequeue {};

struct trace_event_data_offsets_qdisc_destroy {
    u32 dev;
    const void *dev_ptr_;
    u32 kind;
    const void *kind_ptr_;
};

struct trace_event_data_offsets_qdisc_enqueue {};

struct trace_event_data_offsets_qdisc_reset {
    u32 dev;
    const void *dev_ptr_;
    u32 kind;
    const void *kind_ptr_;
};

struct trace_event_data_offsets_rcu_stall_warning {};

struct trace_event_data_offsets_rcu_utilization {};

struct trace_event_data_offsets_reclaim_retry_zone {};

struct trace_event_data_offsets_regcache_drop_region {
    u32 name;
    const void *name_ptr_;
};

struct trace_event_data_offsets_regcache_sync {
    u32 name;
    const void *name_ptr_;
    u32 status;
    const void *status_ptr_;
    u32 type;
    const void *type_ptr_;
};

struct trace_event_data_offsets_regmap_async {
    u32 name;
    const void *name_ptr_;
};

struct trace_event_data_offsets_regmap_block {
    u32 name;
    const void *name_ptr_;
};

struct trace_event_data_offsets_regmap_bool {
    u32 name;
    const void *name_ptr_;
};

struct trace_event_data_offsets_regmap_bulk {
    u32 name;
    const void *name_ptr_;
    u32 buf;
    const void *buf_ptr_;
};

struct trace_event_data_offsets_regmap_reg {
    u32 name;
    const void *name_ptr_;
};

struct trace_event_data_offsets_regulator_basic {
    u32 name;
    const void *name_ptr_;
};

struct trace_event_data_offsets_regulator_range {
    u32 name;
    const void *name_ptr_;
};

struct trace_event_data_offsets_regulator_value {
    u32 name;
    const void *name_ptr_;
};

struct trace_event_data_offsets_rpm_internal {
    u32 name;
    const void *name_ptr_;
};

struct trace_event_data_offsets_rpm_return_int {
    u32 name;
    const void *name_ptr_;
};

struct trace_event_data_offsets_rpm_status {
    u32 name;
    const void *name_ptr_;
};

struct trace_event_data_offsets_rseq_ip_fixup {};

struct trace_event_data_offsets_rseq_update {};

struct trace_event_data_offsets_rss_stat {};

struct trace_event_data_offsets_rtc_alarm_irq_enable {};

struct trace_event_data_offsets_rtc_irq_set_freq {};

struct trace_event_data_offsets_rtc_irq_set_state {};

struct trace_event_data_offsets_rtc_offset_class {};

struct trace_event_data_offsets_rtc_time_alarm_class {};

struct trace_event_data_offsets_rtc_timer_class {};

struct trace_event_data_offsets_rwmmio_post_read {};

struct trace_event_data_offsets_rwmmio_read {};

struct trace_event_data_offsets_rwmmio_rw_template {};

struct trace_event_data_offsets_sched_ext_dump {
    u32 line;
    const void *line_ptr_;
};

struct trace_event_data_offsets_sched_kthread_stop {};

struct trace_event_data_offsets_sched_kthread_stop_ret {};

struct trace_event_data_offsets_sched_kthread_work_execute_end {};

struct trace_event_data_offsets_sched_kthread_work_execute_start {};

struct trace_event_data_offsets_sched_kthread_work_queue_work {};

struct trace_event_data_offsets_sched_migrate_task {};

struct trace_event_data_offsets_sched_move_numa {};

struct trace_event_data_offsets_sched_numa_pair_template {};

struct trace_event_data_offsets_sched_pi_setprio {};

struct trace_event_data_offsets_sched_prepare_exec {
    u32 interp;
    const void *interp_ptr_;
    u32 filename;
    const void *filename_ptr_;
    u32 comm;
    const void *comm_ptr_;
};

struct trace_event_data_offsets_sched_process_exec {
    u32 filename;
    const void *filename_ptr_;
};

struct trace_event_data_offsets_sched_process_fork {};

struct trace_event_data_offsets_sched_process_hang {};

struct trace_event_data_offsets_sched_process_template {};

struct trace_event_data_offsets_sched_process_wait {};

struct trace_event_data_offsets_sched_stat_runtime {};

struct trace_event_data_offsets_sched_stat_template {};

struct trace_event_data_offsets_sched_switch {};

struct trace_event_data_offsets_sched_wake_idle_without_ipi {};

struct trace_event_data_offsets_sched_wakeup_template {};

struct trace_event_data_offsets_scsi_cmd_done_timeout_template {
    u32 cmnd;
    const void *cmnd_ptr_;
};

struct trace_event_data_offsets_scsi_dispatch_cmd_error {
    u32 cmnd;
    const void *cmnd_ptr_;
};

struct trace_event_data_offsets_scsi_dispatch_cmd_start {
    u32 cmnd;
    const void *cmnd_ptr_;
};

struct trace_event_data_offsets_scsi_eh_wakeup {};

struct trace_event_data_offsets_scsi_prepare_zone_append {};

struct trace_event_data_offsets_scsi_zone_wp_update {};

struct trace_event_data_offsets_selinux_audited {
    u32 scontext;
    const void *scontext_ptr_;
    u32 tcontext;
    const void *tcontext_ptr_;
    u32 tclass;
    const void *tclass_ptr_;
};

struct trace_event_data_offsets_signal_deliver {};

struct trace_event_data_offsets_signal_generate {};

struct trace_event_data_offsets_sk_data_ready {};

struct trace_event_data_offsets_skb_copy_datagram_iovec {};

struct trace_event_data_offsets_skip_task_reaping {};

struct trace_event_data_offsets_smbus_read {};

struct trace_event_data_offsets_smbus_reply {};

struct trace_event_data_offsets_smbus_result {};

struct trace_event_data_offsets_smbus_write {};

struct trace_event_data_offsets_sock_exceed_buf_limit {};

struct trace_event_data_offsets_sock_msg_length {};

struct trace_event_data_offsets_sock_rcvqueue_full {};

struct trace_event_data_offsets_softirq {};

struct trace_event_data_offsets_spi_controller {};

struct trace_event_data_offsets_spi_message {};

struct trace_event_data_offsets_spi_message_done {};

struct trace_event_data_offsets_spi_set_cs {};

struct trace_event_data_offsets_spi_setup {};

struct trace_event_data_offsets_spi_transfer {
    u32 rx_buf;
    const void *rx_buf_ptr_;
    u32 tx_buf;
    const void *tx_buf_ptr_;
};

struct trace_event_data_offsets_start_task_reaping {};

struct trace_event_data_offsets_subflow_check_data_avail {};

struct trace_event_data_offsets_suspend_resume {};

struct trace_event_data_offsets_swiotlb_bounced {
    u32 dev_name;
    const void *dev_name_ptr_;
};

struct trace_event_data_offsets_sys_enter {};

struct trace_event_data_offsets_sys_exit {};

struct trace_event_data_offsets_task_newtask {};

struct trace_event_data_offsets_task_prctl_unknown {};

struct trace_event_data_offsets_task_rename {};

struct trace_event_data_offsets_tasklet {};

struct trace_event_data_offsets_tcp_ao_event {};

struct trace_event_data_offsets_tcp_ao_event_sk {};

struct trace_event_data_offsets_tcp_ao_event_sne {};

struct trace_event_data_offsets_tcp_cong_state_set {};

struct trace_event_data_offsets_tcp_event_sk {};

struct trace_event_data_offsets_tcp_event_sk_skb {};

struct trace_event_data_offsets_tcp_event_skb {};

struct trace_event_data_offsets_tcp_hash_event {};

struct trace_event_data_offsets_tcp_probe {};

struct trace_event_data_offsets_tcp_retransmit_synack {};

struct trace_event_data_offsets_tcp_send_reset {};

struct trace_event_data_offsets_test_pages_isolated {};

struct trace_event_data_offsets_thermal_power_cpu_get_power_simple {};

struct trace_event_data_offsets_thermal_power_cpu_limit {
    u32 cpumask;
    const void *cpumask_ptr_;
};

struct trace_event_data_offsets_thermal_power_devfreq_get_power {
    u32 type;
    const void *type_ptr_;
};

struct trace_event_data_offsets_thermal_power_devfreq_limit {
    u32 type;
    const void *type_ptr_;
};

struct trace_event_data_offsets_thermal_temperature {
    u32 thermal_zone;
    const void *thermal_zone_ptr_;
};

struct trace_event_data_offsets_thermal_zone_trip {
    u32 thermal_zone;
    const void *thermal_zone_ptr_;
};

struct trace_event_data_offsets_tick_stop {};

struct trace_event_data_offsets_timer_base_idle {};

struct trace_event_data_offsets_timer_class {};

struct trace_event_data_offsets_timer_expire_entry {};

struct trace_event_data_offsets_timer_start {};

struct trace_event_data_offsets_tlb_flush {};

struct trace_event_data_offsets_tls_contenttype {};

struct trace_event_data_offsets_tmigr_connect_child_parent {};

struct trace_event_data_offsets_tmigr_connect_cpu_parent {};

struct trace_event_data_offsets_tmigr_cpugroup {};

struct trace_event_data_offsets_tmigr_group_and_cpu {};

struct trace_event_data_offsets_tmigr_group_set {};

struct trace_event_data_offsets_tmigr_handle_remote {};

struct trace_event_data_offsets_tmigr_idle {};

struct trace_event_data_offsets_tmigr_update_events {};

struct trace_event_data_offsets_track_foreign_dirty {};

struct trace_event_data_offsets_udp_fail_queue_rcv_skb {};

struct trace_event_data_offsets_unmap {};

struct trace_event_data_offsets_vgic_update_irq_pending {};

struct trace_event_data_offsets_vm_unmapped_area {};

struct trace_event_data_offsets_vma_mas_szero {};

struct trace_event_data_offsets_vma_store {};

struct trace_event_data_offsets_wake_reaper {};

struct trace_event_data_offsets_wakeup_source {
    u32 name;
    const void *name_ptr_;
};

struct trace_event_data_offsets_watchdog_set_timeout {};

struct trace_event_data_offsets_watchdog_template {};

struct trace_event_data_offsets_wbc_class {};

struct trace_event_data_offsets_wbt_lat {};

struct trace_event_data_offsets_wbt_stat {};

struct trace_event_data_offsets_wbt_step {};

struct trace_event_data_offsets_wbt_timer {};

struct trace_event_data_offsets_workqueue_activate_work {};

struct trace_event_data_offsets_workqueue_execute_end {};

struct trace_event_data_offsets_workqueue_execute_start {};

struct trace_event_data_offsets_workqueue_queue_work {
    u32 workqueue;
    const void *workqueue_ptr_;
};

struct trace_event_data_offsets_writeback_bdi_register {};

struct trace_event_data_offsets_writeback_class {};

struct trace_event_data_offsets_writeback_dirty_inode_template {};

struct trace_event_data_offsets_writeback_folio_template {};

struct trace_event_data_offsets_writeback_inode_template {};

struct trace_event_data_offsets_writeback_pages_written {};

struct trace_event_data_offsets_writeback_queue_io {};

struct trace_event_data_offsets_writeback_sb_inodes_requeue {};

struct trace_event_data_offsets_writeback_single_inode_template {};

struct trace_event_data_offsets_writeback_work_class {};

struct trace_event_data_offsets_writeback_write_inode_template {};

struct trace_event_data_offsets_xdp_bulk_tx {};

struct trace_event_data_offsets_xdp_cpumap_enqueue {};

struct trace_event_data_offsets_xdp_cpumap_kthread {};

struct trace_event_data_offsets_xdp_devmap_xmit {};

struct trace_event_data_offsets_xdp_exception {};

struct trace_event_data_offsets_xdp_redirect_template {};

struct trace_event_data_offsets_xhci_dbc_log_request {};

struct trace_event_data_offsets_xhci_log_ctrl_ctx {};

struct trace_event_data_offsets_xhci_log_ctx {
    u32 ctx_data;
    const void *ctx_data_ptr_;
};

struct trace_event_data_offsets_xhci_log_doorbell {};

struct trace_event_data_offsets_xhci_log_ep_ctx {};

struct trace_event_data_offsets_xhci_log_free_virt_dev {};

struct trace_event_data_offsets_xhci_log_msg {
    u32 msg;
    const void *msg_ptr_;
};

struct trace_event_data_offsets_xhci_log_portsc {};

struct trace_event_data_offsets_xhci_log_ring {};

struct trace_event_data_offsets_xhci_log_slot_ctx {};

struct trace_event_data_offsets_xhci_log_stream_ctx {};

struct trace_event_data_offsets_xhci_log_trb {};

struct trace_event_data_offsets_xhci_log_urb {
    u32 devname;
    const void *devname_ptr_;
};

struct trace_event_data_offsets_xhci_log_virt_dev {};

struct trace_event_fields {
    const char *type;
    union {
        struct {
            const char *name;
            const int size;
            const int align;
            const unsigned int is_signed: 1;
            unsigned int needs_test: 1;
            const int filter_type;
            const int len;
        };
        int (*define_fields)(struct trace_event_call *);
    };
};

struct trace_subsystem_dir;

struct trace_event_file {
    struct list_head list;
    struct trace_event_call *event_call;
    struct event_filter *filter;
    struct eventfs_inode *ei;
    struct trace_array *tr;
    struct trace_subsystem_dir *system;
    struct list_head triggers;
    long unsigned int flags;
    refcount_t ref;
    atomic_t sm_ref;
    atomic_t tm_ref;
};

typedef enum print_line_t (*trace_print_func)(struct trace_iterator *, int, struct trace_event *);

struct trace_event_functions {
    trace_print_func trace;
    trace_print_func raw;
    trace_print_func hex;
    trace_print_func binary;
};

struct trace_event_raw_ack_update_msk {
    struct trace_entry ent;
    u64 data_ack;
    u64 old_snd_una;
    u64 new_snd_una;
    u64 new_wnd_end;
    u64 msk_wnd_end;
    char __data[0];
};

struct trace_event_raw_aer_event {
    struct trace_entry ent;
    u32 __data_loc_dev_name;
    u32 status;
    u8 severity;
    u8 tlp_header_valid;
    u32 tlp_header[4];
    char __data[0];
};

struct trace_event_raw_alarm_class {
    struct trace_entry ent;
    void *alarm;
    unsigned char alarm_type;
    s64 expires;
    s64 now;
    char __data[0];
};

struct trace_event_raw_alarmtimer_suspend {
    struct trace_entry ent;
    s64 expires;
    unsigned char alarm_type;
    char __data[0];
};

struct trace_event_raw_alloc_vmap_area {
    struct trace_entry ent;
    long unsigned int addr;
    long unsigned int size;
    long unsigned int align;
    long unsigned int vstart;
    long unsigned int vend;
    int failed;
    char __data[0];
};

struct trace_event_raw_arm_event {
    struct trace_entry ent;
    u64 mpidr;
    u64 midr;
    u32 running_state;
    u32 psci_state;
    u8 affinity;
    char __data[0];
};

struct trace_event_raw_balance_dirty_pages {
    struct trace_entry ent;
    char bdi[32];
    long unsigned int limit;
    long unsigned int setpoint;
    long unsigned int dirty;
    long unsigned int bdi_setpoint;
    long unsigned int bdi_dirty;
    long unsigned int dirty_ratelimit;
    long unsigned int task_ratelimit;
    unsigned int dirtied;
    unsigned int dirtied_pause;
    long unsigned int paused;
    long int pause;
    long unsigned int period;
    long int think;
    ino_t cgroup_ino;
    char __data[0];
};

struct trace_event_raw_bdi_dirty_ratelimit {
    struct trace_entry ent;
    char bdi[32];
    long unsigned int write_bw;
    long unsigned int avg_write_bw;
    long unsigned int dirty_rate;
    long unsigned int dirty_ratelimit;
    long unsigned int task_ratelimit;
    long unsigned int balanced_dirty_ratelimit;
    ino_t cgroup_ino;
    char __data[0];
};

struct trace_event_raw_block_bio {
    struct trace_entry ent;
    dev_t dev;
    sector_t sector;
    unsigned int nr_sector;
    char rwbs[8];
    char comm[16];
    char __data[0];
};

struct trace_event_raw_block_bio_complete {
    struct trace_entry ent;
    dev_t dev;
    sector_t sector;
    unsigned int nr_sector;
    int error;
    char rwbs[8];
    char __data[0];
};

struct trace_event_raw_block_bio_remap {
    struct trace_entry ent;
    dev_t dev;
    sector_t sector;
    unsigned int nr_sector;
    dev_t old_dev;
    sector_t old_sector;
    char rwbs[8];
    char __data[0];
};

struct trace_event_raw_block_buffer {
    struct trace_entry ent;
    dev_t dev;
    sector_t sector;
    size_t size;
    char __data[0];
};

struct trace_event_raw_block_plug {
    struct trace_entry ent;
    char comm[16];
    char __data[0];
};

struct trace_event_raw_block_rq {
    struct trace_entry ent;
    dev_t dev;
    sector_t sector;
    unsigned int nr_sector;
    unsigned int bytes;
    short unsigned int ioprio;
    char rwbs[8];
    char comm[16];
    u32 __data_loc_cmd;
    char __data[0];
};

struct trace_event_raw_block_rq_completion {
    struct trace_entry ent;
    dev_t dev;
    sector_t sector;
    unsigned int nr_sector;
    int error;
    short unsigned int ioprio;
    char rwbs[8];
    u32 __data_loc_cmd;
    char __data[0];
};

struct trace_event_raw_block_rq_remap {
    struct trace_entry ent;
    dev_t dev;
    sector_t sector;
    unsigned int nr_sector;
    dev_t old_dev;
    sector_t old_sector;
    unsigned int nr_bios;
    char rwbs[8];
    char __data[0];
};

struct trace_event_raw_block_rq_requeue {
    struct trace_entry ent;
    dev_t dev;
    sector_t sector;
    unsigned int nr_sector;
    short unsigned int ioprio;
    char rwbs[8];
    u32 __data_loc_cmd;
    char __data[0];
};

struct trace_event_raw_block_split {
    struct trace_entry ent;
    dev_t dev;
    sector_t sector;
    sector_t new_sector;
    char rwbs[8];
    char comm[16];
    char __data[0];
};

struct trace_event_raw_block_unplug {
    struct trace_entry ent;
    int nr_rq;
    char comm[16];
    char __data[0];
};

struct trace_event_raw_bpf_test_finish {
    struct trace_entry ent;
    int err;
    char __data[0];
};

struct trace_event_raw_bpf_trace_printk {
    struct trace_entry ent;
    u32 __data_loc_bpf_string;
    char __data[0];
};

struct trace_event_raw_bpf_trigger_tp {
    struct trace_entry ent;
    int nonce;
    char __data[0];
};

struct trace_event_raw_bpf_xdp_link_attach_failed {
    struct trace_entry ent;
    u32 __data_loc_msg;
    char __data[0];
};

struct trace_event_raw_br_fdb_add {
    struct trace_entry ent;
    u8 ndm_flags;
    u32 __data_loc_dev;
    unsigned char addr[6];
    u16 vid;
    u16 nlh_flags;
    char __data[0];
};

struct trace_event_raw_br_fdb_external_learn_add {
    struct trace_entry ent;
    u32 __data_loc_br_dev;
    u32 __data_loc_dev;
    unsigned char addr[6];
    u16 vid;
    char __data[0];
};

struct trace_event_raw_br_fdb_update {
    struct trace_entry ent;
    u32 __data_loc_br_dev;
    u32 __data_loc_dev;
    unsigned char addr[6];
    u16 vid;
    long unsigned int flags;
    char __data[0];
};

struct trace_event_raw_br_mdb_full {
    struct trace_entry ent;
    u32 __data_loc_dev;
    int af;
    u16 vid;
    __u8 src[16];
    __u8 grp[16];
    __u8 grpmac[6];
    char __data[0];
};

struct trace_event_raw_cap_capable {
    struct trace_entry ent;
    const struct cred *cred;
    struct user_namespace *target_ns;
    const struct user_namespace *capable_ns;
    int cap;
    int ret;
    char __data[0];
};

struct trace_event_raw_cdev_update {
    struct trace_entry ent;
    u32 __data_loc_type;
    long unsigned int target;
    char __data[0];
};

struct trace_event_raw_cgroup {
    struct trace_entry ent;
    int root;
    int level;
    u64 id;
    u32 __data_loc_path;
    char __data[0];
};

struct trace_event_raw_cgroup_event {
    struct trace_entry ent;
    int root;
    int level;
    u64 id;
    u32 __data_loc_path;
    int val;
    char __data[0];
};

struct trace_event_raw_cgroup_migrate {
    struct trace_entry ent;
    int dst_root;
    int dst_level;
    u64 dst_id;
    int pid;
    u32 __data_loc_dst_path;
    u32 __data_loc_comm;
    char __data[0];
};

struct trace_event_raw_cgroup_root {
    struct trace_entry ent;
    int root;
    u16 ss_mask;
    u32 __data_loc_name;
    char __data[0];
};

struct trace_event_raw_cgroup_rstat {
    struct trace_entry ent;
    int root;
    int level;
    u64 id;
    int cpu;
    bool contended;
    char __data[0];
};

struct trace_event_raw_clk {
    struct trace_entry ent;
    u32 __data_loc_name;
    char __data[0];
};

struct trace_event_raw_clk_duty_cycle {
    struct trace_entry ent;
    u32 __data_loc_name;
    unsigned int num;
    unsigned int den;
    char __data[0];
};

struct trace_event_raw_clk_parent {
    struct trace_entry ent;
    u32 __data_loc_name;
    u32 __data_loc_pname;
    char __data[0];
};

struct trace_event_raw_clk_phase {
    struct trace_entry ent;
    u32 __data_loc_name;
    int phase;
    char __data[0];
};

struct trace_event_raw_clk_rate {
    struct trace_entry ent;
    u32 __data_loc_name;
    long unsigned int rate;
    char __data[0];
};

struct trace_event_raw_clk_rate_range {
    struct trace_entry ent;
    u32 __data_loc_name;
    long unsigned int min;
    long unsigned int max;
    char __data[0];
};

struct trace_event_raw_clk_rate_request {
    struct trace_entry ent;
    u32 __data_loc_name;
    u32 __data_loc_pname;
    long unsigned int min;
    long unsigned int max;
    long unsigned int prate;
    char __data[0];
};

struct trace_event_raw_clock {
    struct trace_entry ent;
    u32 __data_loc_name;
    u64 state;
    u64 cpu_id;
    char __data[0];
};

struct trace_event_raw_cma_alloc_busy_retry {
    struct trace_entry ent;
    u32 __data_loc_name;
    long unsigned int pfn;
    const struct page *page;
    long unsigned int count;
    unsigned int align;
    char __data[0];
};

struct trace_event_raw_cma_alloc_finish {
    struct trace_entry ent;
    u32 __data_loc_name;
    long unsigned int pfn;
    const struct page *page;
    long unsigned int count;
    unsigned int align;
    int errorno;
    char __data[0];
};

struct trace_event_raw_cma_alloc_start {
    struct trace_entry ent;
    u32 __data_loc_name;
    long unsigned int count;
    unsigned int align;
    char __data[0];
};

struct trace_event_raw_cma_release {
    struct trace_entry ent;
    u32 __data_loc_name;
    long unsigned int pfn;
    const struct page *page;
    long unsigned int count;
    char __data[0];
};

struct trace_event_raw_compact_retry {
    struct trace_entry ent;
    int order;
    int priority;
    int result;
    int retries;
    int max_retries;
    bool ret;
    char __data[0];
};

struct trace_event_raw_console {
    struct trace_entry ent;
    u32 __data_loc_msg;
    char __data[0];
};

struct trace_event_raw_consume_skb {
    struct trace_entry ent;
    void *skbaddr;
    void *location;
    char __data[0];
};

struct trace_event_raw_contention_begin {
    struct trace_entry ent;
    void *lock_addr;
    unsigned int flags;
    char __data[0];
};

struct trace_event_raw_contention_end {
    struct trace_entry ent;
    void *lock_addr;
    int ret;
    char __data[0];
};

struct trace_event_raw_context_tracking_user {
    struct trace_entry ent;
    int dummy;
    char __data[0];
};

struct trace_event_raw_cpu {
    struct trace_entry ent;
    u32 state;
    u32 cpu_id;
    char __data[0];
};

struct trace_event_raw_cpu_frequency_limits {
    struct trace_entry ent;
    u32 min_freq;
    u32 max_freq;
    u32 cpu_id;
    char __data[0];
};

struct trace_event_raw_cpu_idle_miss {
    struct trace_entry ent;
    u32 cpu_id;
    u32 state;
    bool below;
    char __data[0];
};

struct trace_event_raw_cpu_latency_qos_request {
    struct trace_entry ent;
    s32 value;
    char __data[0];
};

struct trace_event_raw_cpuhp_enter {
    struct trace_entry ent;
    unsigned int cpu;
    int target;
    int idx;
    void *fun;
    char __data[0];
};

struct trace_event_raw_cpuhp_exit {
    struct trace_entry ent;
    unsigned int cpu;
    int state;
    int idx;
    int ret;
    char __data[0];
};

struct trace_event_raw_cpuhp_multi_enter {
    struct trace_entry ent;
    unsigned int cpu;
    int target;
    int idx;
    void *fun;
    char __data[0];
};

struct trace_event_raw_csd_function {
    struct trace_entry ent;
    void *func;
    void *csd;
    char __data[0];
};

struct trace_event_raw_csd_queue_cpu {
    struct trace_entry ent;
    unsigned int cpu;
    void *callsite;
    void *func;
    void *csd;
    char __data[0];
};

struct trace_event_raw_ctime {
    struct trace_entry ent;
    dev_t dev;
    ino_t ino;
    time64_t ctime_s;
    u32 ctime_ns;
    u32 gen;
    char __data[0];
};

struct trace_event_raw_ctime_ns_xchg {
    struct trace_entry ent;
    dev_t dev;
    ino_t ino;
    u32 gen;
    u32 old;
    u32 new;
    u32 cur;
    char __data[0];
};

struct trace_event_raw_dev_pm_qos_request {
    struct trace_entry ent;
    u32 __data_loc_name;
    enum dev_pm_qos_req_type type;
    s32 new_value;
    char __data[0];
};

struct trace_event_raw_devfreq_frequency {
    struct trace_entry ent;
    u32 __data_loc_dev_name;
    long unsigned int freq;
    long unsigned int prev_freq;
    long unsigned int busy_time;
    long unsigned int total_time;
    char __data[0];
};

struct trace_event_raw_devfreq_monitor {
    struct trace_entry ent;
    long unsigned int freq;
    long unsigned int busy_time;
    long unsigned int total_time;
    unsigned int polling_ms;
    u32 __data_loc_dev_name;
    char __data[0];
};

struct trace_event_raw_device_pm_callback_end {
    struct trace_entry ent;
    u32 __data_loc_device;
    u32 __data_loc_driver;
    int error;
    char __data[0];
};

struct trace_event_raw_device_pm_callback_start {
    struct trace_entry ent;
    u32 __data_loc_device;
    u32 __data_loc_driver;
    u32 __data_loc_parent;
    u32 __data_loc_pm_ops;
    int event;
    char __data[0];
};

struct trace_event_raw_devlink_health_recover_aborted {
    struct trace_entry ent;
    u32 __data_loc_bus_name;
    u32 __data_loc_dev_name;
    u32 __data_loc_driver_name;
    u32 __data_loc_reporter_name;
    bool health_state;
    u64 time_since_last_recover;
    char __data[0];
};

struct trace_event_raw_devlink_health_report {
    struct trace_entry ent;
    u32 __data_loc_bus_name;
    u32 __data_loc_dev_name;
    u32 __data_loc_driver_name;
    u32 __data_loc_reporter_name;
    u32 __data_loc_msg;
    char __data[0];
};

struct trace_event_raw_devlink_health_reporter_state_update {
    struct trace_entry ent;
    u32 __data_loc_bus_name;
    u32 __data_loc_dev_name;
    u32 __data_loc_driver_name;
    u32 __data_loc_reporter_name;
    u8 new_state;
    char __data[0];
};

struct trace_event_raw_devlink_hwerr {
    struct trace_entry ent;
    u32 __data_loc_bus_name;
    u32 __data_loc_dev_name;
    u32 __data_loc_driver_name;
    int err;
    u32 __data_loc_msg;
    char __data[0];
};

struct trace_event_raw_devlink_hwmsg {
    struct trace_entry ent;
    u32 __data_loc_bus_name;
    u32 __data_loc_dev_name;
    u32 __data_loc_driver_name;
    bool incoming;
    long unsigned int type;
    u32 __data_loc_buf;
    size_t len;
    char __data[0];
};

struct trace_event_raw_devlink_trap_report {
    struct trace_entry ent;
    u32 __data_loc_bus_name;
    u32 __data_loc_dev_name;
    u32 __data_loc_driver_name;
    u32 __data_loc_trap_name;
    u32 __data_loc_trap_group_name;
    char input_dev_name[16];
    char __data[0];
};

struct trace_event_raw_devres {
    struct trace_entry ent;
    u32 __data_loc_devname;
    struct device *dev;
    const char *op;
    void *node;
    u32 __data_loc_name;
    size_t size;
    char __data[0];
};

struct trace_event_raw_dma_alloc_class {
    struct trace_entry ent;
    u32 __data_loc_device;
    void *virt_addr;
    u64 dma_addr;
    size_t size;
    gfp_t flags;
    enum dma_data_direction dir;
    long unsigned int attrs;
    char __data[0];
};

struct trace_event_raw_dma_alloc_sgt {
    struct trace_entry ent;
    u32 __data_loc_device;
    u32 __data_loc_phys_addrs;
    u64 dma_addr;
    size_t size;
    enum dma_data_direction dir;
    gfp_t flags;
    long unsigned int attrs;
    char __data[0];
};

struct trace_event_raw_dma_fence {
    struct trace_entry ent;
    u32 __data_loc_driver;
    u32 __data_loc_timeline;
    unsigned int context;
    unsigned int seqno;
    char __data[0];
};

struct trace_event_raw_dma_free_class {
    struct trace_entry ent;
    u32 __data_loc_device;
    void *virt_addr;
    u64 dma_addr;
    size_t size;
    enum dma_data_direction dir;
    long unsigned int attrs;
    char __data[0];
};

struct trace_event_raw_dma_free_sgt {
    struct trace_entry ent;
    u32 __data_loc_device;
    u32 __data_loc_phys_addrs;
    u64 dma_addr;
    size_t size;
    enum dma_data_direction dir;
    char __data[0];
};

struct trace_event_raw_dma_map {
    struct trace_entry ent;
    u32 __data_loc_device;
    u64 phys_addr;
    u64 dma_addr;
    size_t size;
    enum dma_data_direction dir;
    long unsigned int attrs;
    char __data[0];
};

struct trace_event_raw_dma_map_sg {
    struct trace_entry ent;
    u32 __data_loc_device;
    u32 __data_loc_phys_addrs;
    u32 __data_loc_dma_addrs;
    u32 __data_loc_lengths;
    enum dma_data_direction dir;
    long unsigned int attrs;
    char __data[0];
};

struct trace_event_raw_dma_map_sg_err {
    struct trace_entry ent;
    u32 __data_loc_device;
    u32 __data_loc_phys_addrs;
    int err;
    enum dma_data_direction dir;
    long unsigned int attrs;
    char __data[0];
};

struct trace_event_raw_dma_sync_sg {
    struct trace_entry ent;
    u32 __data_loc_device;
    u32 __data_loc_dma_addrs;
    u32 __data_loc_lengths;
    enum dma_data_direction dir;
    char __data[0];
};

struct trace_event_raw_dma_sync_single {
    struct trace_entry ent;
    u32 __data_loc_device;
    u64 dma_addr;
    size_t size;
    enum dma_data_direction dir;
    char __data[0];
};

struct trace_event_raw_dma_unmap {
    struct trace_entry ent;
    u32 __data_loc_device;
    u64 addr;
    size_t size;
    enum dma_data_direction dir;
    long unsigned int attrs;
    char __data[0];
};

struct trace_event_raw_dma_unmap_sg {
    struct trace_entry ent;
    u32 __data_loc_device;
    u32 __data_loc_addrs;
    enum dma_data_direction dir;
    long unsigned int attrs;
    char __data[0];
};

struct trace_event_raw_dql_stall_detected {
    struct trace_entry ent;
    short unsigned int thrs;
    unsigned int len;
    long unsigned int last_reap;
    long unsigned int hist_head;
    long unsigned int now;
    long unsigned int hist[4];
    char __data[0];
};

struct trace_event_raw_drm_vblank_event {
    struct trace_entry ent;
    int crtc;
    unsigned int seq;
    ktime_t time;
    bool high_prec;
    char __data[0];
};

struct trace_event_raw_drm_vblank_event_delivered {
    struct trace_entry ent;
    struct drm_file *file;
    int crtc;
    unsigned int seq;
    char __data[0];
};

struct trace_event_raw_drm_vblank_event_queued {
    struct trace_entry ent;
    struct drm_file *file;
    int crtc;
    unsigned int seq;
    char __data[0];
};

struct trace_event_raw_error_report_template {
    struct trace_entry ent;
    enum error_detector error_detector;
    long unsigned int id;
    char __data[0];
};

struct trace_event_raw_exit_mmap {
    struct trace_entry ent;
    struct mm_struct *mm;
    struct maple_tree *mt;
    char __data[0];
};

struct trace_event_raw_ext4__bitmap_load {
    struct trace_entry ent;
    dev_t dev;
    __u32 group;
    char __data[0];
};

struct trace_event_raw_ext4__es_extent {
    struct trace_entry ent;
    dev_t dev;
    ino_t ino;
    ext4_lblk_t lblk;
    ext4_lblk_t len;
    ext4_fsblk_t pblk;
    char status;
    char __data[0];
};

struct trace_event_raw_ext4__es_shrink_enter {
    struct trace_entry ent;
    dev_t dev;
    int nr_to_scan;
    int cache_cnt;
    char __data[0];
};

struct trace_event_raw_ext4__fallocate_mode {
    struct trace_entry ent;
    dev_t dev;
    ino_t ino;
    loff_t offset;
    loff_t len;
    int mode;
    char __data[0];
};

struct trace_event_raw_ext4__folio_op {
    struct trace_entry ent;
    dev_t dev;
    ino_t ino;
    long unsigned int index;
    char __data[0];
};

struct trace_event_raw_ext4__map_blocks_enter {
    struct trace_entry ent;
    dev_t dev;
    ino_t ino;
    ext4_lblk_t lblk;
    unsigned int len;
    unsigned int flags;
    char __data[0];
};

struct trace_event_raw_ext4__map_blocks_exit {
    struct trace_entry ent;
    dev_t dev;
    ino_t ino;
    unsigned int flags;
    ext4_fsblk_t pblk;
    ext4_lblk_t lblk;
    unsigned int len;
    unsigned int mflags;
    int ret;
    char __data[0];
};

struct trace_event_raw_ext4__mb_new_pa {
    struct trace_entry ent;
    dev_t dev;
    ino_t ino;
    __u64 pa_pstart;
    __u64 pa_lstart;
    __u32 pa_len;
    char __data[0];
};

struct trace_event_raw_ext4__mballoc {
    struct trace_entry ent;
    dev_t dev;
    ino_t ino;
    int result_start;
    __u32 result_group;
    int result_len;
    char __data[0];
};

struct trace_event_raw_ext4__trim {
    struct trace_entry ent;
    int dev_major;
    int dev_minor;
    __u32 group;
    int start;
    int len;
    char __data[0];
};

struct trace_event_raw_ext4__truncate {
    struct trace_entry ent;
    dev_t dev;
    ino_t ino;
    __u64 blocks;
    char __data[0];
};

struct trace_event_raw_ext4__write_begin {
    struct trace_entry ent;
    dev_t dev;
    ino_t ino;
    loff_t pos;
    unsigned int len;
    char __data[0];
};

struct trace_event_raw_ext4__write_end {
    struct trace_entry ent;
    dev_t dev;
    ino_t ino;
    loff_t pos;
    unsigned int len;
    unsigned int copied;
    char __data[0];
};

struct trace_event_raw_ext4_alloc_da_blocks {
    struct trace_entry ent;
    dev_t dev;
    ino_t ino;
    unsigned int data_blocks;
    char __data[0];
};

struct trace_event_raw_ext4_allocate_blocks {
    struct trace_entry ent;
    dev_t dev;
    ino_t ino;
    __u64 block;
    unsigned int len;
    __u32 logical;
    __u32 lleft;
    __u32 lright;
    __u64 goal;
    __u64 pleft;
    __u64 pright;
    unsigned int flags;
    char __data[0];
};

struct trace_event_raw_ext4_allocate_inode {
    struct trace_entry ent;
    dev_t dev;
    ino_t ino;
    ino_t dir;
    __u16 mode;
    char __data[0];
};

struct trace_event_raw_ext4_begin_ordered_truncate {
    struct trace_entry ent;
    dev_t dev;
    ino_t ino;
    loff_t new_size;
    char __data[0];
};

struct trace_event_raw_ext4_collapse_range {
    struct trace_entry ent;
    dev_t dev;
    ino_t ino;
    loff_t offset;
    loff_t len;
    char __data[0];
};

struct trace_event_raw_ext4_da_release_space {
    struct trace_entry ent;
    dev_t dev;
    ino_t ino;
    __u64 i_blocks;
    int freed_blocks;
    int reserved_data_blocks;
    __u16 mode;
    char __data[0];
};

struct trace_event_raw_ext4_da_reserve_space {
    struct trace_entry ent;
    dev_t dev;
    ino_t ino;
    __u64 i_blocks;
    int reserve_blocks;
    int reserved_data_blocks;
    __u16 mode;
    char __data[0];
};

struct trace_event_raw_ext4_da_update_reserve_space {
    struct trace_entry ent;
    dev_t dev;
    ino_t ino;
    __u64 i_blocks;
    int used_blocks;
    int reserved_data_blocks;
    int quota_claim;
    __u16 mode;
    char __data[0];
};

struct trace_event_raw_ext4_da_write_pages {
    struct trace_entry ent;
    dev_t dev;
    ino_t ino;
    long unsigned int first_page;
    long int nr_to_write;
    int sync_mode;
    char __data[0];
};

struct trace_event_raw_ext4_da_write_pages_extent {
    struct trace_entry ent;
    dev_t dev;
    ino_t ino;
    __u64 lblk;
    __u32 len;
    __u32 flags;
    char __data[0];
};

struct trace_event_raw_ext4_discard_blocks {
    struct trace_entry ent;
    dev_t dev;
    __u64 blk;
    __u64 count;
    char __data[0];
};

struct trace_event_raw_ext4_discard_preallocations {
    struct trace_entry ent;
    dev_t dev;
    ino_t ino;
    unsigned int len;
    char __data[0];
};

struct trace_event_raw_ext4_drop_inode {
    struct trace_entry ent;
    dev_t dev;
    ino_t ino;
    int drop;
    char __data[0];
};

struct trace_event_raw_ext4_error {
    struct trace_entry ent;
    dev_t dev;
    const char *function;
    unsigned int line;
    char __data[0];
};

struct trace_event_raw_ext4_es_find_extent_range_enter {
    struct trace_entry ent;
    dev_t dev;
    ino_t ino;
    ext4_lblk_t lblk;
    char __data[0];
};

struct trace_event_raw_ext4_es_find_extent_range_exit {
    struct trace_entry ent;
    dev_t dev;
    ino_t ino;
    ext4_lblk_t lblk;
    ext4_lblk_t len;
    ext4_fsblk_t pblk;
    char status;
    char __data[0];
};

struct trace_event_raw_ext4_es_insert_delayed_extent {
    struct trace_entry ent;
    dev_t dev;
    ino_t ino;
    ext4_lblk_t lblk;
    ext4_lblk_t len;
    ext4_fsblk_t pblk;
    char status;
    bool lclu_allocated;
    bool end_allocated;
    char __data[0];
};

struct trace_event_raw_ext4_es_lookup_extent_enter {
    struct trace_entry ent;
    dev_t dev;
    ino_t ino;
    ext4_lblk_t lblk;
    char __data[0];
};

struct trace_event_raw_ext4_es_lookup_extent_exit {
    struct trace_entry ent;
    dev_t dev;
    ino_t ino;
    ext4_lblk_t lblk;
    ext4_lblk_t len;
    ext4_fsblk_t pblk;
    char status;
    int found;
    char __data[0];
};

struct trace_event_raw_ext4_es_remove_extent {
    struct trace_entry ent;
    dev_t dev;
    ino_t ino;
    loff_t lblk;
    loff_t len;
    char __data[0];
};

struct trace_event_raw_ext4_es_shrink {
    struct trace_entry ent;
    dev_t dev;
    int nr_shrunk;
    long long unsigned int scan_time;
    int nr_skipped;
    int retried;
    char __data[0];
};

struct trace_event_raw_ext4_es_shrink_scan_exit {
    struct trace_entry ent;
    dev_t dev;
    int nr_shrunk;
    int cache_cnt;
    char __data[0];
};

struct trace_event_raw_ext4_evict_inode {
    struct trace_entry ent;
    dev_t dev;
    ino_t ino;
    int nlink;
    char __data[0];
};

struct trace_event_raw_ext4_ext_convert_to_initialized_enter {
    struct trace_entry ent;
    dev_t dev;
    ino_t ino;
    ext4_lblk_t m_lblk;
    unsigned int m_len;
    ext4_lblk_t u_lblk;
    unsigned int u_len;
    ext4_fsblk_t u_pblk;
    char __data[0];
};

struct trace_event_raw_ext4_ext_convert_to_initialized_fastpath {
    struct trace_entry ent;
    dev_t dev;
    ino_t ino;
    ext4_lblk_t m_lblk;
    unsigned int m_len;
    ext4_lblk_t u_lblk;
    unsigned int u_len;
    ext4_fsblk_t u_pblk;
    ext4_lblk_t i_lblk;
    unsigned int i_len;
    ext4_fsblk_t i_pblk;
    char __data[0];
};

struct trace_event_raw_ext4_ext_handle_unwritten_extents {
    struct trace_entry ent;
    dev_t dev;
    ino_t ino;
    int flags;
    ext4_lblk_t lblk;
    ext4_fsblk_t pblk;
    unsigned int len;
    unsigned int allocated;
    ext4_fsblk_t newblk;
    char __data[0];
};

struct trace_event_raw_ext4_ext_load_extent {
    struct trace_entry ent;
    dev_t dev;
    ino_t ino;
    ext4_fsblk_t pblk;
    ext4_lblk_t lblk;
    char __data[0];
};

struct trace_event_raw_ext4_ext_remove_space {
    struct trace_entry ent;
    dev_t dev;
    ino_t ino;
    ext4_lblk_t start;
    ext4_lblk_t end;
    int depth;
    char __data[0];
};

struct trace_event_raw_ext4_ext_remove_space_done {
    struct trace_entry ent;
    dev_t dev;
    ino_t ino;
    ext4_lblk_t start;
    ext4_lblk_t end;
    int depth;
    ext4_fsblk_t pc_pclu;
    ext4_lblk_t pc_lblk;
    int pc_state;
    short unsigned int eh_entries;
    char __data[0];
};

struct trace_event_raw_ext4_ext_rm_idx {
    struct trace_entry ent;
    dev_t dev;
    ino_t ino;
    ext4_fsblk_t pblk;
    char __data[0];
};

struct trace_event_raw_ext4_ext_rm_leaf {
    struct trace_entry ent;
    dev_t dev;
    ino_t ino;
    ext4_lblk_t start;
    ext4_lblk_t ee_lblk;
    ext4_fsblk_t ee_pblk;
    short int ee_len;
    ext4_fsblk_t pc_pclu;
    ext4_lblk_t pc_lblk;
    int pc_state;
    char __data[0];
};

struct trace_event_raw_ext4_ext_show_extent {
    struct trace_entry ent;
    dev_t dev;
    ino_t ino;
    ext4_fsblk_t pblk;
    ext4_lblk_t lblk;
    short unsigned int len;
    char __data[0];
};

struct trace_event_raw_ext4_fallocate_exit {
    struct trace_entry ent;
    dev_t dev;
    ino_t ino;
    loff_t pos;
    unsigned int blocks;
    int ret;
    char __data[0];
};

struct trace_event_raw_ext4_fc_cleanup {
    struct trace_entry ent;
    dev_t dev;
    int j_fc_off;
    int full;
    tid_t tid;
    char __data[0];
};

struct trace_event_raw_ext4_fc_commit_start {
    struct trace_entry ent;
    dev_t dev;
    tid_t tid;
    char __data[0];
};

struct trace_event_raw_ext4_fc_commit_stop {
    struct trace_entry ent;
    dev_t dev;
    int nblks;
    int reason;
    int num_fc;
    int num_fc_ineligible;
    int nblks_agg;
    tid_t tid;
    char __data[0];
};

struct trace_event_raw_ext4_fc_replay {
    struct trace_entry ent;
    dev_t dev;
    int tag;
    int ino;
    int priv1;
    int priv2;
    char __data[0];
};

struct trace_event_raw_ext4_fc_replay_scan {
    struct trace_entry ent;
    dev_t dev;
    int error;
    int off;
    char __data[0];
};

struct trace_event_raw_ext4_fc_stats {
    struct trace_entry ent;
    dev_t dev;
    unsigned int fc_ineligible_rc[10];
    long unsigned int fc_commits;
    long unsigned int fc_ineligible_commits;
    long unsigned int fc_numblks;
    char __data[0];
};

struct trace_event_raw_ext4_fc_track_dentry {
    struct trace_entry ent;
    dev_t dev;
    tid_t t_tid;
    ino_t i_ino;
    tid_t i_sync_tid;
    int error;
    char __data[0];
};

struct trace_event_raw_ext4_fc_track_inode {
    struct trace_entry ent;
    dev_t dev;
    tid_t t_tid;
    ino_t i_ino;
    tid_t i_sync_tid;
    int error;
    char __data[0];
};

struct trace_event_raw_ext4_fc_track_range {
    struct trace_entry ent;
    dev_t dev;
    tid_t t_tid;
    ino_t i_ino;
    tid_t i_sync_tid;
    long int start;
    long int end;
    int error;
    char __data[0];
};

struct trace_event_raw_ext4_forget {
    struct trace_entry ent;
    dev_t dev;
    ino_t ino;
    __u64 block;
    int is_metadata;
    __u16 mode;
    char __data[0];
};

struct trace_event_raw_ext4_free_blocks {
    struct trace_entry ent;
    dev_t dev;
    ino_t ino;
    __u64 block;
    long unsigned int count;
    int flags;
    __u16 mode;
    char __data[0];
};

struct trace_event_raw_ext4_free_inode {
    struct trace_entry ent;
    dev_t dev;
    ino_t ino;
    uid_t uid;
    gid_t gid;
    __u64 blocks;
    __u16 mode;
    char __data[0];
};

struct trace_event_raw_ext4_fsmap_class {
    struct trace_entry ent;
    dev_t dev;
    dev_t keydev;
    u32 agno;
    u64 bno;
    u64 len;
    u64 owner;
    char __data[0];
};

struct trace_event_raw_ext4_get_implied_cluster_alloc_exit {
    struct trace_entry ent;
    dev_t dev;
    unsigned int flags;
    ext4_lblk_t lblk;
    ext4_fsblk_t pblk;
    unsigned int len;
    int ret;
    char __data[0];
};

struct trace_event_raw_ext4_getfsmap_class {
    struct trace_entry ent;
    dev_t dev;
    dev_t keydev;
    u64 block;
    u64 len;
    u64 owner;
    u64 flags;
    char __data[0];
};

struct trace_event_raw_ext4_insert_range {
    struct trace_entry ent;
    dev_t dev;
    ino_t ino;
    loff_t offset;
    loff_t len;
    char __data[0];
};

struct trace_event_raw_ext4_invalidate_folio_op {
    struct trace_entry ent;
    dev_t dev;
    ino_t ino;
    long unsigned int index;
    size_t offset;
    size_t length;
    char __data[0];
};

struct trace_event_raw_ext4_journal_start_inode {
    struct trace_entry ent;
    long unsigned int ino;
    dev_t dev;
    long unsigned int ip;
    int blocks;
    int rsv_blocks;
    int revoke_creds;
    int type;
    char __data[0];
};

struct trace_event_raw_ext4_journal_start_reserved {
    struct trace_entry ent;
    dev_t dev;
    long unsigned int ip;
    int blocks;
    char __data[0];
};

struct trace_event_raw_ext4_journal_start_sb {
    struct trace_entry ent;
    dev_t dev;
    long unsigned int ip;
    int blocks;
    int rsv_blocks;
    int revoke_creds;
    int type;
    char __data[0];
};

struct trace_event_raw_ext4_lazy_itable_init {
    struct trace_entry ent;
    dev_t dev;
    __u32 group;
    char __data[0];
};

struct trace_event_raw_ext4_load_inode {
    struct trace_entry ent;
    dev_t dev;
    ino_t ino;
    char __data[0];
};

struct trace_event_raw_ext4_mark_inode_dirty {
    struct trace_entry ent;
    dev_t dev;
    ino_t ino;
    long unsigned int ip;
    char __data[0];
};

struct trace_event_raw_ext4_mb_discard_preallocations {
    struct trace_entry ent;
    dev_t dev;
    int needed;
    char __data[0];
};

struct trace_event_raw_ext4_mb_release_group_pa {
    struct trace_entry ent;
    dev_t dev;
    __u64 pa_pstart;
    __u32 pa_len;
    char __data[0];
};

struct trace_event_raw_ext4_mb_release_inode_pa {
    struct trace_entry ent;
    dev_t dev;
    ino_t ino;
    __u64 block;
    __u32 count;
    char __data[0];
};

struct trace_event_raw_ext4_mballoc_alloc {
    struct trace_entry ent;
    dev_t dev;
    ino_t ino;
    __u32 orig_logical;
    int orig_start;
    __u32 orig_group;
    int orig_len;
    __u32 goal_logical;
    int goal_start;
    __u32 goal_group;
    int goal_len;
    __u32 result_logical;
    int result_start;
    __u32 result_group;
    int result_len;
    __u16 found;
    __u16 groups;
    __u16 buddy;
    __u16 flags;
    __u16 tail;
    __u8 cr;
    char __data[0];
};

struct trace_event_raw_ext4_mballoc_prealloc {
    struct trace_entry ent;
    dev_t dev;
    ino_t ino;
    __u32 orig_logical;
    int orig_start;
    __u32 orig_group;
    int orig_len;
    __u32 result_logical;
    int result_start;
    __u32 result_group;
    int result_len;
    char __data[0];
};

struct trace_event_raw_ext4_nfs_commit_metadata {
    struct trace_entry ent;
    dev_t dev;
    ino_t ino;
    char __data[0];
};

struct trace_event_raw_ext4_other_inode_update_time {
    struct trace_entry ent;
    dev_t dev;
    ino_t ino;
    ino_t orig_ino;
    uid_t uid;
    gid_t gid;
    __u16 mode;
    char __data[0];
};

struct trace_event_raw_ext4_prefetch_bitmaps {
    struct trace_entry ent;
    dev_t dev;
    __u32 group;
    __u32 next;
    __u32 ios;
    char __data[0];
};

struct trace_event_raw_ext4_read_block_bitmap_load {
    struct trace_entry ent;
    dev_t dev;
    __u32 group;
    bool prefetch;
    char __data[0];
};

struct trace_event_raw_ext4_remove_blocks {
    struct trace_entry ent;
    dev_t dev;
    ino_t ino;
    ext4_lblk_t from;
    ext4_lblk_t to;
    ext4_fsblk_t ee_pblk;
    ext4_lblk_t ee_lblk;
    short unsigned int ee_len;
    ext4_fsblk_t pc_pclu;
    ext4_lblk_t pc_lblk;
    int pc_state;
    char __data[0];
};

struct trace_event_raw_ext4_request_blocks {
    struct trace_entry ent;
    dev_t dev;
    ino_t ino;
    unsigned int len;
    __u32 logical;
    __u32 lleft;
    __u32 lright;
    __u64 goal;
    __u64 pleft;
    __u64 pright;
    unsigned int flags;
    char __data[0];
};

struct trace_event_raw_ext4_request_inode {
    struct trace_entry ent;
    dev_t dev;
    ino_t dir;
    __u16 mode;
    char __data[0];
};

struct trace_event_raw_ext4_shutdown {
    struct trace_entry ent;
    dev_t dev;
    unsigned int flags;
    char __data[0];
};

struct trace_event_raw_ext4_sync_file_enter {
    struct trace_entry ent;
    dev_t dev;
    ino_t ino;
    ino_t parent;
    int datasync;
    char __data[0];
};

struct trace_event_raw_ext4_sync_file_exit {
    struct trace_entry ent;
    dev_t dev;
    ino_t ino;
    int ret;
    char __data[0];
};

struct trace_event_raw_ext4_sync_fs {
    struct trace_entry ent;
    dev_t dev;
    int wait;
    char __data[0];
};

struct trace_event_raw_ext4_unlink_enter {
    struct trace_entry ent;
    dev_t dev;
    ino_t ino;
    ino_t parent;
    loff_t size;
    char __data[0];
};

struct trace_event_raw_ext4_unlink_exit {
    struct trace_entry ent;
    dev_t dev;
    ino_t ino;
    int ret;
    char __data[0];
};

struct trace_event_raw_ext4_update_sb {
    struct trace_entry ent;
    dev_t dev;
    ext4_fsblk_t fsblk;
    unsigned int flags;
    char __data[0];
};

struct trace_event_raw_ext4_writepages {
    struct trace_entry ent;
    dev_t dev;
    ino_t ino;
    long int nr_to_write;
    long int pages_skipped;
    loff_t range_start;
    loff_t range_end;
    long unsigned int writeback_index;
    int sync_mode;
    char for_kupdate;
    char range_cyclic;
    char __data[0];
};

struct trace_event_raw_ext4_writepages_result {
    struct trace_entry ent;
    dev_t dev;
    ino_t ino;
    int ret;
    int pages_written;
    long int pages_skipped;
    long unsigned int writeback_index;
    int sync_mode;
    char __data[0];
};

struct trace_event_raw_fdb_delete {
    struct trace_entry ent;
    u32 __data_loc_br_dev;
    u32 __data_loc_dev;
    unsigned char addr[6];
    u16 vid;
    char __data[0];
};

struct trace_event_raw_fib6_table_lookup {
    struct trace_entry ent;
    u32 tb_id;
    int err;
    int oif;
    int iif;
    u32 flowlabel;
    __u8 tos;
    __u8 scope;
    __u8 flags;
    __u8 src[16];
    __u8 dst[16];
    u16 sport;
    u16 dport;
    u8 proto;
    u8 rt_type;
    char name[16];
    __u8 gw[16];
    char __data[0];
};

struct trace_event_raw_fib_table_lookup {
    struct trace_entry ent;
    u32 tb_id;
    int err;
    int oif;
    int iif;
    u8 proto;
    __u8 tos;
    __u8 scope;
    __u8 flags;
    __u8 src[4];
    __u8 dst[4];
    __u8 gw4[4];
    __u8 gw6[16];
    u16 sport;
    u16 dport;
    char name[16];
    char __data[0];
};

struct trace_event_raw_file_check_and_advance_wb_err {
    struct trace_entry ent;
    struct file *file;
    long unsigned int i_ino;
    dev_t s_dev;
    errseq_t old;
    errseq_t new;
    char __data[0];
};

struct trace_event_raw_filelock_lease {
    struct trace_entry ent;
    struct file_lease *fl;
    long unsigned int i_ino;
    dev_t s_dev;
    struct file_lock_core *blocker;
    fl_owner_t owner;
    unsigned int flags;
    unsigned char type;
    long unsigned int break_time;
    long unsigned int downgrade_time;
    char __data[0];
};

struct trace_event_raw_filelock_lock {
    struct trace_entry ent;
    struct file_lock *fl;
    long unsigned int i_ino;
    dev_t s_dev;
    struct file_lock_core *blocker;
    fl_owner_t owner;
    unsigned int pid;
    unsigned int flags;
    unsigned char type;
    loff_t fl_start;
    loff_t fl_end;
    int ret;
    char __data[0];
};

struct trace_event_raw_filemap_set_wb_err {
    struct trace_entry ent;
    long unsigned int i_ino;
    dev_t s_dev;
    errseq_t errseq;
    char __data[0];
};

struct trace_event_raw_fill_mg_cmtime {
    struct trace_entry ent;
    dev_t dev;
    ino_t ino;
    time64_t ctime_s;
    time64_t mtime_s;
    u32 ctime_ns;
    u32 mtime_ns;
    u32 gen;
    char __data[0];
};

struct trace_event_raw_finish_task_reaping {
    struct trace_entry ent;
    int pid;
    char __data[0];
};

struct trace_event_raw_flush_foreign {
    struct trace_entry ent;
    char name[32];
    ino_t cgroup_ino;
    unsigned int frn_bdi_id;
    unsigned int frn_memcg_id;
    char __data[0];
};

struct trace_event_raw_free_vmap_area_noflush {
    struct trace_entry ent;
    long unsigned int va_start;
    long unsigned int nr_lazy;
    long unsigned int nr_lazy_max;
    char __data[0];
};

struct trace_event_raw_generic_add_lease {
    struct trace_entry ent;
    long unsigned int i_ino;
    int wcount;
    int rcount;
    int icount;
    dev_t s_dev;
    fl_owner_t owner;
    unsigned int flags;
    unsigned char type;
    char __data[0];
};

struct trace_event_raw_global_dirty_state {
    struct trace_entry ent;
    long unsigned int nr_dirty;
    long unsigned int nr_writeback;
    long unsigned int background_thresh;
    long unsigned int dirty_thresh;
    long unsigned int dirty_limit;
    long unsigned int nr_dirtied;
    long unsigned int nr_written;
    char __data[0];
};

struct trace_event_raw_gpio_direction {
    struct trace_entry ent;
    unsigned int gpio;
    int in;
    int err;
    char __data[0];
};

struct trace_event_raw_gpio_value {
    struct trace_entry ent;
    unsigned int gpio;
    int get;
    int value;
    char __data[0];
};

struct trace_event_raw_guest_halt_poll_ns {
    struct trace_entry ent;
    bool grow;
    unsigned int new;
    unsigned int old;
    char __data[0];
};

struct trace_event_raw_handshake_alert_class {
    struct trace_entry ent;
    __u8 saddr[28];
    __u8 daddr[28];
    unsigned int netns_ino;
    long unsigned int level;
    long unsigned int description;
    char __data[0];
};

struct trace_event_raw_handshake_complete {
    struct trace_entry ent;
    const void *req;
    const void *sk;
    int status;
    unsigned int netns_ino;
    char __data[0];
};

struct trace_event_raw_handshake_error_class {
    struct trace_entry ent;
    const void *req;
    const void *sk;
    int err;
    unsigned int netns_ino;
    char __data[0];
};

struct trace_event_raw_handshake_event_class {
    struct trace_entry ent;
    const void *req;
    const void *sk;
    unsigned int netns_ino;
    char __data[0];
};

struct trace_event_raw_handshake_fd_class {
    struct trace_entry ent;
    const void *req;
    const void *sk;
    int fd;
    unsigned int netns_ino;
    char __data[0];
};

struct trace_event_raw_hrtimer_class {
    struct trace_entry ent;
    void *hrtimer;
    char __data[0];
};

struct trace_event_raw_hrtimer_expire_entry {
    struct trace_entry ent;
    void *hrtimer;
    s64 now;
    void *function;
    char __data[0];
};

struct trace_event_raw_hrtimer_init {
    struct trace_entry ent;
    void *hrtimer;
    clockid_t clockid;
    enum hrtimer_mode mode;
    char __data[0];
};

struct trace_event_raw_hrtimer_start {
    struct trace_entry ent;
    void *hrtimer;
    void *function;
    s64 expires;
    s64 softexpires;
    enum hrtimer_mode mode;
    char __data[0];
};

struct trace_event_raw_hugepage_set {
    struct trace_entry ent;
    long unsigned int addr;
    long unsigned int pte;
    char __data[0];
};

struct trace_event_raw_hugepage_update {
    struct trace_entry ent;
    long unsigned int addr;
    long unsigned int pte;
    long unsigned int clr;
    long unsigned int set;
    char __data[0];
};

struct trace_event_raw_hugetlbfs__inode {
    struct trace_entry ent;
    dev_t dev;
    ino_t ino;
    __u16 mode;
    loff_t size;
    unsigned int nlink;
    unsigned int seals;
    blkcnt_t blocks;
    char __data[0];
};

struct trace_event_raw_hugetlbfs_alloc_inode {
    struct trace_entry ent;
    dev_t dev;
    ino_t ino;
    ino_t dir;
    __u16 mode;
    char __data[0];
};

struct trace_event_raw_hugetlbfs_fallocate {
    struct trace_entry ent;
    dev_t dev;
    ino_t ino;
    int mode;
    loff_t offset;
    loff_t len;
    loff_t size;
    int ret;
    char __data[0];
};

struct trace_event_raw_hugetlbfs_setattr {
    struct trace_entry ent;
    dev_t dev;
    ino_t ino;
    unsigned int d_len;
    u32 __data_loc_d_name;
    unsigned int ia_valid;
    unsigned int ia_mode;
    loff_t old_size;
    loff_t ia_size;
    char __data[0];
};

struct trace_event_raw_hw_pressure_update {
    struct trace_entry ent;
    long unsigned int hw_pressure;
    int cpu;
    char __data[0];
};

struct trace_event_raw_hwmon_attr_class {
    struct trace_entry ent;
    int index;
    u32 __data_loc_attr_name;
    long int val;
    char __data[0];
};

struct trace_event_raw_hwmon_attr_show_string {
    struct trace_entry ent;
    int index;
    u32 __data_loc_attr_name;
    u32 __data_loc_label;
    char __data[0];
};

struct trace_event_raw_i2c_read {
    struct trace_entry ent;
    int adapter_nr;
    __u16 msg_nr;
    __u16 addr;
    __u16 flags;
    __u16 len;
    char __data[0];
};

struct trace_event_raw_i2c_reply {
    struct trace_entry ent;
    int adapter_nr;
    __u16 msg_nr;
    __u16 addr;
    __u16 flags;
    __u16 len;
    u32 __data_loc_buf;
    char __data[0];
};

struct trace_event_raw_i2c_result {
    struct trace_entry ent;
    int adapter_nr;
    __u16 nr_msgs;
    __s16 ret;
    char __data[0];
};

struct trace_event_raw_i2c_slave {
    struct trace_entry ent;
    int adapter_nr;
    int ret;
    __u16 addr;
    __u16 len;
    enum i2c_slave_event event;
    __u8 buf[1];
    char __data[0];
};

struct trace_event_raw_i2c_write {
    struct trace_entry ent;
    int adapter_nr;
    __u16 msg_nr;
    __u16 addr;
    __u16 flags;
    __u16 len;
    u32 __data_loc_buf;
    char __data[0];
};

struct trace_event_raw_icmp_send {
    struct trace_entry ent;
    const void *skbaddr;
    int type;
    int code;
    __u8 saddr[4];
    __u8 daddr[4];
    __u16 sport;
    __u16 dport;
    short unsigned int ulen;
    char __data[0];
};

struct trace_event_raw_inet_sk_error_report {
    struct trace_entry ent;
    int error;
    __u16 sport;
    __u16 dport;
    __u16 family;
    __u16 protocol;
    __u8 saddr[4];
    __u8 daddr[4];
    __u8 saddr_v6[16];
    __u8 daddr_v6[16];
    char __data[0];
};

struct trace_event_raw_inet_sock_set_state {
    struct trace_entry ent;
    const void *skaddr;
    int oldstate;
    int newstate;
    __u16 sport;
    __u16 dport;
    __u16 family;
    __u16 protocol;
    __u8 saddr[4];
    __u8 daddr[4];
    __u8 saddr_v6[16];
    __u8 daddr_v6[16];
    char __data[0];
};

typedef int (*initcall_t)(void);

struct trace_event_raw_initcall_finish {
    struct trace_entry ent;
    initcall_t func;
    int ret;
    char __data[0];
};

struct trace_event_raw_initcall_level {
    struct trace_entry ent;
    u32 __data_loc_level;
    char __data[0];
};

struct trace_event_raw_initcall_start {
    struct trace_entry ent;
    initcall_t func;
    char __data[0];
};

struct trace_event_raw_inode_foreign_history {
    struct trace_entry ent;
    char name[32];
    ino_t ino;
    ino_t cgroup_ino;
    unsigned int history;
    char __data[0];
};

struct trace_event_raw_inode_switch_wbs {
    struct trace_entry ent;
    char name[32];
    ino_t ino;
    ino_t old_cgroup_ino;
    ino_t new_cgroup_ino;
    char __data[0];
};

struct trace_event_raw_instruction_emulation {
    struct trace_entry ent;
    u32 __data_loc_instr;
    u64 addr;
    char __data[0];
};

struct trace_event_raw_io_uring_complete {
    struct trace_entry ent;
    void *ctx;
    void *req;
    u64 user_data;
    int res;
    unsigned int cflags;
    u64 extra1;
    u64 extra2;
    char __data[0];
};

struct trace_event_raw_io_uring_cqe_overflow {
    struct trace_entry ent;
    void *ctx;
    long long unsigned int user_data;
    s32 res;
    u32 cflags;
    void *ocqe;
    char __data[0];
};

struct trace_event_raw_io_uring_cqring_wait {
    struct trace_entry ent;
    void *ctx;
    int min_events;
    char __data[0];
};

struct trace_event_raw_io_uring_create {
    struct trace_entry ent;
    int fd;
    void *ctx;
    u32 sq_entries;
    u32 cq_entries;
    u32 flags;
    char __data[0];
};

struct trace_event_raw_io_uring_defer {
    struct trace_entry ent;
    void *ctx;
    void *req;
    long long unsigned int data;
    u8 opcode;
    u32 __data_loc_op_str;
    char __data[0];
};

struct trace_event_raw_io_uring_fail_link {
    struct trace_entry ent;
    void *ctx;
    void *req;
    long long unsigned int user_data;
    u8 opcode;
    void *link;
    u32 __data_loc_op_str;
    char __data[0];
};

struct trace_event_raw_io_uring_file_get {
    struct trace_entry ent;
    void *ctx;
    void *req;
    u64 user_data;
    int fd;
    char __data[0];
};

struct trace_event_raw_io_uring_link {
    struct trace_entry ent;
    void *ctx;
    void *req;
    void *target_req;
    char __data[0];
};

struct trace_event_raw_io_uring_local_work_run {
    struct trace_entry ent;
    void *ctx;
    int count;
    unsigned int loops;
    char __data[0];
};

struct trace_event_raw_io_uring_poll_arm {
    struct trace_entry ent;
    void *ctx;
    void *req;
    long long unsigned int user_data;
    u8 opcode;
    int mask;
    int events;
    u32 __data_loc_op_str;
    char __data[0];
};

struct trace_event_raw_io_uring_queue_async_work {
    struct trace_entry ent;
    void *ctx;
    void *req;
    u64 user_data;
    u8 opcode;
    long long unsigned int flags;
    struct io_wq_work *work;
    int rw;
    u32 __data_loc_op_str;
    char __data[0];
};

struct trace_event_raw_io_uring_register {
    struct trace_entry ent;
    void *ctx;
    unsigned int opcode;
    unsigned int nr_files;
    unsigned int nr_bufs;
    long int ret;
    char __data[0];
};

struct trace_event_raw_io_uring_req_failed {
    struct trace_entry ent;
    void *ctx;
    void *req;
    long long unsigned int user_data;
    u8 opcode;
    u8 flags;
    u8 ioprio;
    u64 off;
    u64 addr;
    u32 len;
    u32 op_flags;
    u16 buf_index;
    u16 personality;
    u32 file_index;
    u64 pad1;
    u64 addr3;
    int error;
    u32 __data_loc_op_str;
    char __data[0];
};

struct trace_event_raw_io_uring_short_write {
    struct trace_entry ent;
    void *ctx;
    u64 fpos;
    u64 wanted;
    u64 got;
    char __data[0];
};

struct trace_event_raw_io_uring_submit_req {
    struct trace_entry ent;
    void *ctx;
    void *req;
    long long unsigned int user_data;
    u8 opcode;
    long long unsigned int flags;
    bool sq_thread;
    u32 __data_loc_op_str;
    char __data[0];
};

struct trace_event_raw_io_uring_task_add {
    struct trace_entry ent;
    void *ctx;
    void *req;
    long long unsigned int user_data;
    u8 opcode;
    int mask;
    u32 __data_loc_op_str;
    char __data[0];
};

struct trace_event_raw_io_uring_task_work_run {
    struct trace_entry ent;
    void *tctx;
    unsigned int count;
    char __data[0];
};

struct trace_event_raw_iomap_class {
    struct trace_entry ent;
    dev_t dev;
    u64 ino;
    u64 addr;
    loff_t offset;
    u64 length;
    u16 type;
    u16 flags;
    dev_t bdev;
    char __data[0];
};

struct trace_event_raw_iomap_dio_complete {
    struct trace_entry ent;
    dev_t dev;
    ino_t ino;
    loff_t isize;
    loff_t pos;
    int ki_flags;
    bool aio;
    int error;
    ssize_t ret;
    char __data[0];
};

struct trace_event_raw_iomap_dio_rw_begin {
    struct trace_entry ent;
    dev_t dev;
    ino_t ino;
    loff_t isize;
    loff_t pos;
    size_t count;
    size_t done_before;
    int ki_flags;
    unsigned int dio_flags;
    bool aio;
    char __data[0];
};

struct trace_event_raw_iomap_iter {
    struct trace_entry ent;
    dev_t dev;
    u64 ino;
    loff_t pos;
    u64 length;
    s64 processed;
    unsigned int flags;
    const void *ops;
    long unsigned int caller;
    char __data[0];
};

struct trace_event_raw_iomap_range_class {
    struct trace_entry ent;
    dev_t dev;
    u64 ino;
    loff_t size;
    loff_t offset;
    u64 length;
    char __data[0];
};

struct trace_event_raw_iomap_readpage_class {
    struct trace_entry ent;
    dev_t dev;
    u64 ino;
    int nr_pages;
    char __data[0];
};

struct trace_event_raw_iomap_writepage_map {
    struct trace_entry ent;
    dev_t dev;
    u64 ino;
    u64 pos;
    u64 dirty_len;
    u64 addr;
    loff_t offset;
    u64 length;
    u16 type;
    u16 flags;
    dev_t bdev;
    char __data[0];
};

struct trace_event_raw_iommu_device_event {
    struct trace_entry ent;
    u32 __data_loc_device;
    char __data[0];
};

struct trace_event_raw_iommu_error {
    struct trace_entry ent;
    u32 __data_loc_device;
    u32 __data_loc_driver;
    u64 iova;
    int flags;
    char __data[0];
};

struct trace_event_raw_iommu_group_event {
    struct trace_entry ent;
    int gid;
    u32 __data_loc_device;
    char __data[0];
};

struct trace_event_raw_ipi_handler {
    struct trace_entry ent;
    const char *reason;
    char __data[0];
};

struct trace_event_raw_ipi_raise {
    struct trace_entry ent;
    u32 __data_loc_target_cpus;
    const char *reason;
    char __data[0];
};

struct trace_event_raw_ipi_send_cpu {
    struct trace_entry ent;
    unsigned int cpu;
    void *callsite;
    void *callback;
    char __data[0];
};

struct trace_event_raw_ipi_send_cpumask {
    struct trace_entry ent;
    u32 __data_loc_cpumask;
    void *callsite;
    void *callback;
    char __data[0];
};

struct trace_event_raw_irq_handler_entry {
    struct trace_entry ent;
    int irq;
    u32 __data_loc_name;
    char __data[0];
};

struct trace_event_raw_irq_handler_exit {
    struct trace_entry ent;
    int irq;
    int ret;
    char __data[0];
};

struct trace_event_raw_itimer_expire {
    struct trace_entry ent;
    int which;
    pid_t pid;
    long long unsigned int now;
    char __data[0];
};

struct trace_event_raw_itimer_state {
    struct trace_entry ent;
    int which;
    long long unsigned int expires;
    long int value_sec;
    long int value_nsec;
    long int interval_sec;
    long int interval_nsec;
    char __data[0];
};

struct trace_event_raw_jbd2_checkpoint {
    struct trace_entry ent;
    dev_t dev;
    int result;
    char __data[0];
};

struct trace_event_raw_jbd2_checkpoint_stats {
    struct trace_entry ent;
    dev_t dev;
    tid_t tid;
    long unsigned int chp_time;
    __u32 forced_to_close;
    __u32 written;
    __u32 dropped;
    char __data[0];
};

struct trace_event_raw_jbd2_commit {
    struct trace_entry ent;
    dev_t dev;
    char sync_commit;
    tid_t transaction;
    char __data[0];
};

struct trace_event_raw_jbd2_end_commit {
    struct trace_entry ent;
    dev_t dev;
    char sync_commit;
    tid_t transaction;
    tid_t head;
    char __data[0];
};

struct trace_event_raw_jbd2_handle_extend {
    struct trace_entry ent;
    dev_t dev;
    tid_t tid;
    unsigned int type;
    unsigned int line_no;
    int buffer_credits;
    int requested_blocks;
    char __data[0];
};

struct trace_event_raw_jbd2_handle_start_class {
    struct trace_entry ent;
    dev_t dev;
    tid_t tid;
    unsigned int type;
    unsigned int line_no;
    int requested_blocks;
    char __data[0];
};

struct trace_event_raw_jbd2_handle_stats {
    struct trace_entry ent;
    dev_t dev;
    tid_t tid;
    unsigned int type;
    unsigned int line_no;
    int interval;
    int sync;
    int requested_blocks;
    int dirtied_blocks;
    char __data[0];
};

struct trace_event_raw_jbd2_journal_shrink {
    struct trace_entry ent;
    dev_t dev;
    long unsigned int nr_to_scan;
    long unsigned int count;
    char __data[0];
};

struct trace_event_raw_jbd2_lock_buffer_stall {
    struct trace_entry ent;
    dev_t dev;
    long unsigned int stall_ms;
    char __data[0];
};

struct trace_event_raw_jbd2_run_stats {
    struct trace_entry ent;
    dev_t dev;
    tid_t tid;
    long unsigned int wait;
    long unsigned int request_delay;
    long unsigned int running;
    long unsigned int locked;
    long unsigned int flushing;
    long unsigned int logging;
    __u32 handle_count;
    __u32 blocks;
    __u32 blocks_logged;
    char __data[0];
};

struct trace_event_raw_jbd2_shrink_checkpoint_list {
    struct trace_entry ent;
    dev_t dev;
    tid_t first_tid;
    tid_t tid;
    tid_t last_tid;
    long unsigned int nr_freed;
    tid_t next_tid;
    char __data[0];
};

struct trace_event_raw_jbd2_shrink_scan_exit {
    struct trace_entry ent;
    dev_t dev;
    long unsigned int nr_to_scan;
    long unsigned int nr_shrunk;
    long unsigned int count;
    char __data[0];
};

struct trace_event_raw_jbd2_submit_inode_data {
    struct trace_entry ent;
    dev_t dev;
    ino_t ino;
    char __data[0];
};

struct trace_event_raw_jbd2_update_log_tail {
    struct trace_entry ent;
    dev_t dev;
    tid_t tail_sequence;
    tid_t first_tid;
    long unsigned int block_nr;
    long unsigned int freed;
    char __data[0];
};

struct trace_event_raw_jbd2_write_superblock {
    struct trace_entry ent;
    dev_t dev;
    blk_opf_t write_flags;
    char __data[0];
};

struct trace_event_raw_kcompactd_wake_template {
    struct trace_entry ent;
    int nid;
    int order;
    enum zone_type highest_zoneidx;
    char __data[0];
};

struct trace_event_raw_kfree {
    struct trace_entry ent;
    long unsigned int call_site;
    const void *ptr;
    char __data[0];
};

struct trace_event_raw_kfree_skb {
    struct trace_entry ent;
    void *skbaddr;
    void *location;
    void *rx_sk;
    short unsigned int protocol;
    enum skb_drop_reason reason;
    char __data[0];
};

struct trace_event_raw_kmalloc {
    struct trace_entry ent;
    long unsigned int call_site;
    const void *ptr;
    size_t bytes_req;
    size_t bytes_alloc;
    long unsigned int gfp_flags;
    int node;
    char __data[0];
};

struct trace_event_raw_kmem_cache_alloc {
    struct trace_entry ent;
    long unsigned int call_site;
    const void *ptr;
    size_t bytes_req;
    size_t bytes_alloc;
    long unsigned int gfp_flags;
    int node;
    bool accounted;
    char __data[0];
};

struct trace_event_raw_kmem_cache_free {
    struct trace_entry ent;
    long unsigned int call_site;
    const void *ptr;
    u32 __data_loc_name;
    char __data[0];
};

struct trace_event_raw_kvm_access_fault {
    struct trace_entry ent;
    long unsigned int ipa;
    char __data[0];
};

struct trace_event_raw_kvm_ack_irq {
    struct trace_entry ent;
    unsigned int irqchip;
    unsigned int pin;
    char __data[0];
};

struct trace_event_raw_kvm_age_hva {
    struct trace_entry ent;
    long unsigned int start;
    long unsigned int end;
    char __data[0];
};

struct trace_event_raw_kvm_arm_set_dreg32 {
    struct trace_entry ent;
    const char *name;
    __u64 value;
    char __data[0];
};

struct trace_event_raw_kvm_dirty_ring_exit {
    struct trace_entry ent;
    int vcpu_id;
    char __data[0];
};

struct trace_event_raw_kvm_dirty_ring_push {
    struct trace_entry ent;
    int index;
    u32 dirty_index;
    u32 reset_index;
    u32 slot;
    u64 offset;
    char __data[0];
};

struct trace_event_raw_kvm_dirty_ring_reset {
    struct trace_entry ent;
    int index;
    u32 dirty_index;
    u32 reset_index;
    char __data[0];
};

struct trace_event_raw_kvm_entry {
    struct trace_entry ent;
    long unsigned int vcpu_pc;
    char __data[0];
};

struct trace_event_raw_kvm_exit {
    struct trace_entry ent;
    int ret;
    unsigned int esr_ec;
    long unsigned int vcpu_pc;
    char __data[0];
};

struct trace_event_raw_kvm_forward_sysreg_trap {
    struct trace_entry ent;
    u64 pc;
    u32 sysreg;
    bool is_read;
    char __data[0];
};

struct trace_event_raw_kvm_fpu {
    struct trace_entry ent;
    u32 load;
    char __data[0];
};

struct trace_event_raw_kvm_get_timer_map {
    struct trace_entry ent;
    long unsigned int vcpu_id;
    int direct_vtimer;
    int direct_ptimer;
    int emul_vtimer;
    int emul_ptimer;
    char __data[0];
};

struct trace_event_raw_kvm_guest_fault {
    struct trace_entry ent;
    long unsigned int vcpu_pc;
    long unsigned int hsr;
    long unsigned int hxfar;
    long long unsigned int ipa;
    char __data[0];
};

struct trace_event_raw_kvm_halt_poll_ns {
    struct trace_entry ent;
    bool grow;
    unsigned int vcpu_id;
    unsigned int new;
    unsigned int old;
    char __data[0];
};

struct trace_event_raw_kvm_handle_sys_reg {
    struct trace_entry ent;
    long unsigned int hsr;
    char __data[0];
};

struct trace_event_raw_kvm_hvc_arm64 {
    struct trace_entry ent;
    long unsigned int vcpu_pc;
    long unsigned int r0;
    long unsigned int imm;
    char __data[0];
};

struct trace_event_raw_kvm_inject_nested_exception {
    struct trace_entry ent;
    struct kvm_vcpu *vcpu;
    long unsigned int esr_el2;
    int type;
    long unsigned int spsr_el2;
    long unsigned int pc;
    long unsigned int source_mode;
    long unsigned int hcr_el2;
    char __data[0];
};

struct trace_event_raw_kvm_iocsr {
    struct trace_entry ent;
    u32 type;
    u32 len;
    u64 gpa;
    u64 val;
    char __data[0];
};

struct trace_event_raw_kvm_irq_line {
    struct trace_entry ent;
    unsigned int type;
    int vcpu_idx;
    int irq_num;
    int level;
    char __data[0];
};

struct trace_event_raw_kvm_mmio {
    struct trace_entry ent;
    u32 type;
    u32 len;
    u64 gpa;
    u64 val;
    char __data[0];
};

struct trace_event_raw_kvm_mmio_emulate {
    struct trace_entry ent;
    long unsigned int vcpu_pc;
    long unsigned int instr;
    long unsigned int cpsr;
    char __data[0];
};

struct trace_event_raw_kvm_mmio_nisv {
    struct trace_entry ent;
    long unsigned int vcpu_pc;
    long unsigned int esr;
    long unsigned int far;
    long unsigned int ipa;
    char __data[0];
};

struct trace_event_raw_kvm_nested_eret {
    struct trace_entry ent;
    struct kvm_vcpu *vcpu;
    long unsigned int elr_el2;
    long unsigned int spsr_el2;
    long unsigned int target_mode;
    long unsigned int hcr_el2;
    char __data[0];
};

struct trace_event_raw_kvm_set_guest_debug {
    struct trace_entry ent;
    struct kvm_vcpu *vcpu;
    __u32 guest_debug;
    char __data[0];
};

struct trace_event_raw_kvm_set_irq {
    struct trace_entry ent;
    unsigned int gsi;
    int level;
    int irq_source_id;
    char __data[0];
};

struct trace_event_raw_kvm_set_way_flush {
    struct trace_entry ent;
    long unsigned int vcpu_pc;
    bool cache;
    char __data[0];
};

struct trace_event_raw_kvm_sys_access {
    struct trace_entry ent;
    long unsigned int vcpu_pc;
    bool is_write;
    const char *name;
    u8 Op0;
    u8 Op1;
    u8 CRn;
    u8 CRm;
    u8 Op2;
    char __data[0];
};

struct trace_event_raw_kvm_test_age_hva {
    struct trace_entry ent;
    long unsigned int hva;
    char __data[0];
};

struct trace_event_raw_kvm_timer_emulate {
    struct trace_entry ent;
    int timer_idx;
    bool should_fire;
    char __data[0];
};

struct trace_event_raw_kvm_timer_hrtimer_expire {
    struct trace_entry ent;
    int timer_idx;
    char __data[0];
};

struct trace_event_raw_kvm_timer_restore_state {
    struct trace_entry ent;
    long unsigned int ctl;
    long long unsigned int cval;
    int timer_idx;
    char __data[0];
};

struct trace_event_raw_kvm_timer_save_state {
    struct trace_entry ent;
    long unsigned int ctl;
    long long unsigned int cval;
    int timer_idx;
    char __data[0];
};

struct trace_event_raw_kvm_timer_update_irq {
    struct trace_entry ent;
    long unsigned int vcpu_id;
    __u32 irq;
    int level;
    char __data[0];
};

struct trace_event_raw_kvm_toggle_cache {
    struct trace_entry ent;
    long unsigned int vcpu_pc;
    bool was;
    bool now;
    char __data[0];
};

struct trace_event_raw_kvm_unmap_hva_range {
    struct trace_entry ent;
    long unsigned int start;
    long unsigned int end;
    char __data[0];
};

struct trace_event_raw_kvm_userspace_exit {
    struct trace_entry ent;
    __u32 reason;
    int errno;
    char __data[0];
};

struct trace_event_raw_kvm_vcpu_wakeup {
    struct trace_entry ent;
    __u64 ns;
    bool waited;
    bool valid;
    char __data[0];
};

struct trace_event_raw_kvm_wfx_arm64 {
    struct trace_entry ent;
    long unsigned int vcpu_pc;
    bool is_wfe;
    char __data[0];
};

struct trace_event_raw_leases_conflict {
    struct trace_entry ent;
    void *lease;
    void *breaker;
    unsigned int l_fl_flags;
    unsigned int b_fl_flags;
    unsigned char l_fl_type;
    unsigned char b_fl_type;
    bool conflict;
    char __data[0];
};

struct trace_event_raw_locks_get_lock_context {
    struct trace_entry ent;
    long unsigned int i_ino;
    dev_t s_dev;
    unsigned char type;
    struct file_lock_context *ctx;
    char __data[0];
};

struct trace_event_raw_ma_op {
    struct trace_entry ent;
    const char *fn;
    long unsigned int min;
    long unsigned int max;
    long unsigned int index;
    long unsigned int last;
    void *node;
    char __data[0];
};

struct trace_event_raw_ma_read {
    struct trace_entry ent;
    const char *fn;
    long unsigned int min;
    long unsigned int max;
    long unsigned int index;
    long unsigned int last;
    void *node;
    char __data[0];
};

struct trace_event_raw_ma_write {
    struct trace_entry ent;
    const char *fn;
    long unsigned int min;
    long unsigned int max;
    long unsigned int index;
    long unsigned int last;
    long unsigned int piv;
    void *val;
    void *node;
    char __data[0];
};

struct trace_event_raw_map {
    struct trace_entry ent;
    u64 iova;
    u64 paddr;
    size_t size;
    char __data[0];
};

struct trace_event_raw_mark_victim {
    struct trace_entry ent;
    int pid;
    u32 __data_loc_comm;
    long unsigned int total_vm;
    long unsigned int anon_rss;
    long unsigned int file_rss;
    long unsigned int shmem_rss;
    uid_t uid;
    long unsigned int pgtables;
    short int oom_score_adj;
    char __data[0];
};

struct trace_event_raw_mc_event {
    struct trace_entry ent;
    unsigned int error_type;
    u32 __data_loc_msg;
    u32 __data_loc_label;
    u16 error_count;
    u8 mc_index;
    s8 top_layer;
    s8 middle_layer;
    s8 lower_layer;
    long int address;
    u8 grain_bits;
    long int syndrome;
    u32 __data_loc_driver_detail;
    char __data[0];
};

struct trace_event_raw_mdio_access {
    struct trace_entry ent;
    char busid[61];
    char read;
    u8 addr;
    u16 val;
    unsigned int regnum;
    char __data[0];
};

struct xdp_mem_allocator;

struct trace_event_raw_mem_connect {
    struct trace_entry ent;
    const struct xdp_mem_allocator *xa;
    u32 mem_id;
    u32 mem_type;
    const void *allocator;
    const struct xdp_rxq_info *rxq;
    int ifindex;
    char __data[0];
};

struct trace_event_raw_mem_disconnect {
    struct trace_entry ent;
    const struct xdp_mem_allocator *xa;
    u32 mem_id;
    u32 mem_type;
    const void *allocator;
    char __data[0];
};

struct trace_event_raw_mem_return_failed {
    struct trace_entry ent;
    const struct page *page;
    u32 mem_id;
    u32 mem_type;
    char __data[0];
};

struct trace_event_raw_memcg_flush_stats {
    struct trace_entry ent;
    u64 id;
    s64 stats_updates;
    bool force;
    bool needs_flush;
    char __data[0];
};

struct trace_event_raw_memcg_rstat_events {
    struct trace_entry ent;
    u64 id;
    int item;
    long unsigned int val;
    char __data[0];
};

struct trace_event_raw_memcg_rstat_stats {
    struct trace_entry ent;
    u64 id;
    int item;
    int val;
    char __data[0];
};

struct trace_event_raw_migration_pmd {
    struct trace_entry ent;
    long unsigned int addr;
    long unsigned int pmd;
    char __data[0];
};

struct trace_event_raw_migration_pte {
    struct trace_entry ent;
    long unsigned int addr;
    long unsigned int pte;
    int order;
    char __data[0];
};

struct trace_event_raw_mm_alloc_contig_migrate_range_info {
    struct trace_entry ent;
    long unsigned int start;
    long unsigned int end;
    long unsigned int nr_migrated;
    long unsigned int nr_reclaimed;
    long unsigned int nr_mapped;
    int migratetype;
    char __data[0];
};

struct trace_event_raw_mm_collapse_huge_page {
    struct trace_entry ent;
    struct mm_struct *mm;
    int isolated;
    int status;
    char __data[0];
};

struct trace_event_raw_mm_collapse_huge_page_isolate {
    struct trace_entry ent;
    long unsigned int pfn;
    int none_or_zero;
    int referenced;
    bool writable;
    int status;
    char __data[0];
};

struct trace_event_raw_mm_collapse_huge_page_swapin {
    struct trace_entry ent;
    struct mm_struct *mm;
    int swapped_in;
    int referenced;
    int ret;
    char __data[0];
};

struct trace_event_raw_mm_compaction_begin {
    struct trace_entry ent;
    long unsigned int zone_start;
    long unsigned int migrate_pfn;
    long unsigned int free_pfn;
    long unsigned int zone_end;
    bool sync;
    char __data[0];
};

struct trace_event_raw_mm_compaction_defer_template {
    struct trace_entry ent;
    int nid;
    enum zone_type idx;
    int order;
    unsigned int considered;
    unsigned int defer_shift;
    int order_failed;
    char __data[0];
};

struct trace_event_raw_mm_compaction_end {
    struct trace_entry ent;
    long unsigned int zone_start;
    long unsigned int migrate_pfn;
    long unsigned int free_pfn;
    long unsigned int zone_end;
    bool sync;
    int status;
    char __data[0];
};

struct trace_event_raw_mm_compaction_isolate_template {
    struct trace_entry ent;
    long unsigned int start_pfn;
    long unsigned int end_pfn;
    long unsigned int nr_scanned;
    long unsigned int nr_taken;
    char __data[0];
};

struct trace_event_raw_mm_compaction_kcompactd_sleep {
    struct trace_entry ent;
    int nid;
    char __data[0];
};

struct trace_event_raw_mm_compaction_migratepages {
    struct trace_entry ent;
    long unsigned int nr_migrated;
    long unsigned int nr_failed;
    char __data[0];
};

struct trace_event_raw_mm_compaction_suitable_template {
    struct trace_entry ent;
    int nid;
    enum zone_type idx;
    int order;
    int ret;
    char __data[0];
};

struct trace_event_raw_mm_compaction_try_to_compact_pages {
    struct trace_entry ent;
    int order;
    long unsigned int gfp_mask;
    int prio;
    char __data[0];
};

struct trace_event_raw_mm_filemap_fault {
    struct trace_entry ent;
    long unsigned int i_ino;
    dev_t s_dev;
    long unsigned int index;
    char __data[0];
};

struct trace_event_raw_mm_filemap_op_page_cache {
    struct trace_entry ent;
    long unsigned int pfn;
    long unsigned int i_ino;
    long unsigned int index;
    dev_t s_dev;
    unsigned char order;
    char __data[0];
};

struct trace_event_raw_mm_filemap_op_page_cache_range {
    struct trace_entry ent;
    long unsigned int i_ino;
    dev_t s_dev;
    long unsigned int index;
    long unsigned int last_index;
    char __data[0];
};

struct trace_event_raw_mm_khugepaged_collapse_file {
    struct trace_entry ent;
    struct mm_struct *mm;
    long unsigned int hpfn;
    long unsigned int index;
    long unsigned int addr;
    bool is_shmem;
    u32 __data_loc_filename;
    int nr;
    int result;
    char __data[0];
};

struct trace_event_raw_mm_khugepaged_scan_file {
    struct trace_entry ent;
    struct mm_struct *mm;
    long unsigned int pfn;
    u32 __data_loc_filename;
    int present;
    int swap;
    int result;
    char __data[0];
};

struct trace_event_raw_mm_khugepaged_scan_pmd {
    struct trace_entry ent;
    struct mm_struct *mm;
    long unsigned int pfn;
    bool writable;
    int referenced;
    int none_or_zero;
    int status;
    int unmapped;
    char __data[0];
};

struct trace_event_raw_mm_lru_activate {
    struct trace_entry ent;
    struct folio *folio;
    long unsigned int pfn;
    char __data[0];
};

struct trace_event_raw_mm_lru_insertion {
    struct trace_entry ent;
    struct folio *folio;
    long unsigned int pfn;
    enum lru_list lru;
    long unsigned int flags;
    char __data[0];
};

struct trace_event_raw_mm_migrate_pages {
    struct trace_entry ent;
    long unsigned int succeeded;
    long unsigned int failed;
    long unsigned int thp_succeeded;
    long unsigned int thp_failed;
    long unsigned int thp_split;
    long unsigned int large_folio_split;
    enum migrate_mode mode;
    int reason;
    char __data[0];
};

struct trace_event_raw_mm_migrate_pages_start {
    struct trace_entry ent;
    enum migrate_mode mode;
    int reason;
    char __data[0];
};

struct trace_event_raw_mm_page {
    struct trace_entry ent;
    long unsigned int pfn;
    unsigned int order;
    int migratetype;
    int percpu_refill;
    char __data[0];
};

struct trace_event_raw_mm_page_alloc {
    struct trace_entry ent;
    long unsigned int pfn;
    unsigned int order;
    long unsigned int gfp_flags;
    int migratetype;
    char __data[0];
};

struct trace_event_raw_mm_page_alloc_extfrag {
    struct trace_entry ent;
    long unsigned int pfn;
    int alloc_order;
    int fallback_order;
    int alloc_migratetype;
    int fallback_migratetype;
    int change_ownership;
    char __data[0];
};

struct trace_event_raw_mm_page_free {
    struct trace_entry ent;
    long unsigned int pfn;
    unsigned int order;
    char __data[0];
};

struct trace_event_raw_mm_page_free_batched {
    struct trace_entry ent;
    long unsigned int pfn;
    char __data[0];
};

struct trace_event_raw_mm_page_pcpu_drain {
    struct trace_entry ent;
    long unsigned int pfn;
    unsigned int order;
    int migratetype;
    char __data[0];
};

struct trace_event_raw_mm_shrink_slab_end {
    struct trace_entry ent;
    struct shrinker *shr;
    int nid;
    void *shrink;
    long int unused_scan;
    long int new_scan;
    int retval;
    long int total_scan;
    char __data[0];
};

struct trace_event_raw_mm_shrink_slab_start {
    struct trace_entry ent;
    struct shrinker *shr;
    void *shrink;
    int nid;
    long int nr_objects_to_shrink;
    long unsigned int gfp_flags;
    long unsigned int cache_items;
    long long unsigned int delta;
    long unsigned int total_scan;
    int priority;
    char __data[0];
};

struct trace_event_raw_mm_vmscan_direct_reclaim_begin_template {
    struct trace_entry ent;
    int order;
    long unsigned int gfp_flags;
    char __data[0];
};

struct trace_event_raw_mm_vmscan_direct_reclaim_end_template {
    struct trace_entry ent;
    long unsigned int nr_reclaimed;
    char __data[0];
};

struct trace_event_raw_mm_vmscan_kswapd_sleep {
    struct trace_entry ent;
    int nid;
    char __data[0];
};

struct trace_event_raw_mm_vmscan_kswapd_wake {
    struct trace_entry ent;
    int nid;
    int zid;
    int order;
    char __data[0];
};

struct trace_event_raw_mm_vmscan_lru_isolate {
    struct trace_entry ent;
    int highest_zoneidx;
    int order;
    long unsigned int nr_requested;
    long unsigned int nr_scanned;
    long unsigned int nr_skipped;
    long unsigned int nr_taken;
    int lru;
    char __data[0];
};

struct trace_event_raw_mm_vmscan_lru_shrink_active {
    struct trace_entry ent;
    int nid;
    long unsigned int nr_taken;
    long unsigned int nr_active;
    long unsigned int nr_deactivated;
    long unsigned int nr_referenced;
    int priority;
    int reclaim_flags;
    char __data[0];
};

struct trace_event_raw_mm_vmscan_lru_shrink_inactive {
    struct trace_entry ent;
    int nid;
    long unsigned int nr_scanned;
    long unsigned int nr_reclaimed;
    long unsigned int nr_dirty;
    long unsigned int nr_writeback;
    long unsigned int nr_congested;
    long unsigned int nr_immediate;
    unsigned int nr_activate0;
    unsigned int nr_activate1;
    long unsigned int nr_ref_keep;
    long unsigned int nr_unmap_fail;
    int priority;
    int reclaim_flags;
    char __data[0];
};

struct trace_event_raw_mm_vmscan_node_reclaim_begin {
    struct trace_entry ent;
    int nid;
    int order;
    long unsigned int gfp_flags;
    char __data[0];
};

struct trace_event_raw_mm_vmscan_reclaim_pages {
    struct trace_entry ent;
    int nid;
    long unsigned int nr_scanned;
    long unsigned int nr_reclaimed;
    long unsigned int nr_dirty;
    long unsigned int nr_writeback;
    long unsigned int nr_congested;
    long unsigned int nr_immediate;
    unsigned int nr_activate0;
    unsigned int nr_activate1;
    long unsigned int nr_ref_keep;
    long unsigned int nr_unmap_fail;
    char __data[0];
};

struct trace_event_raw_mm_vmscan_throttled {
    struct trace_entry ent;
    int nid;
    int usec_timeout;
    int usec_delayed;
    int reason;
    char __data[0];
};

struct trace_event_raw_mm_vmscan_wakeup_kswapd {
    struct trace_entry ent;
    int nid;
    int zid;
    int order;
    long unsigned int gfp_flags;
    char __data[0];
};

struct trace_event_raw_mm_vmscan_write_folio {
    struct trace_entry ent;
    long unsigned int pfn;
    int reclaim_flags;
    char __data[0];
};

struct trace_event_raw_mmap_lock {
    struct trace_entry ent;
    struct mm_struct *mm;
    u64 memcg_id;
    bool write;
    char __data[0];
};

struct trace_event_raw_mmap_lock_acquire_returned {
    struct trace_entry ent;
    struct mm_struct *mm;
    u64 memcg_id;
    bool write;
    bool success;
    char __data[0];
};

struct trace_event_raw_mmc_request_done {
    struct trace_entry ent;
    u32 cmd_opcode;
    int cmd_err;
    u32 cmd_resp[4];
    unsigned int cmd_retries;
    u32 stop_opcode;
    int stop_err;
    u32 stop_resp[4];
    unsigned int stop_retries;
    u32 sbc_opcode;
    int sbc_err;
    u32 sbc_resp[4];
    unsigned int sbc_retries;
    unsigned int bytes_xfered;
    int data_err;
    int tag;
    unsigned int can_retune;
    unsigned int doing_retune;
    unsigned int retune_now;
    int need_retune;
    int hold_retune;
    unsigned int retune_period;
    struct mmc_request *mrq;
    u32 __data_loc_name;
    char __data[0];
};

struct trace_event_raw_mmc_request_start {
    struct trace_entry ent;
    u32 cmd_opcode;
    u32 cmd_arg;
    unsigned int cmd_flags;
    unsigned int cmd_retries;
    u32 stop_opcode;
    u32 stop_arg;
    unsigned int stop_flags;
    unsigned int stop_retries;
    u32 sbc_opcode;
    u32 sbc_arg;
    unsigned int sbc_flags;
    unsigned int sbc_retries;
    unsigned int blocks;
    unsigned int blk_addr;
    unsigned int blksz;
    unsigned int data_flags;
    int tag;
    unsigned int can_retune;
    unsigned int doing_retune;
    unsigned int retune_now;
    int need_retune;
    int hold_retune;
    unsigned int retune_period;
    struct mmc_request *mrq;
    u32 __data_loc_name;
    char __data[0];
};

struct trace_event_raw_module_free {
    struct trace_entry ent;
    u32 __data_loc_name;
    char __data[0];
};

struct trace_event_raw_module_load {
    struct trace_entry ent;
    unsigned int taints;
    u32 __data_loc_name;
    char __data[0];
};

struct trace_event_raw_module_refcnt {
    struct trace_entry ent;
    long unsigned int ip;
    int refcnt;
    u32 __data_loc_name;
    char __data[0];
};

struct trace_event_raw_module_request {
    struct trace_entry ent;
    long unsigned int ip;
    bool wait;
    u32 __data_loc_name;
    char __data[0];
};

struct trace_event_raw_mptcp_dump_mpext {
    struct trace_entry ent;
    u64 data_ack;
    u64 data_seq;
    u32 subflow_seq;
    u16 data_len;
    u16 csum;
    u8 use_map;
    u8 dsn64;
    u8 data_fin;
    u8 use_ack;
    u8 ack64;
    u8 mpc_map;
    u8 frozen;
    u8 reset_transient;
    u8 reset_reason;
    u8 csum_reqd;
    u8 infinite_map;
    char __data[0];
};

struct trace_event_raw_mptcp_subflow_get_send {
    struct trace_entry ent;
    bool active;
    bool free;
    u32 snd_wnd;
    u32 pace;
    u8 backup;
    u64 ratio;
    char __data[0];
};

struct trace_event_raw_napi_poll {
    struct trace_entry ent;
    struct napi_struct *napi;
    u32 __data_loc_dev_name;
    int work;
    int budget;
    char __data[0];
};

struct trace_event_raw_neigh__update {
    struct trace_entry ent;
    u32 family;
    u32 __data_loc_dev;
    u8 lladdr[32];
    u8 lladdr_len;
    u8 flags;
    u8 nud_state;
    u8 type;
    u8 dead;
    int refcnt;
    __u8 primary_key4[4];
    __u8 primary_key6[16];
    long unsigned int confirmed;
    long unsigned int updated;
    long unsigned int used;
    u32 err;
    char __data[0];
};

struct trace_event_raw_neigh_create {
    struct trace_entry ent;
    u32 family;
    u32 __data_loc_dev;
    int entries;
    u8 created;
    u8 gc_exempt;
    u8 primary_key4[4];
    u8 primary_key6[16];
    char __data[0];
};

struct trace_event_raw_neigh_update {
    struct trace_entry ent;
    u32 family;
    u32 __data_loc_dev;
    u8 lladdr[32];
    u8 lladdr_len;
    u8 flags;
    u8 nud_state;
    u8 type;
    u8 dead;
    int refcnt;
    __u8 primary_key4[4];
    __u8 primary_key6[16];
    long unsigned int confirmed;
    long unsigned int updated;
    long unsigned int used;
    u8 new_lladdr[32];
    u8 new_state;
    u32 update_flags;
    u32 pid;
    char __data[0];
};

struct trace_event_raw_net_dev_rx_exit_template {
    struct trace_entry ent;
    int ret;
    char __data[0];
};

struct trace_event_raw_net_dev_rx_verbose_template {
    struct trace_entry ent;
    u32 __data_loc_name;
    unsigned int napi_id;
    u16 queue_mapping;
    const void *skbaddr;
    bool vlan_tagged;
    u16 vlan_proto;
    u16 vlan_tci;
    u16 protocol;
    u8 ip_summed;
    u32 hash;
    bool l4_hash;
    unsigned int len;
    unsigned int data_len;
    unsigned int truesize;
    bool mac_header_valid;
    int mac_header;
    unsigned char nr_frags;
    u16 gso_size;
    u16 gso_type;
    char __data[0];
};

struct trace_event_raw_net_dev_start_xmit {
    struct trace_entry ent;
    u32 __data_loc_name;
    u16 queue_mapping;
    const void *skbaddr;
    bool vlan_tagged;
    u16 vlan_proto;
    u16 vlan_tci;
    u16 protocol;
    u8 ip_summed;
    unsigned int len;
    unsigned int data_len;
    int network_offset;
    bool transport_offset_valid;
    int transport_offset;
    u8 tx_flags;
    u16 gso_size;
    u16 gso_segs;
    u16 gso_type;
    char __data[0];
};

struct trace_event_raw_net_dev_template {
    struct trace_entry ent;
    void *skbaddr;
    unsigned int len;
    u32 __data_loc_name;
    char __data[0];
};

struct trace_event_raw_net_dev_xmit {
    struct trace_entry ent;
    void *skbaddr;
    unsigned int len;
    int rc;
    u32 __data_loc_name;
    char __data[0];
};

struct trace_event_raw_net_dev_xmit_timeout {
    struct trace_entry ent;
    u32 __data_loc_name;
    u32 __data_loc_driver;
    int queue_index;
    char __data[0];
};

struct trace_event_raw_netlink_extack {
    struct trace_entry ent;
    u32 __data_loc_msg;
    char __data[0];
};

struct trace_event_raw_non_standard_event {
    struct trace_entry ent;
    char sec_type[16];
    char fru_id[16];
    u32 __data_loc_fru_text;
    u8 sev;
    u32 len;
    u32 __data_loc_buf;
    char __data[0];
};

struct trace_event_raw_notifier_info {
    struct trace_entry ent;
    void *cb;
    char __data[0];
};

struct trace_event_raw_oom_score_adj_update {
    struct trace_entry ent;
    pid_t pid;
    char comm[16];
    short int oom_score_adj;
    char __data[0];
};

struct trace_event_raw_page_pool_release {
    struct trace_entry ent;
    const struct page_pool *pool;
    s32 inflight;
    u32 hold;
    u32 release;
    u64 cnt;
    char __data[0];
};

struct trace_event_raw_page_pool_state_hold {
    struct trace_entry ent;
    const struct page_pool *pool;
    long unsigned int netmem;
    u32 hold;
    long unsigned int pfn;
    char __data[0];
};

struct trace_event_raw_page_pool_state_release {
    struct trace_entry ent;
    const struct page_pool *pool;
    long unsigned int netmem;
    u32 release;
    long unsigned int pfn;
    char __data[0];
};

struct trace_event_raw_page_pool_update_nid {
    struct trace_entry ent;
    const struct page_pool *pool;
    int pool_nid;
    int new_nid;
    char __data[0];
};

struct trace_event_raw_percpu_alloc_percpu {
    struct trace_entry ent;
    long unsigned int call_site;
    bool reserved;
    bool is_atomic;
    size_t size;
    size_t align;
    void *base_addr;
    int off;
    void *ptr;
    size_t bytes_alloc;
    long unsigned int gfp_flags;
    char __data[0];
};

struct trace_event_raw_percpu_alloc_percpu_fail {
    struct trace_entry ent;
    bool reserved;
    bool is_atomic;
    size_t size;
    size_t align;
    char __data[0];
};

struct trace_event_raw_percpu_create_chunk {
    struct trace_entry ent;
    void *base_addr;
    char __data[0];
};

struct trace_event_raw_percpu_destroy_chunk {
    struct trace_entry ent;
    void *base_addr;
    char __data[0];
};

struct trace_event_raw_percpu_free_percpu {
    struct trace_entry ent;
    void *base_addr;
    int off;
    void *ptr;
    char __data[0];
};

struct trace_event_raw_pm_qos_update {
    struct trace_entry ent;
    enum pm_qos_req_action action;
    int prev_value;
    int curr_value;
    char __data[0];
};

struct trace_event_raw_power_domain {
    struct trace_entry ent;
    u32 __data_loc_name;
    u64 state;
    u64 cpu_id;
    char __data[0];
};

struct trace_event_raw_powernv_throttle {
    struct trace_entry ent;
    int chip_id;
    u32 __data_loc_reason;
    int pmax;
    char __data[0];
};

struct trace_event_raw_preemptirq_template {
    struct trace_entry ent;
    s32 caller_offs;
    s32 parent_offs;
    char __data[0];
};

struct trace_event_raw_pstate_sample {
    struct trace_entry ent;
    u32 core_busy;
    u32 scaled_busy;
    u32 from;
    u32 to;
    u64 mperf;
    u64 aperf;
    u64 tsc;
    u32 freq;
    u32 io_boost;
    char __data[0];
};

struct trace_event_raw_purge_vmap_area_lazy {
    struct trace_entry ent;
    long unsigned int start;
    long unsigned int end;
    unsigned int npurged;
    char __data[0];
};

struct trace_event_raw_pwm {
    struct trace_entry ent;
    unsigned int chipid;
    unsigned int hwpwm;
    u64 period;
    u64 duty_cycle;
    enum pwm_polarity polarity;
    bool enabled;
    int err;
    char __data[0];
};

struct trace_event_raw_pwm_read_waveform {
    struct trace_entry ent;
    unsigned int chipid;
    unsigned int hwpwm;
    void *wfhw;
    int err;
    char __data[0];
};

struct trace_event_raw_pwm_round_waveform_fromhw {
    struct trace_entry ent;
    unsigned int chipid;
    unsigned int hwpwm;
    const void *wfhw;
    u64 wf_period_length_ns;
    u64 wf_duty_length_ns;
    u64 wf_duty_offset_ns;
    int err;
    char __data[0];
};

struct trace_event_raw_pwm_round_waveform_tohw {
    struct trace_entry ent;
    unsigned int chipid;
    unsigned int hwpwm;
    u64 wf_period_length_ns;
    u64 wf_duty_length_ns;
    u64 wf_duty_offset_ns;
    void *wfhw;
    int err;
    char __data[0];
};

struct trace_event_raw_pwm_write_waveform {
    struct trace_entry ent;
    unsigned int chipid;
    unsigned int hwpwm;
    const void *wfhw;
    int err;
    char __data[0];
};

struct trace_event_raw_qdisc_create {
    struct trace_entry ent;
    u32 __data_loc_dev;
    u32 __data_loc_kind;
    u32 parent;
    char __data[0];
};

struct trace_event_raw_qdisc_dequeue {
    struct trace_entry ent;
    struct Qdisc *qdisc;
    const struct netdev_queue *txq;
    int packets;
    void *skbaddr;
    int ifindex;
    u32 handle;
    u32 parent;
    long unsigned int txq_state;
    char __data[0];
};

struct trace_event_raw_qdisc_destroy {
    struct trace_entry ent;
    u32 __data_loc_dev;
    u32 __data_loc_kind;
    u32 parent;
    u32 handle;
    char __data[0];
};

struct trace_event_raw_qdisc_enqueue {
    struct trace_entry ent;
    struct Qdisc *qdisc;
    const struct netdev_queue *txq;
    void *skbaddr;
    int ifindex;
    u32 handle;
    u32 parent;
    char __data[0];
};

struct trace_event_raw_qdisc_reset {
    struct trace_entry ent;
    u32 __data_loc_dev;
    u32 __data_loc_kind;
    u32 parent;
    u32 handle;
    char __data[0];
};

struct trace_event_raw_rcu_stall_warning {
    struct trace_entry ent;
    const char *rcuname;
    const char *msg;
    char __data[0];
};

struct trace_event_raw_rcu_utilization {
    struct trace_entry ent;
    const char *s;
    char __data[0];
};

struct trace_event_raw_reclaim_retry_zone {
    struct trace_entry ent;
    int node;
    int zone_idx;
    int order;
    long unsigned int reclaimable;
    long unsigned int available;
    long unsigned int min_wmark;
    int no_progress_loops;
    bool wmark_check;
    char __data[0];
};

struct trace_event_raw_regcache_drop_region {
    struct trace_entry ent;
    u32 __data_loc_name;
    unsigned int from;
    unsigned int to;
    char __data[0];
};

struct trace_event_raw_regcache_sync {
    struct trace_entry ent;
    u32 __data_loc_name;
    u32 __data_loc_status;
    u32 __data_loc_type;
    char __data[0];
};

struct trace_event_raw_regmap_async {
    struct trace_entry ent;
    u32 __data_loc_name;
    char __data[0];
};

struct trace_event_raw_regmap_block {
    struct trace_entry ent;
    u32 __data_loc_name;
    unsigned int reg;
    int count;
    char __data[0];
};

struct trace_event_raw_regmap_bool {
    struct trace_entry ent;
    u32 __data_loc_name;
    int flag;
    char __data[0];
};

struct trace_event_raw_regmap_bulk {
    struct trace_entry ent;
    u32 __data_loc_name;
    unsigned int reg;
    u32 __data_loc_buf;
    int val_len;
    char __data[0];
};

struct trace_event_raw_regmap_reg {
    struct trace_entry ent;
    u32 __data_loc_name;
    unsigned int reg;
    unsigned int val;
    char __data[0];
};

struct trace_event_raw_regulator_basic {
    struct trace_entry ent;
    u32 __data_loc_name;
    char __data[0];
};

struct trace_event_raw_regulator_range {
    struct trace_entry ent;
    u32 __data_loc_name;
    int min;
    int max;
    char __data[0];
};

struct trace_event_raw_regulator_value {
    struct trace_entry ent;
    u32 __data_loc_name;
    unsigned int val;
    char __data[0];
};

struct trace_event_raw_rpm_internal {
    struct trace_entry ent;
    u32 __data_loc_name;
    int flags;
    int usage_count;
    int disable_depth;
    int runtime_auto;
    int request_pending;
    int irq_safe;
    int child_count;
    char __data[0];
};

struct trace_event_raw_rpm_return_int {
    struct trace_entry ent;
    u32 __data_loc_name;
    long unsigned int ip;
    int ret;
    char __data[0];
};

struct trace_event_raw_rpm_status {
    struct trace_entry ent;
    u32 __data_loc_name;
    int status;
    char __data[0];
};

struct trace_event_raw_rseq_ip_fixup {
    struct trace_entry ent;
    long unsigned int regs_ip;
    long unsigned int start_ip;
    long unsigned int post_commit_offset;
    long unsigned int abort_ip;
    char __data[0];
};

struct trace_event_raw_rseq_update {
    struct trace_entry ent;
    s32 cpu_id;
    s32 node_id;
    s32 mm_cid;
    char __data[0];
};

struct trace_event_raw_rss_stat {
    struct trace_entry ent;
    unsigned int mm_id;
    unsigned int curr;
    int member;
    long int size;
    char __data[0];
};

struct trace_event_raw_rtc_alarm_irq_enable {
    struct trace_entry ent;
    unsigned int enabled;
    int err;
    char __data[0];
};

struct trace_event_raw_rtc_irq_set_freq {
    struct trace_entry ent;
    int freq;
    int err;
    char __data[0];
};

struct trace_event_raw_rtc_irq_set_state {
    struct trace_entry ent;
    int enabled;
    int err;
    char __data[0];
};

struct trace_event_raw_rtc_offset_class {
    struct trace_entry ent;
    long int offset;
    int err;
    char __data[0];
};

struct trace_event_raw_rtc_time_alarm_class {
    struct trace_entry ent;
    time64_t secs;
    int err;
    char __data[0];
};

struct trace_event_raw_rtc_timer_class {
    struct trace_entry ent;
    struct rtc_timer *timer;
    ktime_t expires;
    ktime_t period;
    char __data[0];
};

struct trace_event_raw_rwmmio_post_read {
    struct trace_entry ent;
    long unsigned int caller;
    long unsigned int caller0;
    long unsigned int addr;
    u64 val;
    u8 width;
    char __data[0];
};

struct trace_event_raw_rwmmio_read {
    struct trace_entry ent;
    long unsigned int caller;
    long unsigned int caller0;
    long unsigned int addr;
    u8 width;
    char __data[0];
};

struct trace_event_raw_rwmmio_rw_template {
    struct trace_entry ent;
    long unsigned int caller;
    long unsigned int caller0;
    long unsigned int addr;
    u64 val;
    u8 width;
    char __data[0];
};

struct trace_event_raw_sched_ext_dump {
    struct trace_entry ent;
    u32 __data_loc_line;
    char __data[0];
};

struct trace_event_raw_sched_kthread_stop {
    struct trace_entry ent;
    char comm[16];
    pid_t pid;
    char __data[0];
};

struct trace_event_raw_sched_kthread_stop_ret {
    struct trace_entry ent;
    int ret;
    char __data[0];
};

struct trace_event_raw_sched_kthread_work_execute_end {
    struct trace_entry ent;
    void *work;
    void *function;
    char __data[0];
};

struct trace_event_raw_sched_kthread_work_execute_start {
    struct trace_entry ent;
    void *work;
    void *function;
    char __data[0];
};

struct trace_event_raw_sched_kthread_work_queue_work {
    struct trace_entry ent;
    void *work;
    void *function;
    void *worker;
    char __data[0];
};

struct trace_event_raw_sched_migrate_task {
    struct trace_entry ent;
    char comm[16];
    pid_t pid;
    int prio;
    int orig_cpu;
    int dest_cpu;
    char __data[0];
};

struct trace_event_raw_sched_move_numa {
    struct trace_entry ent;
    pid_t pid;
    pid_t tgid;
    pid_t ngid;
    int src_cpu;
    int src_nid;
    int dst_cpu;
    int dst_nid;
    char __data[0];
};

struct trace_event_raw_sched_numa_pair_template {
    struct trace_entry ent;
    pid_t src_pid;
    pid_t src_tgid;
    pid_t src_ngid;
    int src_cpu;
    int src_nid;
    pid_t dst_pid;
    pid_t dst_tgid;
    pid_t dst_ngid;
    int dst_cpu;
    int dst_nid;
    char __data[0];
};

struct trace_event_raw_sched_pi_setprio {
    struct trace_entry ent;
    char comm[16];
    pid_t pid;
    int oldprio;
    int newprio;
    char __data[0];
};

struct trace_event_raw_sched_prepare_exec {
    struct trace_entry ent;
    u32 __data_loc_interp;
    u32 __data_loc_filename;
    pid_t pid;
    u32 __data_loc_comm;
    char __data[0];
};

struct trace_event_raw_sched_process_exec {
    struct trace_entry ent;
    u32 __data_loc_filename;
    pid_t pid;
    pid_t old_pid;
    char __data[0];
};

struct trace_event_raw_sched_process_fork {
    struct trace_entry ent;
    char parent_comm[16];
    pid_t parent_pid;
    char child_comm[16];
    pid_t child_pid;
    char __data[0];
};

struct trace_event_raw_sched_process_hang {
    struct trace_entry ent;
    char comm[16];
    pid_t pid;
    char __data[0];
};

struct trace_event_raw_sched_process_template {
    struct trace_entry ent;
    char comm[16];
    pid_t pid;
    int prio;
    char __data[0];
};

struct trace_event_raw_sched_process_wait {
    struct trace_entry ent;
    char comm[16];
    pid_t pid;
    int prio;
    char __data[0];
};

struct trace_event_raw_sched_stat_runtime {
    struct trace_entry ent;
    char comm[16];
    pid_t pid;
    u64 runtime;
    char __data[0];
};

struct trace_event_raw_sched_stat_template {
    struct trace_entry ent;
    char comm[16];
    pid_t pid;
    u64 delay;
    char __data[0];
};

struct trace_event_raw_sched_switch {
    struct trace_entry ent;
    char prev_comm[16];
    pid_t prev_pid;
    int prev_prio;
    long int prev_state;
    char next_comm[16];
    pid_t next_pid;
    int next_prio;
    char __data[0];
};

struct trace_event_raw_sched_wake_idle_without_ipi {
    struct trace_entry ent;
    int cpu;
    char __data[0];
};

struct trace_event_raw_sched_wakeup_template {
    struct trace_entry ent;
    char comm[16];
    pid_t pid;
    int prio;
    int target_cpu;
    char __data[0];
};

struct trace_event_raw_scsi_cmd_done_timeout_template {
    struct trace_entry ent;
    unsigned int host_no;
    unsigned int channel;
    unsigned int id;
    unsigned int lun;
    int result;
    unsigned int opcode;
    unsigned int cmd_len;
    int driver_tag;
    int scheduler_tag;
    unsigned int data_sglen;
    unsigned int prot_sglen;
    unsigned char prot_op;
    u32 __data_loc_cmnd;
    u8 sense_key;
    u8 asc;
    u8 ascq;
    char __data[0];
};

struct trace_event_raw_scsi_dispatch_cmd_error {
    struct trace_entry ent;
    unsigned int host_no;
    unsigned int channel;
    unsigned int id;
    unsigned int lun;
    int rtn;
    unsigned int opcode;
    unsigned int cmd_len;
    int driver_tag;
    int scheduler_tag;
    unsigned int data_sglen;
    unsigned int prot_sglen;
    unsigned char prot_op;
    u32 __data_loc_cmnd;
    char __data[0];
};

struct trace_event_raw_scsi_dispatch_cmd_start {
    struct trace_entry ent;
    unsigned int host_no;
    unsigned int channel;
    unsigned int id;
    unsigned int lun;
    unsigned int opcode;
    unsigned int cmd_len;
    int driver_tag;
    int scheduler_tag;
    unsigned int data_sglen;
    unsigned int prot_sglen;
    unsigned char prot_op;
    u32 __data_loc_cmnd;
    char __data[0];
};

struct trace_event_raw_scsi_eh_wakeup {
    struct trace_entry ent;
    unsigned int host_no;
    char __data[0];
};

struct trace_event_raw_scsi_prepare_zone_append {
    struct trace_entry ent;
    unsigned int host_no;
    unsigned int channel;
    unsigned int id;
    unsigned int lun;
    sector_t lba;
    unsigned int wp_offset;
    char __data[0];
};

struct trace_event_raw_scsi_zone_wp_update {
    struct trace_entry ent;
    unsigned int host_no;
    unsigned int channel;
    unsigned int id;
    unsigned int lun;
    sector_t rq_sector;
    unsigned int wp_offset;
    unsigned int good_bytes;
    char __data[0];
};

struct trace_event_raw_selinux_audited {
    struct trace_entry ent;
    u32 requested;
    u32 denied;
    u32 audited;
    int result;
    u32 __data_loc_scontext;
    u32 __data_loc_tcontext;
    u32 __data_loc_tclass;
    char __data[0];
};

struct trace_event_raw_signal_deliver {
    struct trace_entry ent;
    int sig;
    int errno;
    int code;
    long unsigned int sa_handler;
    long unsigned int sa_flags;
    char __data[0];
};

struct trace_event_raw_signal_generate {
    struct trace_entry ent;
    int sig;
    int errno;
    int code;
    char comm[16];
    pid_t pid;
    int group;
    int result;
    char __data[0];
};

struct trace_event_raw_sk_data_ready {
    struct trace_entry ent;
    const void *skaddr;
    __u16 family;
    __u16 protocol;
    long unsigned int ip;
    char __data[0];
};

struct trace_event_raw_skb_copy_datagram_iovec {
    struct trace_entry ent;
    const void *skbaddr;
    int len;
    char __data[0];
};

struct trace_event_raw_skip_task_reaping {
    struct trace_entry ent;
    int pid;
    char __data[0];
};

struct trace_event_raw_smbus_read {
    struct trace_entry ent;
    int adapter_nr;
    __u16 flags;
    __u16 addr;
    __u8 command;
    __u32 protocol;
    __u8 buf[34];
    char __data[0];
};

struct trace_event_raw_smbus_reply {
    struct trace_entry ent;
    int adapter_nr;
    __u16 addr;
    __u16 flags;
    __u8 command;
    __u8 len;
    __u32 protocol;
    __u8 buf[34];
    char __data[0];
};

struct trace_event_raw_smbus_result {
    struct trace_entry ent;
    int adapter_nr;
    __u16 addr;
    __u16 flags;
    __u8 read_write;
    __u8 command;
    __s16 res;
    __u32 protocol;
    char __data[0];
};

struct trace_event_raw_smbus_write {
    struct trace_entry ent;
    int adapter_nr;
    __u16 addr;
    __u16 flags;
    __u8 command;
    __u8 len;
    __u32 protocol;
    __u8 buf[34];
    char __data[0];
};

struct trace_event_raw_sock_exceed_buf_limit {
    struct trace_entry ent;
    char name[32];
    long int sysctl_mem[3];
    long int allocated;
    int sysctl_rmem;
    int rmem_alloc;
    int sysctl_wmem;
    int wmem_alloc;
    int wmem_queued;
    int kind;
    char __data[0];
};

struct trace_event_raw_sock_msg_length {
    struct trace_entry ent;
    void *sk;
    __u16 family;
    __u16 protocol;
    int ret;
    int flags;
    char __data[0];
};

struct trace_event_raw_sock_rcvqueue_full {
    struct trace_entry ent;
    int rmem_alloc;
    unsigned int truesize;
    int sk_rcvbuf;
    char __data[0];
};

struct trace_event_raw_softirq {
    struct trace_entry ent;
    unsigned int vec;
    char __data[0];
};

struct trace_event_raw_spi_controller {
    struct trace_entry ent;
    int bus_num;
    char __data[0];
};

struct trace_event_raw_spi_message {
    struct trace_entry ent;
    int bus_num;
    int chip_select;
    struct spi_message *msg;
    char __data[0];
};

struct trace_event_raw_spi_message_done {
    struct trace_entry ent;
    int bus_num;
    int chip_select;
    struct spi_message *msg;
    unsigned int frame;
    unsigned int actual;
    char __data[0];
};

struct trace_event_raw_spi_set_cs {
    struct trace_entry ent;
    int bus_num;
    int chip_select;
    long unsigned int mode;
    bool enable;
    char __data[0];
};

struct trace_event_raw_spi_setup {
    struct trace_entry ent;
    int bus_num;
    int chip_select;
    long unsigned int mode;
    unsigned int bits_per_word;
    unsigned int max_speed_hz;
    int status;
    char __data[0];
};

struct trace_event_raw_spi_transfer {
    struct trace_entry ent;
    int bus_num;
    int chip_select;
    struct spi_transfer *xfer;
    int len;
    u32 __data_loc_rx_buf;
    u32 __data_loc_tx_buf;
    char __data[0];
};

struct trace_event_raw_start_task_reaping {
    struct trace_entry ent;
    int pid;
    char __data[0];
};

struct trace_event_raw_subflow_check_data_avail {
    struct trace_entry ent;
    u8 status;
    const void *skb;
    char __data[0];
};

struct trace_event_raw_suspend_resume {
    struct trace_entry ent;
    const char *action;
    int val;
    bool start;
    char __data[0];
};

struct trace_event_raw_swiotlb_bounced {
    struct trace_entry ent;
    u32 __data_loc_dev_name;
    u64 dma_mask;
    dma_addr_t dev_addr;
    size_t size;
    bool force;
    char __data[0];
};

struct trace_event_raw_sys_enter {
    struct trace_entry ent;
    long int id;
    long unsigned int args[6];
    char __data[0];
};

struct trace_event_raw_sys_exit {
    struct trace_entry ent;
    long int id;
    long int ret;
    char __data[0];
};

struct trace_event_raw_task_newtask {
    struct trace_entry ent;
    pid_t pid;
    char comm[16];
    long unsigned int clone_flags;
    short int oom_score_adj;
    char __data[0];
};

struct trace_event_raw_task_prctl_unknown {
    struct trace_entry ent;
    int option;
    long unsigned int arg2;
    long unsigned int arg3;
    long unsigned int arg4;
    long unsigned int arg5;
    char __data[0];
};

struct trace_event_raw_task_rename {
    struct trace_entry ent;
    char oldcomm[16];
    char newcomm[16];
    short int oom_score_adj;
    char __data[0];
};

struct trace_event_raw_tasklet {
    struct trace_entry ent;
    void *tasklet;
    void *func;
    char __data[0];
};

struct trace_event_raw_tcp_ao_event {
    struct trace_entry ent;
    __u64 net_cookie;
    const void *skbaddr;
    const void *skaddr;
    int state;
    __u8 saddr[28];
    __u8 daddr[28];
    int l3index;
    __u16 sport;
    __u16 dport;
    __u16 family;
    bool fin;
    bool syn;
    bool rst;
    bool psh;
    bool ack;
    __u8 keyid;
    __u8 rnext;
    __u8 maclen;
    char __data[0];
};

struct trace_event_raw_tcp_ao_event_sk {
    struct trace_entry ent;
    __u64 net_cookie;
    const void *skaddr;
    int state;
    __u8 saddr[28];
    __u8 daddr[28];
    __u16 sport;
    __u16 dport;
    __u16 family;
    __u8 keyid;
    __u8 rnext;
    char __data[0];
};

struct trace_event_raw_tcp_ao_event_sne {
    struct trace_entry ent;
    __u64 net_cookie;
    const void *skaddr;
    int state;
    __u8 saddr[28];
    __u8 daddr[28];
    __u16 sport;
    __u16 dport;
    __u16 family;
    __u32 new_sne;
    char __data[0];
};

struct trace_event_raw_tcp_cong_state_set {
    struct trace_entry ent;
    const void *skaddr;
    __u16 sport;
    __u16 dport;
    __u16 family;
    __u8 saddr[4];
    __u8 daddr[4];
    __u8 saddr_v6[16];
    __u8 daddr_v6[16];
    __u8 cong_state;
    char __data[0];
};

struct trace_event_raw_tcp_event_sk {
    struct trace_entry ent;
    const void *skaddr;
    __u16 sport;
    __u16 dport;
    __u16 family;
    __u8 saddr[4];
    __u8 daddr[4];
    __u8 saddr_v6[16];
    __u8 daddr_v6[16];
    __u64 sock_cookie;
    char __data[0];
};

struct trace_event_raw_tcp_event_sk_skb {
    struct trace_entry ent;
    const void *skbaddr;
    const void *skaddr;
    int state;
    __u16 sport;
    __u16 dport;
    __u16 family;
    __u8 saddr[4];
    __u8 daddr[4];
    __u8 saddr_v6[16];
    __u8 daddr_v6[16];
    char __data[0];
};

struct trace_event_raw_tcp_event_skb {
    struct trace_entry ent;
    const void *skbaddr;
    __u8 saddr[28];
    __u8 daddr[28];
    char __data[0];
};

struct trace_event_raw_tcp_hash_event {
    struct trace_entry ent;
    __u64 net_cookie;
    const void *skbaddr;
    const void *skaddr;
    int state;
    __u8 saddr[28];
    __u8 daddr[28];
    int l3index;
    __u16 sport;
    __u16 dport;
    __u16 family;
    bool fin;
    bool syn;
    bool rst;
    bool psh;
    bool ack;
    char __data[0];
};

struct trace_event_raw_tcp_probe {
    struct trace_entry ent;
    __u8 saddr[28];
    __u8 daddr[28];
    __u16 sport;
    __u16 dport;
    __u16 family;
    __u32 mark;
    __u16 data_len;
    __u32 snd_nxt;
    __u32 snd_una;
    __u32 snd_cwnd;
    __u32 ssthresh;
    __u32 snd_wnd;
    __u32 srtt;
    __u32 rcv_wnd;
    __u64 sock_cookie;
    const void *skbaddr;
    const void *skaddr;
    char __data[0];
};

struct trace_event_raw_tcp_retransmit_synack {
    struct trace_entry ent;
    const void *skaddr;
    const void *req;
    __u16 sport;
    __u16 dport;
    __u16 family;
    __u8 saddr[4];
    __u8 daddr[4];
    __u8 saddr_v6[16];
    __u8 daddr_v6[16];
    char __data[0];
};

struct trace_event_raw_tcp_send_reset {
    struct trace_entry ent;
    const void *skbaddr;
    const void *skaddr;
    int state;
    enum sk_rst_reason reason;
    __u8 saddr[28];
    __u8 daddr[28];
    char __data[0];
};

struct trace_event_raw_test_pages_isolated {
    struct trace_entry ent;
    long unsigned int start_pfn;
    long unsigned int end_pfn;
    long unsigned int fin_pfn;
    char __data[0];
};

struct trace_event_raw_thermal_power_cpu_get_power_simple {
    struct trace_entry ent;
    int cpu;
    u32 power;
    char __data[0];
};

struct trace_event_raw_thermal_power_cpu_limit {
    struct trace_entry ent;
    u32 __data_loc_cpumask;
    unsigned int freq;
    long unsigned int cdev_state;
    u32 power;
    char __data[0];
};

struct trace_event_raw_thermal_power_devfreq_get_power {
    struct trace_entry ent;
    u32 __data_loc_type;
    long unsigned int freq;
    u32 busy_time;
    u32 total_time;
    u32 power;
    char __data[0];
};

struct trace_event_raw_thermal_power_devfreq_limit {
    struct trace_entry ent;
    u32 __data_loc_type;
    unsigned int freq;
    long unsigned int cdev_state;
    u32 power;
    char __data[0];
};

struct trace_event_raw_thermal_temperature {
    struct trace_entry ent;
    u32 __data_loc_thermal_zone;
    int id;
    int temp_prev;
    int temp;
    char __data[0];
};

struct trace_event_raw_thermal_zone_trip {
    struct trace_entry ent;
    u32 __data_loc_thermal_zone;
    int id;
    int trip;
    enum thermal_trip_type trip_type;
    char __data[0];
};

struct trace_event_raw_tick_stop {
    struct trace_entry ent;
    int success;
    int dependency;
    char __data[0];
};

struct trace_event_raw_timer_base_idle {
    struct trace_entry ent;
    bool is_idle;
    unsigned int cpu;
    char __data[0];
};

struct trace_event_raw_timer_class {
    struct trace_entry ent;
    void *timer;
    char __data[0];
};

struct trace_event_raw_timer_expire_entry {
    struct trace_entry ent;
    void *timer;
    long unsigned int now;
    void *function;
    long unsigned int baseclk;
    char __data[0];
};

struct trace_event_raw_timer_start {
    struct trace_entry ent;
    void *timer;
    void *function;
    long unsigned int expires;
    long unsigned int bucket_expiry;
    long unsigned int now;
    unsigned int flags;
    char __data[0];
};

struct trace_event_raw_tlb_flush {
    struct trace_entry ent;
    int reason;
    long unsigned int pages;
    char __data[0];
};

struct trace_event_raw_tls_contenttype {
    struct trace_entry ent;
    __u8 saddr[28];
    __u8 daddr[28];
    unsigned int netns_ino;
    long unsigned int type;
    char __data[0];
};

struct trace_event_raw_tmigr_connect_child_parent {
    struct trace_entry ent;
    void *child;
    void *parent;
    unsigned int lvl;
    unsigned int numa_node;
    unsigned int num_children;
    u32 groupmask;
    char __data[0];
};

struct trace_event_raw_tmigr_connect_cpu_parent {
    struct trace_entry ent;
    void *parent;
    unsigned int cpu;
    unsigned int lvl;
    unsigned int numa_node;
    unsigned int num_children;
    u32 groupmask;
    char __data[0];
};

struct trace_event_raw_tmigr_cpugroup {
    struct trace_entry ent;
    u64 wakeup;
    void *parent;
    unsigned int cpu;
    char __data[0];
};

struct trace_event_raw_tmigr_group_and_cpu {
    struct trace_entry ent;
    void *group;
    void *parent;
    unsigned int lvl;
    unsigned int numa_node;
    u32 childmask;
    u8 active;
    u8 migrator;
    char __data[0];
};

struct trace_event_raw_tmigr_group_set {
    struct trace_entry ent;
    void *group;
    unsigned int lvl;
    unsigned int numa_node;
    char __data[0];
};

struct trace_event_raw_tmigr_handle_remote {
    struct trace_entry ent;
    void *group;
    unsigned int lvl;
    char __data[0];
};

struct trace_event_raw_tmigr_idle {
    struct trace_entry ent;
    u64 nextevt;
    u64 wakeup;
    void *parent;
    unsigned int cpu;
    char __data[0];
};

struct trace_event_raw_tmigr_update_events {
    struct trace_entry ent;
    void *child;
    void *group;
    u64 nextevt;
    u64 group_next_expiry;
    u64 child_evt_expiry;
    unsigned int group_lvl;
    unsigned int child_evtcpu;
    u8 child_active;
    u8 group_active;
    char __data[0];
};

struct trace_event_raw_track_foreign_dirty {
    struct trace_entry ent;
    char name[32];
    u64 bdi_id;
    ino_t ino;
    unsigned int memcg_id;
    ino_t cgroup_ino;
    ino_t page_cgroup_ino;
    char __data[0];
};

struct trace_event_raw_udp_fail_queue_rcv_skb {
    struct trace_entry ent;
    int rc;
    __u16 sport;
    __u16 dport;
    __u16 family;
    __u8 saddr[28];
    __u8 daddr[28];
    char __data[0];
};

struct trace_event_raw_unmap {
    struct trace_entry ent;
    u64 iova;
    size_t size;
    size_t unmapped_size;
    char __data[0];
};

struct trace_event_raw_vgic_update_irq_pending {
    struct trace_entry ent;
    long unsigned int vcpu_id;
    __u32 irq;
    bool level;
    char __data[0];
};

struct trace_event_raw_vm_unmapped_area {
    struct trace_entry ent;
    long unsigned int addr;
    long unsigned int total_vm;
    long unsigned int flags;
    long unsigned int length;
    long unsigned int low_limit;
    long unsigned int high_limit;
    long unsigned int align_mask;
    long unsigned int align_offset;
    char __data[0];
};

struct trace_event_raw_vma_mas_szero {
    struct trace_entry ent;
    struct maple_tree *mt;
    long unsigned int start;
    long unsigned int end;
    char __data[0];
};

struct trace_event_raw_vma_store {
    struct trace_entry ent;
    struct maple_tree *mt;
    struct vm_area_struct *vma;
    long unsigned int vm_start;
    long unsigned int vm_end;
    char __data[0];
};

struct trace_event_raw_wake_reaper {
    struct trace_entry ent;
    int pid;
    char __data[0];
};

struct trace_event_raw_wakeup_source {
    struct trace_entry ent;
    u32 __data_loc_name;
    u64 state;
    char __data[0];
};

struct trace_event_raw_watchdog_set_timeout {
    struct trace_entry ent;
    int id;
    unsigned int timeout;
    int err;
    char __data[0];
};

struct trace_event_raw_watchdog_template {
    struct trace_entry ent;
    int id;
    int err;
    char __data[0];
};

struct trace_event_raw_wbc_class {
    struct trace_entry ent;
    char name[32];
    long int nr_to_write;
    long int pages_skipped;
    int sync_mode;
    int for_kupdate;
    int for_background;
    int for_reclaim;
    int range_cyclic;
    long int range_start;
    long int range_end;
    ino_t cgroup_ino;
    char __data[0];
};

struct trace_event_raw_wbt_lat {
    struct trace_entry ent;
    char name[32];
    long unsigned int lat;
    char __data[0];
};

struct trace_event_raw_wbt_stat {
    struct trace_entry ent;
    char name[32];
    s64 rmean;
    u64 rmin;
    u64 rmax;
    s64 rnr_samples;
    s64 rtime;
    s64 wmean;
    u64 wmin;
    u64 wmax;
    s64 wnr_samples;
    s64 wtime;
    char __data[0];
};

struct trace_event_raw_wbt_step {
    struct trace_entry ent;
    char name[32];
    const char *msg;
    int step;
    long unsigned int window;
    unsigned int bg;
    unsigned int normal;
    unsigned int max;
    char __data[0];
};

struct trace_event_raw_wbt_timer {
    struct trace_entry ent;
    char name[32];
    unsigned int status;
    int step;
    unsigned int inflight;
    char __data[0];
};

struct trace_event_raw_workqueue_activate_work {
    struct trace_entry ent;
    void *work;
    void *function;
    char __data[0];
};

struct trace_event_raw_workqueue_execute_end {
    struct trace_entry ent;
    void *work;
    void *function;
    char __data[0];
};

struct trace_event_raw_workqueue_execute_start {
    struct trace_entry ent;
    void *work;
    void *function;
    char __data[0];
};

struct trace_event_raw_workqueue_queue_work {
    struct trace_entry ent;
    void *work;
    void *function;
    u32 __data_loc_workqueue;
    int req_cpu;
    int cpu;
    char __data[0];
};

struct trace_event_raw_writeback_bdi_register {
    struct trace_entry ent;
    char name[32];
    char __data[0];
};

struct trace_event_raw_writeback_class {
    struct trace_entry ent;
    char name[32];
    ino_t cgroup_ino;
    char __data[0];
};

struct trace_event_raw_writeback_dirty_inode_template {
    struct trace_entry ent;
    char name[32];
    ino_t ino;
    long unsigned int state;
    long unsigned int flags;
    char __data[0];
};

struct trace_event_raw_writeback_folio_template {
    struct trace_entry ent;
    char name[32];
    ino_t ino;
    long unsigned int index;
    char __data[0];
};

struct trace_event_raw_writeback_inode_template {
    struct trace_entry ent;
    dev_t dev;
    ino_t ino;
    long unsigned int state;
    __u16 mode;
    long unsigned int dirtied_when;
    char __data[0];
};

struct trace_event_raw_writeback_pages_written {
    struct trace_entry ent;
    long int pages;
    char __data[0];
};

struct trace_event_raw_writeback_queue_io {
    struct trace_entry ent;
    char name[32];
    long unsigned int older;
    long int age;
    int moved;
    int reason;
    ino_t cgroup_ino;
    char __data[0];
};

struct trace_event_raw_writeback_sb_inodes_requeue {
    struct trace_entry ent;
    char name[32];
    ino_t ino;
    long unsigned int state;
    long unsigned int dirtied_when;
    ino_t cgroup_ino;
    char __data[0];
};

struct trace_event_raw_writeback_single_inode_template {
    struct trace_entry ent;
    char name[32];
    ino_t ino;
    long unsigned int state;
    long unsigned int dirtied_when;
    long unsigned int writeback_index;
    long int nr_to_write;
    long unsigned int wrote;
    ino_t cgroup_ino;
    char __data[0];
};

struct trace_event_raw_writeback_work_class {
    struct trace_entry ent;
    char name[32];
    long int nr_pages;
    dev_t sb_dev;
    int sync_mode;
    int for_kupdate;
    int range_cyclic;
    int for_background;
    int reason;
    ino_t cgroup_ino;
    char __data[0];
};

struct trace_event_raw_writeback_write_inode_template {
    struct trace_entry ent;
    char name[32];
    ino_t ino;
    int sync_mode;
    ino_t cgroup_ino;
    char __data[0];
};

struct trace_event_raw_xdp_bulk_tx {
    struct trace_entry ent;
    int ifindex;
    u32 act;
    int drops;
    int sent;
    int err;
    char __data[0];
};

struct trace_event_raw_xdp_cpumap_enqueue {
    struct trace_entry ent;
    int map_id;
    u32 act;
    int cpu;
    unsigned int drops;
    unsigned int processed;
    int to_cpu;
    char __data[0];
};

struct trace_event_raw_xdp_cpumap_kthread {
    struct trace_entry ent;
    int map_id;
    u32 act;
    int cpu;
    unsigned int drops;
    unsigned int processed;
    int sched;
    unsigned int xdp_pass;
    unsigned int xdp_drop;
    unsigned int xdp_redirect;
    char __data[0];
};

struct trace_event_raw_xdp_devmap_xmit {
    struct trace_entry ent;
    int from_ifindex;
    u32 act;
    int to_ifindex;
    int drops;
    int sent;
    int err;
    char __data[0];
};

struct trace_event_raw_xdp_exception {
    struct trace_entry ent;
    int prog_id;
    u32 act;
    int ifindex;
    char __data[0];
};

struct trace_event_raw_xdp_redirect_template {
    struct trace_entry ent;
    int prog_id;
    u32 act;
    int ifindex;
    int err;
    int to_ifindex;
    u32 map_id;
    int map_index;
    char __data[0];
};

struct trace_event_raw_xhci_dbc_log_request {
    struct trace_entry ent;
    struct dbc_request *req;
    bool dir;
    unsigned int actual;
    unsigned int length;
    int status;
    char __data[0];
};

struct trace_event_raw_xhci_log_ctrl_ctx {
    struct trace_entry ent;
    u32 drop;
    u32 add;
    char __data[0];
};

struct trace_event_raw_xhci_log_ctx {
    struct trace_entry ent;
    int ctx_64;
    unsigned int ctx_type;
    dma_addr_t ctx_dma;
    u8 *ctx_va;
    unsigned int ctx_ep_num;
    u32 __data_loc_ctx_data;
    char __data[0];
};

struct trace_event_raw_xhci_log_doorbell {
    struct trace_entry ent;
    u32 slot;
    u32 doorbell;
    char __data[0];
};

struct trace_event_raw_xhci_log_ep_ctx {
    struct trace_entry ent;
    u32 info;
    u32 info2;
    u64 deq;
    u32 tx_info;
    char __data[0];
};

struct trace_event_raw_xhci_log_free_virt_dev {
    struct trace_entry ent;
    void *vdev;
    long long unsigned int out_ctx;
    long long unsigned int in_ctx;
    int slot_id;
    u16 current_mel;
    char __data[0];
};

struct trace_event_raw_xhci_log_msg {
    struct trace_entry ent;
    u32 __data_loc_msg;
    char __data[0];
};

struct trace_event_raw_xhci_log_portsc {
    struct trace_entry ent;
    u32 busnum;
    u32 portnum;
    u32 portsc;
    char __data[0];
};

struct trace_event_raw_xhci_log_ring {
    struct trace_entry ent;
    u32 type;
    void *ring;
    dma_addr_t enq;
    dma_addr_t deq;
    unsigned int num_segs;
    unsigned int stream_id;
    unsigned int cycle_state;
    unsigned int bounce_buf_len;
    char __data[0];
};

struct trace_event_raw_xhci_log_slot_ctx {
    struct trace_entry ent;
    u32 info;
    u32 info2;
    u32 tt_info;
    u32 state;
    char __data[0];
};

struct trace_event_raw_xhci_log_stream_ctx {
    struct trace_entry ent;
    unsigned int stream_id;
    u64 stream_ring;
    dma_addr_t ctx_array_dma;
    char __data[0];
};

struct trace_event_raw_xhci_log_trb {
    struct trace_entry ent;
    dma_addr_t dma;
    u32 type;
    u32 field0;
    u32 field1;
    u32 field2;
    u32 field3;
    char __data[0];
};

struct trace_event_raw_xhci_log_urb {
    struct trace_entry ent;
    u32 __data_loc_devname;
    void *urb;
    unsigned int pipe;
    unsigned int stream;
    int status;
    unsigned int flags;
    int num_mapped_sgs;
    int num_sgs;
    int length;
    int actual;
    int epnum;
    int dir_in;
    int type;
    int slot_id;
    char __data[0];
};

struct trace_event_raw_xhci_log_virt_dev {
    struct trace_entry ent;
    void *vdev;
    long long unsigned int out_ctx;
    long long unsigned int in_ctx;
    int devnum;
    int state;
    int speed;
    u8 portnum;
    u8 level;
    int slot_id;
    char __data[0];
};

struct trace_export {
    struct trace_export *next;
    void (*write)(struct trace_export *, const void *, unsigned int);
    int flags;
};

struct trace_fprobe {
    struct dyn_event devent;
    struct fprobe fp;
    const char *symbol;
    struct tracepoint *tpoint;
    struct module *mod;
    struct trace_probe tp;
};

struct trace_func_repeats {
    long unsigned int ip;
    long unsigned int parent_ip;
    long unsigned int count;
    u64 ts_last_call;
};

struct trace_kprobe {
    struct dyn_event devent;
    struct kretprobe rp;
    long unsigned int *nhit;
    const char *symbol;
    struct trace_probe tp;
};

struct trace_mark {
    long long unsigned int val;
    char sym;
};

struct trace_min_max_param {
    struct mutex *lock;
    u64 *val;
    u64 *min;
    u64 *max;
};

struct tracer_opt;

struct tracer_flags;

struct trace_option_dentry {
    struct tracer_opt *opt;
    struct tracer_flags *flags;
    struct trace_array *tr;
    struct dentry *entry;
};

struct trace_options {
    struct tracer *tracer;
    struct trace_option_dentry *topts;
};

union upper_chunk;

struct trace_pid_list {
    raw_spinlock_t lock;
    struct irq_work refill_irqwork;
    union upper_chunk *upper[256];
    union upper_chunk *upper_list;
    union lower_chunk *lower_list;
    int free_upper_chunks;
    int free_lower_chunks;
};

struct trace_print_flags {
    long unsigned int mask;
    const char *name;
};

struct trace_uprobe_filter {
    rwlock_t rwlock;
    int nr_systemwide;
    struct list_head perf_events;
};

struct trace_probe_event {
    unsigned int flags;
    struct trace_event_class class;
    struct trace_event_call call;
    struct list_head files;
    struct list_head probes;
    struct trace_uprobe_filter filter[0];
};

struct trace_probe_log {
    const char *subsystem;
    const char **argv;
    int argc;
    int index;
};

struct trace_subsystem_dir {
    struct list_head list;
    struct event_subsystem *subsystem;
    struct trace_array *tr;
    struct eventfs_inode *ei;
    int ref_count;
    int nr_events;
};

struct trace_uprobe {
    struct dyn_event devent;
    struct uprobe_consumer consumer;
    struct path path;
    char *filename;
    struct uprobe *uprobe;
    long unsigned int offset;
    long unsigned int ref_ctr_offset;
    long unsigned int *nhits;
    struct trace_probe tp;
};

struct tracefs_dir_ops {
    int (*mkdir)(const char *);
    int (*rmdir)(const char *);
};

struct tracefs_fs_info {
    kuid_t uid;
    kgid_t gid;
    umode_t mode;
    unsigned int opts;
};

struct tracefs_inode {
    struct inode vfs_inode;
    struct list_head list;
    long unsigned int flags;
    void *private;
};

struct tracepoint_ext;

struct tracepoint {
    const char *name;
    struct static_key_false key;
    struct static_call_key *static_call_key;
    void *static_call_tramp;
    void *iterator;
    void *probestub;
    struct tracepoint_func *funcs;
    struct tracepoint_ext *ext;
};

struct tracepoint_ext {
    int (*regfunc)(void);
    void (*unregfunc)(void);
    unsigned int faultable: 1;
};

struct traceprobe_parse_context {
    struct trace_event_call *event;
    const char *funcname;
    const struct btf_type *proto;
    const struct btf_param *params;
    s32 nr_params;
    struct btf *btf;
    const struct btf_type *last_type;
    u32 last_bitoffs;
    u32 last_bitsize;
    struct trace_probe *tp;
    unsigned int flags;
    int offset;
};

struct tracer {
    const char *name;
    int (*init)(struct trace_array *);
    void (*reset)(struct trace_array *);
    void (*start)(struct trace_array *);
    void (*stop)(struct trace_array *);
    int (*update_thresh)(struct trace_array *);
    void (*open)(struct trace_iterator *);
    void (*pipe_open)(struct trace_iterator *);
    void (*close)(struct trace_iterator *);
    void (*pipe_close)(struct trace_iterator *);
    ssize_t (*read)(struct trace_iterator *, struct file *, char *, size_t, loff_t *);
    ssize_t (*splice_read)(struct trace_iterator *, struct file *, loff_t *, struct pipe_inode_info *, size_t, unsigned int);
    void (*print_header)(struct seq_file *);
    enum print_line_t (*print_line)(struct trace_iterator *);
    int (*set_flag)(struct trace_array *, u32, u32, int);
    int (*flag_changed)(struct trace_array *, u32, int);
    struct tracer *next;
    struct tracer_flags *flags;
    int enabled;
    bool print_max;
    bool allow_instances;
    bool use_max_tr;
    bool noboot;
};

struct tracer_flags {
    u32 val;
    struct tracer_opt *opts;
    struct tracer *trace;
};

struct tracer_opt {
    const char *name;
    u32 bit;
};

struct tracing_log_err {
    struct list_head list;
    struct err_info info;
    char loc[128];
    char *cmd;
};

typedef int (*tracing_map_cmp_fn_t)(void *, void *);

struct tracing_map_field {
    tracing_map_cmp_fn_t cmp_fn;
    union {
        atomic64_t sum;
        unsigned int offset;
    };
};

struct tracing_map_array;

struct tracing_map_ops;

struct tracing_map {
    unsigned int key_size;
    unsigned int map_bits;
    unsigned int map_size;
    unsigned int max_elts;
    atomic_t next_elt;
    struct tracing_map_array *elts;
    struct tracing_map_array *map;
    const struct tracing_map_ops *ops;
    void *private_data;
    struct tracing_map_field fields[6];
    unsigned int n_fields;
    int key_idx[3];
    unsigned int n_keys;
    struct tracing_map_sort_key sort_key;
    unsigned int n_vars;
    atomic64_t hits;
    atomic64_t drops;
};

struct tracing_map_array {
    unsigned int entries_per_page;
    unsigned int entry_size_shift;
    unsigned int entry_shift;
    unsigned int entry_mask;
    unsigned int n_pages;
    void **pages;
};

struct tracing_map_elt {
    struct tracing_map *map;
    struct tracing_map_field *fields;
    atomic64_t *vars;
    bool *var_set;
    void *key;
    void *private_data;
};

struct tracing_map_entry {
    u32 key;
    struct tracing_map_elt *val;
};

struct tracing_map_ops {
    int (*elt_alloc)(struct tracing_map_elt *);
    void (*elt_free)(struct tracing_map_elt *);
    void (*elt_clear)(struct tracing_map_elt *);
    void (*elt_init)(struct tracing_map_elt *);
};

struct tracing_map_sort_entry {
    void *key;
    struct tracing_map_elt *elt;
    bool elt_copied;
    bool dup;
};

struct track {
    long unsigned int addr;
    depot_stack_handle_t handle;
    int cpu;
    int pid;
    long unsigned int when;
};

struct track_data {
    u64 track_val;
    bool updated;
    unsigned int key_len;
    void *key;
    struct tracing_map_elt elt;
    struct action_data *action_data;
    struct hist_trigger_data *hist_data;
};

struct trans_pgd_info {
    void * (*trans_alloc_page)(void *);
    void *trans_alloc_arg;
};

struct transaction_chp_stats_s {
    long unsigned int cs_chp_time;
    __u32 cs_forced_to_close;
    __u32 cs_written;
    __u32 cs_dropped;
};

struct transaction_s {
    journal_t *t_journal;
    tid_t t_tid;
    enum {
        T_RUNNING = 0,
        T_LOCKED = 1,
        T_SWITCH = 2,
        T_FLUSH = 3,
        T_COMMIT = 4,
        T_COMMIT_DFLUSH = 5,
        T_COMMIT_JFLUSH = 6,
        T_COMMIT_CALLBACK = 7,
        T_FINISHED = 8,
    } t_state;
    long unsigned int t_log_start;
    int t_nr_buffers;
    struct journal_head *t_reserved_list;
    struct journal_head *t_buffers;
    struct journal_head *t_forget;
    struct journal_head *t_checkpoint_list;
    struct journal_head *t_shadow_list;
    struct list_head t_inode_list;
    long unsigned int t_max_wait;
    long unsigned int t_start;
    long unsigned int t_requested;
    struct transaction_chp_stats_s t_chp_stats;
    atomic_t t_updates;
    atomic_t t_outstanding_credits;
    atomic_t t_outstanding_revokes;
    atomic_t t_handle_count;
    transaction_t *t_cpnext;
    transaction_t *t_cpprev;
    long unsigned int t_expires;
    ktime_t t_start_time;
    unsigned int t_synchronous_commit: 1;
    int t_need_data_flush;
    struct list_head t_private_list;
};

struct trap_bits {
    const enum vcpu_sysreg index;
    const enum trap_behaviour behaviour;
    const u64 value;
    const u64 mask;
};

struct trc_stall_chk_rdr {
    int nesting;
    int ipi_to_cpu;
    u8 needqs;
};

typedef struct tree_desc_s tree_desc;

struct tree_descr {
    const char *name;
    const struct file_operations *ops;
    int mode;
};

struct trie_use_stats;

struct trie {
    struct key_vector kv[1];
    struct trie_use_stats *stats;
};

struct trie_stat {
    unsigned int totdepth;
    unsigned int maxdepth;
    unsigned int tnodes;
    unsigned int leaves;
    unsigned int nullpointers;
    unsigned int prefixes;
    unsigned int nodesizes[32];
};

struct trie_use_stats {
    unsigned int gets;
    unsigned int backtrack;
    unsigned int semantic_match_passed;
    unsigned int semantic_match_miss;
    unsigned int null_node_hit;
    unsigned int resize_node_skipped;
};

struct trusted_key_payload;

struct trusted_key_ops {
    unsigned char migratable;
    int (*init)(void);
    int (*seal)(struct trusted_key_payload *, char *);
    int (*unseal)(struct trusted_key_payload *, char *);
    int (*get_random)(unsigned char *, size_t);
    void (*exit)(void);
};

struct trusted_key_options {
    uint16_t keytype;
    uint32_t keyhandle;
    unsigned char keyauth[20];
    uint32_t blobauth_len;
    unsigned char blobauth[20];
    uint32_t pcrinfo_len;
    unsigned char pcrinfo[64];
    int pcrlock;
    uint32_t hash;
    uint32_t policydigest_len;
    unsigned char policydigest[64];
    uint32_t policyhandle;
};

struct trusted_key_payload {
    struct callback_head rcu;
    unsigned int key_len;
    unsigned int blob_len;
    unsigned char migratable;
    unsigned char old_format;
    unsigned char key[129];
    unsigned char blob[512];
};

struct trusted_key_source {
    char *name;
    struct trusted_key_ops *ops;
};

struct ts_ops;

struct ts_state;

struct ts_config {
    struct ts_ops *ops;
    int flags;
    unsigned int (*get_next_block)(unsigned int, const u8 **, struct ts_config *, struct ts_state *);
    void (*finish)(struct ts_config *, struct ts_state *);
};

struct ts_linear_state {
    unsigned int len;
    const void *data;
};

struct ts_ops {
    const char *name;
    struct ts_config * (*init)(const void *, unsigned int, gfp_t, int);
    unsigned int (*find)(struct ts_config *, struct ts_state *);
    void (*destroy)(struct ts_config *);
    void * (*get_pattern)(struct ts_config *);
    unsigned int (*get_pattern_len)(struct ts_config *);
    struct module *owner;
    struct list_head list;
};

struct ts_state {
    unsigned int offset;
    char cb[48];
};

struct tsconfig_reply_data {
    struct ethnl_reply_data base;
    struct hwtstamp_provider_desc hwprov_desc;
    struct {
        u32 tx_type;
        u32 rx_filter;
        u32 flags;
    } hwtst_config;
};

struct tsconfig_req_info {
    struct ethnl_req_info base;
};

struct tsinfo_reply_data {
    struct ethnl_reply_data base;
    struct kernel_ethtool_ts_info ts_info;
    struct ethtool_ts_stats stats;
};

struct tsinfo_req_info {
    struct ethnl_req_info base;
    struct hwtstamp_provider_desc hwprov_desc;
};

struct tso_t {
    int next_frag_idx;
    int size;
    void *data;
    u16 ip_id;
    u8 tlen;
    bool ipv6;
    u32 tcp_seq;
};

struct tsq_tasklet {
    struct tasklet_struct tasklet;
    struct list_head head;
};

struct tty_audit_buf {
    struct mutex mutex;
    dev_t dev;
    bool icanon;
    size_t valid;
    u8 *data;
};

struct tty_operations;

struct tty_driver {
    struct kref kref;
    struct cdev **cdevs;
    struct module *owner;
    const char *driver_name;
    const char *name;
    int name_base;
    int major;
    int minor_start;
    unsigned int num;
    short int type;
    short int subtype;
    struct ktermios init_termios;
    long unsigned int flags;
    struct proc_dir_entry *proc_entry;
    struct tty_driver *other;
    struct tty_struct **ttys;
    struct tty_port **ports;
    struct ktermios **termios;
    void *driver_state;
    const struct tty_operations *ops;
    struct list_head tty_drivers;
};

struct tty_file_private {
    struct tty_struct *tty;
    struct file *file;
    struct list_head list;
};

struct tty_ldisc_ops;

struct tty_ldisc {
    struct tty_ldisc_ops *ops;
    struct tty_struct *tty;
};

struct tty_ldisc_ops {
    char *name;
    int num;
    int (*open)(struct tty_struct *);
    void (*close)(struct tty_struct *);
    void (*flush_buffer)(struct tty_struct *);
    ssize_t (*read)(struct tty_struct *, struct file *, u8 *, size_t, void **, long unsigned int);
    ssize_t (*write)(struct tty_struct *, struct file *, const u8 *, size_t);
    int (*ioctl)(struct tty_struct *, unsigned int, long unsigned int);
    int (*compat_ioctl)(struct tty_struct *, unsigned int, long unsigned int);
    void (*set_termios)(struct tty_struct *, const struct ktermios *);
    __poll_t (*poll)(struct tty_struct *, struct file *, struct poll_table_struct *);
    void (*hangup)(struct tty_struct *);
    void (*receive_buf)(struct tty_struct *, const u8 *, const u8 *, size_t);
    void (*write_wakeup)(struct tty_struct *);
    void (*dcd_change)(struct tty_struct *, bool);
    size_t (*receive_buf2)(struct tty_struct *, const u8 *, const u8 *, size_t);
    void (*lookahead_buf)(struct tty_struct *, const u8 *, const u8 *, size_t);
    struct module *owner;
};

struct tty_operations {
    struct tty_struct * (*lookup)(struct tty_driver *, struct file *, int);
    int (*install)(struct tty_driver *, struct tty_struct *);
    void (*remove)(struct tty_driver *, struct tty_struct *);
    int (*open)(struct tty_struct *, struct file *);
    void (*close)(struct tty_struct *, struct file *);
    void (*shutdown)(struct tty_struct *);
    void (*cleanup)(struct tty_struct *);
    ssize_t (*write)(struct tty_struct *, const u8 *, size_t);
    int (*put_char)(struct tty_struct *, u8);
    void (*flush_chars)(struct tty_struct *);
    unsigned int (*write_room)(struct tty_struct *);
    unsigned int (*chars_in_buffer)(struct tty_struct *);
    int (*ioctl)(struct tty_struct *, unsigned int, long unsigned int);
    long int (*compat_ioctl)(struct tty_struct *, unsigned int, long unsigned int);
    void (*set_termios)(struct tty_struct *, const struct ktermios *);
    void (*throttle)(struct tty_struct *);
    void (*unthrottle)(struct tty_struct *);
    void (*stop)(struct tty_struct *);
    void (*start)(struct tty_struct *);
    void (*hangup)(struct tty_struct *);
    int (*break_ctl)(struct tty_struct *, int);
    void (*flush_buffer)(struct tty_struct *);
    int (*ldisc_ok)(struct tty_struct *, int);
    void (*set_ldisc)(struct tty_struct *);
    void (*wait_until_sent)(struct tty_struct *, int);
    void (*send_xchar)(struct tty_struct *, u8);
    int (*tiocmget)(struct tty_struct *);
    int (*tiocmset)(struct tty_struct *, unsigned int, unsigned int);
    int (*resize)(struct tty_struct *, struct winsize *);
    int (*get_icount)(struct tty_struct *, struct serial_icounter_struct *);
    int (*get_serial)(struct tty_struct *, struct serial_struct *);
    int (*set_serial)(struct tty_struct *, struct serial_struct *);
    void (*show_fdinfo)(struct tty_struct *, struct seq_file *);
    int (*poll_init)(struct tty_driver *, int, char *);
    int (*poll_get_char)(struct tty_driver *, int);
    void (*poll_put_char)(struct tty_driver *, int, char);
    int (*proc_show)(struct seq_file *, void *);
};

struct tty_port_client_operations {
    size_t (*receive_buf)(struct tty_port *, const u8 *, const u8 *, size_t);
    void (*lookahead_buf)(struct tty_port *, const u8 *, const u8 *, size_t);
    void (*write_wakeup)(struct tty_port *);
};

struct tty_port_operations {
    bool (*carrier_raised)(struct tty_port *);
    void (*dtr_rts)(struct tty_port *, bool);
    void (*shutdown)(struct tty_port *);
    int (*activate)(struct tty_port *, struct tty_struct *);
    void (*destruct)(struct tty_port *);
};

struct tty_struct {
    struct kref kref;
    int index;
    struct device *dev;
    struct tty_driver *driver;
    struct tty_port *port;
    const struct tty_operations *ops;
    struct tty_ldisc *ldisc;
    struct ld_semaphore ldisc_sem;
    struct mutex atomic_write_lock;
    struct mutex legacy_mutex;
    struct mutex throttle_mutex;
    struct rw_semaphore termios_rwsem;
    struct mutex winsize_mutex;
    struct ktermios termios;
    struct ktermios termios_locked;
    char name[64];
    long unsigned int flags;
    int count;
    unsigned int receive_room;
    struct winsize winsize;
    struct {
        spinlock_t lock;
        bool stopped;
        bool tco_stopped;
    } flow;
    struct {
        struct pid *pgrp;
        struct pid *session;
        spinlock_t lock;
        unsigned char pktstatus;
        bool packet;
    } ctrl;
    bool hw_stopped;
    bool closing;
    int flow_change;
    struct tty_struct *link;
    struct fasync_struct *fasync;
    wait_queue_head_t write_wait;
    wait_queue_head_t read_wait;
    struct work_struct hangup_work;
    void *disc_data;
    void *driver_data;
    spinlock_t files_lock;
    int write_cnt;
    u8 *write_buf;
    struct list_head tty_files;
    struct work_struct SAK_work;
};

struct ttyprintk_port {
    struct tty_port port;
    spinlock_t spinlock;
};

struct tun_security_struct {
    u32 sid;
};

struct type_datum {
    u32 value;
    u32 bounds;
    unsigned char primary;
    unsigned char attribute;
};

struct type_descriptor {
    u16 type_kind;
    u16 type_info;
    char type_name[0];
};

struct type_mismatch_data {
    struct source_location location;
    struct type_descriptor *type;
    long unsigned int alignment;
    unsigned char type_check_kind;
};

struct type_mismatch_data_common {
    struct source_location *location;
    struct type_descriptor *type;
    long unsigned int alignment;
    unsigned char type_check_kind;
};

struct type_mismatch_data_v1 {
    struct source_location location;
    struct type_descriptor *type;
    unsigned char log_alignment;
    unsigned char type_check_kind;
};

struct type_set {
    struct ebitmap types;
    struct ebitmap negset;
    u32 flags;
};

struct typec_connector {
    void (*attach)(struct typec_connector *, struct device *);
    void (*deattach)(struct typec_connector *, struct device *);
};

struct u32_fract {
    __u32 numerator;
    __u32 denominator;
};

struct uart_8250_em485 {
    struct hrtimer start_tx_timer;
    struct hrtimer stop_tx_timer;
    struct hrtimer *active_timer;
    struct uart_8250_port *port;
    unsigned int tx_stopped: 1;
};

struct uart_8250_ops {
    int (*setup_irq)(struct uart_8250_port *);
    void (*release_irq)(struct uart_8250_port *);
    void (*setup_timer)(struct uart_8250_port *);
};

struct uart_8250_port {
    struct uart_port port;
    struct timer_list timer;
    struct list_head list;
    u32 capabilities;
    u16 bugs;
    unsigned int tx_loadsz;
    unsigned char acr;
    unsigned char fcr;
    unsigned char ier;
    unsigned char lcr;
    unsigned char mcr;
    unsigned char cur_iotype;
    unsigned int rpm_tx_active;
    unsigned char canary;
    unsigned char probe;
    struct mctrl_gpios *gpios;
    u16 lsr_saved_flags;
    u16 lsr_save_mask;
    unsigned char msr_saved_flags;
    struct uart_8250_dma *dma;
    const struct uart_8250_ops *ops;
    u32 (*dl_read)(struct uart_8250_port *);
    void (*dl_write)(struct uart_8250_port *, u32);
    struct uart_8250_em485 *em485;
    void (*rs485_start_tx)(struct uart_8250_port *, bool);
    void (*rs485_stop_tx)(struct uart_8250_port *, bool);
    struct delayed_work overrun_backoff;
    u32 overrun_backoff_time_ms;
};

struct vendor_data;

struct uart_amba_port {
    struct uart_port port;
    const u16 *reg_offset;
    struct clk *clk;
    const struct vendor_data *vendor;
    unsigned int im;
    unsigned int old_status;
    unsigned int fifosize;
    unsigned int fixed_baud;
    char type[12];
    ktime_t rs485_tx_drain_interval;
    enum pl011_rs485_tx_state rs485_tx_state;
    struct hrtimer trigger_start_tx;
    struct hrtimer trigger_stop_tx;
    unsigned int dmacr;
    bool using_tx_dma;
    bool using_rx_dma;
    struct pl011_dmarx_data dmarx;
    struct pl011_dmatx_data dmatx;
    bool dma_probed;
};

struct uart_driver {
    struct module *owner;
    const char *driver_name;
    const char *dev_name;
    int major;
    int minor;
    int nr;
    struct console *cons;
    struct uart_state *state;
    struct tty_driver *tty_driver;
};

struct uart_match {
    struct uart_port *port;
    struct uart_driver *driver;
};

struct uart_ops {
    unsigned int (*tx_empty)(struct uart_port *);
    void (*set_mctrl)(struct uart_port *, unsigned int);
    unsigned int (*get_mctrl)(struct uart_port *);
    void (*stop_tx)(struct uart_port *);
    void (*start_tx)(struct uart_port *);
    void (*throttle)(struct uart_port *);
    void (*unthrottle)(struct uart_port *);
    void (*send_xchar)(struct uart_port *, char);
    void (*stop_rx)(struct uart_port *);
    void (*start_rx)(struct uart_port *);
    void (*enable_ms)(struct uart_port *);
    void (*break_ctl)(struct uart_port *, int);
    int (*startup)(struct uart_port *);
    void (*shutdown)(struct uart_port *);
    void (*flush_buffer)(struct uart_port *);
    void (*set_termios)(struct uart_port *, struct ktermios *, const struct ktermios *);
    void (*set_ldisc)(struct uart_port *, struct ktermios *);
    void (*pm)(struct uart_port *, unsigned int, unsigned int);
    const char * (*type)(struct uart_port *);
    void (*release_port)(struct uart_port *);
    int (*request_port)(struct uart_port *);
    void (*config_port)(struct uart_port *, int);
    int (*verify_port)(struct uart_port *, struct serial_struct *);
    int (*ioctl)(struct uart_port *, unsigned int, long unsigned int);
    int (*poll_init)(struct uart_port *);
    void (*poll_put_char)(struct uart_port *, unsigned char);
    int (*poll_get_char)(struct uart_port *);
};

struct uart_state {
    struct tty_port port;
    enum uart_pm_state pm_state;
    atomic_t refcount;
    wait_queue_head_t remove_wait;
    struct uart_port *uart_port;
};

struct ubuf_info_msgzc {
    struct ubuf_info ubuf;
    union {
        struct {
            long unsigned int desc;
            void *ctx;
        };
        struct {
            u32 id;
            u16 len;
            u16 zerocopy: 1;
            u32 bytelen;
        };
    };
    struct mmpin mmp;
};

struct ubuf_info_ops {
    void (*complete)(struct sk_buff *, struct ubuf_info *, bool);
    int (*link_skb)(struct sk_buff *, struct ubuf_info *);
};

struct ucounts {
    struct hlist_node node;
    struct user_namespace *ns;
    kuid_t uid;
    atomic_t count;
    atomic_long_t ucount[12];
    atomic_long_t rlimit[4];
};

struct ucred {
    __u32 pid;
    __u32 uid;
    __u32 gid;
};

struct udmabuf {
    long unsigned int pagecount;
    struct folio **folios;
    long unsigned int nr_pinned;
    struct folio **pinned_folios;
    struct sg_table *sg;
    struct miscdevice *device;
    long unsigned int *offsets;
};

struct udmabuf_create {
    __u32 memfd;
    __u32 flags;
    __u64 offset;
    __u64 size;
};

struct udmabuf_create_item {
    __u32 memfd;
    __u32 __pad;
    __u64 offset;
    __u64 size;
};

struct udmabuf_create_list {
    __u32 flags;
    __u32 count;
    struct udmabuf_create_item list[0];
};

struct udp_sock {
    struct inet_sock inet;
    long unsigned int udp_flags;
    int pending;
    __u8 encap_type;
    __u16 udp_lrpa_hash;
    struct hlist_nulls_node udp_lrpa_node;
    __u16 len;
    __u16 gso_size;
    __u16 pcslen;
    __u16 pcrlen;
    int (*encap_rcv)(struct sock *, struct sk_buff *);
    void (*encap_err_rcv)(struct sock *, struct sk_buff *, int, __be16, u32, u8 *);
    int (*encap_err_lookup)(struct sock *, struct sk_buff *);
    void (*encap_destroy)(struct sock *);
    struct sk_buff * (*gro_receive)(struct sock *, struct list_head *, struct sk_buff *);
    int (*gro_complete)(struct sock *, struct sk_buff *, int);
    struct sk_buff_head reader_queue;
    int forward_deficit;
    int forward_threshold;
    bool peeking_with_offset;
    long: 64;
    long: 64;
    long: 64;
};

struct udp6_sock {
    struct udp_sock udp;
    struct ipv6_pinfo inet6;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
};

struct udp_dev_scratch {
    u32 _tsize_state;
    u16 len;
    bool is_linear;
    bool csum_unnecessary;
};

struct udp_hslot {
    union {
        struct hlist_head head;
        struct hlist_nulls_head nulls_head;
    };
    int count;
    spinlock_t lock;
};

struct udp_hslot_main {
    struct udp_hslot hslot;
    u32 hash4_cnt;
    long: 64;
};

struct udp_mib {
    long unsigned int mibs[10];
};

struct udp_seq_afinfo {
    sa_family_t family;
    struct udp_table *udp_table;
};

struct udp_skb_cb {
    union {
        struct inet_skb_parm h4;
        struct inet6_skb_parm h6;
    } header;
    __u16 cscov;
    __u8 partial_cov;
};

struct udp_table {
    struct udp_hslot *hash;
    struct udp_hslot_main *hash2;
    struct udp_hslot *hash4;
    unsigned int mask;
    unsigned int log;
};

struct udp_tunnel_info {
    short unsigned int type;
    sa_family_t sa_family;
    __be16 port;
    u8 hw_priv;
};

struct udp_tunnel_nic_table_info {
    unsigned int n_entries;
    unsigned int tunnel_types;
};

struct udp_tunnel_nic_shared;

struct udp_tunnel_nic_info {
    int (*set_port)(struct net_device *, unsigned int, unsigned int, struct udp_tunnel_info *);
    int (*unset_port)(struct net_device *, unsigned int, unsigned int, struct udp_tunnel_info *);
    int (*sync_table)(struct net_device *, unsigned int);
    struct udp_tunnel_nic_shared *shared;
    unsigned int flags;
    struct udp_tunnel_nic_table_info tables[4];
};

struct udp_tunnel_nic_ops {
    void (*get_port)(struct net_device *, unsigned int, unsigned int, struct udp_tunnel_info *);
    void (*set_port_priv)(struct net_device *, unsigned int, unsigned int, u8);
    void (*add_port)(struct net_device *, struct udp_tunnel_info *);
    void (*del_port)(struct net_device *, struct udp_tunnel_info *);
    void (*reset_ntf)(struct net_device *);
    size_t (*dump_size)(struct net_device *, unsigned int);
    int (*dump_write)(struct net_device *, unsigned int, struct sk_buff *);
};

struct udp_tunnel_nic_shared {
    struct udp_tunnel_nic *udp_tunnel_nic_info;
    struct list_head devices;
};

struct uevent_sock {
    struct list_head list;
    struct sock *sk;
};

struct uffd_msg {
    __u8 event;
    __u8 reserved1;
    __u16 reserved2;
    __u32 reserved3;
    union {
        struct {
            __u64 flags;
            __u64 address;
            union {
                __u32 ptid;
            } feat;
        } pagefault;
        struct {
            __u32 ufd;
        } fork;
        struct {
            __u64 from;
            __u64 to;
            __u64 len;
        } remap;
        struct {
            __u64 start;
            __u64 end;
        } remove;
        struct {
            __u64 reserved1;
            __u64 reserved2;
            __u64 reserved3;
        } reserved;
    } arg;
};

struct uffdio_api {
    __u64 api;
    __u64 features;
    __u64 ioctls;
};

struct uffdio_range {
    __u64 start;
    __u64 len;
};

struct uffdio_continue {
    struct uffdio_range range;
    __u64 mode;
    __s64 mapped;
};

struct uffdio_copy {
    __u64 dst;
    __u64 src;
    __u64 len;
    __u64 mode;
    __s64 copy;
};

struct uffdio_move {
    __u64 dst;
    __u64 src;
    __u64 len;
    __u64 mode;
    __s64 move;
};

struct uffdio_poison {
    struct uffdio_range range;
    __u64 mode;
    __s64 updated;
};

struct uffdio_register {
    struct uffdio_range range;
    __u64 mode;
    __u64 ioctls;
};

struct uffdio_writeprotect {
    struct uffdio_range range;
    __u64 mode;
};

struct uffdio_zeropage {
    struct uffdio_range range;
    __u64 mode;
    __s64 zeropage;
};

struct uncached_list {
    spinlock_t lock;
    struct list_head head;
};

struct uncharge_gather {
    struct mem_cgroup *memcg;
    long unsigned int nr_memory;
    long unsigned int pgpgout;
    long unsigned int nr_kmem;
    int nid;
};

struct uni_pagedict {
    u16 **uni_pgdir[32];
    long unsigned int refcount;
    long unsigned int sum;
    unsigned char *inverse_translations[4];
    u16 *inverse_trans_unicode;
};

struct utf8data;

struct utf8data_table;

struct unicode_map {
    unsigned int version;
    const struct utf8data *ntab[2];
    const struct utf8data_table *tables;
};

struct unimac_mdio_pdata {
    u32 phy_mask;
    int (*wait_func)(void *);
    void *wait_func_data;
    const char *bus_name;
    struct clk *clk;
};

struct unimac_mdio_priv {
    struct mii_bus *mii_bus;
    void *base;
    int (*wait_func)(void *);
    void *wait_func_data;
    struct clk *clk;
    u32 clk_freq;
};

struct unipair;

struct unimapdesc {
    short unsigned int entry_ct;
    struct unipair *entries;
};

struct unipair {
    short unsigned int unicode;
    short unsigned int fontpos;
};

struct unix_address {
    refcount_t refcnt;
    int len;
    struct sockaddr_un name[0];
};

struct unix_edge {
    struct unix_sock *predecessor;
    struct unix_sock *successor;
    struct list_head vertex_entry;
    struct list_head stack_entry;
};

struct unix_skb_parms {
    struct pid *pid;
    kuid_t uid;
    kgid_t gid;
    struct scm_fp_list *fp;
    u32 secid;
    u32 consumed;
};

struct unix_vertex;

struct unix_sock {
    struct sock sk;
    struct unix_address *addr;
    struct path path;
    struct mutex iolock;
    struct mutex bindlock;
    struct sock *peer;
    struct sock *listener;
    struct unix_vertex *vertex;
    spinlock_t lock;
    struct socket_wq peer_wq;
    wait_queue_entry_t peer_wake;
    struct scm_stat scm_stat;
    struct sk_buff *oob_skb;
};

struct unix_stream_read_state {
    int (*recv_actor)(struct sk_buff *, int, int, struct unix_stream_read_state *);
    struct socket *socket;
    struct msghdr *msg;
    struct pipe_inode_info *pipe;
    size_t size;
    int flags;
    unsigned int splice_flags;
};

struct unix_vertex {
    struct list_head edges;
    struct list_head entry;
    struct list_head scc_entry;
    long unsigned int out_degree;
    long unsigned int index;
    long unsigned int scc_index;
};

struct unixware_slice {
    __le16 s_label;
    __le16 s_flags;
    __le32 start_sect;
    __le32 nr_sects;
};

struct unixware_vtoc {
    __le32 v_magic;
    __le32 v_version;
    char v_name[8];
    __le16 v_nslices;
    __le16 v_unknown1;
    __le32 v_reserved[10];
    struct unixware_slice v_slice[16];
};

struct unixware_disklabel {
    __le32 d_type;
    __le32 d_magic;
    __le32 d_version;
    char d_serial[12];
    __le32 d_ncylinders;
    __le32 d_ntracks;
    __le32 d_nsectors;
    __le32 d_secsize;
    __le32 d_part_start;
    __le32 d_unknown1[12];
    __le32 d_alt_tbl;
    __le32 d_alt_len;
    __le32 d_phys_cyl;
    __le32 d_phys_trk;
    __le32 d_phys_sec;
    __le32 d_phys_bytes;
    __le32 d_unknown2;
    __le32 d_unknown3;
    __le32 d_pad[8];
    struct unixware_vtoc vtoc;
};

struct unlink_vma_file_batch {
    int count;
    struct vm_area_struct *vmas[8];
};

struct unreachable_data {
    struct source_location location;
};

struct update_classid_context {
    u32 classid;
    unsigned int batch;
};

union upper_chunk {
    union upper_chunk *next;
    union lower_chunk *data[256];
};

struct uprobe {
    struct rb_node rb_node;
    refcount_t ref;
    struct rw_semaphore register_rwsem;
    struct rw_semaphore consumer_rwsem;
    struct list_head pending_list;
    struct list_head consumers;
    struct inode *inode;
    union {
        struct callback_head rcu;
        struct work_struct work;
    };
    loff_t offset;
    loff_t ref_ctr_offset;
    long unsigned int flags;
    struct arch_uprobe arch;
};

struct uprobe_cpu_buffer {
    struct mutex mutex;
    void *buf;
    int dsize;
};

struct uprobe_dispatch_data {
    struct trace_uprobe *tu;
    long unsigned int bp_addr;
};

struct uprobe_task {
    enum uprobe_task_state state;
    unsigned int depth;
    struct return_instance *return_instances;
    struct return_instance *ri_pool;
    struct timer_list ri_timer;
    seqcount_t ri_seqcount;
    union {
        struct {
            struct arch_uprobe_task autask;
            long unsigned int vaddr;
        };
        struct {
            struct callback_head dup_xol_work;
            long unsigned int dup_xol_addr;
        };
    };
    struct uprobe *active_uprobe;
    long unsigned int xol_vaddr;
    struct arch_uprobe *auprobe;
};

struct uprobe_trace_entry_head {
    struct trace_entry ent;
    long unsigned int vaddr[0];
};

typedef void (*usb_complete_t)(struct urb *);

struct usb_iso_packet_descriptor {
    unsigned int offset;
    unsigned int length;
    unsigned int actual_length;
    int status;
};

struct urb {
    struct kref kref;
    int unlinked;
    void *hcpriv;
    atomic_t use_count;
    atomic_t reject;
    struct list_head urb_list;
    struct list_head anchor_list;
    struct usb_anchor *anchor;
    struct usb_device *dev;
    struct usb_host_endpoint *ep;
    unsigned int pipe;
    unsigned int stream_id;
    int status;
    unsigned int transfer_flags;
    void *transfer_buffer;
    dma_addr_t transfer_dma;
    struct scatterlist *sg;
    int num_mapped_sgs;
    int num_sgs;
    u32 transfer_buffer_length;
    u32 actual_length;
    unsigned char *setup_packet;
    dma_addr_t setup_dma;
    int start_frame;
    int number_of_packets;
    int interval;
    int error_count;
    void *context;
    usb_complete_t complete;
    struct usb_iso_packet_descriptor iso_frame_desc[0];
};

struct xhci_segment;

struct xhci_td {
    struct list_head td_list;
    struct list_head cancelled_td_list;
    int status;
    enum xhci_cancelled_td_status cancel_status;
    struct urb *urb;
    struct xhci_segment *start_seg;
    union xhci_trb *start_trb;
    struct xhci_segment *end_seg;
    union xhci_trb *end_trb;
    struct xhci_segment *bounce_seg;
    bool urb_length_set;
    bool error_mid_td;
};

struct urb_priv {
    int num_tds;
    int num_tds_done;
    struct xhci_td td[0];
};

struct usage_priority {
    __u32 usage;
    bool global;
    unsigned int slot_overwrite;
};

struct usb2_lpm_parameters {
    unsigned int besl;
    int timeout;
};

struct usb3_lpm_parameters {
    unsigned int mel;
    unsigned int pel;
    unsigned int sel;
    int timeout;
};

struct usb_bos_descriptor {
    __u8 bLength;
    __u8 bDescriptorType;
    __le16 wTotalLength;
    __u8 bNumDeviceCaps;
} __attribute__((packed));

struct mon_bus;

struct usb_bus {
    struct device *controller;
    struct device *sysdev;
    int busnum;
    const char *bus_name;
    u8 uses_pio_for_control;
    u8 otg_port;
    unsigned int is_b_host: 1;
    unsigned int b_hnp_enable: 1;
    unsigned int no_stop_on_short: 1;
    unsigned int no_sg_constraint: 1;
    unsigned int sg_tablesize;
    int devnum_next;
    struct mutex devnum_next_mutex;
    long unsigned int devmap[2];
    struct usb_device *root_hub;
    struct usb_bus *hs_companion;
    int bandwidth_allocated;
    int bandwidth_int_reqs;
    int bandwidth_isoc_reqs;
    unsigned int resuming_ports;
    struct mon_bus *mon_bus;
    int monitored;
};

struct usb_cdc_acm_descriptor {
    __u8 bLength;
    __u8 bDescriptorType;
    __u8 bDescriptorSubType;
    __u8 bmCapabilities;
};

struct usb_cdc_call_mgmt_descriptor {
    __u8 bLength;
    __u8 bDescriptorType;
    __u8 bDescriptorSubType;
    __u8 bmCapabilities;
    __u8 bDataInterface;
};

struct usb_cdc_country_functional_desc {
    __u8 bLength;
    __u8 bDescriptorType;
    __u8 bDescriptorSubType;
    __u8 iCountryCodeRelDate;
    __le16 wCountyCode0;
};

struct usb_cdc_dmm_desc {
    __u8 bFunctionLength;
    __u8 bDescriptorType;
    __u8 bDescriptorSubtype;
    __u16 bcdVersion;
    __le16 wMaxCommand;
} __attribute__((packed));

struct usb_cdc_ether_desc {
    __u8 bLength;
    __u8 bDescriptorType;
    __u8 bDescriptorSubType;
    __u8 iMACAddress;
    __le32 bmEthernetStatistics;
    __le16 wMaxSegmentSize;
    __le16 wNumberMCFilters;
    __u8 bNumberPowerFilters;
} __attribute__((packed));

struct usb_cdc_header_desc {
    __u8 bLength;
    __u8 bDescriptorType;
    __u8 bDescriptorSubType;
    __le16 bcdCDC;
} __attribute__((packed));

struct usb_cdc_mbim_desc {
    __u8 bLength;
    __u8 bDescriptorType;
    __u8 bDescriptorSubType;
    __le16 bcdMBIMVersion;
    __le16 wMaxControlMessage;
    __u8 bNumberFilters;
    __u8 bMaxFilterSize;
    __le16 wMaxSegmentSize;
    __u8 bmNetworkCapabilities;
} __attribute__((packed));

struct usb_cdc_mbim_extended_desc {
    __u8 bLength;
    __u8 bDescriptorType;
    __u8 bDescriptorSubType;
    __le16 bcdMBIMExtendedVersion;
    __u8 bMaxOutstandingCommandMessages;
    __le16 wMTU;
} __attribute__((packed));

struct usb_cdc_mdlm_desc {
    __u8 bLength;
    __u8 bDescriptorType;
    __u8 bDescriptorSubType;
    __le16 bcdVersion;
    __u8 bGUID[16];
} __attribute__((packed));

struct usb_cdc_mdlm_detail_desc {
    __u8 bLength;
    __u8 bDescriptorType;
    __u8 bDescriptorSubType;
    __u8 bGuidDescriptorType;
    __u8 bDetailData[0];
};

struct usb_cdc_ncm_desc {
    __u8 bLength;
    __u8 bDescriptorType;
    __u8 bDescriptorSubType;
    __le16 bcdNcmVersion;
    __u8 bmNetworkCapabilities;
} __attribute__((packed));

struct usb_cdc_network_terminal_desc {
    __u8 bLength;
    __u8 bDescriptorType;
    __u8 bDescriptorSubType;
    __u8 bEntityId;
    __u8 iName;
    __u8 bChannelIndex;
    __u8 bPhysicalInterface;
};

struct usb_cdc_obex_desc {
    __u8 bLength;
    __u8 bDescriptorType;
    __u8 bDescriptorSubType;
    __le16 bcdVersion;
} __attribute__((packed));

struct usb_cdc_union_desc;

struct usb_cdc_parsed_header {
    struct usb_cdc_union_desc *usb_cdc_union_desc;
    struct usb_cdc_header_desc *usb_cdc_header_desc;
    struct usb_cdc_call_mgmt_descriptor *usb_cdc_call_mgmt_descriptor;
    struct usb_cdc_acm_descriptor *usb_cdc_acm_descriptor;
    struct usb_cdc_country_functional_desc *usb_cdc_country_functional_desc;
    struct usb_cdc_network_terminal_desc *usb_cdc_network_terminal_desc;
    struct usb_cdc_ether_desc *usb_cdc_ether_desc;
    struct usb_cdc_dmm_desc *usb_cdc_dmm_desc;
    struct usb_cdc_mdlm_desc *usb_cdc_mdlm_desc;
    struct usb_cdc_mdlm_detail_desc *usb_cdc_mdlm_detail_desc;
    struct usb_cdc_obex_desc *usb_cdc_obex_desc;
    struct usb_cdc_ncm_desc *usb_cdc_ncm_desc;
    struct usb_cdc_mbim_desc *usb_cdc_mbim_desc;
    struct usb_cdc_mbim_extended_desc *usb_cdc_mbim_extended_desc;
    bool phonet_magic_present;
};

struct usb_cdc_union_desc {
    __u8 bLength;
    __u8 bDescriptorType;
    __u8 bDescriptorSubType;
    __u8 bMasterInterface0;
    __u8 bSlaveInterface0;
};

struct usb_charger_current {
    unsigned int sdp_min;
    unsigned int sdp_max;
    unsigned int dcp_min;
    unsigned int dcp_max;
    unsigned int cdp_min;
    unsigned int cdp_max;
    unsigned int aca_min;
    unsigned int aca_max;
};

struct usb_class_driver {
    char *name;
    char * (*devnode)(const struct device *, umode_t *);
    const struct file_operations *fops;
    int minor_base;
};

struct usb_config_descriptor {
    __u8 bLength;
    __u8 bDescriptorType;
    __le16 wTotalLength;
    __u8 bNumInterfaces;
    __u8 bConfigurationValue;
    __u8 iConfiguration;
    __u8 bmAttributes;
    __u8 bMaxPower;
} __attribute__((packed));

struct usb_ctrlrequest {
    __u8 bRequestType;
    __u8 bRequest;
    __le16 wValue;
    __le16 wIndex;
    __le16 wLength;
};

struct usb_descriptor_header {
    __u8 bLength;
    __u8 bDescriptorType;
};

struct usb_dev_cap_header {
    __u8 bLength;
    __u8 bDescriptorType;
    __u8 bDevCapabilityType;
};

struct usb_dev_state {
    struct list_head list;
    struct usb_device *dev;
    struct file *file;
    spinlock_t lock;
    struct list_head async_pending;
    struct list_head async_completed;
    struct list_head memory_list;
    wait_queue_head_t wait;
    wait_queue_head_t wait_for_resume;
    unsigned int discsignr;
    struct pid *disc_pid;
    const struct cred *cred;
    sigval_t disccontext;
    long unsigned int ifclaimed;
    u32 disabled_bulk_eps;
    long unsigned int interface_allowed_mask;
    int not_yet_resumed;
    bool suspend_allowed;
    bool privileges_dropped;
};

struct usb_endpoint_descriptor {
    __u8 bLength;
    __u8 bDescriptorType;
    __u8 bEndpointAddress;
    __u8 bmAttributes;
    __le16 wMaxPacketSize;
    __u8 bInterval;
    __u8 bRefresh;
    __u8 bSynchAddress;
} __attribute__((packed));

struct usb_ss_ep_comp_descriptor {
    __u8 bLength;
    __u8 bDescriptorType;
    __u8 bMaxBurst;
    __u8 bmAttributes;
    __le16 wBytesPerInterval;
};

struct usb_ssp_isoc_ep_comp_descriptor {
    __u8 bLength;
    __u8 bDescriptorType;
    __le16 wReseved;
    __le32 dwBytesPerInterval;
};

struct usb_host_endpoint {
    struct usb_endpoint_descriptor desc;
    struct usb_ss_ep_comp_descriptor ss_ep_comp;
    struct usb_ssp_isoc_ep_comp_descriptor ssp_isoc_ep_comp;
    long: 0;
    struct list_head urb_list;
    void *hcpriv;
    struct ep_device *ep_dev;
    unsigned char *extra;
    int extralen;
    int enabled;
    int streams;
    long: 0;
} __attribute__((packed));

struct usb_device_descriptor {
    __u8 bLength;
    __u8 bDescriptorType;
    __le16 bcdUSB;
    __u8 bDeviceClass;
    __u8 bDeviceSubClass;
    __u8 bDeviceProtocol;
    __u8 bMaxPacketSize0;
    __le16 idVendor;
    __le16 idProduct;
    __le16 bcdDevice;
    __u8 iManufacturer;
    __u8 iProduct;
    __u8 iSerialNumber;
    __u8 bNumConfigurations;
};

struct usb_host_bos;

struct usb_host_config;

struct usb_device {
    int devnum;
    char devpath[16];
    u32 route;
    enum usb_device_state state;
    enum usb_device_speed speed;
    unsigned int rx_lanes;
    unsigned int tx_lanes;
    enum usb_ssp_rate ssp_rate;
    struct usb_tt *tt;
    int ttport;
    unsigned int toggle[2];
    struct usb_device *parent;
    struct usb_bus *bus;
    struct usb_host_endpoint ep0;
    struct device dev;
    struct usb_device_descriptor descriptor;
    struct usb_host_bos *bos;
    struct usb_host_config *config;
    struct usb_host_config *actconfig;
    struct usb_host_endpoint *ep_in[16];
    struct usb_host_endpoint *ep_out[16];
    char **rawdescriptors;
    short unsigned int bus_mA;
    u8 portnum;
    u8 level;
    u8 devaddr;
    unsigned int can_submit: 1;
    unsigned int persist_enabled: 1;
    unsigned int reset_in_progress: 1;
    unsigned int have_langid: 1;
    unsigned int authorized: 1;
    unsigned int authenticated: 1;
    unsigned int lpm_capable: 1;
    unsigned int lpm_devinit_allow: 1;
    unsigned int usb2_hw_lpm_capable: 1;
    unsigned int usb2_hw_lpm_besl_capable: 1;
    unsigned int usb2_hw_lpm_enabled: 1;
    unsigned int usb2_hw_lpm_allowed: 1;
    unsigned int usb3_lpm_u1_enabled: 1;
    unsigned int usb3_lpm_u2_enabled: 1;
    int string_langid;
    char *product;
    char *manufacturer;
    char *serial;
    struct list_head filelist;
    int maxchild;
    u32 quirks;
    atomic_t urbnum;
    long unsigned int active_duration;
    long unsigned int connect_time;
    unsigned int do_remote_wakeup: 1;
    unsigned int reset_resume: 1;
    unsigned int port_is_suspended: 1;
    enum usb_link_tunnel_mode tunnel_mode;
    int slot_id;
    struct usb2_lpm_parameters l1_params;
    struct usb3_lpm_parameters u1_params;
    struct usb3_lpm_parameters u2_params;
    unsigned int lpm_disable_count;
    u16 hub_delay;
    unsigned int use_generic_driver: 1;
};

struct usb_device_id;

struct usb_device_driver {
    const char *name;
    bool (*match)(struct usb_device *);
    int (*probe)(struct usb_device *);
    void (*disconnect)(struct usb_device *);
    int (*suspend)(struct usb_device *, pm_message_t);
    int (*resume)(struct usb_device *, pm_message_t);
    int (*choose_configuration)(struct usb_device *);
    const struct attribute_group **dev_groups;
    struct device_driver driver;
    const struct usb_device_id *id_table;
    unsigned int supports_autosuspend: 1;
    unsigned int generic_subclass: 1;
};

struct usb_device_id {
    __u16 match_flags;
    __u16 idVendor;
    __u16 idProduct;
    __u16 bcdDevice_lo;
    __u16 bcdDevice_hi;
    __u8 bDeviceClass;
    __u8 bDeviceSubClass;
    __u8 bDeviceProtocol;
    __u8 bInterfaceClass;
    __u8 bInterfaceSubClass;
    __u8 bInterfaceProtocol;
    __u8 bInterfaceNumber;
    kernel_ulong_t driver_info;
};

struct usb_dynids {
    struct list_head list;
};

struct usb_driver {
    const char *name;
    int (*probe)(struct usb_interface *, const struct usb_device_id *);
    void (*disconnect)(struct usb_interface *);
    int (*unlocked_ioctl)(struct usb_interface *, unsigned int, void *);
    int (*suspend)(struct usb_interface *, pm_message_t);
    int (*resume)(struct usb_interface *);
    int (*reset_resume)(struct usb_interface *);
    int (*pre_reset)(struct usb_interface *);
    int (*post_reset)(struct usb_interface *);
    void (*shutdown)(struct usb_interface *);
    const struct usb_device_id *id_table;
    const struct attribute_group **dev_groups;
    struct usb_dynids dynids;
    struct device_driver driver;
    unsigned int no_dynamic_id: 1;
    unsigned int supports_autosuspend: 1;
    unsigned int disable_hub_initiated_lpm: 1;
    unsigned int soft_unbind: 1;
};

struct usb_dynid {
    struct list_head node;
    struct usb_device_id id;
};

struct usb_ext_cap_descriptor {
    __u8 bLength;
    __u8 bDescriptorType;
    __u8 bDevCapabilityType;
    __le32 bmAttributes;
} __attribute__((packed));

struct usb_phy_roothub;

struct usb_hcd {
    struct usb_bus self;
    struct kref kref;
    const char *product_desc;
    int speed;
    char irq_descr[24];
    struct timer_list rh_timer;
    struct urb *status_urb;
    struct work_struct wakeup_work;
    struct work_struct died_work;
    const struct hc_driver *driver;
    struct usb_phy *usb_phy;
    struct usb_phy_roothub *phy_roothub;
    long unsigned int flags;
    enum usb_dev_authorize_policy dev_policy;
    unsigned int rh_registered: 1;
    unsigned int rh_pollable: 1;
    unsigned int msix_enabled: 1;
    unsigned int msi_enabled: 1;
    unsigned int skip_phy_initialization: 1;
    unsigned int uses_new_polling: 1;
    unsigned int has_tt: 1;
    unsigned int amd_resume_bug: 1;
    unsigned int can_do_streams: 1;
    unsigned int tpl_support: 1;
    unsigned int cant_recv_wakeups: 1;
    unsigned int irq;
    void *regs;
    resource_size_t rsrc_start;
    resource_size_t rsrc_len;
    unsigned int power_budget;
    struct giveback_urb_bh high_prio_bh;
    struct giveback_urb_bh low_prio_bh;
    struct mutex *address0_mutex;
    struct mutex *bandwidth_mutex;
    struct usb_hcd *shared_hcd;
    struct usb_hcd *primary_hcd;
    struct dma_pool *pool[4];
    int state;
    struct gen_pool *localmem_pool;
    long unsigned int hcd_priv[0];
};

struct usb_ss_cap_descriptor;

struct usb_ssp_cap_descriptor;

struct usb_ss_container_id_descriptor;

struct usb_ptm_cap_descriptor;

struct usb_host_bos {
    struct usb_bos_descriptor *desc;
    struct usb_ext_cap_descriptor *ext_cap;
    struct usb_ss_cap_descriptor *ss_cap;
    struct usb_ssp_cap_descriptor *ssp_cap;
    struct usb_ss_container_id_descriptor *ss_id;
    struct usb_ptm_cap_descriptor *ptm_cap;
};

struct usb_interface_assoc_descriptor;

struct usb_interface_cache;

struct usb_host_config {
    struct usb_config_descriptor desc;
    char *string;
    struct usb_interface_assoc_descriptor *intf_assoc[16];
    struct usb_interface *interface[32];
    struct usb_interface_cache *intf_cache[32];
    unsigned char *extra;
    int extralen;
};

struct usb_interface_descriptor {
    __u8 bLength;
    __u8 bDescriptorType;
    __u8 bInterfaceNumber;
    __u8 bAlternateSetting;
    __u8 bNumEndpoints;
    __u8 bInterfaceClass;
    __u8 bInterfaceSubClass;
    __u8 bInterfaceProtocol;
    __u8 iInterface;
};

struct usb_host_interface {
    struct usb_interface_descriptor desc;
    int extralen;
    unsigned char *extra;
    struct usb_host_endpoint *endpoint;
    char *string;
};

struct usb_hub_status {
    __le16 wHubStatus;
    __le16 wHubChange;
};

struct usb_port_status {
    __le16 wPortStatus;
    __le16 wPortChange;
    __le32 dwExtPortStatus;
};

struct usb_tt {
    struct usb_device *hub;
    int multi;
    unsigned int think_time;
    void *hcpriv;
    spinlock_t lock;
    struct list_head clear_list;
    struct work_struct clear_work;
};

struct usb_hub_descriptor;

struct usb_port;

struct usb_hub {
    struct device *intfdev;
    struct usb_device *hdev;
    struct kref kref;
    struct urb *urb;
    u8 (*buffer)[8];
    union {
        struct usb_hub_status hub;
        struct usb_port_status port;
    } *status;
    struct mutex status_mutex;
    int error;
    int nerrors;
    long unsigned int event_bits[1];
    long unsigned int change_bits[1];
    long unsigned int removed_bits[1];
    long unsigned int wakeup_bits[1];
    long unsigned int power_bits[1];
    long unsigned int child_usage_bits[1];
    long unsigned int warm_reset_bits[1];
    struct usb_hub_descriptor *descriptor;
    struct usb_tt tt;
    unsigned int mA_per_port;
    unsigned int wakeup_enabled_descendants;
    unsigned int limited_power: 1;
    unsigned int quiescing: 1;
    unsigned int disconnected: 1;
    unsigned int in_reset: 1;
    unsigned int quirk_disable_autosuspend: 1;
    unsigned int quirk_check_port_auto_suspend: 1;
    unsigned int has_indicators: 1;
    u8 indicator[31];
    struct delayed_work leds;
    struct delayed_work init_work;
    struct work_struct events;
    spinlock_t irq_urb_lock;
    struct timer_list irq_urb_retry;
    struct usb_port **ports;
    struct list_head onboard_devs;
};

struct usb_hub_descriptor {
    __u8 bDescLength;
    __u8 bDescriptorType;
    __u8 bNbrPorts;
    __le16 wHubCharacteristics;
    __u8 bPwrOn2PwrGood;
    __u8 bHubContrCurrent;
    union {
        struct {
            __u8 DeviceRemovable[4];
            __u8 PortPwrCtrlMask[4];
        } hs;
        struct {
            __u8 bHubHdrDecLat;
            __le16 wHubDelay;
            __le16 DeviceRemovable;
        } __attribute__((packed)) ss;
    } u;
} __attribute__((packed));

struct usb_interface {
    struct usb_host_interface *altsetting;
    struct usb_host_interface *cur_altsetting;
    unsigned int num_altsetting;
    struct usb_interface_assoc_descriptor *intf_assoc;
    int minor;
    enum usb_interface_condition condition;
    unsigned int sysfs_files_created: 1;
    unsigned int ep_devs_created: 1;
    unsigned int unregistering: 1;
    unsigned int needs_remote_wakeup: 1;
    unsigned int needs_altsetting0: 1;
    unsigned int needs_binding: 1;
    unsigned int resetting_device: 1;
    unsigned int authorized: 1;
    enum usb_wireless_status wireless_status;
    struct work_struct wireless_status_work;
    struct device dev;
    struct device *usb_dev;
    struct work_struct reset_ws;
};

struct usb_interface_assoc_descriptor {
    __u8 bLength;
    __u8 bDescriptorType;
    __u8 bFirstInterface;
    __u8 bInterfaceCount;
    __u8 bFunctionClass;
    __u8 bFunctionSubClass;
    __u8 bFunctionProtocol;
    __u8 iFunction;
};

struct usb_interface_cache {
    unsigned int num_altsetting;
    struct kref ref;
    struct usb_host_interface altsetting[0];
};

struct usb_memory {
    struct list_head memlist;
    int vma_use_count;
    int urb_use_count;
    u32 size;
    void *mem;
    dma_addr_t dma_handle;
    long unsigned int vm_start;
    struct usb_dev_state *ps;
};

struct usb_mon_operations {
    void (*urb_submit)(struct usb_bus *, struct urb *);
    void (*urb_submit_error)(struct usb_bus *, struct urb *, int);
    void (*urb_complete)(struct usb_bus *, struct urb *, int);
};

struct usb_gadget;

struct usb_otg {
    u8 default_a;
    struct phy *phy;
    struct usb_phy *usb_phy;
    struct usb_bus *host;
    struct usb_gadget *gadget;
    enum usb_otg_state state;
    int (*set_host)(struct usb_otg *, struct usb_bus *);
    int (*set_peripheral)(struct usb_otg *, struct usb_gadget *);
    int (*set_vbus)(struct usb_otg *, bool);
    int (*start_srp)(struct usb_otg *);
    int (*start_hnp)(struct usb_otg *);
};

struct usb_otg_caps {
    u16 otg_rev;
    bool hnp_support;
    bool srp_support;
    bool adp_support;
};

struct usb_phy_io_ops;

struct usb_phy {
    struct device *dev;
    const char *label;
    unsigned int flags;
    enum usb_phy_type type;
    enum usb_phy_events last_event;
    struct usb_otg *otg;
    struct device *io_dev;
    struct usb_phy_io_ops *io_ops;
    void *io_priv;
    struct extcon_dev *edev;
    struct extcon_dev *id_edev;
    struct notifier_block vbus_nb;
    struct notifier_block id_nb;
    struct notifier_block type_nb;
    enum usb_charger_type chg_type;
    enum usb_charger_state chg_state;
    struct usb_charger_current chg_cur;
    struct work_struct chg_work;
    struct atomic_notifier_head notifier;
    u16 port_status;
    u16 port_change;
    struct list_head head;
    int (*init)(struct usb_phy *);
    void (*shutdown)(struct usb_phy *);
    int (*set_vbus)(struct usb_phy *, int);
    int (*set_power)(struct usb_phy *, unsigned int);
    int (*set_suspend)(struct usb_phy *, int);
    int (*set_wakeup)(struct usb_phy *, bool);
    int (*notify_connect)(struct usb_phy *, enum usb_device_speed);
    int (*notify_disconnect)(struct usb_phy *, enum usb_device_speed);
    enum usb_charger_type (*charger_detect)(struct usb_phy *);
};

struct usb_phy_io_ops {
    int (*read)(struct usb_phy *, u32);
    int (*write)(struct usb_phy *, u32, u32);
};

struct usb_phy_roothub {
    struct phy *phy;
    struct list_head list;
};

struct usb_port {
    struct usb_device *child;
    struct device dev;
    struct usb_dev_state *port_owner;
    struct usb_port *peer;
    struct typec_connector *connector;
    struct dev_pm_qos_request *req;
    enum usb_port_connect_type connect_type;
    enum usb_device_state state;
    struct kernfs_node *state_kn;
    usb_port_location_t location;
    struct mutex status_lock;
    u32 over_current_count;
    u8 portnum;
    u32 quirks;
    unsigned int early_stop: 1;
    unsigned int ignore_event: 1;
    unsigned int is_superspeed: 1;
    unsigned int usb3_lpm_u1_permit: 1;
    unsigned int usb3_lpm_u2_permit: 1;
};

struct usb_ptm_cap_descriptor {
    __u8 bLength;
    __u8 bDescriptorType;
    __u8 bDevCapabilityType;
};

struct usb_qualifier_descriptor {
    __u8 bLength;
    __u8 bDescriptorType;
    __le16 bcdUSB;
    __u8 bDeviceClass;
    __u8 bDeviceSubClass;
    __u8 bDeviceProtocol;
    __u8 bMaxPacketSize0;
    __u8 bNumConfigurations;
    __u8 bRESERVED;
};

struct usb_set_sel_req {
    __u8 u1_sel;
    __u8 u1_pel;
    __le16 u2_sel;
    __le16 u2_pel;
};

struct usb_sg_request {
    int status;
    size_t bytes;
    spinlock_t lock;
    struct usb_device *dev;
    int pipe;
    int entries;
    struct urb **urbs;
    int count;
    struct completion complete;
};

struct usb_ss_cap_descriptor {
    __u8 bLength;
    __u8 bDescriptorType;
    __u8 bDevCapabilityType;
    __u8 bmAttributes;
    __le16 wSpeedSupported;
    __u8 bFunctionalitySupport;
    __u8 bU1devExitLat;
    __le16 bU2DevExitLat;
};

struct usb_ss_container_id_descriptor {
    __u8 bLength;
    __u8 bDescriptorType;
    __u8 bDevCapabilityType;
    __u8 bReserved;
    __u8 ContainerID[16];
};

struct usb_ssp_cap_descriptor {
    __u8 bLength;
    __u8 bDescriptorType;
    __u8 bDevCapabilityType;
    __u8 bReserved;
    __le32 bmAttributes;
    __le16 wFunctionalitySupport;
    __le16 wReserved;
    union {
        __le32 legacy_padding;
        struct {
            struct {} __empty_bmSublinkSpeedAttr;
            __le32 bmSublinkSpeedAttr[0];
        };
    };
};

struct usb_tt_clear {
    struct list_head clear_list;
    unsigned int tt;
    u16 devinfo;
    struct usb_hcd *hcd;
    struct usb_host_endpoint *ep;
};

struct usbdevfs_bulktransfer {
    unsigned int ep;
    unsigned int len;
    unsigned int timeout;
    void *data;
};

struct usbdevfs_bulktransfer32 {
    compat_uint_t ep;
    compat_uint_t len;
    compat_uint_t timeout;
    compat_caddr_t data;
};

struct usbdevfs_connectinfo {
    unsigned int devnum;
    unsigned char slow;
};

struct usbdevfs_conninfo_ex {
    __u32 size;
    __u32 busnum;
    __u32 devnum;
    __u32 speed;
    __u8 num_ports;
    __u8 ports[7];
};

struct usbdevfs_ctrltransfer {
    __u8 bRequestType;
    __u8 bRequest;
    __u16 wValue;
    __u16 wIndex;
    __u16 wLength;
    __u32 timeout;
    void *data;
};

struct usbdevfs_ctrltransfer32 {
    u8 bRequestType;
    u8 bRequest;
    u16 wValue;
    u16 wIndex;
    u16 wLength;
    u32 timeout;
    compat_caddr_t data;
};

struct usbdevfs_disconnect_claim {
    unsigned int interface;
    unsigned int flags;
    char driver[256];
};

struct usbdevfs_disconnectsignal {
    unsigned int signr;
    void *context;
};

struct usbdevfs_disconnectsignal32 {
    compat_int_t signr;
    compat_caddr_t context;
};

struct usbdevfs_getdriver {
    unsigned int interface;
    char driver[256];
};

struct usbdevfs_hub_portinfo {
    char nports;
    char port[127];
};

struct usbdevfs_ioctl {
    int ifno;
    int ioctl_code;
    void *data;
};

struct usbdevfs_ioctl32 {
    s32 ifno;
    s32 ioctl_code;
    compat_caddr_t data;
};

struct usbdevfs_iso_packet_desc {
    unsigned int length;
    unsigned int actual_length;
    unsigned int status;
};

struct usbdevfs_setinterface {
    unsigned int interface;
    unsigned int altsetting;
};

struct usbdevfs_streams {
    unsigned int num_streams;
    unsigned int num_eps;
    unsigned char eps[0];
};

struct usbdevfs_urb {
    unsigned char type;
    unsigned char endpoint;
    int status;
    unsigned int flags;
    void *buffer;
    int buffer_length;
    int actual_length;
    int start_frame;
    union {
        int number_of_packets;
        unsigned int stream_id;
    };
    int error_count;
    unsigned int signr;
    void *usercontext;
    struct usbdevfs_iso_packet_desc iso_frame_desc[0];
};

struct usbdevfs_urb32 {
    unsigned char type;
    unsigned char endpoint;
    compat_int_t status;
    compat_uint_t flags;
    compat_caddr_t buffer;
    compat_int_t buffer_length;
    compat_int_t actual_length;
    compat_int_t start_frame;
    compat_int_t number_of_packets;
    compat_int_t error_count;
    compat_uint_t signr;
    compat_caddr_t usercontext;
    struct usbdevfs_iso_packet_desc iso_frame_desc[0];
};

struct usbnet {
    struct usb_device *udev;
    struct usb_interface *intf;
    const struct driver_info *driver_info;
    const char *driver_name;
    void *driver_priv;
    wait_queue_head_t wait;
    struct mutex phy_mutex;
    unsigned char suspend_count;
    unsigned char pkt_cnt;
    unsigned char pkt_err;
    short unsigned int rx_qlen;
    short unsigned int tx_qlen;
    unsigned int can_dma_sg: 1;
    unsigned int in;
    unsigned int out;
    struct usb_host_endpoint *status;
    unsigned int maxpacket;
    struct timer_list delay;
    const char *padding_pkt;
    struct net_device *net;
    int msg_enable;
    long unsigned int data[5];
    u32 xid;
    u32 hard_mtu;
    size_t rx_urb_size;
    struct mii_if_info mii;
    long int rx_speed;
    long int tx_speed;
    struct sk_buff_head rxq;
    struct sk_buff_head txq;
    struct sk_buff_head done;
    struct sk_buff_head rxq_pause;
    struct urb *interrupt;
    unsigned int interrupt_count;
    struct mutex interrupt_mutex;
    struct usb_anchor deferred;
    struct tasklet_struct bh;
    struct work_struct kevent;
    long unsigned int flags;
};

struct used_address {
    struct __kernel_sockaddr_storage name;
    unsigned int name_len;
};

struct user_access_state {
    u64 por_el0;
};

struct user_arg_ptr {
    bool is_compat;
    union {
        const char * const *native;
        const compat_uptr_t *compat;
    } ptr;
};

struct za_context;

struct zt_context;

struct user_ctxs {
    struct fpsimd_context *fpsimd;
    u32 fpsimd_size;
    struct sve_context *sve;
    u32 sve_size;
    struct tpidr2_context *tpidr2;
    u32 tpidr2_size;
    struct za_context *za;
    u32 za_size;
    struct zt_context *zt;
    u32 zt_size;
    struct fpmr_context *fpmr;
    u32 fpmr_size;
    struct poe_context *poe;
    u32 poe_size;
    struct gcs_context *gcs;
    u32 gcs_size;
};

struct user_datum {
    u32 value;
    u32 bounds;
    struct ebitmap roles;
    struct mls_range range;
    struct mls_level dfltlevel;
};

struct user_event_group;

struct user_event {
    struct user_event_group *group;
    char *reg_name;
    struct tracepoint tracepoint;
    struct trace_event_call call;
    struct trace_event_class class;
    struct dyn_event devent;
    struct hlist_node node;
    struct list_head fields;
    struct list_head validators;
    struct work_struct put_work;
    refcount_t refcnt;
    int min_size;
    int reg_flags;
    char status;
};

struct user_event_enabler {
    struct list_head mm_enablers_link;
    struct user_event *event;
    long unsigned int addr;
    long unsigned int values;
};

struct user_event_enabler_fault {
    struct work_struct work;
    struct user_event_mm *mm;
    struct user_event_enabler *enabler;
    int attempt;
};

struct user_event_refs;

struct user_event_file_info {
    struct user_event_group *group;
    struct user_event_refs *refs;
};

struct user_event_group {
    char *system_name;
    char *system_multi_name;
    struct hlist_node node;
    struct mutex reg_mutex;
    struct hlist_head register_table[256];
    u64 multi_id;
};

struct user_event_mm {
    struct list_head mms_link;
    struct list_head enablers;
    struct mm_struct *mm;
    struct user_event_mm *next;
    refcount_t refcnt;
    refcount_t tasks;
    struct rcu_work put_rwork;
};

struct user_event_refs {
    struct callback_head rcu;
    int count;
    struct user_event *events[0];
};

struct user_event_validator {
    struct list_head user_event_link;
    int offset;
    int flags;
};

struct user_key_payload {
    struct callback_head rcu;
    short unsigned int datalen;
    long: 0;
    char data[0];
};

struct user_namespace {
    struct uid_gid_map uid_map;
    struct uid_gid_map gid_map;
    struct uid_gid_map projid_map;
    struct user_namespace *parent;
    int level;
    kuid_t owner;
    kgid_t group;
    struct ns_common ns;
    long unsigned int flags;
    bool parent_could_setfcap;
    struct list_head keyring_name_list;
    struct key *user_keyring_register;
    struct rw_semaphore keyring_sem;
    struct key *persistent_keyring_register;
    struct work_struct work;
    struct ctl_table_set set;
    struct ctl_table_header *sysctls;
    struct ucounts *ucounts;
    long int ucount_max[12];
    long int rlimit_max[4];
    struct binfmt_misc *binfmt_misc;
};

struct user_pac_address_keys {
    __int128 unsigned apiakey;
    __int128 unsigned apibkey;
    __int128 unsigned apdakey;
    __int128 unsigned apdbkey;
};

struct user_pac_generic_keys {
    __int128 unsigned apgakey;
};

struct user_pac_mask {
    __u64 data_mask;
    __u64 insn_mask;
};

struct user_reg {
    __u32 size;
    __u8 enable_bit;
    __u8 enable_size;
    __u16 flags;
    __u64 enable_addr;
    __u64 name_args;
    __u32 write_index;
} __attribute__((packed));

struct user_regset;

typedef int user_regset_get2_fn(struct task_struct *, const struct user_regset *, struct membuf);

typedef int user_regset_set_fn(struct task_struct *, const struct user_regset *, unsigned int, unsigned int, const void *, const void *);

typedef int user_regset_active_fn(struct task_struct *, const struct user_regset *);

typedef int user_regset_writeback_fn(struct task_struct *, const struct user_regset *, int);

struct user_regset {
    user_regset_get2_fn *regset_get;
    user_regset_set_fn *set;
    user_regset_active_fn *active;
    user_regset_writeback_fn *writeback;
    unsigned int n;
    unsigned int size;
    unsigned int align;
    unsigned int bias;
    unsigned int core_note_type;
};

struct user_regset_view {
    const char *name;
    const struct user_regset *regsets;
    unsigned int n;
    u32 e_flags;
    u16 e_machine;
    u8 ei_osabi;
};

struct vchiq_service;

struct vchiq_instance;

struct vchiq_header;

struct user_service {
    struct vchiq_service *service;
    void *userdata;
    struct vchiq_instance *instance;
    char is_vchi;
    char dequeue_pending;
    char close_pending;
    int message_available_pos;
    int msg_insert;
    int msg_remove;
    struct completion insert_event;
    struct completion remove_event;
    struct completion close_event;
    struct vchiq_header *msg_queue[128];
};

struct user_struct {
    refcount_t __count;
    struct percpu_counter epoll_watches;
    long unsigned int unix_inflight;
    atomic_long_t pipe_bufs;
    struct hlist_node uidhash_node;
    kuid_t uid;
    atomic_long_t locked_vm;
    atomic_t nr_watches;
    struct ratelimit_state ratelimit;
};

struct user_sve_header {
    __u32 size;
    __u32 max_size;
    __u16 vl;
    __u16 max_vl;
    __u16 flags;
    __u16 __reserved;
};

struct user_syms {
    const char **syms;
    char *buf;
};

struct user_threshold {
    struct list_head list_node;
    int temperature;
    int direction;
};

struct user_unreg {
    __u32 size;
    __u8 disable_bit;
    __u8 __reserved;
    __u16 __reserved2;
    __u64 disable_addr;
};

struct userfaultfd_ctx {
    wait_queue_head_t fault_pending_wqh;
    wait_queue_head_t fault_wqh;
    wait_queue_head_t fd_wqh;
    wait_queue_head_t event_wqh;
    seqcount_spinlock_t refile_seq;
    refcount_t refcount;
    unsigned int flags;
    unsigned int features;
    bool released;
    struct rw_semaphore map_changing_lock;
    atomic_t mmap_changing;
    struct mm_struct *mm;
};

struct userfaultfd_fork_ctx {
    struct userfaultfd_ctx *orig;
    struct userfaultfd_ctx *new;
    struct list_head list;
};

struct userfaultfd_unmap_ctx {
    struct userfaultfd_ctx *ctx;
    long unsigned int start;
    long unsigned int end;
    struct list_head list;
};

struct userfaultfd_wait_queue {
    struct uffd_msg msg;
    wait_queue_entry_t wq;
    struct userfaultfd_ctx *ctx;
    bool waken;
};

struct userfaultfd_wake_range {
    long unsigned int start;
    long unsigned int len;
};

struct userspace_policy {
    unsigned int is_managed;
    unsigned int setspeed;
    struct mutex mutex;
};

struct userstack_entry {
    struct trace_entry ent;
    unsigned int tgid;
    long unsigned int caller[8];
};

struct ustat {
    __kernel_daddr_t f_tfree;
    long unsigned int f_tinode;
    char f_fname[6];
    char f_fpack[6];
};

struct ustring_buffer {
    char buffer[1024];
};

struct utf8_table {
    int cmask;
    int cval;
    int shift;
    long int lmask;
    long int lval;
};

struct utf8cursor {
    const struct unicode_map *um;
    enum utf8_normalization n;
    const char *s;
    const char *p;
    const char *ss;
    const char *sp;
    unsigned int len;
    unsigned int slen;
    short int ccc;
    short int nccc;
    unsigned char hangul[12];
};

struct utf8data {
    unsigned int maxage;
    unsigned int offset;
};

struct utf8data_table {
    const unsigned int *utf8agetab;
    int utf8agetab_size;
    const struct utf8data *utf8nfdicfdata;
    int utf8nfdicfdata_size;
    const struct utf8data *utf8nfdidata;
    int utf8nfdidata_size;
    const unsigned char *utf8data;
};

struct uts_namespace {
    struct new_utsname name;
    struct user_namespace *user_ns;
    struct ucounts *ucounts;
    struct ns_common ns;
};

union uu {
    short unsigned int us;
    unsigned char b[2];
};

struct uuidcmp {
    const char *uuid;
    int len;
};

struct v2m_data {
    struct list_head entry;
    struct fwnode_handle *fwnode;
    struct resource res;
    void *base;
    u32 spi_start;
    u32 nr_spis;
    u32 spi_offset;
    long unsigned int *bm;
    u32 flags;
};

struct va_format {
    const char *fmt;
    va_list *va;
};

struct val_table_ent {
    const char *str;
    int value;
};

struct value_name_pair {
    int value;
    const char *name;
};

struct vc {
    struct vc_data *d;
    struct work_struct SAK_work;
};

struct vc_state {
    unsigned int x;
    unsigned int y;
    unsigned char color;
    unsigned char Gx_charset[2];
    unsigned int charset: 1;
    enum vc_intensity intensity;
    bool italic;
    bool underline;
    bool blink;
    bool reverse;
};

struct vt_mode {
    char mode;
    char waitv;
    short int relsig;
    short int acqsig;
    short int frsig;
};

struct vc_data {
    struct tty_port port;
    struct vc_state state;
    struct vc_state saved_state;
    short unsigned int vc_num;
    unsigned int vc_cols;
    unsigned int vc_rows;
    unsigned int vc_size_row;
    unsigned int vc_scan_lines;
    unsigned int vc_cell_height;
    long unsigned int vc_origin;
    long unsigned int vc_scr_end;
    long unsigned int vc_visible_origin;
    unsigned int vc_top;
    unsigned int vc_bottom;
    const struct consw *vc_sw;
    short unsigned int *vc_screenbuf;
    unsigned int vc_screenbuf_size;
    unsigned char vc_mode;
    unsigned char vc_attr;
    unsigned char vc_def_color;
    unsigned char vc_ulcolor;
    unsigned char vc_itcolor;
    unsigned char vc_halfcolor;
    unsigned int vc_cursor_type;
    short unsigned int vc_complement_mask;
    short unsigned int vc_s_complement_mask;
    long unsigned int vc_pos;
    short unsigned int vc_hi_font_mask;
    struct console_font vc_font;
    short unsigned int vc_video_erase_char;
    unsigned int vc_state;
    unsigned int vc_npar;
    unsigned int vc_par[16];
    struct vt_mode vt_mode;
    struct pid *vt_pid;
    int vt_newvt;
    wait_queue_head_t paste_wait;
    unsigned int vc_disp_ctrl: 1;
    unsigned int vc_toggle_meta: 1;
    unsigned int vc_decscnm: 1;
    unsigned int vc_decom: 1;
    unsigned int vc_decawm: 1;
    unsigned int vc_deccm: 1;
    unsigned int vc_decim: 1;
    unsigned int vc_priv: 3;
    unsigned int vc_need_wrap: 1;
    unsigned int vc_can_do_color: 1;
    unsigned int vc_report_mouse: 2;
    unsigned char vc_utf: 1;
    unsigned char vc_utf_count;
    int vc_utf_char;
    long unsigned int vc_tab_stop[4];
    unsigned char vc_palette[48];
    short unsigned int *vc_translate;
    unsigned int vc_bell_pitch;
    unsigned int vc_bell_duration;
    short unsigned int vc_cur_blink_ms;
    struct vc_data **vc_display_fg;
    struct uni_pagedict *uni_pagedict;
    struct uni_pagedict **uni_pagedict_loc;
    u32 **vc_uni_lines;
};

struct vc_dmaman {
    void *dma_base;
    u32 chan_available;
    u32 has_feature[4];
    struct mutex lock;
};

struct vc_draw_region {
    long unsigned int from;
    long unsigned int to;
    int x;
};

struct vc_mem_dma {
    struct device *dev;
    int dma_chan;
    int dma_irq;
    void *dma_chan_base;
    wait_queue_head_t dma_waitq;
    void *cb_base;
    dma_addr_t cb_handle;
};

struct vc_mem_dmacopy {
    void *dst;
    __u32 src;
    __u32 length;
};

struct vc_mem_dmacopy32 {
    compat_uptr_t dst;
    __u32 src;
    __u32 length;
};

struct vc_selection {
    struct mutex lock;
    struct vc_data *cons;
    char *buffer;
    unsigned int buf_len;
    volatile int start;
    int end;
};

struct vchiq_state;

struct vchiq_arm_state {
    struct task_struct *ka_thread;
    struct completion ka_evt;
    atomic_t ka_use_count;
    atomic_t ka_use_ack_count;
    atomic_t ka_release_count;
    rwlock_t susp_res_lock;
    struct vchiq_state *state;
    int videocore_use_count;
    int peer_use_count;
    int first_connect;
};

struct vchiq_completion_data;

struct vchiq_await_completion {
    unsigned int count;
    struct vchiq_completion_data *buf;
    unsigned int msgbufsize;
    unsigned int msgbufcount;
    void **msgbufs;
};

struct vchiq_await_completion32 {
    unsigned int count;
    compat_uptr_t buf;
    unsigned int msgbufsize;
    unsigned int msgbufcount;
    compat_uptr_t msgbufs;
};

struct vchiq_bulk {
    short int mode;
    short int dir;
    void *cb_data;
    void *cb_userdata;
    struct bulk_waiter *waiter;
    dma_addr_t dma_addr;
    int size;
    void *remote_data;
    int remote_size;
    int actual;
    void *offset;
    void *uoffset;
};

struct vchiq_bulk_queue {
    int local_insert;
    int remote_insert;
    int process;
    int remote_notify;
    int remove;
    struct vchiq_bulk bulks[4];
};

struct vchiq_completion_data {
    enum vchiq_reason reason;
    struct vchiq_header *header;
    void *service_userdata;
    void *cb_userdata;
};

struct vchiq_completion_data32 {
    enum vchiq_reason reason;
    compat_uptr_t header;
    compat_uptr_t service_userdata;
    compat_uptr_t cb_data;
};

struct vchiq_completion_data_kernel {
    enum vchiq_reason reason;
    struct vchiq_header *header;
    void *service_userdata;
    void *cb_data;
    void *cb_userdata;
};

struct vchiq_config {
    unsigned int max_msg_size;
    unsigned int bulk_threshold;
    unsigned int max_outstanding_bulks;
    unsigned int max_services;
    short int version;
    short int version_min;
};

struct vchiq_service_params {
    int fourcc;
    int (*callback)(enum vchiq_reason, struct vchiq_header *, unsigned int, void *);
    void *userdata;
    short int version;
    short int version_min;
};

struct vchiq_create_service {
    struct vchiq_service_params params;
    int is_open;
    int is_vchi;
    unsigned int handle;
};

struct vchiq_service_params32 {
    int fourcc;
    compat_uptr_t callback;
    compat_uptr_t userdata;
    short int version;
    short int version_min;
};

struct vchiq_create_service32 {
    struct vchiq_service_params32 params;
    int is_open;
    int is_vchi;
    unsigned int handle;
};

struct vchiq_debugfs_node {
    struct dentry *dentry;
};

struct vchiq_dequeue_message {
    unsigned int handle;
    int blocking;
    unsigned int bufsize;
    void *buf;
};

struct vchiq_dequeue_message32 {
    unsigned int handle;
    int blocking;
    unsigned int bufsize;
    compat_uptr_t buf;
};

struct vchiq_drv_mgmt;

struct vchiq_device {
    struct device dev;
    struct vchiq_drv_mgmt *drv_mgmt;
};

struct vchiq_device_id {
    char name[32];
};

struct vchiq_driver {
    int (*probe)(struct vchiq_device *);
    void (*remove)(struct vchiq_device *);
    int (*resume)(struct vchiq_device *);
    int (*suspend)(struct vchiq_device *, pm_message_t);
    const struct vchiq_device_id *id_table;
    struct device_driver driver;
};

struct vchiq_service_quota {
    short unsigned int slot_quota;
    short unsigned int slot_use_count;
    short unsigned int message_quota;
    short unsigned int message_use_count;
    struct completion quota_event;
    int previous_tx_index;
};

struct vchiq_slot_info {
    short int use_count;
    short int release_count;
};

struct opaque_platform_state;

struct vchiq_shared_state;

struct vchiq_slot;

struct vchiq_state {
    struct device *dev;
    int id;
    int initialised;
    enum vchiq_connstate conn_state;
    short int version_common;
    struct vchiq_shared_state *local;
    struct vchiq_shared_state *remote;
    struct vchiq_slot *slot_data;
    short unsigned int default_slot_quota;
    short unsigned int default_message_quota;
    struct completion connect;
    struct mutex mutex;
    struct vchiq_instance **instance;
    struct task_struct *slot_handler_thread;
    struct task_struct *recycle_thread;
    struct task_struct *sync_thread;
    wait_queue_head_t trigger_event;
    wait_queue_head_t recycle_event;
    wait_queue_head_t sync_trigger_event;
    wait_queue_head_t sync_release_event;
    char *tx_data;
    char *rx_data;
    struct vchiq_slot_info *rx_info;
    struct mutex slot_mutex;
    struct mutex recycle_mutex;
    struct mutex sync_mutex;
    spinlock_t msg_queue_spinlock;
    spinlock_t bulk_waiter_spinlock;
    spinlock_t quota_spinlock;
    int rx_pos;
    int local_tx_pos;
    int slot_queue_available;
    int poll_needed;
    int previous_data_index;
    short unsigned int data_use_count;
    short unsigned int data_quota;
    atomic_t poll_services[128];
    int unused_service;
    struct completion slot_available_event;
    struct completion data_quota_event;
    struct state_stats_struct stats;
    struct vchiq_service *services[4096];
    struct vchiq_service_quota service_quotas[4096];
    struct vchiq_slot_info slot_info[128];
    struct opaque_platform_state *platform_state;
};

struct vchiq_platform_info;

struct vchiq_drv_mgmt {
    struct rpi_firmware *fw;
    const struct vchiq_platform_info *info;
    bool connected;
    int num_deferred_callbacks;
    struct mutex connected_mutex;
    void (*deferred_callback[10])(void);
    struct semaphore free_fragments_sema;
    struct semaphore free_fragments_mutex;
    char *fragments_base;
    char *free_fragments;
    unsigned int fragments_size;
    void *regs;
    struct vchiq_state state;
};

struct vchiq_element {
    const void *data;
    unsigned int size;
};

struct vchiq_element32 {
    compat_uptr_t data;
    unsigned int size;
};

struct vchiq_get_config {
    unsigned int config_size;
    struct vchiq_config *pconfig;
};

struct vchiq_get_config32 {
    unsigned int config_size;
    compat_uptr_t pconfig;
};

struct vchiq_header {
    int msgid;
    unsigned int size;
    char data[0];
};

struct vchiq_instance {
    struct vchiq_state *state;
    struct vchiq_completion_data_kernel completions[128];
    int completion_insert;
    int completion_remove;
    struct completion insert_event;
    struct completion remove_event;
    struct mutex completion_mutex;
    int connected;
    int closing;
    int pid;
    int mark;
    int use_close_delivered;
    int trace;
    struct list_head bulk_waiter_list;
    struct mutex bulk_waiter_list_mutex;
    struct vchiq_debugfs_node debugfs_node;
};

struct vchiq_io_copy_callback_context {
    struct vchiq_element *element;
    size_t element_offset;
    long unsigned int elements_to_go;
};

struct vchiq_open_payload {
    int fourcc;
    int client_id;
    short int version;
    short int version_min;
};

struct vchiq_openack_payload {
    short int version;
};

struct vchiq_pagelist_info {
    struct pagelist *pagelist;
    size_t pagelist_buffer_size;
    dma_addr_t dma_addr;
    bool is_from_pool;
    enum dma_data_direction dma_dir;
    unsigned int num_pages;
    unsigned int pages_need_release;
    struct page **pages;
    struct scatterlist *scatterlist;
    unsigned int scatterlist_mapped;
};

struct vchiq_platform_info {
    unsigned int cache_line_size;
    bool use_36bit_addrs;
};

struct vchiq_queue_bulk_transfer {
    unsigned int handle;
    void *data;
    unsigned int size;
    void *userdata;
    enum vchiq_bulk_mode mode;
};

struct vchiq_queue_bulk_transfer32 {
    unsigned int handle;
    compat_uptr_t data;
    unsigned int size;
    compat_uptr_t userdata;
    enum vchiq_bulk_mode mode;
};

struct vchiq_queue_message {
    unsigned int handle;
    unsigned int count;
    const struct vchiq_element *elements;
};

struct vchiq_queue_message32 {
    unsigned int handle;
    unsigned int count;
    compat_uptr_t elements;
};

struct vchiq_service_base {
    int fourcc;
    int (*callback)(struct vchiq_instance *, enum vchiq_reason, struct vchiq_header *, unsigned int, void *, void *);
    void *userdata;
};

struct vchiq_service {
    struct vchiq_service_base base;
    unsigned int handle;
    struct kref ref_count;
    struct callback_head rcu;
    int srvstate;
    void (*userdata_term)(void *);
    unsigned int localport;
    unsigned int remoteport;
    int public_fourcc;
    int client_id;
    char auto_close;
    char sync;
    char closing;
    char trace;
    atomic_t poll_flags;
    short int version;
    short int version_min;
    short int peer_version;
    struct vchiq_state *state;
    struct vchiq_instance *instance;
    int service_use_count;
    struct vchiq_bulk_queue bulk_tx;
    struct vchiq_bulk_queue bulk_rx;
    struct completion remove_event;
    struct completion bulk_remove_event;
    struct mutex bulk_mutex;
    struct service_stats_struct stats;
    int msg_queue_read;
    int msg_queue_write;
    struct completion msg_queue_pop;
    struct completion msg_queue_push;
    struct vchiq_header *msg_queue[128];
};

struct vchiq_service_params_kernel {
    int fourcc;
    int (*callback)(struct vchiq_instance *, enum vchiq_reason, struct vchiq_header *, unsigned int, void *, void *);
    void *userdata;
    short int version;
    short int version_min;
};

struct vchiq_set_service_option {
    unsigned int handle;
    enum vchiq_service_option option;
    int value;
};

struct vchiq_shared_state {
    int initialised;
    int slot_first;
    int slot_last;
    int slot_sync;
    struct remote_event trigger;
    int tx_pos;
    struct remote_event recycle;
    int slot_queue_recycle;
    struct remote_event sync_trigger;
    struct remote_event sync_release;
    int slot_queue[64];
    int debug[11];
};

struct vchiq_slot {
    char data[4096];
};

struct vchiq_slot_zero {
    int magic;
    short int version;
    short int version_min;
    int slot_zero_size;
    int slot_size;
    int max_slots;
    int max_slots_per_side;
    int platform_data[2];
    struct vchiq_shared_state master;
    struct vchiq_shared_state slave;
    struct vchiq_slot_info slots[128];
};

struct vcio_data {
    struct rpi_firmware *fw;
    struct miscdevice misc_dev;
};

struct vcs_poll_data {
    struct notifier_block notifier;
    unsigned int cons_num;
    int event;
    wait_queue_head_t waitq;
    struct fasync_struct *fasync;
};

struct vm_special_mapping;

struct vdso_abi_info {
    const char *name;
    const char *vdso_code_start;
    const char *vdso_code_end;
    long unsigned int vdso_pages;
    struct vm_special_mapping *cm;
};

struct vdso_timestamp {
    u64 sec;
    u64 nsec;
};

struct vdso_data {
    u32 seq;
    s32 clock_mode;
    u64 cycle_last;
    u64 mask;
    u32 mult;
    u32 shift;
    union {
        struct vdso_timestamp basetime[12];
        struct timens_offset offset[12];
    };
    s32 tz_minuteswest;
    s32 tz_dsttime;
    u32 hrtimer_res;
    u32 __unused;
    struct arch_vdso_time_data arch_data;
};

union vdso_data_store {
    struct vdso_data data[2];
    u8 page[4096];
};

struct vdso_rng_data {
    u64 generation;
    u8 is_ready;
};

struct vendor_data {
    const u16 *reg_offset;
    unsigned int ifls;
    unsigned int fr_busy;
    unsigned int fr_dsr;
    unsigned int fr_cts;
    unsigned int fr_ri;
    unsigned int inv_fr;
    bool access_32b;
    bool oversampling;
    bool dma_threshold;
    bool cts_event_workaround;
    bool always_enabled;
    bool fixed_options;
    unsigned int (*get_fifosize)(struct amba_device *);
};

struct vfree_deferred {
    struct llist_head list;
    struct work_struct wq;
};

struct vfs_cap_data {
    __le32 magic_etc;
    struct {
        __le32 permitted;
        __le32 inheritable;
    } data[2];
};

struct vfs_ns_cap_data {
    __le32 magic_etc;
    struct {
        __le32 permitted;
        __le32 inheritable;
    } data[2];
    __le32 rootid;
};

struct vgic_global {
    enum vgic_type type;
    phys_addr_t vcpu_base;
    void *vcpu_base_va;
    void *vcpu_hyp_va;
    void *vctrl_base;
    void *vctrl_hyp;
    int nr_lr;
    unsigned int maint_irq;
    int max_gic_vcpus;
    bool can_emulate_gicv2;
    bool has_gicv4;
    bool has_gicv4_1;
    bool no_hw_deactivation;
    struct static_key_false gicv3_cpuif;
    u32 ich_vtr_el2;
};

struct vgic_irq {
    raw_spinlock_t irq_lock;
    struct callback_head rcu;
    struct list_head ap_list;
    struct kvm_vcpu *vcpu;
    struct kvm_vcpu *target_vcpu;
    u32 intid;
    bool line_level;
    bool pending_latch;
    bool active;
    bool enabled;
    bool hw;
    struct kref refcount;
    u32 hwintid;
    unsigned int host_irq;
    union {
        u8 targets;
        u32 mpidr;
    };
    u8 source;
    u8 active_source;
    u8 priority;
    u8 group;
    enum vgic_irq_config config;
    struct irq_ops *ops;
    void *owner;
};

struct vgic_its {
    gpa_t vgic_its_base;
    bool enabled;
    struct vgic_io_device iodev;
    struct kvm_device *dev;
    u64 baser_device_table;
    u64 baser_coll_table;
    struct mutex cmd_lock;
    u64 cbaser;
    u32 creadr;
    u32 cwriter;
    u32 abi_rev;
    struct mutex its_lock;
    struct list_head device_list;
    struct list_head collection_list;
    struct xarray translation_cache;
};

struct vgic_its_abi {
    int cte_esz;
    int dte_esz;
    int ite_esz;
    int (*save_tables)(struct vgic_its *);
    int (*restore_tables)(struct vgic_its *);
    int (*commit)(struct vgic_its *);
};

struct vgic_redist_region {
    u32 index;
    gpa_t base;
    u32 count;
    u32 free_index;
    struct list_head list;
};

struct vgic_reg_attr {
    struct kvm_vcpu *vcpu;
    gpa_t addr;
};

struct vgic_register_region {
    unsigned int reg_offset;
    unsigned int len;
    unsigned int bits_per_irq;
    unsigned int access_flags;
    union {
        long unsigned int (*read)(struct kvm_vcpu *, gpa_t, unsigned int);
        long unsigned int (*its_read)(struct kvm *, struct vgic_its *, gpa_t, unsigned int);
    };
    union {
        void (*write)(struct kvm_vcpu *, gpa_t, unsigned int, long unsigned int);
        void (*its_write)(struct kvm *, struct vgic_its *, gpa_t, unsigned int, long unsigned int);
    };
    long unsigned int (*uaccess_read)(struct kvm_vcpu *, gpa_t, unsigned int);
    union {
        int (*uaccess_write)(struct kvm_vcpu *, gpa_t, unsigned int, long unsigned int);
        int (*uaccess_its_write)(struct kvm *, struct vgic_its *, gpa_t, unsigned int, long unsigned int);
    };
};

struct vgic_state_iter {
    int nr_cpus;
    int nr_spis;
    int nr_lpis;
    int dist_id;
    int vcpu_id;
    long unsigned int intid;
    int lpi_idx;
};

struct vgic_vmcr {
    u32 grpen0;
    u32 grpen1;
    u32 ackctl;
    u32 fiqen;
    u32 cbpr;
    u32 eoim;
    u32 abpr;
    u32 bpr;
    u32 pmr;
};

struct vhost_task {
    bool (*fn)(void *);
    void (*handle_sigkill)(void *);
    void *data;
    struct completion exited;
    long unsigned int flags;
    struct task_struct *task;
    struct mutex exit_mutex;
};

struct videomode {
    long unsigned int pixelclock;
    u32 hactive;
    u32 hfront_porch;
    u32 hback_porch;
    u32 hsync_len;
    u32 vactive;
    u32 vfront_porch;
    u32 vback_porch;
    u32 vsync_len;
    enum display_flags flags;
};

struct vif_entry_notifier_info {
    struct fib_notifier_info info;
    struct net_device *dev;
    short unsigned int vif_index;
    short unsigned int vif_flags;
    u32 tb_id;
};

struct vifctl {
    vifi_t vifc_vifi;
    unsigned char vifc_flags;
    unsigned char vifc_threshold;
    unsigned int vifc_rate_limit;
    union {
        struct in_addr vifc_lcl_addr;
        int vifc_lcl_ifindex;
    };
    struct in_addr vifc_rmt_addr;
};

struct virtio_device_id {
    __u32 device;
    __u32 vendor;
};

struct virtio_config_ops;

struct vringh_config_ops;

struct virtio_device {
    int index;
    bool failed;
    bool config_core_enabled;
    bool config_driver_disabled;
    bool config_change_pending;
    spinlock_t config_lock;
    spinlock_t vqs_list_lock;
    struct device dev;
    struct virtio_device_id id;
    const struct virtio_config_ops *config;
    const struct vringh_config_ops *vringh_config;
    struct list_head vqs;
    u64 features;
    void *priv;
};

struct virtio_net_hdr {
    __u8 flags;
    __u8 gso_type;
    __virtio16 hdr_len;
    __virtio16 gso_size;
    __virtio16 csum_start;
    __virtio16 csum_offset;
};

struct virtio_net_hdr_mrg_rxbuf {
    struct virtio_net_hdr hdr;
    __virtio16 num_buffers;
};

struct vl_config {
    int __default_vl;
};

struct vl_info {
    enum vec_type type;
    const char *name;
    int min_vl;
    int max_vl;
    int max_virtualisable_vl;
    long unsigned int vq_map[8];
    long unsigned int vq_partial_map[8];
};

struct vlan_priority_tci_mapping;

struct vlan_pcpu_stats;

struct vlan_dev_priv {
    unsigned int nr_ingress_mappings;
    u32 ingress_priority_map[8];
    unsigned int nr_egress_mappings;
    struct vlan_priority_tci_mapping *egress_priority_map[16];
    __be16 vlan_proto;
    u16 vlan_id;
    u16 flags;
    struct net_device *real_dev;
    netdevice_tracker dev_tracker;
    unsigned char real_dev_addr[6];
    struct proc_dir_entry *dent;
    struct vlan_pcpu_stats *vlan_pcpu_stats;
    struct netpoll *netpoll;
};

struct vlan_ethhdr {
    union {
        struct {
            unsigned char h_dest[6];
            unsigned char h_source[6];
        };
        struct {
            unsigned char h_dest[6];
            unsigned char h_source[6];
        } addrs;
    };
    __be16 h_vlan_proto;
    __be16 h_vlan_TCI;
    __be16 h_vlan_encapsulated_proto;
};

struct vlan_group {
    unsigned int nr_vlan_devs;
    struct hlist_node hlist;
    struct net_device **vlan_devices_arrays[16];
};

struct vlan_hdr {
    __be16 h_vlan_TCI;
    __be16 h_vlan_encapsulated_proto;
};

struct vlan_info {
    struct net_device *real_dev;
    struct vlan_group grp;
    struct list_head vid_list;
    unsigned int nr_vids;
    struct callback_head rcu;
};

struct vlan_pcpu_stats {
    u64_stats_t rx_packets;
    u64_stats_t rx_bytes;
    u64_stats_t rx_multicast;
    u64_stats_t tx_packets;
    u64_stats_t tx_bytes;
    struct u64_stats_sync syncp;
    u32 rx_errors;
    u32 tx_dropped;
};

struct vlan_priority_tci_mapping {
    u32 priority;
    u16 vlan_qos;
    struct vlan_priority_tci_mapping *next;
};

struct vlan_vid_info {
    struct list_head list;
    __be16 proto;
    u16 vid;
    int refcount;
};

struct vm_userfaultfd_ctx {
    struct userfaultfd_ctx *ctx;
};

struct vma_lock;

struct vm_area_struct {
    union {
        struct {
            long unsigned int vm_start;
            long unsigned int vm_end;
        };
        struct callback_head vm_rcu;
    };
    struct mm_struct *vm_mm;
    pgprot_t vm_page_prot;
    union {
        const vm_flags_t vm_flags;
        vm_flags_t __vm_flags;
    };
    bool detached;
    unsigned int vm_lock_seq;
    struct vma_lock *vm_lock;
    struct {
        struct rb_node rb;
        long unsigned int rb_subtree_last;
    } shared;
    struct list_head anon_vma_chain;
    struct anon_vma *anon_vma;
    const struct vm_operations_struct *vm_ops;
    long unsigned int vm_pgoff;
    struct file *vm_file;
    void *vm_private_data;
    struct anon_vma_name *anon_name;
    atomic_long_t swap_readahead_info;
    struct vm_userfaultfd_ctx vm_userfaultfd_ctx;
};

struct vm_event_state {
    long unsigned int event[102];
};

struct vm_fault {
    const struct {
        struct vm_area_struct *vma;
        gfp_t gfp_mask;
        long unsigned int pgoff;
        long unsigned int address;
        long unsigned int real_address;
    };
    enum fault_flag flags;
    pmd_t *pmd;
    pud_t *pud;
    union {
        pte_t orig_pte;
        pmd_t orig_pmd;
    };
    struct page *cow_page;
    struct page *page;
    pte_t *pte;
    spinlock_t *ptl;
    pgtable_t prealloc_pte;
};

struct vm_operations_struct {
    void (*open)(struct vm_area_struct *);
    void (*close)(struct vm_area_struct *);
    int (*may_split)(struct vm_area_struct *, long unsigned int);
    int (*mremap)(struct vm_area_struct *);
    int (*mprotect)(struct vm_area_struct *, long unsigned int, long unsigned int, long unsigned int);
    vm_fault_t (*fault)(struct vm_fault *);
    vm_fault_t (*huge_fault)(struct vm_fault *, unsigned int);
    vm_fault_t (*map_pages)(struct vm_fault *, long unsigned int, long unsigned int);
    long unsigned int (*pagesize)(struct vm_area_struct *);
    vm_fault_t (*page_mkwrite)(struct vm_fault *);
    vm_fault_t (*pfn_mkwrite)(struct vm_fault *);
    int (*access)(struct vm_area_struct *, long unsigned int, void *, int, int);
    const char * (*name)(struct vm_area_struct *);
    struct page * (*find_special_page)(struct vm_area_struct *, long unsigned int);
};

struct vm_special_mapping {
    const char *name;
    struct page **pages;
    vm_fault_t (*fault)(const struct vm_special_mapping *, struct vm_area_struct *, struct vm_fault *);
    int (*mremap)(const struct vm_special_mapping *, struct vm_area_struct *);
    void (*close)(const struct vm_special_mapping *, struct vm_area_struct *);
};

struct vm_stack {
    struct callback_head rcu;
    struct vm_struct *stack_vm_area;
};

struct vm_struct {
    struct vm_struct *next;
    void *addr;
    long unsigned int size;
    long unsigned int flags;
    struct page **pages;
    unsigned int page_order;
    unsigned int nr_pages;
    phys_addr_t phys_addr;
    const void *caller;
    long unsigned int requested_size;
};

struct vm_unmapped_area_info {
    long unsigned int flags;
    long unsigned int length;
    long unsigned int low_limit;
    long unsigned int high_limit;
    long unsigned int align_mask;
    long unsigned int align_offset;
    long unsigned int start_gap;
};

struct vma_list {
    struct vm_area_struct *vma;
    struct list_head head;
    refcount_t mmap_count;
};

struct vma_lock {
    struct rw_semaphore lock;
};

struct vma_merge_struct {
    struct mm_struct *mm;
    struct vma_iterator *vmi;
    long unsigned int pgoff;
    struct vm_area_struct *prev;
    struct vm_area_struct *next;
    struct vm_area_struct *vma;
    long unsigned int start;
    long unsigned int end;
    long unsigned int flags;
    struct file *file;
    struct anon_vma *anon_vma;
    struct mempolicy *policy;
    struct vm_userfaultfd_ctx uffd_ctx;
    struct anon_vma_name *anon_name;
    enum vma_merge_flags merge_flags;
    enum vma_merge_state state;
    bool give_up_on_oom: 1;
};

struct vma_prepare {
    struct vm_area_struct *vma;
    struct vm_area_struct *adj_next;
    struct file *file;
    struct address_space *mapping;
    struct anon_vma *anon_vma;
    struct vm_area_struct *insert;
    struct vm_area_struct *remove;
    struct vm_area_struct *remove2;
};

struct vmap_area {
    long unsigned int va_start;
    long unsigned int va_end;
    struct rb_node rb_node;
    struct list_head list;
    union {
        long unsigned int subtree_max_size;
        struct vm_struct *vm;
    };
    long unsigned int flags;
};

struct vmap_block {
    spinlock_t lock;
    struct vmap_area *va;
    long unsigned int free;
    long unsigned int dirty;
    long unsigned int used_map[16];
    long unsigned int dirty_min;
    long unsigned int dirty_max;
    struct list_head free_list;
    struct callback_head callback_head;
    struct list_head purge;
    unsigned int cpu;
};

struct vmap_block_queue {
    spinlock_t lock;
    struct list_head free;
    struct xarray vmap_blocks;
};

struct vmap_pool {
    struct list_head head;
    long unsigned int len;
};

struct vmap_node {
    struct vmap_pool pool[256];
    spinlock_t pool_lock;
    bool skip_populate;
    struct rb_list busy;
    struct rb_list lazy;
    struct list_head purge_list;
    struct work_struct purge_work;
    long unsigned int nr_purged;
};

struct vmap_pfn_data {
    long unsigned int *pfns;
    pgprot_t prot;
    unsigned int idx;
};

struct vmcore_cb {
    bool (*pfn_is_ram)(struct vmcore_cb *, long unsigned int);
    int (*get_device_ram)(struct vmcore_cb *, struct list_head *);
    struct list_head next;
};

struct vmcore_range {
    struct list_head list;
    long long unsigned int paddr;
    long long unsigned int size;
    loff_t offset;
};

struct vmcoredd_data {
    char dump_name[44];
    unsigned int size;
    int (*vmcoredd_callback)(struct vmcoredd_data *, void *);
};

struct vmcoredd_header {
    __u32 n_namesz;
    __u32 n_descsz;
    __u32 n_type;
    __u8 name[8];
    __u8 dump_name[44];
};

struct vmcoredd_node {
    struct list_head list;
    void *buf;
    unsigned int size;
};

struct vmpressure_event {
    struct eventfd_ctx *efd;
    enum vmpressure_levels level;
    enum vmpressure_modes mode;
    struct list_head node;
};

struct vt_consize {
    short unsigned int v_rows;
    short unsigned int v_cols;
    short unsigned int v_vlin;
    short unsigned int v_clin;
    short unsigned int v_vcol;
    short unsigned int v_ccol;
};

struct vt_event {
    unsigned int event;
    unsigned int oldev;
    unsigned int newev;
    unsigned int pad[4];
};

struct vt_event_wait {
    struct list_head list;
    struct vt_event event;
    int done;
};

struct vt_notifier_param {
    struct vc_data *vc;
    unsigned int c;
};

struct vt_setactivate {
    unsigned int console;
    struct vt_mode mode;
};

struct vt_sizes {
    short unsigned int v_rows;
    short unsigned int v_cols;
    short unsigned int v_scrollsize;
};

struct vt_spawn_console {
    spinlock_t lock;
    struct pid *pid;
    int sig;
};

struct vt_stat {
    short unsigned int v_active;
    short unsigned int v_signal;
    short unsigned int v_state;
};

struct vxlan_metadata {
    u32 gbp;
};

struct wait_bit_key {
    long unsigned int *flags;
    int bit_nr;
    long unsigned int timeout;
};

struct wait_bit_queue_entry {
    struct wait_bit_key key;
    struct wait_queue_entry wq_entry;
};

struct wait_page_key {
    struct folio *folio;
    int bit_nr;
    int page_match;
};

struct wake_irq {
    struct device *dev;
    unsigned int status;
    int irq;
    const char *name;
};

struct wakeup_source {
    const char *name;
    int id;
    struct list_head entry;
    spinlock_t lock;
    struct wake_irq *wakeirq;
    struct timer_list timer;
    long unsigned int timer_expires;
    ktime_t total_time;
    ktime_t max_time;
    ktime_t last_time;
    ktime_t start_prevent_time;
    ktime_t prevent_sleep_time;
    long unsigned int event_count;
    long unsigned int active_count;
    long unsigned int relax_count;
    long unsigned int expire_count;
    long unsigned int wakeup_count;
    struct device *dev;
    bool active: 1;
    bool autosleep_enabled: 1;
};

struct walk_rcec_data {
    struct pci_dev *rcec;
    int (*user_callback)(struct pci_dev *, void *);
    void *user_data;
};

struct warn_args {
    const char *fmt;
    va_list args;
};

struct watch {
    union {
        struct callback_head rcu;
        u32 info_id;
    };
    struct watch_queue *queue;
    struct hlist_node queue_node;
    struct watch_list *watch_list;
    struct hlist_node list_node;
    const struct cred *cred;
    void *private;
    u64 id;
    struct kref usage;
};

struct watch_type_filter {
    enum watch_notification_type type;
    __u32 subtype_filter[1];
    __u32 info_filter;
    __u32 info_mask;
};

struct watch_filter {
    union {
        struct callback_head rcu;
        long unsigned int type_filter[1];
    };
    u32 nr_filters;
    struct watch_type_filter filters[0];
};

struct watch_list {
    struct callback_head rcu;
    struct hlist_head watchers;
    void (*release_watch)(struct watch *);
    spinlock_t lock;
};

struct watch_notification_type_filter {
    __u32 type;
    __u32 info_filter;
    __u32 info_mask;
    __u32 subtype_filter[8];
};

struct watch_notification_filter {
    __u32 nr_filters;
    __u32 __reserved;
    struct watch_notification_type_filter filters[0];
};

struct watch_notification_removal {
    struct watch_notification watch;
    __u64 id;
};

struct watch_queue {
    struct callback_head rcu;
    struct watch_filter *filter;
    struct pipe_inode_info *pipe;
    struct hlist_head watches;
    struct page **notes;
    long unsigned int *notes_bitmap;
    struct kref usage;
    spinlock_t lock;
    unsigned int nr_notes;
    unsigned int nr_pages;
};

struct watchdog_device;

struct watchdog_core_data {
    struct device dev;
    struct cdev cdev;
    struct watchdog_device *wdd;
    struct mutex lock;
    ktime_t last_keepalive;
    ktime_t last_hw_keepalive;
    ktime_t open_deadline;
    struct hrtimer timer;
    struct kthread_work work;
    long unsigned int status;
};

struct watchdog_info;

struct watchdog_ops;

struct watchdog_device {
    int id;
    struct device *parent;
    const struct attribute_group **groups;
    const struct watchdog_info *info;
    const struct watchdog_ops *ops;
    const struct watchdog_governor *gov;
    unsigned int bootstatus;
    unsigned int timeout;
    unsigned int pretimeout;
    unsigned int min_timeout;
    unsigned int max_timeout;
    unsigned int min_hw_heartbeat_ms;
    unsigned int max_hw_heartbeat_ms;
    struct notifier_block reboot_nb;
    struct notifier_block restart_nb;
    struct notifier_block pm_nb;
    void *driver_data;
    struct watchdog_core_data *wd_data;
    long unsigned int status;
    struct list_head deferred;
};

struct watchdog_governor {
    const char name[20];
    void (*pretimeout)(struct watchdog_device *);
};

struct watchdog_info {
    __u32 options;
    __u32 firmware_version;
    __u8 identity[32];
};

struct watchdog_ops {
    struct module *owner;
    int (*start)(struct watchdog_device *);
    int (*stop)(struct watchdog_device *);
    int (*ping)(struct watchdog_device *);
    unsigned int (*status)(struct watchdog_device *);
    int (*set_timeout)(struct watchdog_device *, unsigned int);
    int (*set_pretimeout)(struct watchdog_device *, unsigned int);
    unsigned int (*get_timeleft)(struct watchdog_device *);
    int (*restart)(struct watchdog_device *, long unsigned int, void *);
    long int (*ioctl)(struct watchdog_device *, unsigned int, long unsigned int);
};

struct watchdog_pretimeout {
    struct watchdog_device *wdd;
    struct list_head entry;
};

struct wb_lock_cookie {
    bool locked;
    long unsigned int flags;
};

struct wb_stats {
    long unsigned int nr_dirty;
    long unsigned int nr_io;
    long unsigned int nr_more_io;
    long unsigned int nr_dirty_time;
    long unsigned int nr_writeback;
    long unsigned int nr_reclaimable;
    long unsigned int nr_dirtied;
    long unsigned int nr_written;
    long unsigned int dirty_thresh;
    long unsigned int wb_thresh;
};

struct wb_writeback_work {
    long int nr_pages;
    struct super_block *sb;
    enum writeback_sync_modes sync_mode;
    unsigned int tagged_writepages: 1;
    unsigned int for_kupdate: 1;
    unsigned int range_cyclic: 1;
    unsigned int for_background: 1;
    unsigned int for_sync: 1;
    unsigned int auto_free: 1;
    enum wb_reason reason;
    struct list_head list;
    struct wb_completion *done;
};

struct wbt_wait_data {
    struct rq_wb *rwb;
    enum wbt_flags wb_acct;
    blk_opf_t opf;
};

struct wchan_info {
    long unsigned int pc;
    int count;
};

struct wci_ent {
    work_func_t func;
    atomic64_t cnt;
    struct hlist_node hash_node;
};

struct win_certificate {
    uint32_t length;
    uint16_t revision;
    uint16_t cert_type;
};

struct rfkill;

struct wiphy_iftype_akm_suites;

struct wiphy_wowlan_support;

struct wiphy_iftype_ext_capab;

struct wiphy_coalesce_support;

struct wiphy_vendor_command;

struct wiphy_radio;

struct wiphy {
    struct mutex mtx;
    u8 perm_addr[6];
    u8 addr_mask[6];
    struct mac_address *addresses;
    const struct ieee80211_txrx_stypes *mgmt_stypes;
    const struct ieee80211_iface_combination *iface_combinations;
    int n_iface_combinations;
    u16 software_iftypes;
    u16 n_addresses;
    u16 interface_modes;
    u16 max_acl_mac_addrs;
    u32 flags;
    u32 regulatory_flags;
    u32 features;
    u8 ext_features[9];
    u32 ap_sme_capa;
    enum cfg80211_signal_type signal_type;
    int bss_priv_size;
    u8 max_scan_ssids;
    u8 max_sched_scan_reqs;
    u8 max_sched_scan_ssids;
    u8 max_match_sets;
    u16 max_scan_ie_len;
    u16 max_sched_scan_ie_len;
    u32 max_sched_scan_plans;
    u32 max_sched_scan_plan_interval;
    u32 max_sched_scan_plan_iterations;
    int n_cipher_suites;
    const u32 *cipher_suites;
    int n_akm_suites;
    const u32 *akm_suites;
    const struct wiphy_iftype_akm_suites *iftype_akm_suites;
    unsigned int num_iftype_akm_suites;
    u8 retry_short;
    u8 retry_long;
    u32 frag_threshold;
    u32 rts_threshold;
    u8 coverage_class;
    char fw_version[32];
    u32 hw_version;
    const struct wiphy_wowlan_support *wowlan;
    struct cfg80211_wowlan *wowlan_config;
    u16 max_remain_on_channel_duration;
    u8 max_num_pmkids;
    u32 available_antennas_tx;
    u32 available_antennas_rx;
    u32 probe_resp_offload;
    const u8 *extended_capabilities;
    const u8 *extended_capabilities_mask;
    u8 extended_capabilities_len;
    const struct wiphy_iftype_ext_capab *iftype_ext_capab;
    unsigned int num_iftype_ext_capab;
    const void *privid;
    struct ieee80211_supported_band *bands[6];
    void (*reg_notifier)(struct wiphy *, struct regulatory_request *);
    const struct ieee80211_regdomain *regd;
    struct device dev;
    bool registered;
    struct dentry *debugfsdir;
    const struct ieee80211_ht_cap *ht_capa_mod_mask;
    const struct ieee80211_vht_cap *vht_capa_mod_mask;
    struct list_head wdev_list;
    possible_net_t _net;
    const struct iw_handler_def *wext;
    const struct wiphy_coalesce_support *coalesce;
    const struct wiphy_vendor_command *vendor_commands;
    const struct nl80211_vendor_cmd_info *vendor_events;
    int n_vendor_commands;
    int n_vendor_events;
    u16 max_ap_assoc_sta;
    u8 max_num_csa_counters;
    u32 bss_select_support;
    u8 nan_supported_bands;
    u32 txq_limit;
    u32 txq_memory_limit;
    u32 txq_quantum;
    long unsigned int tx_queue_len;
    u8 support_mbssid: 1;
    u8 support_only_he_mbssid: 1;
    const struct cfg80211_pmsr_capabilities *pmsr_capa;
    struct {
        u64 peer;
        u64 vif;
        u8 max_retry;
    } tid_config_support;
    u8 max_data_retry_count;
    const struct cfg80211_sar_capa *sar_capa;
    struct rfkill *rfkill;
    u8 mbssid_max_interfaces;
    u8 ema_max_profile_periodicity;
    u16 max_num_akm_suites;
    u16 hw_timestamp_max_peers;
    int n_radio;
    const struct wiphy_radio *radio;
    char priv[0];
};

struct wiphy_coalesce_support {
    int n_rules;
    int max_delay;
    int n_patterns;
    int pattern_max_len;
    int pattern_min_len;
    int max_pkt_offset;
};

struct wiphy_iftype_akm_suites {
    u16 iftypes_mask;
    const u32 *akm_suites;
    int n_akm_suites;
};

struct wiphy_iftype_ext_capab {
    enum nl80211_iftype iftype;
    const u8 *extended_capabilities;
    const u8 *extended_capabilities_mask;
    u8 extended_capabilities_len;
    u16 eml_capabilities;
    u16 mld_capa_and_ops;
};

struct wiphy_radio_freq_range;

struct wiphy_radio {
    const struct wiphy_radio_freq_range *freq_range;
    int n_freq_range;
    const struct ieee80211_iface_combination *iface_combinations;
    int n_iface_combinations;
    u32 antenna_mask;
};

struct wiphy_radio_freq_range {
    u32 start_freq;
    u32 end_freq;
};

struct wiphy_vendor_command {
    struct nl80211_vendor_cmd_info info;
    u32 flags;
    int (*doit)(struct wiphy *, struct wireless_dev *, const void *, int);
    int (*dumpit)(struct wiphy *, struct wireless_dev *, struct sk_buff *, const void *, int, long unsigned int *);
    const struct nla_policy *policy;
    unsigned int maxattr;
};

struct wiphy_work;

typedef void (*wiphy_work_func_t)(struct wiphy *, struct wiphy_work *);

struct wiphy_work {
    struct list_head entry;
    wiphy_work_func_t func;
};

struct wiphy_wowlan_tcp_support;

struct wiphy_wowlan_support {
    u32 flags;
    int n_patterns;
    int pattern_max_len;
    int pattern_min_len;
    int max_pkt_offset;
    int max_nd_match_sets;
    const struct wiphy_wowlan_tcp_support *tcp;
};

struct wiphy_wowlan_tcp_support {
    const struct nl80211_wowlan_tcp_data_token_feature *tok;
    u32 data_payload_max;
    u32 data_interval_max;
    u32 wake_payload_max;
    bool seq;
};

struct cfg80211_conn;

struct cfg80211_cached_keys;

struct cfg80211_cqm_config;

struct cfg80211_internal_bss;

struct wireless_dev {
    struct wiphy *wiphy;
    enum nl80211_iftype iftype;
    struct list_head list;
    struct net_device *netdev;
    u32 identifier;
    struct list_head mgmt_registrations;
    u8 mgmt_registrations_need_update: 1;
    bool use_4addr;
    bool is_running;
    bool registered;
    bool registering;
    short: 0;
    u8 address[6];
    struct cfg80211_conn *conn;
    struct cfg80211_cached_keys *connect_keys;
    enum ieee80211_bss_type conn_bss_type;
    u32 conn_owner_nlportid;
    struct work_struct disconnect_wk;
    u8 disconnect_bssid[6];
    struct list_head event_list;
    spinlock_t event_lock;
    u8 connected: 1;
    bool ps;
    int ps_timeout;
    u32 ap_unexpected_nlportid;
    u32 owner_nlportid;
    bool nl_owner_dead;
    struct {
        struct cfg80211_ibss_params ibss;
        struct cfg80211_connect_params connect;
        struct cfg80211_cached_keys *keys;
        const u8 *ie;
        size_t ie_len;
        u8 bssid[6];
        u8 prev_bssid[6];
        u8 ssid[32];
        s8 default_key;
        s8 default_mgmt_key;
        bool prev_bssid_valid;
    } wext;
    struct wiphy_work cqm_rssi_work;
    struct cfg80211_cqm_config *cqm_config;
    struct list_head pmsr_list;
    spinlock_t pmsr_lock;
    struct work_struct pmsr_free_wk;
    long unsigned int unprot_beacon_reported;
    union {
        struct {
            u8 connected_addr[6];
            u8 ssid[32];
            u8 ssid_len;
            long: 0;
        } client;
        struct {
            int beacon_interval;
            struct cfg80211_chan_def preset_chandef;
            struct cfg80211_chan_def chandef;
            u8 id[32];
            u8 id_len;
            u8 id_up_len;
        } mesh;
        struct {
            struct cfg80211_chan_def preset_chandef;
            u8 ssid[32];
            u8 ssid_len;
        } ap;
        struct {
            struct cfg80211_internal_bss *current_bss;
            struct cfg80211_chan_def chandef;
            int beacon_interval;
            u8 ssid[32];
            u8 ssid_len;
        } ibss;
        struct {
            struct cfg80211_chan_def chandef;
        } ocb;
    } u;
    struct {
        u8 addr[6];
        union {
            struct {
                unsigned int beacon_interval;
                struct cfg80211_chan_def chandef;
            } ap;
            struct {
                struct cfg80211_internal_bss *current_bss;
            } client;
        };
        bool cac_started;
        long unsigned int cac_start_time;
        unsigned int cac_time_ms;
    } links[15];
    u16 valid_links;
    u32 radio_mask;
};

struct wol_reply_data {
    struct ethnl_reply_data base;
    struct ethtool_wolinfo wol;
    bool show_sopass;
};

struct word_at_a_time {
    const long unsigned int one_bits;
    const long unsigned int high_bits;
};

struct work_for_cpu {
    struct work_struct work;
    long int (*fn)(void *);
    void *arg;
    long int ret;
};

struct work_offq_data {
    u32 pool_id;
    u32 disable;
    u32 flags;
};

struct worker {
    union {
        struct list_head entry;
        struct hlist_node hentry;
    };
    struct work_struct *current_work;
    work_func_t current_func;
    struct pool_workqueue *current_pwq;
    u64 current_at;
    unsigned int current_color;
    int sleeping;
    work_func_t last_func;
    struct list_head scheduled;
    struct task_struct *task;
    struct worker_pool *pool;
    struct list_head node;
    long unsigned int last_active;
    unsigned int flags;
    int id;
    char desc[32];
    struct workqueue_struct *rescue_wq;
};

struct worker_pool {
    raw_spinlock_t lock;
    int cpu;
    int node;
    int id;
    unsigned int flags;
    long unsigned int watchdog_ts;
    bool cpu_stall;
    int nr_running;
    struct list_head worklist;
    int nr_workers;
    int nr_idle;
    struct list_head idle_list;
    struct timer_list idle_timer;
    struct work_struct idle_cull_work;
    struct timer_list mayday_timer;
    struct hlist_head busy_hash[64];
    struct worker *manager;
    struct list_head workers;
    struct ida worker_ida;
    struct workqueue_attrs *attrs;
    struct hlist_node hash_node;
    int refcnt;
    struct callback_head rcu;
};

struct workqueue_attrs {
    int nice;
    cpumask_var_t cpumask;
    cpumask_var_t __pod_cpumask;
    bool affn_strict;
    enum wq_affn_scope affn_scope;
    bool ordered;
};

struct wq_flusher;

struct wq_device;

struct wq_node_nr_active;

struct workqueue_struct {
    struct list_head pwqs;
    struct list_head list;
    struct mutex mutex;
    int work_color;
    int flush_color;
    atomic_t nr_pwqs_to_flush;
    struct wq_flusher *first_flusher;
    struct list_head flusher_queue;
    struct list_head flusher_overflow;
    struct list_head maydays;
    struct worker *rescuer;
    int nr_drainers;
    int max_active;
    int min_active;
    int saved_max_active;
    int saved_min_active;
    struct workqueue_attrs *unbound_attrs;
    struct pool_workqueue *dfl_pwq;
    struct wq_device *wq_dev;
    char name[32];
    struct callback_head rcu;
    long: 64;
    long: 64;
    unsigned int flags;
    struct pool_workqueue **cpu_pwq;
    struct wq_node_nr_active *node_nr_active[0];
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
};

struct workspace {
    void *mem;
    size_t mem_size;
    size_t window_size;
};

struct wpan_phy;

struct wpan_dev_header_ops;

struct wpan_dev {
    struct wpan_phy *wpan_phy;
    int iftype;
    struct list_head list;
    struct net_device *netdev;
    const struct wpan_dev_header_ops *header_ops;
    struct net_device *lowpan_dev;
    u32 identifier;
    __le16 pan_id;
    __le16 short_addr;
    __le64 extended_addr;
    atomic_t bsn;
    atomic_t dsn;
    u8 min_be;
    u8 max_be;
    u8 csma_retries;
    s8 frame_retries;
    bool lbt;
    bool ackreq;
    struct mutex association_lock;
    struct ieee802154_pan_device *parent;
    struct list_head children;
    unsigned int max_associations;
    unsigned int nchildren;
};

struct wpan_dev_header_ops {
    int (*create)(struct sk_buff *, struct net_device *, const struct ieee802154_addr *, const struct ieee802154_addr *, unsigned int);
};

struct wpan_phy_supported {
    u32 channels[32];
    u32 cca_modes;
    u32 cca_opts;
    u32 iftypes;
    enum nl802154_supported_bool_states lbt;
    u8 min_minbe;
    u8 max_minbe;
    u8 min_maxbe;
    u8 max_maxbe;
    u8 min_csma_backoffs;
    u8 max_csma_backoffs;
    s8 min_frame_retries;
    s8 max_frame_retries;
    size_t tx_powers_size;
    size_t cca_ed_levels_size;
    const s32 *tx_powers;
    const s32 *cca_ed_levels;
};

struct wpan_phy_cca {
    enum nl802154_cca_modes mode;
    enum nl802154_cca_opts opt;
};

struct wpan_phy {
    const void *privid;
    long unsigned int flags;
    u8 current_channel;
    u8 current_page;
    struct wpan_phy_supported supported;
    s32 transmit_power;
    struct wpan_phy_cca cca;
    __le64 perm_extended_addr;
    s32 cca_ed_level;
    u32 symbol_duration;
    u16 lifs_period;
    u16 sifs_period;
    struct device dev;
    possible_net_t _net;
    spinlock_t queue_lock;
    atomic_t ongoing_txs;
    atomic_t hold_txs;
    wait_queue_head_t sync_txq;
    enum ieee802154_filtering_level filtering;
    long: 0;
    char priv[0];
};

struct wq_barrier {
    struct work_struct work;
    struct completion done;
    struct task_struct *task;
};

struct wq_device {
    struct workqueue_struct *wq;
    struct device dev;
};

struct wq_drain_dead_softirq_work {
    struct work_struct work;
    struct worker_pool *pool;
    struct completion done;
};

struct wq_flusher {
    struct list_head list;
    int flush_color;
    struct completion done;
};

struct wq_node_nr_active {
    int max;
    atomic_t nr;
    raw_spinlock_t lock;
    struct list_head pending_pwqs;
};

struct wq_pod_type {
    int nr_pods;
    cpumask_var_t *pod_cpus;
    int *pod_node;
    int *cpu_pod;
};

typedef void (*swap_func_t)(void *, void *, int);

struct wrapper {
    cmp_func_t cmp;
    swap_func_t swap;
};

struct writeback_control {
    long int nr_to_write;
    long int pages_skipped;
    loff_t range_start;
    loff_t range_end;
    enum writeback_sync_modes sync_mode;
    unsigned int for_kupdate: 1;
    unsigned int for_background: 1;
    unsigned int tagged_writepages: 1;
    unsigned int for_reclaim: 1;
    unsigned int range_cyclic: 1;
    unsigned int for_sync: 1;
    unsigned int unpinned_netfs_wb: 1;
    unsigned int no_cgroup_owner: 1;
    struct swap_iocb **swap_plug;
    struct list_head *list;
    struct folio_batch fbatch;
    long unsigned int index;
    int saved_err;
    struct bdi_writeback *wb;
    struct inode *inode;
    int wb_id;
    int wb_lcand_id;
    int wb_tcand_id;
    size_t wb_bytes;
    size_t wb_lcand_bytes;
    size_t wb_tcand_bytes;
};

struct writer {
    uint8_t *buffer;
    uint8_t previous_byte;
    size_t buffer_pos;
    int bufsize;
    size_t global_pos;
    long int (*flush)(void *, long unsigned int);
    struct lzma_header *header;
};

struct ww_class {
    atomic_long_t stamp;
    struct lock_class_key acquire_key;
    struct lock_class_key mutex_key;
    const char *acquire_name;
    const char *mutex_name;
    unsigned int is_wait_die;
};

struct x509_certificate {
    struct x509_certificate *next;
    struct x509_certificate *signer;
    struct public_key *pub;
    struct public_key_signature *sig;
    char *issuer;
    char *subject;
    struct asymmetric_key_id *id;
    struct asymmetric_key_id *skid;
    time64_t valid_from;
    time64_t valid_to;
    const void *tbs;
    unsigned int tbs_size;
    unsigned int raw_sig_size;
    const void *raw_sig;
    const void *raw_serial;
    unsigned int raw_serial_size;
    unsigned int raw_issuer_size;
    const void *raw_issuer;
    const void *raw_subject;
    unsigned int raw_subject_size;
    unsigned int raw_skid_size;
    const void *raw_skid;
    unsigned int index;
    bool seen;
    bool verified;
    bool self_signed;
    bool unsupported_sig;
    bool blacklisted;
};

struct x509_parse_context {
    struct x509_certificate *cert;
    long unsigned int data;
    const void *key;
    size_t key_size;
    const void *params;
    size_t params_size;
    enum OID key_algo;
    enum OID last_oid;
    enum OID sig_algo;
    u8 o_size;
    u8 cn_size;
    u8 email_size;
    u16 o_offset;
    u16 cn_offset;
    u16 email_offset;
    unsigned int raw_akid_size;
    const void *raw_akid;
    const void *akid_raw_issuer;
    unsigned int akid_raw_issuer_size;
};

struct xa_limit {
    u32 max;
    u32 min;
};

struct xa_node {
    unsigned char shift;
    unsigned char offset;
    unsigned char count;
    unsigned char nr_values;
    struct xa_node *parent;
    struct xarray *array;
    union {
        struct list_head private_list;
        struct callback_head callback_head;
    };
    void *slots[64];
    union {
        long unsigned int tags[3];
        long unsigned int marks[3];
    };
};

typedef void (*xa_update_node_t)(struct xa_node *);

struct xa_state {
    struct xarray *xa;
    long unsigned int xa_index;
    unsigned char xa_shift;
    unsigned char xa_sibs;
    unsigned char xa_offset;
    unsigned char xa_pad;
    struct xa_node *xa_node;
    struct xa_node *xa_alloc;
    xa_update_node_t xa_update;
    struct list_lru *xa_lru;
};

struct xattr {
    const char *name;
    void *value;
    size_t value_len;
};

struct xattr_args {
    __u64 value;
    __u32 size;
    __u32 flags;
};

struct xattr_handler {
    const char *name;
    const char *prefix;
    int flags;
    bool (*list)(struct dentry *);
    int (*get)(const struct xattr_handler *, struct dentry *, struct inode *, const char *, void *, size_t);
    int (*set)(const struct xattr_handler *, struct mnt_idmap *, struct dentry *, struct inode *, const char *, const void *, size_t, int);
};

struct xattr_list {
    struct list_head list;
    char *name;
    bool enabled;
};

struct xattr_name {
    char name[256];
};

struct xbc_node {
    uint16_t next;
    uint16_t child;
    uint16_t parent;
    uint16_t data;
};

struct xdp_attachment_info {
    struct bpf_prog *prog;
    u32 flags;
};

struct xdp_buff_xsk {
    struct xdp_buff xdp;
    u8 cb[24];
    dma_addr_t dma;
    dma_addr_t frame_dma;
    struct xsk_buff_pool *pool;
    struct list_head list_node;
    long: 64;
};

struct xdp_bulk_queue {
    void *q[8];
    struct list_head flush_node;
    struct bpf_cpu_map_entry *obj;
    unsigned int count;
};

struct xdp_cpumap_stats {
    unsigned int redirect;
    unsigned int pass;
    unsigned int drop;
};

struct xdp_desc {
    __u64 addr;
    __u32 len;
    __u32 options;
};

struct xdp_dev_bulk_queue {
    struct xdp_frame *q[16];
    struct list_head flush_node;
    struct net_device *dev;
    struct net_device *dev_rx;
    struct bpf_prog *xdp_prog;
    unsigned int count;
};

struct xdp_frame {
    void *data;
    u32 len;
    u32 headroom;
    u32 metasize;
    enum xdp_mem_type mem_type: 32;
    struct net_device *dev_rx;
    u32 frame_sz;
    u32 flags;
};

struct xdp_frame_bulk {
    int count;
    netmem_ref q[16];
};

struct xdp_mem_allocator {
    struct xdp_mem_info mem;
    union {
        void *allocator;
        struct page_pool *page_pool;
    };
    struct rhash_head node;
    struct callback_head rcu;
};

struct xdp_metadata_ops {
    int (*xmo_rx_timestamp)(const struct xdp_md *, u64 *);
    int (*xmo_rx_hash)(const struct xdp_md *, u32 *, enum xdp_rss_hash_type *);
    int (*xmo_rx_vlan_tag)(const struct xdp_md *, __be16 *, u16 *);
};

struct xdp_ring_offset {
    __u64 producer;
    __u64 consumer;
    __u64 desc;
    __u64 flags;
};

struct xdp_mmap_offsets {
    struct xdp_ring_offset rx;
    struct xdp_ring_offset tx;
    struct xdp_ring_offset fr;
    struct xdp_ring_offset cr;
};

struct xdp_ring_offset_v1 {
    __u64 producer;
    __u64 consumer;
    __u64 desc;
};

struct xdp_mmap_offsets_v1 {
    struct xdp_ring_offset_v1 rx;
    struct xdp_ring_offset_v1 tx;
    struct xdp_ring_offset_v1 fr;
    struct xdp_ring_offset_v1 cr;
};

struct xdp_options {
    __u32 flags;
};

struct xdp_page_head {
    struct xdp_buff orig_ctx;
    struct xdp_buff ctx;
    union {
        struct {
            struct {} __empty_frame;
            struct xdp_frame frame[0];
        };
        struct {
            struct {} __empty_data;
            u8 data[0];
        };
    };
};

struct xdp_ring {
    u32 producer;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    u32 pad1;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    u32 consumer;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    u32 pad2;
    u32 flags;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    u32 pad3;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
};

struct xdp_rxtx_ring {
    struct xdp_ring ptrs;
    struct xdp_desc desc[0];
};

struct xsk_queue;

struct xdp_umem;

struct xdp_sock {
    struct sock sk;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    struct xsk_queue *rx;
    struct net_device *dev;
    struct xdp_umem *umem;
    struct list_head flush_node;
    struct xsk_buff_pool *pool;
    u16 queue_id;
    bool zc;
    bool sg;
    enum {
        XSK_READY = 0,
        XSK_BOUND = 1,
        XSK_UNBOUND = 2,
    } state;
    long: 64;
    struct xsk_queue *tx;
    struct list_head tx_list;
    u32 tx_budget_spent;
    u64 rx_dropped;
    u64 rx_queue_full;
    struct sk_buff *skb;
    struct list_head map_list;
    spinlock_t map_list_lock;
    struct mutex mutex;
    struct xsk_queue *fq_tmp;
    struct xsk_queue *cq_tmp;
};

struct xdp_statistics {
    __u64 rx_dropped;
    __u64 rx_invalid_descs;
    __u64 tx_invalid_descs;
    __u64 rx_ring_full;
    __u64 rx_fill_ring_empty_descs;
    __u64 tx_ring_empty_descs;
};

struct xdp_test_data {
    struct xdp_buff *orig_ctx;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    long: 64;
    struct xdp_rxq_info rxq;
    struct net_device *dev;
    struct page_pool *pp;
    struct xdp_frame **frames;
    struct sk_buff **skbs;
    struct xdp_mem_info mem;
    u32 batch_size;
    u32 frame_cnt;
    long: 64;
    long: 64;
};

struct xdp_txq_info {
    struct net_device *dev;
};

struct xdp_umem {
    void *addrs;
    u64 size;
    u32 headroom;
    u32 chunk_size;
    u32 chunks;
    u32 npgs;
    struct user_struct *user;
    refcount_t users;
    u8 flags;
    u8 tx_metadata_len;
    bool zc;
    struct page **pgs;
    int id;
    struct list_head xsk_dma_list;
    struct work_struct work;
};

struct xdp_umem_reg {
    __u64 addr;
    __u64 len;
    __u32 chunk_size;
    __u32 headroom;
    __u32 flags;
    __u32 tx_metadata_len;
};

struct xdp_umem_ring {
    struct xdp_ring ptrs;
    u64 desc[0];
};

struct xdr_netobj {
    unsigned int len;
    u8 *data;
};

struct xfrm4_protocol {
    int (*handler)(struct sk_buff *);
    int (*input_handler)(struct sk_buff *, int, __be32, int);
    int (*cb_handler)(struct sk_buff *, int);
    int (*err_handler)(struct sk_buff *, u32);
    struct xfrm4_protocol *next;
    int priority;
};

struct xfrm6_protocol {
    int (*handler)(struct sk_buff *);
    int (*input_handler)(struct sk_buff *, int, __be32, int);
    int (*cb_handler)(struct sk_buff *, int);
    int (*err_handler)(struct sk_buff *, struct inet6_skb_parm *, u8, u8, int, __be32);
    struct xfrm6_protocol *next;
    int priority;
};

struct xfrm_address_filter {
    xfrm_address_t saddr;
    xfrm_address_t daddr;
    __u16 family;
    __u8 splen;
    __u8 dplen;
};

struct xfrm_algo {
    char alg_name[64];
    unsigned int alg_key_len;
    char alg_key[0];
};

struct xfrm_algo_aead {
    char alg_name[64];
    unsigned int alg_key_len;
    unsigned int alg_icv_len;
    char alg_key[0];
};

struct xfrm_algo_auth {
    char alg_name[64];
    unsigned int alg_key_len;
    unsigned int alg_trunc_len;
    char alg_key[0];
};

struct xfrm_dev_offload {
    struct net_device *dev;
    netdevice_tracker dev_tracker;
    struct net_device *real_dev;
    long unsigned int offload_handle;
    u8 dir: 2;
    u8 type: 2;
    u8 flags: 2;
};

struct xfrm_dst {
    union {
        struct dst_entry dst;
        struct rtable rt;
        struct rt6_info rt6;
    } u;
    struct dst_entry *route;
    struct dst_entry *child;
    struct dst_entry *path;
    struct xfrm_policy *pols[2];
    int num_pols;
    int num_xfrms;
    u32 xfrm_genid;
    u32 policy_genid;
    u32 route_mtu_cached;
    u32 child_mtu_cached;
    u32 route_cookie;
    u32 path_cookie;
};

struct xfrm_dst_lookup_params {
    struct net *net;
    dscp_t dscp;
    int oif;
    xfrm_address_t *saddr;
    xfrm_address_t *daddr;
    u32 mark;
    __u8 ipproto;
    union flowi_uli uli;
};

struct xfrm_encap_tmpl {
    __u16 encap_type;
    __be16 encap_sport;
    __be16 encap_dport;
    xfrm_address_t encap_oa;
};

struct xfrm_flo {
    struct dst_entry *dst_orig;
    u8 flags;
};

struct xfrm_flow_keys {
    struct flow_dissector_key_basic basic;
    struct flow_dissector_key_control control;
    union {
        struct flow_dissector_key_ipv4_addrs ipv4;
        struct flow_dissector_key_ipv6_addrs ipv6;
    } addrs;
    struct flow_dissector_key_ip ip;
    struct flow_dissector_key_icmp icmp;
    struct flow_dissector_key_ports ports;
    struct flow_dissector_key_keyid gre;
};

struct xfrm_hash_state_ptrs {
    const struct hlist_head *bydst;
    const struct hlist_head *bysrc;
    const struct hlist_head *byspi;
    unsigned int hmask;
};

struct xfrm_id {
    xfrm_address_t daddr;
    __be32 spi;
    __u8 proto;
};

struct xfrm_if_decode_session_result;

struct xfrm_if_cb {
    bool (*decode_session)(struct sk_buff *, short unsigned int, struct xfrm_if_decode_session_result *);
};

struct xfrm_if_decode_session_result {
    struct net *net;
    u32 if_id;
};

struct xfrm_input_afinfo {
    u8 family;
    bool is_ipip;
    int (*callback)(struct sk_buff *, u8, int);
};

struct xfrm_kmaddress {
    xfrm_address_t local;
    xfrm_address_t remote;
    u32 reserved;
    u16 family;
};

struct xfrm_lifetime_cfg {
    __u64 soft_byte_limit;
    __u64 hard_byte_limit;
    __u64 soft_packet_limit;
    __u64 hard_packet_limit;
    __u64 soft_add_expires_seconds;
    __u64 hard_add_expires_seconds;
    __u64 soft_use_expires_seconds;
    __u64 hard_use_expires_seconds;
};

struct xfrm_lifetime_cur {
    __u64 bytes;
    __u64 packets;
    __u64 add_time;
    __u64 use_time;
};

struct xfrm_mark {
    __u32 v;
    __u32 m;
};

struct xfrm_tmpl;

struct xfrm_selector;

struct xfrm_migrate;

struct xfrm_mgr {
    struct list_head list;
    int (*notify)(struct xfrm_state *, const struct km_event *);
    int (*acquire)(struct xfrm_state *, struct xfrm_tmpl *, struct xfrm_policy *);
    struct xfrm_policy * (*compile_policy)(struct sock *, int, u8 *, int, int *);
    int (*new_mapping)(struct xfrm_state *, xfrm_address_t *, __be16);
    int (*notify_policy)(struct xfrm_policy *, int, const struct km_event *);
    int (*report)(struct net *, u8, struct xfrm_selector *, xfrm_address_t *);
    int (*migrate)(const struct xfrm_selector *, u8, u8, const struct xfrm_migrate *, int, const struct xfrm_kmaddress *, const struct xfrm_encap_tmpl *);
    bool (*is_alive)(const struct km_event *);
};

struct xfrm_migrate {
    xfrm_address_t old_daddr;
    xfrm_address_t old_saddr;
    xfrm_address_t new_daddr;
    xfrm_address_t new_saddr;
    u8 proto;
    u8 mode;
    u16 reserved;
    u32 reqid;
    u16 old_family;
    u16 new_family;
};

struct xfrm_mode {
    u8 encap;
    u8 family;
    u8 flags;
};

struct xfrm_mode_cbs {
    struct module *owner;
    int (*init_state)(struct xfrm_state *);
    int (*clone_state)(struct xfrm_state *, struct xfrm_state *);
    void (*destroy_state)(struct xfrm_state *);
    int (*user_init)(struct net *, struct xfrm_state *, struct nlattr **, struct netlink_ext_ack *);
    int (*copy_to_user)(struct xfrm_state *, struct sk_buff *);
    unsigned int (*sa_len)(const struct xfrm_state *);
    u32 (*get_inner_mtu)(struct xfrm_state *, int);
    int (*input)(struct xfrm_state *, struct sk_buff *);
    int (*output)(struct net *, struct sock *, struct sk_buff *);
    int (*prepare_output)(struct xfrm_state *, struct sk_buff *);
};

struct xfrm_tunnel_skb_cb {
    union {
        struct inet_skb_parm h4;
        struct inet6_skb_parm h6;
    } header;
    union {
        struct ip_tunnel *ip4;
        struct ip6_tnl *ip6;
    } tunnel;
};

struct xfrm_mode_skb_cb {
    struct xfrm_tunnel_skb_cb header;
    __be16 id;
    __be16 frag_off;
    u8 ihl;
    u8 tos;
    u8 ttl;
    u8 protocol;
    u8 optlen;
    u8 flow_lbl[3];
};

struct xfrm_pol_inexact_key {
    possible_net_t net;
    u32 if_id;
    u16 family;
    u8 dir;
    u8 type;
};

struct xfrm_pol_inexact_bin {
    struct xfrm_pol_inexact_key k;
    struct rhash_head head;
    struct hlist_head hhead;
    seqcount_spinlock_t count;
    struct rb_root root_d;
    struct rb_root root_s;
    struct list_head inexact_bins;
    struct callback_head rcu;
};

struct xfrm_pol_inexact_candidates {
    struct hlist_head *res[4];
};

struct xfrm_pol_inexact_node {
    struct rb_node node;
    union {
        xfrm_address_t addr;
        struct callback_head rcu;
    };
    u8 prefixlen;
    struct rb_root root;
    struct hlist_head hhead;
};

struct xfrm_selector {
    xfrm_address_t daddr;
    xfrm_address_t saddr;
    __be16 dport;
    __be16 dport_mask;
    __be16 sport;
    __be16 sport_mask;
    __u16 family;
    __u8 prefixlen_d;
    __u8 prefixlen_s;
    __u8 proto;
    int ifindex;
    __kernel_uid32_t user;
};

struct xfrm_policy_walk_entry {
    struct list_head all;
    u8 dead;
};

struct xfrm_policy_queue {
    struct sk_buff_head hold_queue;
    struct timer_list hold_timer;
    long unsigned int timeout;
};

struct xfrm_tmpl {
    struct xfrm_id id;
    xfrm_address_t saddr;
    short unsigned int encap_family;
    u32 reqid;
    u8 mode;
    u8 share;
    u8 optional;
    u8 allalgs;
    u32 aalgos;
    u32 ealgos;
    u32 calgos;
};

struct xfrm_policy {
    possible_net_t xp_net;
    struct hlist_node bydst;
    struct hlist_node byidx;
    struct hlist_head state_cache_list;
    rwlock_t lock;
    refcount_t refcnt;
    u32 pos;
    struct timer_list timer;
    atomic_t genid;
    u32 priority;
    u32 index;
    u32 if_id;
    struct xfrm_mark mark;
    struct xfrm_selector selector;
    struct xfrm_lifetime_cfg lft;
    struct xfrm_lifetime_cur curlft;
    struct xfrm_policy_walk_entry walk;
    struct xfrm_policy_queue polq;
    bool bydst_reinsert;
    u8 type;
    u8 action;
    u8 flags;
    u8 xfrm_nr;
    u16 family;
    struct xfrm_sec_ctx *security;
    struct xfrm_tmpl xfrm_vec[6];
    struct callback_head rcu;
    struct xfrm_dev_offload xdo;
};

struct xfrm_policy_afinfo {
    struct dst_ops *dst_ops;
    struct dst_entry * (*dst_lookup)(const struct xfrm_dst_lookup_params *);
    int (*get_saddr)(xfrm_address_t *, const struct xfrm_dst_lookup_params *);
    int (*fill_dst)(struct xfrm_dst *, struct net_device *, const struct flowi *);
    struct dst_entry * (*blackhole_route)(struct net *, struct dst_entry *);
};

struct xfrm_policy_walk {
    struct xfrm_policy_walk_entry walk;
    u8 type;
    u32 seq;
};

struct xfrm_replay_state {
    __u32 oseq;
    __u32 seq;
    __u32 bitmap;
};

struct xfrm_replay_state_esn {
    unsigned int bmp_len;
    __u32 oseq;
    __u32 seq;
    __u32 oseq_hi;
    __u32 seq_hi;
    __u32 replay_window;
    __u32 bmp[0];
};

struct xfrm_sec_ctx {
    __u8 ctx_doi;
    __u8 ctx_alg;
    __u16 ctx_len;
    __u32 ctx_sid;
    char ctx_str[0];
};

struct xfrm_skb_cb {
    struct xfrm_tunnel_skb_cb header;
    union {
        struct {
            __u32 low;
            __u32 hi;
        } output;
        struct {
            __be32 low;
            __be32 hi;
        } input;
    } seq;
};

struct xfrm_spi_skb_cb {
    struct xfrm_tunnel_skb_cb header;
    unsigned int daddroff;
    unsigned int family;
    __be32 seq;
};

struct xfrm_state_walk {
    struct list_head all;
    u8 state;
    u8 dying;
    u8 proto;
    u32 seq;
    struct xfrm_address_filter *filter;
};

struct xfrm_stats {
    __u32 replay_window;
    __u32 replay;
    __u32 integrity_failed;
};

struct xfrm_type;

struct xfrm_type_offload;

struct xfrm_state {
    possible_net_t xs_net;
    union {
        struct hlist_node gclist;
        struct hlist_node bydst;
    };
    union {
        struct hlist_node dev_gclist;
        struct hlist_node bysrc;
    };
    struct hlist_node byspi;
    struct hlist_node byseq;
    struct hlist_node state_cache;
    struct hlist_node state_cache_input;
    refcount_t refcnt;
    spinlock_t lock;
    u32 pcpu_num;
    struct xfrm_id id;
    struct xfrm_selector sel;
    struct xfrm_mark mark;
    u32 if_id;
    u32 tfcpad;
    u32 genid;
    struct xfrm_state_walk km;
    struct {
        u32 reqid;
        u8 mode;
        u8 replay_window;
        u8 aalgo;
        u8 ealgo;
        u8 calgo;
        u8 flags;
        u16 family;
        xfrm_address_t saddr;
        int header_len;
        int enc_hdr_len;
        int trailer_len;
        u32 extra_flags;
        struct xfrm_mark smark;
    } props;
    struct xfrm_lifetime_cfg lft;
    struct xfrm_algo_auth *aalg;
    struct xfrm_algo *ealg;
    struct xfrm_algo *calg;
    struct xfrm_algo_aead *aead;
    const char *geniv;
    __be16 new_mapping_sport;
    u32 new_mapping;
    u32 mapping_maxage;
    struct xfrm_encap_tmpl *encap;
    struct sock *encap_sk;
    u32 nat_keepalive_interval;
    time64_t nat_keepalive_expiration;
    xfrm_address_t *coaddr;
    struct xfrm_state *tunnel;
    atomic_t tunnel_users;
    struct xfrm_replay_state replay;
    struct xfrm_replay_state_esn *replay_esn;
    struct xfrm_replay_state preplay;
    struct xfrm_replay_state_esn *preplay_esn;
    enum xfrm_replay_mode repl_mode;
    u32 xflags;
    u32 replay_maxage;
    u32 replay_maxdiff;
    struct timer_list rtimer;
    struct xfrm_stats stats;
    struct xfrm_lifetime_cur curlft;
    struct hrtimer mtimer;
    struct xfrm_dev_offload xso;
    long int saved_tmo;
    time64_t lastused;
    struct page_frag xfrag;
    const struct xfrm_type *type;
    struct xfrm_mode inner_mode;
    struct xfrm_mode inner_mode_iaf;
    struct xfrm_mode outer_mode;
    const struct xfrm_type_offload *type_offload;
    struct xfrm_sec_ctx *security;
    void *data;
    u8 dir;
    const struct xfrm_mode_cbs *mode_cbs;
    void *mode_data;
};

struct xfrm_state_afinfo {
    u8 family;
    u8 proto;
    const struct xfrm_type_offload *type_offload_esp;
    const struct xfrm_type *type_esp;
    const struct xfrm_type *type_ipip;
    const struct xfrm_type *type_ipip6;
    const struct xfrm_type *type_comp;
    const struct xfrm_type *type_ah;
    const struct xfrm_type *type_routing;
    const struct xfrm_type *type_dstopts;
    int (*output)(struct net *, struct sock *, struct sk_buff *);
    int (*transport_finish)(struct sk_buff *, int);
    void (*local_error)(struct sk_buff *, u32);
};

struct xfrm_trans_cb {
    union {
        struct inet_skb_parm h4;
        struct inet6_skb_parm h6;
    } header;
    int (*finish)(struct net *, struct sock *, struct sk_buff *);
    struct net *net;
};

struct xfrm_trans_tasklet {
    struct work_struct work;
    spinlock_t queue_lock;
    struct sk_buff_head queue;
};

struct xfrm_translator {
    int (*alloc_compat)(struct sk_buff *, const struct nlmsghdr *);
    struct nlmsghdr * (*rcv_msg_compat)(const struct nlmsghdr *, int, const struct nla_policy *, struct netlink_ext_ack *);
    int (*xlate_user_policy_sockptr)(u8 **, int);
    struct module *owner;
};

struct xfrm_type {
    struct module *owner;
    u8 proto;
    u8 flags;
    int (*init_state)(struct xfrm_state *, struct netlink_ext_ack *);
    void (*destructor)(struct xfrm_state *);
    int (*input)(struct xfrm_state *, struct sk_buff *);
    int (*output)(struct xfrm_state *, struct sk_buff *);
    int (*reject)(struct xfrm_state *, struct sk_buff *, const struct flowi *);
};

struct xfrm_type_offload {
    struct module *owner;
    u8 proto;
    void (*encap)(struct xfrm_state *, struct sk_buff *);
    int (*input_tail)(struct xfrm_state *, struct sk_buff *);
    int (*xmit)(struct xfrm_state *, struct sk_buff *, netdev_features_t);
};

struct xfrm_user_offload {
    int ifindex;
    __u8 flags;
};

struct xfrm_user_sec_ctx {
    __u16 len;
    __u16 exttype;
    __u8 ctx_alg;
    __u8 ctx_doi;
    __u16 ctx_len;
};

struct xfrmdev_ops {
    int (*xdo_dev_state_add)(struct xfrm_state *, struct netlink_ext_ack *);
    void (*xdo_dev_state_delete)(struct xfrm_state *);
    void (*xdo_dev_state_free)(struct xfrm_state *);
    bool (*xdo_dev_offload_ok)(struct sk_buff *, struct xfrm_state *);
    void (*xdo_dev_state_advance_esn)(struct xfrm_state *);
    void (*xdo_dev_state_update_stats)(struct xfrm_state *);
    int (*xdo_dev_policy_add)(struct xfrm_policy *, struct netlink_ext_ack *);
    void (*xdo_dev_policy_delete)(struct xfrm_policy *);
    void (*xdo_dev_policy_free)(struct xfrm_policy *);
};

struct xfrmk_sadinfo {
    u32 sadhcnt;
    u32 sadhmcnt;
    u32 sadcnt;
};

struct xfrmk_spdinfo {
    u32 incnt;
    u32 outcnt;
    u32 fwdcnt;
    u32 inscnt;
    u32 outscnt;
    u32 fwdscnt;
    u32 spdhcnt;
    u32 spdhmcnt;
};

struct xhci_bus_state {
    long unsigned int bus_suspended;
    long unsigned int next_statechange;
    u32 port_c_suspend;
    u32 suspended_ports;
    u32 port_remote_wakeup;
    long unsigned int resuming_ports;
};

struct xhci_bw_info {
    unsigned int ep_interval;
    unsigned int mult;
    unsigned int num_packets;
    unsigned int max_packet_size;
    unsigned int max_esit_payload;
    unsigned int type;
};

struct xhci_cap_regs {
    __le32 hc_capbase;
    __le32 hcs_params1;
    __le32 hcs_params2;
    __le32 hcs_params3;
    __le32 hcc_params;
    __le32 db_off;
    __le32 run_regs_off;
    __le32 hcc_params2;
};

struct xhci_container_ctx;

struct xhci_command {
    struct xhci_container_ctx *in_ctx;
    u32 status;
    u32 comp_param;
    int slot_id;
    struct completion *completion;
    union xhci_trb *command_trb;
    struct list_head cmd_list;
    unsigned int timeout_ms;
};

struct xhci_container_ctx {
    unsigned int type;
    int size;
    u8 *bytes;
    dma_addr_t dma;
};

struct xhci_erst_entry;

struct xhci_erst {
    struct xhci_erst_entry *entries;
    unsigned int num_entries;
    dma_addr_t erst_dma_addr;
};

struct xhci_hcd;

struct xhci_dbc {
    spinlock_t lock;
    struct device *dev;
    struct xhci_hcd *xhci;
    struct dbc_regs *regs;
    struct xhci_ring *ring_evt;
    struct xhci_ring *ring_in;
    struct xhci_ring *ring_out;
    struct xhci_erst erst;
    struct xhci_container_ctx *ctx;
    struct dbc_str_descs *string;
    dma_addr_t string_dma;
    size_t string_size;
    u16 idVendor;
    u16 idProduct;
    u16 bcdDevice;
    u8 bInterfaceProtocol;
    enum dbc_state state;
    struct delayed_work event_work;
    unsigned int poll_interval;
    long unsigned int xfer_timestamp;
    unsigned int resume_required: 1;
    struct dbc_ep eps[2];
    const struct dbc_driver *driver;
    void *priv;
};

struct xhci_device_context_array {
    __le64 dev_context_ptrs[256];
    dma_addr_t dma;
};

struct xhci_doorbell_array {
    __le32 doorbell[256];
};

struct xhci_driver_overrides {
    size_t extra_priv_size;
    int (*reset)(struct usb_hcd *);
    int (*start)(struct usb_hcd *);
    int (*add_endpoint)(struct usb_hcd *, struct usb_device *, struct usb_host_endpoint *);
    int (*drop_endpoint)(struct usb_hcd *, struct usb_device *, struct usb_host_endpoint *);
    int (*check_bandwidth)(struct usb_hcd *, struct usb_device *);
    void (*reset_bandwidth)(struct usb_hcd *, struct usb_device *);
    int (*update_hub_device)(struct usb_hcd *, struct usb_device *, struct usb_tt *, gfp_t);
    int (*hub_control)(struct usb_hcd *, u16, u16, u16, char *, u16);
};

struct xhci_ep_ctx {
    __le32 ep_info;
    __le32 ep_info2;
    __le64 deq;
    __le32 tx_info;
    __le32 reserved[3];
};

struct xhci_stream_info;

struct xhci_ep_priv {
    char name[32];
    struct dentry *root;
    struct xhci_stream_info *stream_info;
    struct xhci_ring *show_ring;
    unsigned int stream_id;
};

struct xhci_erst_entry {
    __le64 seg_addr;
    __le32 seg_size;
    __le32 rsvd;
};

struct xhci_event_cmd {
    __le64 cmd_trb;
    __le32 status;
    __le32 flags;
};

struct xhci_file_map {
    const char *name;
    int (*show)(struct seq_file *, void *);
};

struct xhci_generic_trb {
    __le32 field[4];
};

struct xhci_port;

struct xhci_hub {
    struct xhci_port **ports;
    unsigned int num_ports;
    struct usb_hcd *hcd;
    struct xhci_bus_state bus_state;
    u8 maj_rev;
    u8 min_rev;
};

struct xhci_op_regs;

struct xhci_run_regs;

struct xhci_interrupter;

struct xhci_scratchpad;

struct xhci_virt_device;

struct xhci_root_port_bw_info;

struct xhci_port_cap;

struct xhci_hcd {
    struct usb_hcd *main_hcd;
    struct usb_hcd *shared_hcd;
    struct xhci_cap_regs *cap_regs;
    struct xhci_op_regs *op_regs;
    struct xhci_run_regs *run_regs;
    struct xhci_doorbell_array *dba;
    __u32 hcs_params1;
    __u32 hcs_params2;
    __u32 hcs_params3;
    __u32 hcc_params;
    __u32 hcc_params2;
    spinlock_t lock;
    u16 hci_version;
    u16 max_interrupters;
    u32 imod_interval;
    int page_size;
    int page_shift;
    int nvecs;
    struct clk *clk;
    struct clk *reg_clk;
    struct reset_control *reset;
    struct xhci_device_context_array *dcbaa;
    struct xhci_interrupter **interrupters;
    struct xhci_ring *cmd_ring;
    unsigned int cmd_ring_state;
    struct list_head cmd_list;
    unsigned int cmd_ring_reserved_trbs;
    struct delayed_work cmd_timer;
    struct completion cmd_ring_stop_completion;
    struct xhci_command *current_cmd;
    struct xhci_scratchpad *scratchpad;
    struct mutex mutex;
    struct xhci_virt_device *devs[256];
    struct xhci_root_port_bw_info *rh_bw;
    struct dma_pool *device_pool;
    struct dma_pool *segment_pool;
    struct dma_pool *small_streams_pool;
    struct dma_pool *medium_streams_pool;
    unsigned int xhc_state;
    long unsigned int run_graceperiod;
    struct s3_save s3;
    long long unsigned int quirks;
    unsigned int num_active_eps;
    unsigned int limit_active_eps;
    struct xhci_port *hw_ports;
    struct xhci_hub usb2_rhub;
    struct xhci_hub usb3_rhub;
    unsigned int hw_lpm_support: 1;
    unsigned int broken_suspend: 1;
    unsigned int allow_single_roothub: 1;
    struct xhci_port_cap *port_caps;
    unsigned int num_port_caps;
    struct timer_list comp_mode_recovery_timer;
    u32 port_status_u0;
    u16 test_mode;
    struct dentry *debugfs_root;
    struct dentry *debugfs_slots;
    struct list_head regset_list;
    void *dbc;
    long unsigned int priv[0];
};

struct xhci_input_control_ctx {
    __le32 drop_flags;
    __le32 add_flags;
    __le32 rsvd2[6];
};

struct xhci_intr_reg;

struct xhci_interrupter {
    struct xhci_ring *event_ring;
    struct xhci_erst erst;
    struct xhci_intr_reg *ir_set;
    unsigned int intr_num;
    bool ip_autoclear;
    u32 isoc_bei_interval;
    u32 s3_irq_pending;
    u32 s3_irq_control;
    u32 s3_erst_size;
    u64 s3_erst_base;
    u64 s3_erst_dequeue;
};

struct xhci_interval_bw {
    unsigned int num_packets;
    struct list_head endpoints;
    unsigned int overhead[3];
};

struct xhci_interval_bw_table {
    unsigned int interval0_esit_payload;
    struct xhci_interval_bw interval_bw[16];
    unsigned int bw_used;
    unsigned int ss_bw_in;
    unsigned int ss_bw_out;
};

struct xhci_intr_reg {
    __le32 irq_pending;
    __le32 irq_control;
    __le32 erst_size;
    __le32 rsvd;
    __le64 erst_base;
    __le64 erst_dequeue;
};

struct xhci_link_trb {
    __le64 segment_ptr;
    __le32 intr_target;
    __le32 control;
};

struct xhci_op_regs {
    __le32 command;
    __le32 status;
    __le32 page_size;
    __le32 reserved1;
    __le32 reserved2;
    __le32 dev_notification;
    __le64 cmd_ring;
    __le32 reserved3[4];
    __le64 dcbaa_ptr;
    __le32 config_reg;
    __le32 reserved4[241];
    __le32 port_status_base;
    __le32 port_power_base;
    __le32 port_link_base;
    __le32 reserved5;
    __le32 reserved6[1016];
};

struct xhci_port {
    __le32 *addr;
    int hw_portnum;
    int hcd_portnum;
    struct xhci_hub *rhub;
    struct xhci_port_cap *port_cap;
    unsigned int lpm_incapable: 1;
    long unsigned int resume_timestamp;
    bool rexit_active;
    int slot_id;
    struct completion rexit_done;
    struct completion u3exit_done;
};

struct xhci_port_cap {
    u32 *psi;
    u8 psi_count;
    u8 psi_uid_count;
    u8 maj_rev;
    u8 min_rev;
    u32 protocol_caps;
};

struct xhci_regset {
    char name[32];
    struct debugfs_regset32 regset;
    size_t nregs;
    struct list_head list;
};

struct xhci_ring {
    struct xhci_segment *first_seg;
    struct xhci_segment *last_seg;
    union xhci_trb *enqueue;
    struct xhci_segment *enq_seg;
    union xhci_trb *dequeue;
    struct xhci_segment *deq_seg;
    struct list_head td_list;
    u32 cycle_state;
    unsigned int stream_id;
    unsigned int num_segs;
    unsigned int num_trbs_free;
    unsigned int bounce_buf_len;
    enum xhci_ring_type type;
    u32 old_trb_comp_code;
    struct xarray *trb_address_map;
};

struct xhci_root_port_bw_info {
    struct list_head tts;
    unsigned int num_active_tts;
    struct xhci_interval_bw_table bw_table;
};

struct xhci_run_regs {
    __le32 microframe_index;
    __le32 rsvd[7];
    struct xhci_intr_reg ir_set[128];
};

struct xhci_scratchpad {
    u64 *sp_array;
    dma_addr_t sp_dma;
    void **sp_buffers;
};

struct xhci_segment {
    union xhci_trb *trbs;
    struct xhci_segment *next;
    unsigned int num;
    dma_addr_t dma;
    dma_addr_t bounce_dma;
    void *bounce_buf;
    unsigned int bounce_offs;
    unsigned int bounce_len;
};

struct xhci_slot_ctx {
    __le32 dev_info;
    __le32 dev_info2;
    __le32 tt_info;
    __le32 dev_state;
    __le32 reserved[4];
};

struct xhci_slot_priv {
    char name[32];
    struct dentry *root;
    struct xhci_ep_priv *eps[31];
    struct xhci_virt_device *dev;
};

struct xhci_stream_ctx {
    __le64 stream_ring;
    __le32 reserved[2];
};

struct xhci_stream_info {
    struct xhci_ring **stream_rings;
    unsigned int num_streams;
    struct xhci_stream_ctx *stream_ctx_array;
    unsigned int num_stream_ctxs;
    dma_addr_t ctx_array_dma;
    struct xarray trb_address_map;
    struct xhci_command *free_streams_command;
};

struct xhci_transfer_event {
    __le64 buffer;
    __le32 transfer_len;
    __le32 flags;
};

union xhci_trb {
    struct xhci_link_trb link;
    struct xhci_transfer_event trans_event;
    struct xhci_event_cmd event_cmd;
    struct xhci_generic_trb generic;
};

struct xhci_tt_bw_info {
    struct list_head tt_list;
    int slot_id;
    int ttport;
    struct xhci_interval_bw_table bw_table;
    int active_eps;
};

struct xhci_virt_ep {
    struct xhci_virt_device *vdev;
    unsigned int ep_index;
    struct xhci_ring *ring;
    struct xhci_stream_info *stream_info;
    struct xhci_ring *new_ring;
    unsigned int err_count;
    unsigned int ep_state;
    struct list_head cancelled_td_list;
    struct xhci_hcd *xhci;
    struct xhci_segment *queued_deq_seg;
    union xhci_trb *queued_deq_ptr;
    bool skip;
    struct xhci_bw_info bw_info;
    struct list_head bw_endpoint_list;
    long unsigned int stop_time;
    int next_frame_id;
    bool use_extended_tbc;
};

struct xhci_virt_device {
    int slot_id;
    struct usb_device *udev;
    struct xhci_container_ctx *out_ctx;
    struct xhci_container_ctx *in_ctx;
    struct xhci_virt_ep eps[31];
    struct xhci_port *rhub_port;
    struct xhci_interval_bw_table *bw_table;
    struct xhci_tt_bw_info *tt_info;
    long unsigned int flags;
    u16 current_mel;
    void *debugfs_private;
};

struct xol_area {
    wait_queue_head_t wq;
    long unsigned int *bitmap;
    struct page *page;
    long unsigned int vaddr;
};

struct xprt_create;

struct xprt_class {
    struct list_head list;
    int ident;
    struct rpc_xprt * (*setup)(struct xprt_create *);
    struct module *owner;
    char name[32];
    const char *netid[0];
};

struct xprt_create {
    int ident;
    struct net *net;
    struct sockaddr *srcaddr;
    struct sockaddr *dstaddr;
    size_t addrlen;
    const char *servername;
    struct svc_xprt *bc_xprt;
    struct rpc_xprt_switch *bc_xps;
    unsigned int flags;
    struct xprtsec_parms xprtsec;
    long unsigned int connect_timeout;
    long unsigned int reconnect_timeout;
};

struct xps_map;

struct xps_dev_maps {
    struct callback_head rcu;
    unsigned int nr_ids;
    s16 num_tc;
    struct xps_map *attr_map[0];
};

struct xps_map {
    unsigned int len;
    unsigned int alloc_len;
    struct callback_head rcu;
    u16 queues[0];
};

struct xsk_buff_pool {
    struct device *dev;
    struct net_device *netdev;
    struct list_head xsk_tx_list;
    spinlock_t xsk_tx_list_lock;
    refcount_t users;
    struct xdp_umem *umem;
    struct work_struct work;
    spinlock_t rx_lock;
    struct list_head free_list;
    struct list_head xskb_list;
    u32 heads_cnt;
    u16 queue_id;
    struct xsk_queue *fq;
    struct xsk_queue *cq;
    dma_addr_t *dma_pages;
    struct xdp_buff_xsk *heads;
    struct xdp_desc *tx_descs;
    u64 chunk_mask;
    u64 addrs_cnt;
    u32 free_list_cnt;
    u32 dma_pages_cnt;
    u32 free_heads_cnt;
    u32 headroom;
    u32 chunk_size;
    u32 chunk_shift;
    u32 frame_len;
    u32 xdp_zc_max_segs;
    u8 tx_metadata_len;
    u8 cached_need_wakeup;
    bool uses_need_wakeup;
    bool unaligned;
    bool tx_sw_csum;
    void *addrs;
    spinlock_t cq_lock;
    struct xdp_buff_xsk *free_heads[0];
    long: 64;
    long: 64;
};

struct xsk_cb_desc {
    void *src;
    u8 off;
    u8 bytes;
};

struct xsk_dma_map {
    dma_addr_t *dma_pages;
    struct device *dev;
    struct net_device *netdev;
    refcount_t users;
    struct list_head list;
    u32 dma_pages_cnt;
};

struct xsk_map {
    struct bpf_map map;
    spinlock_t lock;
    atomic_t count;
    struct xdp_sock *xsk_map[0];
};

struct xsk_map_node {
    struct list_head node;
    struct xsk_map *map;
    struct xdp_sock **map_entry;
};

struct xsk_queue {
    u32 ring_mask;
    u32 nentries;
    u32 cached_prod;
    u32 cached_cons;
    struct xdp_ring *ring;
    u64 invalid_descs;
    u64 queue_empty_descs;
    size_t ring_vmalloc_size;
};

struct xsk_tx_metadata {
    __u64 flags;
    union {
        struct {
            __u16 csum_start;
            __u16 csum_offset;
            __u64 launch_time;
        } request;
        struct {
            __u64 tx_timestamp;
        } completion;
    };
};

struct xsk_tx_metadata_ops {
    void (*tmo_request_timestamp)(void *);
    u64 (*tmo_fill_timestamp)(void *);
    void (*tmo_request_checksum)(u16, u16, void *);
    void (*tmo_request_launch_time)(u64, void *);
};

struct xxh32_state {
    uint32_t total_len_32;
    uint32_t large_len;
    uint32_t v1;
    uint32_t v2;
    uint32_t v3;
    uint32_t v4;
    uint32_t mem32[4];
    uint32_t memsize;
};

struct xz_dec_hash {
    vli_type unpadded;
    vli_type uncompressed;
    uint32_t crc32;
};

struct xz_dec_lzma2;

struct xz_dec_bcj;

struct xz_dec {
    enum {
        SEQ_STREAM_HEADER = 0,
        SEQ_BLOCK_START = 1,
        SEQ_BLOCK_HEADER = 2,
        SEQ_BLOCK_UNCOMPRESS = 3,
        SEQ_BLOCK_PADDING = 4,
        SEQ_BLOCK_CHECK = 5,
        SEQ_INDEX = 6,
        SEQ_INDEX_PADDING = 7,
        SEQ_INDEX_CRC32 = 8,
        SEQ_STREAM_FOOTER = 9,
    } sequence;
    uint32_t pos;
    vli_type vli;
    size_t in_start;
    size_t out_start;
    uint32_t crc32;
    enum xz_check check_type;
    enum xz_mode mode;
    bool allow_buf_error;
    struct {
        vli_type compressed;
        vli_type uncompressed;
        uint32_t size;
    } block_header;
    struct {
        vli_type compressed;
        vli_type uncompressed;
        vli_type count;
        struct xz_dec_hash hash;
    } block;
    struct {
        enum {
            SEQ_INDEX_COUNT = 0,
            SEQ_INDEX_UNPADDED = 1,
            SEQ_INDEX_UNCOMPRESSED = 2,
        } sequence;
        vli_type size;
        vli_type count;
        struct xz_dec_hash hash;
    } index;
    struct {
        size_t pos;
        size_t size;
        uint8_t buf[1024];
    } temp;
    struct xz_dec_lzma2 *lzma2;
    struct xz_dec_bcj *bcj;
    bool bcj_active;
};

struct xz_dec_bcj {
    enum {
        BCJ_X86 = 4,
        BCJ_POWERPC = 5,
        BCJ_IA64 = 6,
        BCJ_ARM = 7,
        BCJ_ARMTHUMB = 8,
        BCJ_SPARC = 9,
        BCJ_ARM64 = 10,
        BCJ_RISCV = 11,
    } type;
    enum xz_ret ret;
    bool single_call;
    uint32_t pos;
    uint32_t x86_prev_mask;
    uint8_t *out;
    size_t out_pos;
    size_t out_size;
    struct {
        size_t filtered;
        size_t size;
        uint8_t buf[16];
    } temp;
};

struct xz_dec_lzma2 {
    struct rc_dec rc;
    struct dictionary dict;
    struct lzma2_dec lzma2;
    struct lzma_dec lzma;
    struct {
        uint32_t size;
        uint8_t buf[63];
    } temp;
};

struct xz_dec_microlzma {
    struct xz_dec_lzma2 s;
};

struct za_context {
    struct _aarch64_ctx head;
    __u16 vl;
    __u16 __reserved[3];
};

struct zap_details {
    struct folio *single_folio;
    bool even_cows;
    bool reclaim_pt;
    zap_flags_t zap_flags;
};

struct zbud_header {
    struct list_head buddy;
    unsigned int first_chunks;
    unsigned int last_chunks;
};

struct zbud_pool {
    spinlock_t lock;
    union {
        struct list_head buddied;
        struct list_head unbuddied[63];
    };
    u64 pages_nr;
};

struct zone_report_args {
    struct blk_zone *zones;
};

struct zpool_driver;

struct zpool {
    struct zpool_driver *driver;
    void *pool;
};

struct zpool_driver {
    char *type;
    struct module *owner;
    atomic_t refcount;
    struct list_head list;
    void * (*create)(const char *, gfp_t);
    void (*destroy)(void *);
    bool malloc_support_movable;
    int (*malloc)(void *, size_t, gfp_t, long unsigned int *);
    void (*free)(void *, long unsigned int);
    bool sleep_mapped;
    void * (*map)(void *, long unsigned int, enum zpool_mapmode);
    void (*unmap)(void *, long unsigned int);
    u64 (*total_pages)(void *);
};

struct zswap_pool;

struct zswap_entry {
    swp_entry_t swpentry;
    unsigned int length;
    bool referenced;
    struct zswap_pool *pool;
    long unsigned int handle;
    struct obj_cgroup *objcg;
    struct list_head lru;
};

struct zswap_pool {
    struct zpool *zpool;
    struct crypto_acomp_ctx *acomp_ctx;
    struct percpu_ref ref;
    struct list_head list;
    struct work_struct release_work;
    struct hlist_node node;
    char tfm_name[128];
};

struct zt_context {
    struct _aarch64_ctx head;
    __u16 nregs;
    __u16 __reserved[3];
};

typedef size_t (*ZSTD_blockCompressor)(ZSTD_matchState_t *, seqStore_t *, U32 *, const void *, size_t);

typedef U32 (*ZSTD_getAllMatchesFn)(ZSTD_match_t *, ZSTD_matchState_t *, U32 *, const BYTE *, const BYTE *, const U32 *, const U32, const U32);

typedef size_t (*ZSTD_sequenceCopier)(ZSTD_CCtx *, ZSTD_sequencePosition *, const ZSTD_Sequence * const, size_t, const void *, size_t);

typedef void (*alternative_cb_t)(struct alt_instr *, __le32 *, __le32 *, int);

typedef int (*arch_set_vga_state_t)(struct pci_dev *, bool, unsigned int, u32);

typedef bool (*ate_match_fn_t)(const struct arch_timer_erratum_workaround *, const void *);

typedef void blk_log_action_t(struct trace_iterator *, const char *, bool);

typedef int (*bpf_aux_classic_check_t)(struct sock_filter *, unsigned int);

typedef u32 (*bpf_convert_ctx_access_t)(enum bpf_access_type, const struct bpf_insn *, struct bpf_insn *, struct bpf_prog *, u32 *);

typedef long unsigned int (*bpf_ctx_copy_t)(void *, const void *, long unsigned int, long unsigned int);

typedef unsigned int (*bpf_dispatcher_fn)(const void *, const struct bpf_insn *, unsigned int (*)(const void *, const struct bpf_insn *));

typedef unsigned int (*bpf_func_t)(const void *, const struct bpf_insn *);

typedef void (*bpf_jit_fill_hole_t)(void *, unsigned int);

typedef int (*bpf_op_t)(struct net_device *, struct netdev_bpf *);

typedef u32 (*bpf_prog_run_fn)(const struct bpf_prog *, const void *);

typedef u64 (*bpf_trampoline_enter_t)(struct bpf_prog *, struct bpf_tramp_run_ctx *);

typedef void (*bpf_trampoline_exit_t)(struct bpf_prog *, u64, struct bpf_tramp_run_ctx *);

typedef u64 (*btf_bpf_bind)(struct bpf_sock_addr_kern *, struct sockaddr *, int);

typedef u64 (*btf_bpf_btf_find_by_name_kind)(char *, int, u32, int);

typedef u64 (*btf_bpf_cgrp_storage_delete)(struct bpf_map *, struct cgroup *);

typedef u64 (*btf_bpf_cgrp_storage_get)(struct bpf_map *, struct cgroup *, void *, u64, gfp_t);

typedef u64 (*btf_bpf_clone_redirect)(struct sk_buff *, u32, u64);

typedef u64 (*btf_bpf_copy_from_user)(void *, u32, const void *);

typedef u64 (*btf_bpf_copy_from_user_task)(void *, u32, const void *, struct task_struct *, u64);

typedef u64 (*btf_bpf_csum_diff)(__be32 *, u32, __be32 *, u32, __wsum);

typedef u64 (*btf_bpf_csum_level)(struct sk_buff *, u64);

typedef u64 (*btf_bpf_csum_update)(struct sk_buff *, __wsum);

typedef u64 (*btf_bpf_current_task_under_cgroup)(struct bpf_map *, u32);

typedef u64 (*btf_bpf_d_path)(struct path *, char *, u32);

typedef u64 (*btf_bpf_dynptr_data)(const struct bpf_dynptr_kern *, u32, u32);

typedef u64 (*btf_bpf_dynptr_from_mem)(void *, u32, u64, struct bpf_dynptr_kern *);

typedef u64 (*btf_bpf_dynptr_read)(void *, u32, const struct bpf_dynptr_kern *, u32, u64);

typedef u64 (*btf_bpf_dynptr_write)(const struct bpf_dynptr_kern *, u32, void *, u32, u64);

typedef u64 (*btf_bpf_event_output_data)(void *, struct bpf_map *, u64, void *, u64);

typedef u64 (*btf_bpf_find_vma)(struct task_struct *, u64, bpf_callback_t, void *, u64);

typedef u64 (*btf_bpf_flow_dissector_load_bytes)(const struct bpf_flow_dissector *, u32, void *, u32);

typedef u64 (*btf_bpf_for_each_map_elem)(struct bpf_map *, void *, void *, u64);

typedef u64 (*btf_bpf_get_attach_cookie_kprobe_multi)(struct pt_regs *);

typedef u64 (*btf_bpf_get_attach_cookie_pe)(struct bpf_perf_event_data_kern *);

typedef u64 (*btf_bpf_get_attach_cookie_trace)(void *);

typedef u64 (*btf_bpf_get_attach_cookie_tracing)(void *);

typedef u64 (*btf_bpf_get_attach_cookie_uprobe_multi)(struct pt_regs *);

typedef u64 (*btf_bpf_get_branch_snapshot)(void *, u32, u64);

typedef u64 (*btf_bpf_get_cgroup_classid)(const struct sk_buff *);

typedef u64 (*btf_bpf_get_cgroup_classid_curr)(void);

typedef u64 (*btf_bpf_get_current_ancestor_cgroup_id)(int);

typedef u64 (*btf_bpf_get_current_cgroup_id)(void);

typedef u64 (*btf_bpf_get_current_comm)(char *, u32);

typedef u64 (*btf_bpf_get_current_pid_tgid)(void);

typedef u64 (*btf_bpf_get_current_task)(void);

typedef u64 (*btf_bpf_get_current_task_btf)(void);

typedef u64 (*btf_bpf_get_current_uid_gid)(void);

typedef u64 (*btf_bpf_get_func_ip_kprobe)(struct pt_regs *);

typedef u64 (*btf_bpf_get_func_ip_kprobe_multi)(struct pt_regs *);

typedef u64 (*btf_bpf_get_func_ip_tracing)(void *);

typedef u64 (*btf_bpf_get_func_ip_uprobe_multi)(struct pt_regs *);

typedef u64 (*btf_bpf_get_hash_recalc)(struct sk_buff *);

typedef u64 (*btf_bpf_get_listener_sock)(struct sock *);

typedef u64 (*btf_bpf_get_local_storage)(struct bpf_map *, u64);

typedef u64 (*btf_bpf_get_netns_cookie)(struct sk_buff *);

typedef u64 (*btf_bpf_get_netns_cookie_sk_msg)(struct sk_msg *);

typedef u64 (*btf_bpf_get_netns_cookie_sock)(struct sock *);

typedef u64 (*btf_bpf_get_netns_cookie_sock_addr)(struct bpf_sock_addr_kern *);

typedef u64 (*btf_bpf_get_netns_cookie_sock_ops)(struct bpf_sock_ops_kern *);

typedef u64 (*btf_bpf_get_netns_cookie_sockopt)(struct bpf_sockopt_kern *);

typedef u64 (*btf_bpf_get_ns_current_pid_tgid)(u64, u64, struct bpf_pidns_info *, u32);

typedef u64 (*btf_bpf_get_numa_node_id)(void);

typedef u64 (*btf_bpf_get_raw_cpu_id)(void);

typedef u64 (*btf_bpf_get_retval)(void);

typedef u64 (*btf_bpf_get_route_realm)(const struct sk_buff *);

typedef u64 (*btf_bpf_get_smp_processor_id)(void);

typedef u64 (*btf_bpf_get_socket_cookie)(struct sk_buff *);

typedef u64 (*btf_bpf_get_socket_cookie_sock)(struct sock *);

typedef u64 (*btf_bpf_get_socket_cookie_sock_addr)(struct bpf_sock_addr_kern *);

typedef u64 (*btf_bpf_get_socket_cookie_sock_ops)(struct bpf_sock_ops_kern *);

typedef u64 (*btf_bpf_get_socket_ptr_cookie)(struct sock *);

typedef u64 (*btf_bpf_get_socket_uid)(struct sk_buff *);

typedef u64 (*btf_bpf_get_stack)(struct pt_regs *, void *, u32, u64);

typedef u64 (*btf_bpf_get_stack_pe)(struct bpf_perf_event_data_kern *, void *, u32, u64);

typedef u64 (*btf_bpf_get_stack_raw_tp)(struct bpf_raw_tracepoint_args *, void *, u32, u64);

typedef u64 (*btf_bpf_get_stack_sleepable)(struct pt_regs *, void *, u32, u64);

typedef u64 (*btf_bpf_get_stack_tp)(void *, void *, u32, u64);

typedef u64 (*btf_bpf_get_stackid)(struct pt_regs *, struct bpf_map *, u64);

typedef u64 (*btf_bpf_get_stackid_pe)(struct bpf_perf_event_data_kern *, struct bpf_map *, u64);

typedef u64 (*btf_bpf_get_stackid_raw_tp)(struct bpf_raw_tracepoint_args *, struct bpf_map *, u64);

typedef u64 (*btf_bpf_get_stackid_tp)(void *, struct bpf_map *, u64);

typedef u64 (*btf_bpf_get_task_stack)(struct task_struct *, void *, u32, u64);

typedef u64 (*btf_bpf_get_task_stack_sleepable)(struct task_struct *, void *, u32, u64);

typedef u64 (*btf_bpf_jiffies64)(void);

typedef u64 (*btf_bpf_kallsyms_lookup_name)(const char *, int, int, u64 *);

typedef u64 (*btf_bpf_kptr_xchg)(void *, void *);

typedef u64 (*btf_bpf_ktime_get_boot_ns)(void);

typedef u64 (*btf_bpf_ktime_get_coarse_ns)(void);

typedef u64 (*btf_bpf_ktime_get_ns)(void);

typedef u64 (*btf_bpf_ktime_get_tai_ns)(void);

typedef u64 (*btf_bpf_l3_csum_replace)(struct sk_buff *, u32, u64, u64, u64);

typedef u64 (*btf_bpf_l4_csum_replace)(struct sk_buff *, u32, u64, u64, u64);

typedef u64 (*btf_bpf_loop)(u32, void *, void *, u64);

typedef u64 (*btf_bpf_lwt_in_push_encap)(struct sk_buff *, u32, void *, u32);

typedef u64 (*btf_bpf_lwt_seg6_action)(struct sk_buff *, u32, void *, u32);

typedef u64 (*btf_bpf_lwt_seg6_adjust_srh)(struct sk_buff *, u32, s32);

typedef u64 (*btf_bpf_lwt_seg6_store_bytes)(struct sk_buff *, u32, const void *, u32);

typedef u64 (*btf_bpf_lwt_xmit_push_encap)(struct sk_buff *, u32, void *, u32);

typedef u64 (*btf_bpf_map_delete_elem)(struct bpf_map *, void *);

typedef u64 (*btf_bpf_map_lookup_elem)(struct bpf_map *, void *);

typedef u64 (*btf_bpf_map_lookup_percpu_elem)(struct bpf_map *, void *, u32);

typedef u64 (*btf_bpf_map_peek_elem)(struct bpf_map *, void *);

typedef u64 (*btf_bpf_map_pop_elem)(struct bpf_map *, void *);

typedef u64 (*btf_bpf_map_push_elem)(struct bpf_map *, void *, u64);

typedef u64 (*btf_bpf_map_update_elem)(struct bpf_map *, void *, void *, u64);

typedef u64 (*btf_bpf_msg_apply_bytes)(struct sk_msg *, u32);

typedef u64 (*btf_bpf_msg_cork_bytes)(struct sk_msg *, u32);

typedef u64 (*btf_bpf_msg_pop_data)(struct sk_msg *, u32, u32, u64);

typedef u64 (*btf_bpf_msg_pull_data)(struct sk_msg *, u32, u32, u64);

typedef u64 (*btf_bpf_msg_push_data)(struct sk_msg *, u32, u32, u64);

typedef u64 (*btf_bpf_msg_redirect_hash)(struct sk_msg *, struct bpf_map *, void *, u64);

typedef u64 (*btf_bpf_msg_redirect_map)(struct sk_msg *, struct bpf_map *, u32, u64);

typedef u64 (*btf_bpf_per_cpu_ptr)(const void *, u32);

typedef u64 (*btf_bpf_perf_event_output)(struct pt_regs *, struct bpf_map *, u64, void *, u64);

typedef u64 (*btf_bpf_perf_event_output_raw_tp)(struct bpf_raw_tracepoint_args *, struct bpf_map *, u64, void *, u64);

typedef u64 (*btf_bpf_perf_event_output_tp)(void *, struct bpf_map *, u64, void *, u64);

typedef u64 (*btf_bpf_perf_event_read)(struct bpf_map *, u64);

typedef u64 (*btf_bpf_perf_event_read_value)(struct bpf_map *, u64, struct bpf_perf_event_value *, u32);

typedef u64 (*btf_bpf_perf_prog_read_value)(struct bpf_perf_event_data_kern *, struct bpf_perf_event_value *, u32);

typedef u64 (*btf_bpf_probe_read_compat)(void *, u32, const void *);

typedef u64 (*btf_bpf_probe_read_compat_str)(void *, u32, const void *);

typedef u64 (*btf_bpf_probe_read_kernel)(void *, u32, const void *);

typedef u64 (*btf_bpf_probe_read_kernel_str)(void *, u32, const void *);

typedef u64 (*btf_bpf_probe_read_user)(void *, u32, const void *);

typedef u64 (*btf_bpf_probe_read_user_str)(void *, u32, const void *);

typedef u64 (*btf_bpf_probe_write_user)(void *, const void *, u32);

typedef u64 (*btf_bpf_read_branch_records)(struct bpf_perf_event_data_kern *, void *, u32, u64);

typedef u64 (*btf_bpf_redirect)(u32, u64);

typedef u64 (*btf_bpf_redirect_neigh)(u32, struct bpf_redir_neigh *, int, u64);

typedef u64 (*btf_bpf_redirect_peer)(u32, u64);

typedef u64 (*btf_bpf_ringbuf_discard)(void *, u64);

typedef u64 (*btf_bpf_ringbuf_discard_dynptr)(struct bpf_dynptr_kern *, u64);

typedef u64 (*btf_bpf_ringbuf_output)(struct bpf_map *, void *, u64, u64);

typedef u64 (*btf_bpf_ringbuf_query)(struct bpf_map *, u64);

typedef u64 (*btf_bpf_ringbuf_reserve)(struct bpf_map *, u64, u64);

typedef u64 (*btf_bpf_ringbuf_reserve_dynptr)(struct bpf_map *, u32, u64, struct bpf_dynptr_kern *);

typedef u64 (*btf_bpf_ringbuf_submit)(void *, u64);

typedef u64 (*btf_bpf_ringbuf_submit_dynptr)(struct bpf_dynptr_kern *, u64);

typedef u64 (*btf_bpf_send_signal)(u32);

typedef u64 (*btf_bpf_send_signal_thread)(u32);

typedef u64 (*btf_bpf_seq_printf)(struct seq_file *, char *, u32, const void *, u32);

typedef u64 (*btf_bpf_seq_printf_btf)(struct seq_file *, struct btf_ptr *, u32, u64);

typedef u64 (*btf_bpf_seq_write)(struct seq_file *, const void *, u32);

typedef u64 (*btf_bpf_set_hash)(struct sk_buff *, u32);

typedef u64 (*btf_bpf_set_hash_invalid)(struct sk_buff *);

typedef u64 (*btf_bpf_set_retval)(int);

typedef u64 (*btf_bpf_sk_ancestor_cgroup_id)(struct sock *, int);

typedef u64 (*btf_bpf_sk_assign)(struct sk_buff *, struct sock *, u64);

typedef u64 (*btf_bpf_sk_cgroup_id)(struct sock *);

typedef u64 (*btf_bpf_sk_fullsock)(struct sock *);

typedef u64 (*btf_bpf_sk_getsockopt)(struct sock *, int, int, char *, int);

typedef u64 (*btf_bpf_sk_lookup_assign)(struct bpf_sk_lookup_kern *, struct sock *, u64);

typedef u64 (*btf_bpf_sk_lookup_tcp)(struct sk_buff *, struct bpf_sock_tuple *, u32, u64, u64);

typedef u64 (*btf_bpf_sk_lookup_udp)(struct sk_buff *, struct bpf_sock_tuple *, u32, u64, u64);

typedef u64 (*btf_bpf_sk_redirect_hash)(struct sk_buff *, struct bpf_map *, void *, u64);

typedef u64 (*btf_bpf_sk_redirect_map)(struct sk_buff *, struct bpf_map *, u32, u64);

typedef u64 (*btf_bpf_sk_release)(struct sock *);

typedef u64 (*btf_bpf_sk_setsockopt)(struct sock *, int, int, char *, int);

typedef u64 (*btf_bpf_sk_storage_delete)(struct bpf_map *, struct sock *);

typedef u64 (*btf_bpf_sk_storage_delete_tracing)(struct bpf_map *, struct sock *);

typedef u64 (*btf_bpf_sk_storage_get)(struct bpf_map *, struct sock *, void *, u64, gfp_t);

typedef u64 (*btf_bpf_sk_storage_get_tracing)(struct bpf_map *, struct sock *, void *, u64, gfp_t);

typedef u64 (*btf_bpf_skb_adjust_room)(struct sk_buff *, s32, u32, u64);

typedef u64 (*btf_bpf_skb_ancestor_cgroup_id)(const struct sk_buff *, int);

typedef u64 (*btf_bpf_skb_cgroup_classid)(const struct sk_buff *);

typedef u64 (*btf_bpf_skb_cgroup_id)(const struct sk_buff *);

typedef u64 (*btf_bpf_skb_change_head)(struct sk_buff *, u32, u64);

typedef u64 (*btf_bpf_skb_change_proto)(struct sk_buff *, __be16, u64);

typedef u64 (*btf_bpf_skb_change_tail)(struct sk_buff *, u32, u64);

typedef u64 (*btf_bpf_skb_change_type)(struct sk_buff *, u32);

typedef u64 (*btf_bpf_skb_check_mtu)(struct sk_buff *, u32, u32 *, s32, u64);

typedef u64 (*btf_bpf_skb_ecn_set_ce)(struct sk_buff *);

typedef u64 (*btf_bpf_skb_event_output)(struct sk_buff *, struct bpf_map *, u64, void *, u64);

typedef u64 (*btf_bpf_skb_fib_lookup)(struct sk_buff *, struct bpf_fib_lookup *, int, u32);

typedef u64 (*btf_bpf_skb_get_nlattr)(struct sk_buff *, u32, u32);

typedef u64 (*btf_bpf_skb_get_nlattr_nest)(struct sk_buff *, u32, u32);

typedef u64 (*btf_bpf_skb_get_pay_offset)(struct sk_buff *);

typedef u64 (*btf_bpf_skb_get_tunnel_key)(struct sk_buff *, struct bpf_tunnel_key *, u32, u64);

typedef u64 (*btf_bpf_skb_get_tunnel_opt)(struct sk_buff *, u8 *, u32);

typedef u64 (*btf_bpf_skb_get_xfrm_state)(struct sk_buff *, u32, struct bpf_xfrm_state *, u32, u64);

typedef u64 (*btf_bpf_skb_load_bytes)(const struct sk_buff *, u32, void *, u32);

typedef u64 (*btf_bpf_skb_load_bytes_relative)(const struct sk_buff *, u32, void *, u32, u32);

typedef u64 (*btf_bpf_skb_load_helper_16)(const struct sk_buff *, const void *, int, int);

typedef u64 (*btf_bpf_skb_load_helper_16_no_cache)(const struct sk_buff *, int);

typedef u64 (*btf_bpf_skb_load_helper_32)(const struct sk_buff *, const void *, int, int);

typedef u64 (*btf_bpf_skb_load_helper_32_no_cache)(const struct sk_buff *, int);

typedef u64 (*btf_bpf_skb_load_helper_8)(const struct sk_buff *, const void *, int, int);

typedef u64 (*btf_bpf_skb_load_helper_8_no_cache)(const struct sk_buff *, int);

typedef u64 (*btf_bpf_skb_pull_data)(struct sk_buff *, u32);

typedef u64 (*btf_bpf_skb_set_tstamp)(struct sk_buff *, u64, u32);

typedef u64 (*btf_bpf_skb_set_tunnel_key)(struct sk_buff *, const struct bpf_tunnel_key *, u32, u64);

typedef u64 (*btf_bpf_skb_set_tunnel_opt)(struct sk_buff *, const u8 *, u32);

typedef u64 (*btf_bpf_skb_store_bytes)(struct sk_buff *, u32, const void *, u32, u64);

typedef u64 (*btf_bpf_skb_under_cgroup)(struct sk_buff *, struct bpf_map *, u32);

typedef u64 (*btf_bpf_skb_vlan_pop)(struct sk_buff *);

typedef u64 (*btf_bpf_skb_vlan_push)(struct sk_buff *, __be16, u16);

typedef u64 (*btf_bpf_skc_lookup_tcp)(struct sk_buff *, struct bpf_sock_tuple *, u32, u64, u64);

typedef u64 (*btf_bpf_skc_to_mptcp_sock)(struct sock *);

typedef u64 (*btf_bpf_skc_to_tcp6_sock)(struct sock *);

typedef u64 (*btf_bpf_skc_to_tcp_request_sock)(struct sock *);

typedef u64 (*btf_bpf_skc_to_tcp_sock)(struct sock *);

typedef u64 (*btf_bpf_skc_to_tcp_timewait_sock)(struct sock *);

typedef u64 (*btf_bpf_skc_to_udp6_sock)(struct sock *);

typedef u64 (*btf_bpf_skc_to_unix_sock)(struct sock *);

typedef u64 (*btf_bpf_snprintf)(char *, u32, char *, const void *, u32);

typedef u64 (*btf_bpf_snprintf_btf)(char *, u32, struct btf_ptr *, u32, u64);

typedef u64 (*btf_bpf_sock_addr_getsockopt)(struct bpf_sock_addr_kern *, int, int, char *, int);

typedef u64 (*btf_bpf_sock_addr_setsockopt)(struct bpf_sock_addr_kern *, int, int, char *, int);

typedef u64 (*btf_bpf_sock_addr_sk_lookup_tcp)(struct bpf_sock_addr_kern *, struct bpf_sock_tuple *, u32, u64, u64);

typedef u64 (*btf_bpf_sock_addr_sk_lookup_udp)(struct bpf_sock_addr_kern *, struct bpf_sock_tuple *, u32, u64, u64);

typedef u64 (*btf_bpf_sock_addr_skc_lookup_tcp)(struct bpf_sock_addr_kern *, struct bpf_sock_tuple *, u32, u64, u64);

typedef u64 (*btf_bpf_sock_from_file)(struct file *);

typedef u64 (*btf_bpf_sock_hash_update)(struct bpf_sock_ops_kern *, struct bpf_map *, void *, u64);

typedef u64 (*btf_bpf_sock_map_update)(struct bpf_sock_ops_kern *, struct bpf_map *, void *, u64);

typedef u64 (*btf_bpf_sock_ops_cb_flags_set)(struct bpf_sock_ops_kern *, int);

typedef u64 (*btf_bpf_sock_ops_getsockopt)(struct bpf_sock_ops_kern *, int, int, char *, int);

typedef u64 (*btf_bpf_sock_ops_load_hdr_opt)(struct bpf_sock_ops_kern *, void *, u32, u64);

typedef u64 (*btf_bpf_sock_ops_reserve_hdr_opt)(struct bpf_sock_ops_kern *, u32, u64);

typedef u64 (*btf_bpf_sock_ops_setsockopt)(struct bpf_sock_ops_kern *, int, int, char *, int);

typedef u64 (*btf_bpf_sock_ops_store_hdr_opt)(struct bpf_sock_ops_kern *, const void *, u32, u64);

typedef u64 (*btf_bpf_spin_lock)(struct bpf_spin_lock *);

typedef u64 (*btf_bpf_spin_unlock)(struct bpf_spin_lock *);

typedef u64 (*btf_bpf_strncmp)(const char *, u32, const char *);

typedef u64 (*btf_bpf_strtol)(const char *, size_t, u64, s64 *);

typedef u64 (*btf_bpf_strtoul)(const char *, size_t, u64, u64 *);

typedef u64 (*btf_bpf_sys_bpf)(int, union bpf_attr *, u32);

typedef u64 (*btf_bpf_sys_close)(u32);

typedef u64 (*btf_bpf_sysctl_get_current_value)(struct bpf_sysctl_kern *, char *, size_t);

typedef u64 (*btf_bpf_sysctl_get_name)(struct bpf_sysctl_kern *, char *, size_t, u64);

typedef u64 (*btf_bpf_sysctl_get_new_value)(struct bpf_sysctl_kern *, char *, size_t);

typedef u64 (*btf_bpf_sysctl_set_new_value)(struct bpf_sysctl_kern *, const char *, size_t);

typedef u64 (*btf_bpf_task_pt_regs)(struct task_struct *);

typedef u64 (*btf_bpf_task_storage_delete)(struct bpf_map *, struct task_struct *);

typedef u64 (*btf_bpf_task_storage_delete_recur)(struct bpf_map *, struct task_struct *);

typedef u64 (*btf_bpf_task_storage_get)(struct bpf_map *, struct task_struct *, void *, u64, gfp_t);

typedef u64 (*btf_bpf_task_storage_get_recur)(struct bpf_map *, struct task_struct *, void *, u64, gfp_t);

typedef u64 (*btf_bpf_tc_sk_lookup_tcp)(struct sk_buff *, struct bpf_sock_tuple *, u32, u64, u64);

typedef u64 (*btf_bpf_tc_sk_lookup_udp)(struct sk_buff *, struct bpf_sock_tuple *, u32, u64, u64);

typedef u64 (*btf_bpf_tc_skc_lookup_tcp)(struct sk_buff *, struct bpf_sock_tuple *, u32, u64, u64);

typedef u64 (*btf_bpf_tcp_check_syncookie)(struct sock *, void *, u32, struct tcphdr *, u32);

typedef u64 (*btf_bpf_tcp_gen_syncookie)(struct sock *, void *, u32, struct tcphdr *, u32);

typedef u64 (*btf_bpf_tcp_raw_check_syncookie_ipv4)(struct iphdr *, struct tcphdr *);

typedef u64 (*btf_bpf_tcp_raw_check_syncookie_ipv6)(struct ipv6hdr *, struct tcphdr *);

typedef u64 (*btf_bpf_tcp_raw_gen_syncookie_ipv4)(struct iphdr *, struct tcphdr *, u32);

typedef u64 (*btf_bpf_tcp_raw_gen_syncookie_ipv6)(struct ipv6hdr *, struct tcphdr *, u32);

typedef u64 (*btf_bpf_tcp_send_ack)(struct tcp_sock *, u32);

typedef u64 (*btf_bpf_tcp_sock)(struct sock *);

typedef u64 (*btf_bpf_this_cpu_ptr)(const void *);

typedef u64 (*btf_bpf_timer_cancel)(struct bpf_async_kern *);

typedef u64 (*btf_bpf_timer_init)(struct bpf_async_kern *, struct bpf_map *, u64);

typedef u64 (*btf_bpf_timer_set_callback)(struct bpf_async_kern *, void *, struct bpf_prog_aux *);

typedef u64 (*btf_bpf_timer_start)(struct bpf_async_kern *, u64, u64);

typedef u64 (*btf_bpf_trace_printk)(char *, u32, u64, u64, u64);

typedef u64 (*btf_bpf_trace_vprintk)(char *, u32, const void *, u32);

typedef u64 (*btf_bpf_unlocked_sk_getsockopt)(struct sock *, int, int, char *, int);

typedef u64 (*btf_bpf_unlocked_sk_setsockopt)(struct sock *, int, int, char *, int);

typedef u64 (*btf_bpf_user_ringbuf_drain)(struct bpf_map *, void *, void *, u64);

typedef u64 (*btf_bpf_user_rnd_u32)(void);

typedef u64 (*btf_bpf_xdp_adjust_head)(struct xdp_buff *, int);

typedef u64 (*btf_bpf_xdp_adjust_meta)(struct xdp_buff *, int);

typedef u64 (*btf_bpf_xdp_adjust_tail)(struct xdp_buff *, int);

typedef u64 (*btf_bpf_xdp_check_mtu)(struct xdp_buff *, u32, u32 *, s32, u64);

typedef u64 (*btf_bpf_xdp_event_output)(struct xdp_buff *, struct bpf_map *, u64, void *, u64);

typedef u64 (*btf_bpf_xdp_fib_lookup)(struct xdp_buff *, struct bpf_fib_lookup *, int, u32);

typedef u64 (*btf_bpf_xdp_get_buff_len)(struct xdp_buff *);

typedef u64 (*btf_bpf_xdp_load_bytes)(struct xdp_buff *, u32, void *, u32);

typedef u64 (*btf_bpf_xdp_redirect)(u32, u64);

typedef u64 (*btf_bpf_xdp_redirect_map)(struct bpf_map *, u64, u64);

typedef u64 (*btf_bpf_xdp_sk_lookup_tcp)(struct xdp_buff *, struct bpf_sock_tuple *, u32, u32, u64);

typedef u64 (*btf_bpf_xdp_sk_lookup_udp)(struct xdp_buff *, struct bpf_sock_tuple *, u32, u32, u64);

typedef u64 (*btf_bpf_xdp_skc_lookup_tcp)(struct xdp_buff *, struct bpf_sock_tuple *, u32, u32, u64);

typedef u64 (*btf_bpf_xdp_store_bytes)(struct xdp_buff *, u32, void *, u32);

typedef u64 (*btf_get_func_arg)(void *, u32, u64 *);

typedef u64 (*btf_get_func_arg_cnt)(void *);

typedef u64 (*btf_get_func_ret)(void *, u64 *);

typedef u64 (*btf_sk_reuseport_load_bytes)(const struct sk_reuseport_kern *, u32, void *, u32);

typedef u64 (*btf_sk_reuseport_load_bytes_relative)(const struct sk_reuseport_kern *, u32, void *, u32, u32);

typedef u64 (*btf_sk_select_reuseport)(struct sk_reuseport_kern *, struct bpf_map *, void *, u32);

typedef u64 (*btf_sk_skb_adjust_room)(struct sk_buff *, s32, u32, u64);

typedef u64 (*btf_sk_skb_change_head)(struct sk_buff *, u32, u64);

typedef u64 (*btf_sk_skb_change_tail)(struct sk_buff *, u32, u64);

typedef u64 (*btf_sk_skb_pull_data)(struct sk_buff *, u32);

typedef void (*btf_trace_ack_update_msk)(void *, u64, u64, u64, u64, u64);

typedef void (*btf_trace_add_device_to_group)(void *, int, struct device *);

typedef void (*btf_trace_aer_event)(void *, const char *, const u32, const u8, const u8, struct pcie_tlp_log *);

typedef void (*btf_trace_alarmtimer_cancel)(void *, struct alarm *, ktime_t);

typedef void (*btf_trace_alarmtimer_fired)(void *, struct alarm *, ktime_t);

typedef void (*btf_trace_alarmtimer_start)(void *, struct alarm *, ktime_t);

typedef void (*btf_trace_alarmtimer_suspend)(void *, ktime_t, int);

typedef void (*btf_trace_alloc_vmap_area)(void *, long unsigned int, long unsigned int, long unsigned int, long unsigned int, long unsigned int, int);

typedef void (*btf_trace_arm_event)(void *, const struct cper_sec_proc_arm *);

typedef void (*btf_trace_attach_device_to_domain)(void *, struct device *);

typedef void (*btf_trace_balance_dirty_pages)(void *, struct bdi_writeback *, struct dirty_throttle_control *, long unsigned int, long unsigned int, long unsigned int, long unsigned int, long int, long unsigned int);

typedef void (*btf_trace_bdi_dirty_ratelimit)(void *, struct bdi_writeback *, long unsigned int, long unsigned int);

typedef void (*btf_trace_block_bio_backmerge)(void *, struct bio *);

typedef void (*btf_trace_block_bio_bounce)(void *, struct bio *);

typedef void (*btf_trace_block_bio_complete)(void *, struct request_queue *, struct bio *);

typedef void (*btf_trace_block_bio_frontmerge)(void *, struct bio *);

typedef void (*btf_trace_block_bio_queue)(void *, struct bio *);

typedef void (*btf_trace_block_bio_remap)(void *, struct bio *, dev_t, sector_t);

typedef void (*btf_trace_block_dirty_buffer)(void *, struct buffer_head *);

typedef void (*btf_trace_block_getrq)(void *, struct bio *);

typedef void (*btf_trace_block_io_done)(void *, struct request *);

typedef void (*btf_trace_block_io_start)(void *, struct request *);

typedef void (*btf_trace_block_plug)(void *, struct request_queue *);

typedef void (*btf_trace_block_rq_complete)(void *, struct request *, blk_status_t, unsigned int);

typedef void (*btf_trace_block_rq_error)(void *, struct request *, blk_status_t, unsigned int);

typedef void (*btf_trace_block_rq_insert)(void *, struct request *);

typedef void (*btf_trace_block_rq_issue)(void *, struct request *);

typedef void (*btf_trace_block_rq_merge)(void *, struct request *);

typedef void (*btf_trace_block_rq_remap)(void *, struct request *, dev_t, sector_t);

typedef void (*btf_trace_block_rq_requeue)(void *, struct request *);

typedef void (*btf_trace_block_split)(void *, struct bio *, unsigned int);

typedef void (*btf_trace_block_touch_buffer)(void *, struct buffer_head *);

typedef void (*btf_trace_block_unplug)(void *, struct request_queue *, unsigned int, bool);

typedef void (*btf_trace_bpf_test_finish)(void *, int *);

typedef void (*btf_trace_bpf_trace_printk)(void *, const char *);

typedef void (*btf_trace_bpf_trigger_tp)(void *, int);

typedef void (*btf_trace_bpf_xdp_link_attach_failed)(void *, const char *);

typedef void (*btf_trace_br_fdb_add)(void *, struct ndmsg *, struct net_device *, const unsigned char *, u16, u16);

typedef void (*btf_trace_br_fdb_external_learn_add)(void *, struct net_bridge *, struct net_bridge_port *, const unsigned char *, u16);

typedef void (*btf_trace_br_fdb_update)(void *, struct net_bridge *, struct net_bridge_port *, const unsigned char *, u16, long unsigned int);

typedef void (*btf_trace_br_mdb_full)(void *, const struct net_device *, const struct br_ip *);

typedef void (*btf_trace_break_lease_block)(void *, struct inode *, struct file_lease *);

typedef void (*btf_trace_break_lease_noblock)(void *, struct inode *, struct file_lease *);

typedef void (*btf_trace_break_lease_unblock)(void *, struct inode *, struct file_lease *);

typedef void (*btf_trace_cap_capable)(void *, const struct cred *, struct user_namespace *, const struct user_namespace *, int, int);

typedef void (*btf_trace_cdev_update)(void *, struct thermal_cooling_device *, long unsigned int);

typedef void (*btf_trace_cgroup_attach_task)(void *, struct cgroup *, const char *, struct task_struct *, bool);

typedef void (*btf_trace_cgroup_destroy_root)(void *, struct cgroup_root *);

typedef void (*btf_trace_cgroup_freeze)(void *, struct cgroup *, const char *);

typedef void (*btf_trace_cgroup_mkdir)(void *, struct cgroup *, const char *);

typedef void (*btf_trace_cgroup_notify_frozen)(void *, struct cgroup *, const char *, int);

typedef void (*btf_trace_cgroup_notify_populated)(void *, struct cgroup *, const char *, int);

typedef void (*btf_trace_cgroup_release)(void *, struct cgroup *, const char *);

typedef void (*btf_trace_cgroup_remount)(void *, struct cgroup_root *);

typedef void (*btf_trace_cgroup_rename)(void *, struct cgroup *, const char *);

typedef void (*btf_trace_cgroup_rmdir)(void *, struct cgroup *, const char *);

typedef void (*btf_trace_cgroup_rstat_cpu_lock_contended)(void *, struct cgroup *, int, bool);

typedef void (*btf_trace_cgroup_rstat_cpu_lock_contended_fastpath)(void *, struct cgroup *, int, bool);

typedef void (*btf_trace_cgroup_rstat_cpu_locked)(void *, struct cgroup *, int, bool);

typedef void (*btf_trace_cgroup_rstat_cpu_locked_fastpath)(void *, struct cgroup *, int, bool);

typedef void (*btf_trace_cgroup_rstat_cpu_unlock)(void *, struct cgroup *, int, bool);

typedef void (*btf_trace_cgroup_rstat_cpu_unlock_fastpath)(void *, struct cgroup *, int, bool);

typedef void (*btf_trace_cgroup_rstat_lock_contended)(void *, struct cgroup *, int, bool);

typedef void (*btf_trace_cgroup_rstat_locked)(void *, struct cgroup *, int, bool);

typedef void (*btf_trace_cgroup_rstat_unlock)(void *, struct cgroup *, int, bool);

typedef void (*btf_trace_cgroup_setup_root)(void *, struct cgroup_root *);

typedef void (*btf_trace_cgroup_transfer_tasks)(void *, struct cgroup *, const char *, struct task_struct *, bool);

typedef void (*btf_trace_cgroup_unfreeze)(void *, struct cgroup *, const char *);

typedef void (*btf_trace_clk_disable)(void *, struct clk_core *);

typedef void (*btf_trace_clk_disable_complete)(void *, struct clk_core *);

typedef void (*btf_trace_clk_enable)(void *, struct clk_core *);

typedef void (*btf_trace_clk_enable_complete)(void *, struct clk_core *);

typedef void (*btf_trace_clk_prepare)(void *, struct clk_core *);

typedef void (*btf_trace_clk_prepare_complete)(void *, struct clk_core *);

typedef void (*btf_trace_clk_rate_request_done)(void *, struct clk_rate_request *);

typedef void (*btf_trace_clk_rate_request_start)(void *, struct clk_rate_request *);

typedef void (*btf_trace_clk_set_duty_cycle)(void *, struct clk_core *, struct clk_duty *);

typedef void (*btf_trace_clk_set_duty_cycle_complete)(void *, struct clk_core *, struct clk_duty *);

typedef void (*btf_trace_clk_set_max_rate)(void *, struct clk_core *, long unsigned int);

typedef void (*btf_trace_clk_set_min_rate)(void *, struct clk_core *, long unsigned int);

typedef void (*btf_trace_clk_set_parent)(void *, struct clk_core *, struct clk_core *);

typedef void (*btf_trace_clk_set_parent_complete)(void *, struct clk_core *, struct clk_core *);

typedef void (*btf_trace_clk_set_phase)(void *, struct clk_core *, int);

typedef void (*btf_trace_clk_set_phase_complete)(void *, struct clk_core *, int);

typedef void (*btf_trace_clk_set_rate)(void *, struct clk_core *, long unsigned int);

typedef void (*btf_trace_clk_set_rate_complete)(void *, struct clk_core *, long unsigned int);

typedef void (*btf_trace_clk_set_rate_range)(void *, struct clk_core *, long unsigned int, long unsigned int);

typedef void (*btf_trace_clk_unprepare)(void *, struct clk_core *);

typedef void (*btf_trace_clk_unprepare_complete)(void *, struct clk_core *);

typedef void (*btf_trace_clock_disable)(void *, const char *, unsigned int, unsigned int);

typedef void (*btf_trace_clock_enable)(void *, const char *, unsigned int, unsigned int);

typedef void (*btf_trace_clock_set_rate)(void *, const char *, unsigned int, unsigned int);

typedef void (*btf_trace_cma_alloc_busy_retry)(void *, const char *, long unsigned int, const struct page *, long unsigned int, unsigned int);

typedef void (*btf_trace_cma_alloc_finish)(void *, const char *, long unsigned int, const struct page *, long unsigned int, unsigned int, int);

typedef void (*btf_trace_cma_alloc_start)(void *, const char *, long unsigned int, unsigned int);

typedef void (*btf_trace_cma_release)(void *, const char *, long unsigned int, const struct page *, long unsigned int);

typedef void (*btf_trace_compact_retry)(void *, int, enum compact_priority, enum compact_result, int, int, bool);

typedef void (*btf_trace_console)(void *, const char *, size_t);

typedef void (*btf_trace_consume_skb)(void *, struct sk_buff *, void *);

typedef void (*btf_trace_contention_begin)(void *, void *, unsigned int);

typedef void (*btf_trace_contention_end)(void *, void *, int);

typedef void (*btf_trace_count_memcg_events)(void *, struct mem_cgroup *, int, long unsigned int);

typedef void (*btf_trace_cpu_frequency)(void *, unsigned int, unsigned int);

typedef void (*btf_trace_cpu_frequency_limits)(void *, struct cpufreq_policy *);

typedef void (*btf_trace_cpu_idle)(void *, unsigned int, unsigned int);

typedef void (*btf_trace_cpu_idle_miss)(void *, unsigned int, unsigned int, bool);

typedef void (*btf_trace_cpuhp_enter)(void *, unsigned int, int, int, int (*)(unsigned int));

typedef void (*btf_trace_cpuhp_exit)(void *, unsigned int, int, int, int);

typedef void (*btf_trace_cpuhp_multi_enter)(void *, unsigned int, int, int, int (*)(unsigned int, struct hlist_node *), struct hlist_node *);

typedef void (*btf_trace_csd_function_entry)(void *, smp_call_func_t, call_single_data_t *);

typedef void (*btf_trace_csd_function_exit)(void *, smp_call_func_t, call_single_data_t *);

typedef void (*btf_trace_csd_queue_cpu)(void *, const unsigned int, long unsigned int, smp_call_func_t, call_single_data_t *);

typedef void (*btf_trace_ctime_ns_xchg)(void *, struct inode *, u32, u32, u32);

typedef void (*btf_trace_ctime_xchg_skip)(void *, struct inode *, struct timespec64 *);

typedef void (*btf_trace_dev_pm_qos_add_request)(void *, const char *, enum dev_pm_qos_req_type, s32);

typedef void (*btf_trace_dev_pm_qos_remove_request)(void *, const char *, enum dev_pm_qos_req_type, s32);

typedef void (*btf_trace_dev_pm_qos_update_request)(void *, const char *, enum dev_pm_qos_req_type, s32);

typedef void (*btf_trace_devfreq_frequency)(void *, struct devfreq *, long unsigned int, long unsigned int);

typedef void (*btf_trace_devfreq_monitor)(void *, struct devfreq *);

typedef void (*btf_trace_device_pm_callback_end)(void *, struct device *, int);

typedef void (*btf_trace_device_pm_callback_start)(void *, struct device *, const char *, int);

typedef void (*btf_trace_devlink_health_recover_aborted)(void *, const struct devlink *, const char *, bool, u64);

typedef void (*btf_trace_devlink_health_report)(void *, const struct devlink *, const char *, const char *);

typedef void (*btf_trace_devlink_health_reporter_state_update)(void *, const struct devlink *, const char *, bool);

typedef void (*btf_trace_devlink_hwerr)(void *, const struct devlink *, int, const char *);

typedef void (*btf_trace_devlink_hwmsg)(void *, const struct devlink *, bool, long unsigned int, const u8 *, size_t);

typedef void (*btf_trace_devlink_trap_report)(void *, const struct devlink *, struct sk_buff *, const struct devlink_trap_metadata *);

typedef void (*btf_trace_devres_log)(void *, struct device *, const char *, void *, const char *, size_t);

typedef void (*btf_trace_dma_alloc)(void *, struct device *, void *, dma_addr_t, size_t, enum dma_data_direction, gfp_t, long unsigned int);

typedef void (*btf_trace_dma_alloc_pages)(void *, struct device *, void *, dma_addr_t, size_t, enum dma_data_direction, gfp_t, long unsigned int);

typedef void (*btf_trace_dma_alloc_sgt)(void *, struct device *, struct sg_table *, size_t, enum dma_data_direction, gfp_t, long unsigned int);

typedef void (*btf_trace_dma_alloc_sgt_err)(void *, struct device *, void *, dma_addr_t, size_t, enum dma_data_direction, gfp_t, long unsigned int);

typedef void (*btf_trace_dma_fence_destroy)(void *, struct dma_fence *);

typedef void (*btf_trace_dma_fence_emit)(void *, struct dma_fence *);

typedef void (*btf_trace_dma_fence_enable_signal)(void *, struct dma_fence *);

typedef void (*btf_trace_dma_fence_init)(void *, struct dma_fence *);

typedef void (*btf_trace_dma_fence_signaled)(void *, struct dma_fence *);

typedef void (*btf_trace_dma_fence_wait_end)(void *, struct dma_fence *);

typedef void (*btf_trace_dma_fence_wait_start)(void *, struct dma_fence *);

typedef void (*btf_trace_dma_free)(void *, struct device *, void *, dma_addr_t, size_t, enum dma_data_direction, long unsigned int);

typedef void (*btf_trace_dma_free_pages)(void *, struct device *, void *, dma_addr_t, size_t, enum dma_data_direction, long unsigned int);

typedef void (*btf_trace_dma_free_sgt)(void *, struct device *, struct sg_table *, size_t, enum dma_data_direction);

typedef void (*btf_trace_dma_map_page)(void *, struct device *, phys_addr_t, dma_addr_t, size_t, enum dma_data_direction, long unsigned int);

typedef void (*btf_trace_dma_map_resource)(void *, struct device *, phys_addr_t, dma_addr_t, size_t, enum dma_data_direction, long unsigned int);

typedef void (*btf_trace_dma_map_sg)(void *, struct device *, struct scatterlist *, int, int, enum dma_data_direction, long unsigned int);

typedef void (*btf_trace_dma_map_sg_err)(void *, struct device *, struct scatterlist *, int, int, enum dma_data_direction, long unsigned int);

typedef void (*btf_trace_dma_sync_sg_for_cpu)(void *, struct device *, struct scatterlist *, int, enum dma_data_direction);

typedef void (*btf_trace_dma_sync_sg_for_device)(void *, struct device *, struct scatterlist *, int, enum dma_data_direction);

typedef void (*btf_trace_dma_sync_single_for_cpu)(void *, struct device *, dma_addr_t, size_t, enum dma_data_direction);

typedef void (*btf_trace_dma_sync_single_for_device)(void *, struct device *, dma_addr_t, size_t, enum dma_data_direction);

typedef void (*btf_trace_dma_unmap_page)(void *, struct device *, dma_addr_t, size_t, enum dma_data_direction, long unsigned int);

typedef void (*btf_trace_dma_unmap_resource)(void *, struct device *, dma_addr_t, size_t, enum dma_data_direction, long unsigned int);

typedef void (*btf_trace_dma_unmap_sg)(void *, struct device *, struct scatterlist *, int, enum dma_data_direction, long unsigned int);

typedef void (*btf_trace_dql_stall_detected)(void *, short unsigned int, unsigned int, long unsigned int, long unsigned int, long unsigned int, long unsigned int *);

typedef void (*btf_trace_drm_vblank_event)(void *, int, unsigned int, ktime_t, bool);

typedef void (*btf_trace_drm_vblank_event_delivered)(void *, struct drm_file *, int, unsigned int);

typedef void (*btf_trace_drm_vblank_event_queued)(void *, struct drm_file *, int, unsigned int);

typedef void (*btf_trace_error_report_end)(void *, enum error_detector, long unsigned int);

typedef void (*btf_trace_exit_mmap)(void *, struct mm_struct *);

typedef void (*btf_trace_ext4_alloc_da_blocks)(void *, struct inode *);

typedef void (*btf_trace_ext4_allocate_blocks)(void *, struct ext4_allocation_request *, long long unsigned int);

typedef void (*btf_trace_ext4_allocate_inode)(void *, struct inode *, struct inode *, int);

typedef void (*btf_trace_ext4_begin_ordered_truncate)(void *, struct inode *, loff_t);

typedef void (*btf_trace_ext4_collapse_range)(void *, struct inode *, loff_t, loff_t);

typedef void (*btf_trace_ext4_da_release_space)(void *, struct inode *, int);

typedef void (*btf_trace_ext4_da_reserve_space)(void *, struct inode *, int);

typedef void (*btf_trace_ext4_da_update_reserve_space)(void *, struct inode *, int, int);

typedef void (*btf_trace_ext4_da_write_begin)(void *, struct inode *, loff_t, unsigned int);

typedef void (*btf_trace_ext4_da_write_end)(void *, struct inode *, loff_t, unsigned int, unsigned int);

typedef void (*btf_trace_ext4_da_write_pages)(void *, struct inode *, long unsigned int, struct writeback_control *);

typedef void (*btf_trace_ext4_da_write_pages_extent)(void *, struct inode *, struct ext4_map_blocks *);

typedef void (*btf_trace_ext4_discard_blocks)(void *, struct super_block *, long long unsigned int, long long unsigned int);

typedef void (*btf_trace_ext4_discard_preallocations)(void *, struct inode *, unsigned int);

typedef void (*btf_trace_ext4_drop_inode)(void *, struct inode *, int);

typedef void (*btf_trace_ext4_error)(void *, struct super_block *, const char *, unsigned int);

typedef void (*btf_trace_ext4_es_cache_extent)(void *, struct inode *, struct extent_status *);

typedef void (*btf_trace_ext4_es_find_extent_range_enter)(void *, struct inode *, ext4_lblk_t);

typedef void (*btf_trace_ext4_es_find_extent_range_exit)(void *, struct inode *, struct extent_status *);

typedef void (*btf_trace_ext4_es_insert_delayed_extent)(void *, struct inode *, struct extent_status *, bool, bool);

typedef void (*btf_trace_ext4_es_insert_extent)(void *, struct inode *, struct extent_status *);

typedef void (*btf_trace_ext4_es_lookup_extent_enter)(void *, struct inode *, ext4_lblk_t);

typedef void (*btf_trace_ext4_es_lookup_extent_exit)(void *, struct inode *, struct extent_status *, int);

typedef void (*btf_trace_ext4_es_remove_extent)(void *, struct inode *, ext4_lblk_t, ext4_lblk_t);

typedef void (*btf_trace_ext4_es_shrink)(void *, struct super_block *, int, u64, int, int);

typedef void (*btf_trace_ext4_es_shrink_count)(void *, struct super_block *, int, int);

typedef void (*btf_trace_ext4_es_shrink_scan_enter)(void *, struct super_block *, int, int);

typedef void (*btf_trace_ext4_es_shrink_scan_exit)(void *, struct super_block *, int, int);

typedef void (*btf_trace_ext4_evict_inode)(void *, struct inode *);

typedef void (*btf_trace_ext4_ext_convert_to_initialized_enter)(void *, struct inode *, struct ext4_map_blocks *, struct ext4_extent *);

typedef void (*btf_trace_ext4_ext_convert_to_initialized_fastpath)(void *, struct inode *, struct ext4_map_blocks *, struct ext4_extent *, struct ext4_extent *);

typedef void (*btf_trace_ext4_ext_handle_unwritten_extents)(void *, struct inode *, struct ext4_map_blocks *, int, unsigned int, ext4_fsblk_t);

typedef void (*btf_trace_ext4_ext_load_extent)(void *, struct inode *, ext4_lblk_t, ext4_fsblk_t);

typedef void (*btf_trace_ext4_ext_map_blocks_enter)(void *, struct inode *, ext4_lblk_t, unsigned int, unsigned int);

typedef void (*btf_trace_ext4_ext_map_blocks_exit)(void *, struct inode *, unsigned int, struct ext4_map_blocks *, int);

typedef void (*btf_trace_ext4_ext_remove_space)(void *, struct inode *, ext4_lblk_t, ext4_lblk_t, int);

typedef void (*btf_trace_ext4_ext_remove_space_done)(void *, struct inode *, ext4_lblk_t, ext4_lblk_t, int, struct partial_cluster *, __le16);

typedef void (*btf_trace_ext4_ext_rm_idx)(void *, struct inode *, ext4_fsblk_t);

typedef void (*btf_trace_ext4_ext_rm_leaf)(void *, struct inode *, ext4_lblk_t, struct ext4_extent *, struct partial_cluster *);

typedef void (*btf_trace_ext4_ext_show_extent)(void *, struct inode *, ext4_lblk_t, ext4_fsblk_t, short unsigned int);

typedef void (*btf_trace_ext4_fallocate_enter)(void *, struct inode *, loff_t, loff_t, int);

typedef void (*btf_trace_ext4_fallocate_exit)(void *, struct inode *, loff_t, unsigned int, int);

typedef void (*btf_trace_ext4_fc_cleanup)(void *, journal_t *, int, tid_t);

typedef void (*btf_trace_ext4_fc_commit_start)(void *, struct super_block *, tid_t);

typedef void (*btf_trace_ext4_fc_commit_stop)(void *, struct super_block *, int, int, tid_t);

typedef void (*btf_trace_ext4_fc_replay)(void *, struct super_block *, int, int, int, int);

typedef void (*btf_trace_ext4_fc_replay_scan)(void *, struct super_block *, int, int);

typedef void (*btf_trace_ext4_fc_stats)(void *, struct super_block *);

typedef void (*btf_trace_ext4_fc_track_create)(void *, handle_t *, struct inode *, struct dentry *, int);

typedef void (*btf_trace_ext4_fc_track_inode)(void *, handle_t *, struct inode *, int);

typedef void (*btf_trace_ext4_fc_track_link)(void *, handle_t *, struct inode *, struct dentry *, int);

typedef void (*btf_trace_ext4_fc_track_range)(void *, handle_t *, struct inode *, long int, long int, int);

typedef void (*btf_trace_ext4_fc_track_unlink)(void *, handle_t *, struct inode *, struct dentry *, int);

typedef void (*btf_trace_ext4_forget)(void *, struct inode *, int, __u64);

typedef void (*btf_trace_ext4_free_blocks)(void *, struct inode *, __u64, long unsigned int, int);

typedef void (*btf_trace_ext4_free_inode)(void *, struct inode *);

typedef void (*btf_trace_ext4_fsmap_high_key)(void *, struct super_block *, u32, u32, u64, u64, u64);

typedef void (*btf_trace_ext4_fsmap_low_key)(void *, struct super_block *, u32, u32, u64, u64, u64);

typedef void (*btf_trace_ext4_fsmap_mapping)(void *, struct super_block *, u32, u32, u64, u64, u64);

typedef void (*btf_trace_ext4_get_implied_cluster_alloc_exit)(void *, struct super_block *, struct ext4_map_blocks *, int);

typedef void (*btf_trace_ext4_getfsmap_high_key)(void *, struct super_block *, struct ext4_fsmap *);

typedef void (*btf_trace_ext4_getfsmap_low_key)(void *, struct super_block *, struct ext4_fsmap *);

typedef void (*btf_trace_ext4_getfsmap_mapping)(void *, struct super_block *, struct ext4_fsmap *);

typedef void (*btf_trace_ext4_ind_map_blocks_enter)(void *, struct inode *, ext4_lblk_t, unsigned int, unsigned int);

typedef void (*btf_trace_ext4_ind_map_blocks_exit)(void *, struct inode *, unsigned int, struct ext4_map_blocks *, int);

typedef void (*btf_trace_ext4_insert_range)(void *, struct inode *, loff_t, loff_t);

typedef void (*btf_trace_ext4_invalidate_folio)(void *, struct folio *, size_t, size_t);

typedef void (*btf_trace_ext4_journal_start_inode)(void *, struct inode *, int, int, int, int, long unsigned int);

typedef void (*btf_trace_ext4_journal_start_reserved)(void *, struct super_block *, int, long unsigned int);

typedef void (*btf_trace_ext4_journal_start_sb)(void *, struct super_block *, int, int, int, int, long unsigned int);

typedef void (*btf_trace_ext4_journalled_invalidate_folio)(void *, struct folio *, size_t, size_t);

typedef void (*btf_trace_ext4_journalled_write_end)(void *, struct inode *, loff_t, unsigned int, unsigned int);

typedef void (*btf_trace_ext4_lazy_itable_init)(void *, struct super_block *, ext4_group_t);

typedef void (*btf_trace_ext4_load_inode)(void *, struct super_block *, long unsigned int);

typedef void (*btf_trace_ext4_load_inode_bitmap)(void *, struct super_block *, long unsigned int);

typedef void (*btf_trace_ext4_mark_inode_dirty)(void *, struct inode *, long unsigned int);

typedef void (*btf_trace_ext4_mb_bitmap_load)(void *, struct super_block *, long unsigned int);

typedef void (*btf_trace_ext4_mb_buddy_bitmap_load)(void *, struct super_block *, long unsigned int);

typedef void (*btf_trace_ext4_mb_discard_preallocations)(void *, struct super_block *, int);

typedef void (*btf_trace_ext4_mb_new_group_pa)(void *, struct ext4_allocation_context *, struct ext4_prealloc_space *);

typedef void (*btf_trace_ext4_mb_new_inode_pa)(void *, struct ext4_allocation_context *, struct ext4_prealloc_space *);

typedef void (*btf_trace_ext4_mb_release_group_pa)(void *, struct super_block *, struct ext4_prealloc_space *);

typedef void (*btf_trace_ext4_mb_release_inode_pa)(void *, struct ext4_prealloc_space *, long long unsigned int, unsigned int);

typedef void (*btf_trace_ext4_mballoc_alloc)(void *, struct ext4_allocation_context *);

typedef void (*btf_trace_ext4_mballoc_discard)(void *, struct super_block *, struct inode *, ext4_group_t, ext4_grpblk_t, ext4_grpblk_t);

typedef void (*btf_trace_ext4_mballoc_free)(void *, struct super_block *, struct inode *, ext4_group_t, ext4_grpblk_t, ext4_grpblk_t);

typedef void (*btf_trace_ext4_mballoc_prealloc)(void *, struct ext4_allocation_context *);

typedef void (*btf_trace_ext4_nfs_commit_metadata)(void *, struct inode *);

typedef void (*btf_trace_ext4_other_inode_update_time)(void *, struct inode *, ino_t);

typedef void (*btf_trace_ext4_prefetch_bitmaps)(void *, struct super_block *, ext4_group_t, ext4_group_t, unsigned int);

typedef void (*btf_trace_ext4_punch_hole)(void *, struct inode *, loff_t, loff_t, int);

typedef void (*btf_trace_ext4_read_block_bitmap_load)(void *, struct super_block *, long unsigned int, bool);

typedef void (*btf_trace_ext4_read_folio)(void *, struct inode *, struct folio *);

typedef void (*btf_trace_ext4_release_folio)(void *, struct inode *, struct folio *);

typedef void (*btf_trace_ext4_remove_blocks)(void *, struct inode *, struct ext4_extent *, ext4_lblk_t, ext4_fsblk_t, struct partial_cluster *);

typedef void (*btf_trace_ext4_request_blocks)(void *, struct ext4_allocation_request *);

typedef void (*btf_trace_ext4_request_inode)(void *, struct inode *, int);

typedef void (*btf_trace_ext4_shutdown)(void *, struct super_block *, long unsigned int);

typedef void (*btf_trace_ext4_sync_file_enter)(void *, struct file *, int);

typedef void (*btf_trace_ext4_sync_file_exit)(void *, struct inode *, int);

typedef void (*btf_trace_ext4_sync_fs)(void *, struct super_block *, int);

typedef void (*btf_trace_ext4_trim_all_free)(void *, struct super_block *, ext4_group_t, ext4_grpblk_t, ext4_grpblk_t);

typedef void (*btf_trace_ext4_trim_extent)(void *, struct super_block *, ext4_group_t, ext4_grpblk_t, ext4_grpblk_t);

typedef void (*btf_trace_ext4_truncate_enter)(void *, struct inode *);

typedef void (*btf_trace_ext4_truncate_exit)(void *, struct inode *);

typedef void (*btf_trace_ext4_unlink_enter)(void *, struct inode *, struct dentry *);

typedef void (*btf_trace_ext4_unlink_exit)(void *, struct dentry *, int);

typedef void (*btf_trace_ext4_update_sb)(void *, struct super_block *, ext4_fsblk_t, unsigned int);

typedef void (*btf_trace_ext4_write_begin)(void *, struct inode *, loff_t, unsigned int);

typedef void (*btf_trace_ext4_write_end)(void *, struct inode *, loff_t, unsigned int, unsigned int);

typedef void (*btf_trace_ext4_writepages)(void *, struct inode *, struct writeback_control *);

typedef void (*btf_trace_ext4_writepages_result)(void *, struct inode *, struct writeback_control *, int, int);

typedef void (*btf_trace_ext4_zero_range)(void *, struct inode *, loff_t, loff_t, int);

typedef void (*btf_trace_fcntl_setlk)(void *, struct inode *, struct file_lock *, int);

typedef void (*btf_trace_fdb_delete)(void *, struct net_bridge *, struct net_bridge_fdb_entry *);

typedef void (*btf_trace_fib6_table_lookup)(void *, const struct net *, const struct fib6_result *, struct fib6_table *, const struct flowi6 *);

typedef void (*btf_trace_fib_table_lookup)(void *, u32, const struct flowi4 *, const struct fib_nh_common *, int);

typedef void (*btf_trace_file_check_and_advance_wb_err)(void *, struct file *, errseq_t);

typedef void (*btf_trace_filemap_set_wb_err)(void *, struct address_space *, errseq_t);

typedef void (*btf_trace_fill_mg_cmtime)(void *, struct inode *, struct timespec64 *, struct timespec64 *);

typedef void (*btf_trace_finish_task_reaping)(void *, int);

typedef void (*btf_trace_flock_lock_inode)(void *, struct inode *, struct file_lock *, int);

typedef void (*btf_trace_flush_foreign)(void *, struct bdi_writeback *, unsigned int, unsigned int);

typedef void (*btf_trace_folio_wait_writeback)(void *, struct folio *, struct address_space *);

typedef void (*btf_trace_free_vmap_area_noflush)(void *, long unsigned int, long unsigned int, long unsigned int);

typedef void (*btf_trace_generic_add_lease)(void *, struct inode *, struct file_lease *);

typedef void (*btf_trace_generic_delete_lease)(void *, struct inode *, struct file_lease *);

typedef void (*btf_trace_get_mapping_status)(void *, struct mptcp_ext *);

typedef void (*btf_trace_global_dirty_state)(void *, long unsigned int, long unsigned int);

typedef void (*btf_trace_gpio_direction)(void *, unsigned int, int, int);

typedef void (*btf_trace_gpio_value)(void *, unsigned int, int, int);

typedef void (*btf_trace_guest_halt_poll_ns)(void *, bool, unsigned int, unsigned int);

typedef void (*btf_trace_handshake_cancel)(void *, const struct net *, const struct handshake_req *, const struct sock *);

typedef void (*btf_trace_handshake_cancel_busy)(void *, const struct net *, const struct handshake_req *, const struct sock *);

typedef void (*btf_trace_handshake_cancel_none)(void *, const struct net *, const struct handshake_req *, const struct sock *);

typedef void (*btf_trace_handshake_cmd_accept)(void *, const struct net *, const struct handshake_req *, const struct sock *, int);

typedef void (*btf_trace_handshake_cmd_accept_err)(void *, const struct net *, const struct handshake_req *, const struct sock *, int);

typedef void (*btf_trace_handshake_cmd_done)(void *, const struct net *, const struct handshake_req *, const struct sock *, int);

typedef void (*btf_trace_handshake_cmd_done_err)(void *, const struct net *, const struct handshake_req *, const struct sock *, int);

typedef void (*btf_trace_handshake_complete)(void *, const struct net *, const struct handshake_req *, const struct sock *, int);

typedef void (*btf_trace_handshake_destruct)(void *, const struct net *, const struct handshake_req *, const struct sock *);

typedef void (*btf_trace_handshake_notify_err)(void *, const struct net *, const struct handshake_req *, const struct sock *, int);

typedef void (*btf_trace_handshake_submit)(void *, const struct net *, const struct handshake_req *, const struct sock *);

typedef void (*btf_trace_handshake_submit_err)(void *, const struct net *, const struct handshake_req *, const struct sock *, int);

typedef void (*btf_trace_hrtimer_cancel)(void *, struct hrtimer *);

typedef void (*btf_trace_hrtimer_expire_entry)(void *, struct hrtimer *, ktime_t *);

typedef void (*btf_trace_hrtimer_expire_exit)(void *, struct hrtimer *);

typedef void (*btf_trace_hrtimer_init)(void *, struct hrtimer *, clockid_t, enum hrtimer_mode);

typedef void (*btf_trace_hrtimer_start)(void *, struct hrtimer *, enum hrtimer_mode);

typedef void (*btf_trace_hugepage_set_pmd)(void *, long unsigned int, long unsigned int);

typedef void (*btf_trace_hugepage_set_pud)(void *, long unsigned int, long unsigned int);

typedef void (*btf_trace_hugepage_update_pmd)(void *, long unsigned int, long unsigned int, long unsigned int, long unsigned int);

typedef void (*btf_trace_hugepage_update_pud)(void *, long unsigned int, long unsigned int, long unsigned int, long unsigned int);

typedef void (*btf_trace_hugetlbfs_alloc_inode)(void *, struct inode *, struct inode *, int);

typedef void (*btf_trace_hugetlbfs_evict_inode)(void *, struct inode *);

typedef void (*btf_trace_hugetlbfs_fallocate)(void *, struct inode *, int, loff_t, loff_t, int);

typedef void (*btf_trace_hugetlbfs_free_inode)(void *, struct inode *);

typedef void (*btf_trace_hugetlbfs_setattr)(void *, struct inode *, struct dentry *, struct iattr *);

typedef void (*btf_trace_hw_pressure_update)(void *, int, long unsigned int);

typedef void (*btf_trace_hwmon_attr_show)(void *, int, const char *, long int);

typedef void (*btf_trace_hwmon_attr_show_string)(void *, int, const char *, const char *);

typedef void (*btf_trace_hwmon_attr_store)(void *, int, const char *, long int);

typedef void (*btf_trace_i2c_read)(void *, const struct i2c_adapter *, const struct i2c_msg *, int);

typedef void (*btf_trace_i2c_reply)(void *, const struct i2c_adapter *, const struct i2c_msg *, int);

typedef void (*btf_trace_i2c_result)(void *, const struct i2c_adapter *, int, int);

typedef void (*btf_trace_i2c_slave)(void *, const struct i2c_client *, enum i2c_slave_event, __u8 *, int);

typedef void (*btf_trace_i2c_write)(void *, const struct i2c_adapter *, const struct i2c_msg *, int);

typedef void (*btf_trace_icmp_send)(void *, const struct sk_buff *, int, int);

typedef void (*btf_trace_inet_sk_error_report)(void *, const struct sock *);

typedef void (*btf_trace_inet_sock_set_state)(void *, const struct sock *, const int, const int);

typedef void (*btf_trace_initcall_finish)(void *, initcall_t, int);

typedef void (*btf_trace_initcall_level)(void *, const char *);

typedef void (*btf_trace_initcall_start)(void *, initcall_t);

typedef void (*btf_trace_inode_foreign_history)(void *, struct inode *, struct writeback_control *, unsigned int);

typedef void (*btf_trace_inode_set_ctime_to_ts)(void *, struct inode *, struct timespec64 *);

typedef void (*btf_trace_inode_switch_wbs)(void *, struct inode *, struct bdi_writeback *, struct bdi_writeback *);

typedef void (*btf_trace_instruction_emulation)(void *, const char *, u64);

typedef void (*btf_trace_io_page_fault)(void *, struct device *, long unsigned int, int);

typedef void (*btf_trace_io_uring_complete)(void *, struct io_ring_ctx *, void *, struct io_uring_cqe *);

typedef void (*btf_trace_io_uring_cqe_overflow)(void *, void *, long long unsigned int, s32, u32, void *);

typedef void (*btf_trace_io_uring_cqring_wait)(void *, void *, int);

typedef void (*btf_trace_io_uring_create)(void *, int, void *, u32, u32, u32);

typedef void (*btf_trace_io_uring_defer)(void *, struct io_kiocb *);

typedef void (*btf_trace_io_uring_fail_link)(void *, struct io_kiocb *, struct io_kiocb *);

typedef void (*btf_trace_io_uring_file_get)(void *, struct io_kiocb *, int);

typedef void (*btf_trace_io_uring_link)(void *, struct io_kiocb *, struct io_kiocb *);

typedef void (*btf_trace_io_uring_local_work_run)(void *, void *, int, unsigned int);

typedef void (*btf_trace_io_uring_poll_arm)(void *, struct io_kiocb *, int, int);

typedef void (*btf_trace_io_uring_queue_async_work)(void *, struct io_kiocb *, int);

typedef void (*btf_trace_io_uring_register)(void *, void *, unsigned int, unsigned int, unsigned int, long int);

typedef void (*btf_trace_io_uring_req_failed)(void *, const struct io_uring_sqe *, struct io_kiocb *, int);

typedef void (*btf_trace_io_uring_short_write)(void *, void *, u64, u64, u64);

typedef void (*btf_trace_io_uring_submit_req)(void *, struct io_kiocb *);

typedef void (*btf_trace_io_uring_task_add)(void *, struct io_kiocb *, int);

typedef void (*btf_trace_io_uring_task_work_run)(void *, void *, unsigned int);

typedef void (*btf_trace_iomap_dio_complete)(void *, struct kiocb *, int, ssize_t);

typedef void (*btf_trace_iomap_dio_invalidate_fail)(void *, struct inode *, loff_t, u64);

typedef void (*btf_trace_iomap_dio_rw_begin)(void *, struct kiocb *, struct iov_iter *, unsigned int, size_t);

typedef void (*btf_trace_iomap_dio_rw_queued)(void *, struct inode *, loff_t, u64);

typedef void (*btf_trace_iomap_invalidate_folio)(void *, struct inode *, loff_t, u64);

typedef void (*btf_trace_iomap_iter)(void *, struct iomap_iter *, const void *, long unsigned int);

typedef void (*btf_trace_iomap_iter_dstmap)(void *, struct inode *, struct iomap *);

typedef void (*btf_trace_iomap_iter_srcmap)(void *, struct inode *, struct iomap *);

typedef void (*btf_trace_iomap_readahead)(void *, struct inode *, int);

typedef void (*btf_trace_iomap_readpage)(void *, struct inode *, int);

typedef void (*btf_trace_iomap_release_folio)(void *, struct inode *, loff_t, u64);

typedef void (*btf_trace_iomap_writepage)(void *, struct inode *, loff_t, u64);

typedef void (*btf_trace_iomap_writepage_map)(void *, struct inode *, u64, unsigned int, struct iomap *);

typedef void (*btf_trace_ipi_entry)(void *, const char *);

typedef void (*btf_trace_ipi_exit)(void *, const char *);

typedef void (*btf_trace_ipi_raise)(void *, const struct cpumask *, const char *);

typedef void (*btf_trace_ipi_send_cpu)(void *, const unsigned int, long unsigned int, void *);

typedef void (*btf_trace_ipi_send_cpumask)(void *, const struct cpumask *, long unsigned int, void *);

typedef void (*btf_trace_irq_disable)(void *, long unsigned int, long unsigned int);

typedef void (*btf_trace_irq_enable)(void *, long unsigned int, long unsigned int);

typedef void (*btf_trace_irq_handler_entry)(void *, int, struct irqaction *);

typedef void (*btf_trace_irq_handler_exit)(void *, int, struct irqaction *, int);

typedef void (*btf_trace_itimer_expire)(void *, int, struct pid *, long long unsigned int);

typedef void (*btf_trace_itimer_state)(void *, int, const struct itimerspec64 * const, long long unsigned int);

typedef void (*btf_trace_jbd2_checkpoint)(void *, journal_t *, int);

typedef void (*btf_trace_jbd2_checkpoint_stats)(void *, dev_t, tid_t, struct transaction_chp_stats_s *);

typedef void (*btf_trace_jbd2_commit_flushing)(void *, journal_t *, transaction_t *);

typedef void (*btf_trace_jbd2_commit_locking)(void *, journal_t *, transaction_t *);

typedef void (*btf_trace_jbd2_commit_logging)(void *, journal_t *, transaction_t *);

typedef void (*btf_trace_jbd2_drop_transaction)(void *, journal_t *, transaction_t *);

typedef void (*btf_trace_jbd2_end_commit)(void *, journal_t *, transaction_t *);

typedef void (*btf_trace_jbd2_handle_extend)(void *, dev_t, tid_t, unsigned int, unsigned int, int, int);

typedef void (*btf_trace_jbd2_handle_restart)(void *, dev_t, tid_t, unsigned int, unsigned int, int);

typedef void (*btf_trace_jbd2_handle_start)(void *, dev_t, tid_t, unsigned int, unsigned int, int);

typedef void (*btf_trace_jbd2_handle_stats)(void *, dev_t, tid_t, unsigned int, unsigned int, int, int, int, int);

typedef void (*btf_trace_jbd2_lock_buffer_stall)(void *, dev_t, long unsigned int);

typedef void (*btf_trace_jbd2_run_stats)(void *, dev_t, tid_t, struct transaction_run_stats_s *);

typedef void (*btf_trace_jbd2_shrink_checkpoint_list)(void *, journal_t *, tid_t, tid_t, tid_t, long unsigned int, tid_t);

typedef void (*btf_trace_jbd2_shrink_count)(void *, journal_t *, long unsigned int, long unsigned int);

typedef void (*btf_trace_jbd2_shrink_scan_enter)(void *, journal_t *, long unsigned int, long unsigned int);

typedef void (*btf_trace_jbd2_shrink_scan_exit)(void *, journal_t *, long unsigned int, long unsigned int, long unsigned int);

typedef void (*btf_trace_jbd2_start_commit)(void *, journal_t *, transaction_t *);

typedef void (*btf_trace_jbd2_submit_inode_data)(void *, struct inode *);

typedef void (*btf_trace_jbd2_update_log_tail)(void *, journal_t *, tid_t, long unsigned int, long unsigned int);

typedef void (*btf_trace_jbd2_write_superblock)(void *, journal_t *, blk_opf_t);

typedef void (*btf_trace_kfree)(void *, long unsigned int, const void *);

typedef void (*btf_trace_kfree_skb)(void *, struct sk_buff *, void *, enum skb_drop_reason, struct sock *);

typedef void (*btf_trace_kmalloc)(void *, long unsigned int, const void *, size_t, size_t, gfp_t, int);

typedef void (*btf_trace_kmem_cache_alloc)(void *, long unsigned int, const void *, struct kmem_cache *, gfp_t, int);

typedef void (*btf_trace_kmem_cache_free)(void *, long unsigned int, const void *, const struct kmem_cache *);

typedef void (*btf_trace_kvm_access_fault)(void *, long unsigned int);

typedef void (*btf_trace_kvm_ack_irq)(void *, unsigned int, unsigned int);

typedef void (*btf_trace_kvm_age_hva)(void *, long unsigned int, long unsigned int);

typedef void (*btf_trace_kvm_arm_set_dreg32)(void *, const char *, __u64);

typedef void (*btf_trace_kvm_dirty_ring_exit)(void *, struct kvm_vcpu *);

typedef void (*btf_trace_kvm_dirty_ring_push)(void *, struct kvm_dirty_ring *, u32, u64);

typedef void (*btf_trace_kvm_dirty_ring_reset)(void *, struct kvm_dirty_ring *);

typedef void (*btf_trace_kvm_entry)(void *, long unsigned int);

typedef void (*btf_trace_kvm_exit)(void *, int, unsigned int, long unsigned int);

typedef void (*btf_trace_kvm_forward_sysreg_trap)(void *, struct kvm_vcpu *, u32, bool);

typedef void (*btf_trace_kvm_fpu)(void *, int);

typedef void (*btf_trace_kvm_get_timer_map)(void *, long unsigned int, struct timer_map *);

typedef void (*btf_trace_kvm_guest_fault)(void *, long unsigned int, long unsigned int, long unsigned int, long long unsigned int);

typedef void (*btf_trace_kvm_halt_poll_ns)(void *, bool, unsigned int, unsigned int, unsigned int);

typedef void (*btf_trace_kvm_handle_sys_reg)(void *, long unsigned int);

typedef void (*btf_trace_kvm_hvc_arm64)(void *, long unsigned int, long unsigned int, long unsigned int);

typedef void (*btf_trace_kvm_inject_nested_exception)(void *, struct kvm_vcpu *, u64, int);

typedef void (*btf_trace_kvm_iocsr)(void *, int, int, u64, void *);

typedef void (*btf_trace_kvm_irq_line)(void *, unsigned int, int, int, int);

typedef void (*btf_trace_kvm_mmio)(void *, int, int, u64, void *);

typedef void (*btf_trace_kvm_mmio_emulate)(void *, long unsigned int, long unsigned int, long unsigned int);

typedef void (*btf_trace_kvm_mmio_nisv)(void *, long unsigned int, long unsigned int, long unsigned int, long unsigned int);

typedef void (*btf_trace_kvm_nested_eret)(void *, struct kvm_vcpu *, long unsigned int, long unsigned int);

typedef void (*btf_trace_kvm_set_guest_debug)(void *, struct kvm_vcpu *, __u32);

typedef void (*btf_trace_kvm_set_irq)(void *, unsigned int, int, int);

typedef void (*btf_trace_kvm_set_way_flush)(void *, long unsigned int, bool);

typedef void (*btf_trace_kvm_sys_access)(void *, long unsigned int, struct sys_reg_params *, const struct sys_reg_desc *);

typedef void (*btf_trace_kvm_test_age_hva)(void *, long unsigned int);

typedef void (*btf_trace_kvm_timer_emulate)(void *, struct arch_timer_context *, bool);

typedef void (*btf_trace_kvm_timer_hrtimer_expire)(void *, struct arch_timer_context *);

typedef void (*btf_trace_kvm_timer_restore_state)(void *, struct arch_timer_context *);

typedef void (*btf_trace_kvm_timer_save_state)(void *, struct arch_timer_context *);

typedef void (*btf_trace_kvm_timer_update_irq)(void *, long unsigned int, __u32, int);

typedef void (*btf_trace_kvm_toggle_cache)(void *, long unsigned int, bool, bool);

typedef void (*btf_trace_kvm_unmap_hva_range)(void *, long unsigned int, long unsigned int);

typedef void (*btf_trace_kvm_userspace_exit)(void *, __u32, int);

typedef void (*btf_trace_kvm_vcpu_wakeup)(void *, __u64, bool, bool);

typedef void (*btf_trace_kvm_wfx_arm64)(void *, long unsigned int, bool);

typedef void (*btf_trace_leases_conflict)(void *, bool, struct file_lease *, struct file_lease *);

typedef void (*btf_trace_locks_get_lock_context)(void *, struct inode *, int, struct file_lock_context *);

typedef void (*btf_trace_locks_remove_posix)(void *, struct inode *, struct file_lock *, int);

typedef void (*btf_trace_ma_op)(void *, const char *, struct ma_state *);

typedef void (*btf_trace_ma_read)(void *, const char *, struct ma_state *);

typedef void (*btf_trace_ma_write)(void *, const char *, struct ma_state *, long unsigned int, void *);

typedef void (*btf_trace_map)(void *, long unsigned int, phys_addr_t, size_t);

typedef void (*btf_trace_mark_victim)(void *, struct task_struct *, uid_t);

typedef void (*btf_trace_mc_event)(void *, const unsigned int, const char *, const char *, const int, const u8, const s8, const s8, const s8, long unsigned int, const u8, long unsigned int, const char *);

typedef void (*btf_trace_mdio_access)(void *, struct mii_bus *, char, u8, unsigned int, u16, int);

typedef void (*btf_trace_mem_connect)(void *, const struct xdp_mem_allocator *, const struct xdp_rxq_info *);

typedef void (*btf_trace_mem_disconnect)(void *, const struct xdp_mem_allocator *);

typedef void (*btf_trace_mem_return_failed)(void *, const struct xdp_mem_info *, const struct page *);

typedef void (*btf_trace_memcg_flush_stats)(void *, struct mem_cgroup *, s64, bool, bool);

typedef void (*btf_trace_mm_alloc_contig_migrate_range_info)(void *, long unsigned int, long unsigned int, long unsigned int, long unsigned int, long unsigned int, int);

typedef void (*btf_trace_mm_collapse_huge_page)(void *, struct mm_struct *, int, int);

typedef void (*btf_trace_mm_collapse_huge_page_isolate)(void *, struct page *, int, int, bool, int);

typedef void (*btf_trace_mm_collapse_huge_page_swapin)(void *, struct mm_struct *, int, int, int);

typedef void (*btf_trace_mm_compaction_begin)(void *, struct compact_control *, long unsigned int, long unsigned int, bool);

typedef void (*btf_trace_mm_compaction_defer_compaction)(void *, struct zone *, int);

typedef void (*btf_trace_mm_compaction_defer_reset)(void *, struct zone *, int);

typedef void (*btf_trace_mm_compaction_deferred)(void *, struct zone *, int);

typedef void (*btf_trace_mm_compaction_end)(void *, struct compact_control *, long unsigned int, long unsigned int, bool, int);

typedef void (*btf_trace_mm_compaction_fast_isolate_freepages)(void *, long unsigned int, long unsigned int, long unsigned int, long unsigned int);

typedef void (*btf_trace_mm_compaction_finished)(void *, struct zone *, int, int);

typedef void (*btf_trace_mm_compaction_isolate_freepages)(void *, long unsigned int, long unsigned int, long unsigned int, long unsigned int);

typedef void (*btf_trace_mm_compaction_isolate_migratepages)(void *, long unsigned int, long unsigned int, long unsigned int, long unsigned int);

typedef void (*btf_trace_mm_compaction_kcompactd_sleep)(void *, int);

typedef void (*btf_trace_mm_compaction_kcompactd_wake)(void *, int, int, enum zone_type);

typedef void (*btf_trace_mm_compaction_migratepages)(void *, unsigned int, unsigned int);

typedef void (*btf_trace_mm_compaction_suitable)(void *, struct zone *, int, int);

typedef void (*btf_trace_mm_compaction_try_to_compact_pages)(void *, int, gfp_t, int);

typedef void (*btf_trace_mm_compaction_wakeup_kcompactd)(void *, int, int, enum zone_type);

typedef void (*btf_trace_mm_filemap_add_to_page_cache)(void *, struct folio *);

typedef void (*btf_trace_mm_filemap_delete_from_page_cache)(void *, struct folio *);

typedef void (*btf_trace_mm_filemap_fault)(void *, struct address_space *, long unsigned int);

typedef void (*btf_trace_mm_filemap_get_pages)(void *, struct address_space *, long unsigned int, long unsigned int);

typedef void (*btf_trace_mm_filemap_map_pages)(void *, struct address_space *, long unsigned int, long unsigned int);

typedef void (*btf_trace_mm_khugepaged_collapse_file)(void *, struct mm_struct *, struct folio *, long unsigned int, long unsigned int, bool, struct file *, int, int);

typedef void (*btf_trace_mm_khugepaged_scan_file)(void *, struct mm_struct *, struct folio *, struct file *, int, int, int);

typedef void (*btf_trace_mm_khugepaged_scan_pmd)(void *, struct mm_struct *, struct page *, bool, int, int, int, int);

typedef void (*btf_trace_mm_lru_activate)(void *, struct folio *);

typedef void (*btf_trace_mm_lru_insertion)(void *, struct folio *);

typedef void (*btf_trace_mm_migrate_pages)(void *, long unsigned int, long unsigned int, long unsigned int, long unsigned int, long unsigned int, long unsigned int, enum migrate_mode, int);

typedef void (*btf_trace_mm_migrate_pages_start)(void *, enum migrate_mode, int);

typedef void (*btf_trace_mm_page_alloc)(void *, struct page *, unsigned int, gfp_t, int);

typedef void (*btf_trace_mm_page_alloc_extfrag)(void *, struct page *, int, int, int, int);

typedef void (*btf_trace_mm_page_alloc_zone_locked)(void *, struct page *, unsigned int, int, int);

typedef void (*btf_trace_mm_page_free)(void *, struct page *, unsigned int);

typedef void (*btf_trace_mm_page_free_batched)(void *, struct page *);

typedef void (*btf_trace_mm_page_pcpu_drain)(void *, struct page *, unsigned int, int);

typedef void (*btf_trace_mm_shrink_slab_end)(void *, struct shrinker *, int, int, long int, long int, long int);

typedef void (*btf_trace_mm_shrink_slab_start)(void *, struct shrinker *, struct shrink_control *, long int, long unsigned int, long long unsigned int, long unsigned int, int);

typedef void (*btf_trace_mm_vmscan_direct_reclaim_begin)(void *, int, gfp_t);

typedef void (*btf_trace_mm_vmscan_direct_reclaim_end)(void *, long unsigned int);

typedef void (*btf_trace_mm_vmscan_kswapd_sleep)(void *, int);

typedef void (*btf_trace_mm_vmscan_kswapd_wake)(void *, int, int, int);

typedef void (*btf_trace_mm_vmscan_lru_isolate)(void *, int, int, long unsigned int, long unsigned int, long unsigned int, long unsigned int, int);

typedef void (*btf_trace_mm_vmscan_lru_shrink_active)(void *, int, long unsigned int, long unsigned int, long unsigned int, long unsigned int, int, int);

typedef void (*btf_trace_mm_vmscan_lru_shrink_inactive)(void *, int, long unsigned int, long unsigned int, struct reclaim_stat *, int, int);

typedef void (*btf_trace_mm_vmscan_memcg_reclaim_begin)(void *, int, gfp_t);

typedef void (*btf_trace_mm_vmscan_memcg_reclaim_end)(void *, long unsigned int);

typedef void (*btf_trace_mm_vmscan_memcg_softlimit_reclaim_begin)(void *, int, gfp_t);

typedef void (*btf_trace_mm_vmscan_memcg_softlimit_reclaim_end)(void *, long unsigned int);

typedef void (*btf_trace_mm_vmscan_node_reclaim_begin)(void *, int, int, gfp_t);

typedef void (*btf_trace_mm_vmscan_node_reclaim_end)(void *, long unsigned int);

typedef void (*btf_trace_mm_vmscan_reclaim_pages)(void *, int, long unsigned int, long unsigned int, struct reclaim_stat *);

typedef void (*btf_trace_mm_vmscan_throttled)(void *, int, int, int, int);

typedef void (*btf_trace_mm_vmscan_wakeup_kswapd)(void *, int, int, int, gfp_t);

typedef void (*btf_trace_mm_vmscan_write_folio)(void *, struct folio *);

typedef void (*btf_trace_mmap_lock_acquire_returned)(void *, struct mm_struct *, bool, bool);

typedef void (*btf_trace_mmap_lock_released)(void *, struct mm_struct *, bool);

typedef void (*btf_trace_mmap_lock_start_locking)(void *, struct mm_struct *, bool);

typedef void (*btf_trace_mmc_request_done)(void *, struct mmc_host *, struct mmc_request *);

typedef void (*btf_trace_mmc_request_start)(void *, struct mmc_host *, struct mmc_request *);

typedef void (*btf_trace_mod_memcg_lruvec_state)(void *, struct mem_cgroup *, int, int);

typedef void (*btf_trace_mod_memcg_state)(void *, struct mem_cgroup *, int, int);

typedef void (*btf_trace_module_free)(void *, struct module *);

typedef void (*btf_trace_module_get)(void *, struct module *, long unsigned int);

typedef void (*btf_trace_module_load)(void *, struct module *);

typedef void (*btf_trace_module_put)(void *, struct module *, long unsigned int);

typedef void (*btf_trace_module_request)(void *, char *, bool, long unsigned int);

typedef void (*btf_trace_mptcp_sendmsg_frag)(void *, struct mptcp_ext *);

typedef void (*btf_trace_mptcp_subflow_get_send)(void *, struct mptcp_subflow_context *);

typedef void (*btf_trace_napi_gro_frags_entry)(void *, const struct sk_buff *);

typedef void (*btf_trace_napi_gro_frags_exit)(void *, int);

typedef void (*btf_trace_napi_gro_receive_entry)(void *, const struct sk_buff *);

typedef void (*btf_trace_napi_gro_receive_exit)(void *, int);

typedef void (*btf_trace_napi_poll)(void *, struct napi_struct *, int, int);

typedef void (*btf_trace_neigh_cleanup_and_release)(void *, struct neighbour *, int);

typedef void (*btf_trace_neigh_create)(void *, struct neigh_table *, struct net_device *, const void *, const struct neighbour *, bool);

typedef void (*btf_trace_neigh_event_send_dead)(void *, struct neighbour *, int);

typedef void (*btf_trace_neigh_event_send_done)(void *, struct neighbour *, int);

typedef void (*btf_trace_neigh_timer_handler)(void *, struct neighbour *, int);

typedef void (*btf_trace_neigh_update)(void *, struct neighbour *, const u8 *, u8, u32, u32);

typedef void (*btf_trace_neigh_update_done)(void *, struct neighbour *, int);

typedef void (*btf_trace_net_dev_queue)(void *, struct sk_buff *);

typedef void (*btf_trace_net_dev_start_xmit)(void *, const struct sk_buff *, const struct net_device *);

typedef void (*btf_trace_net_dev_xmit)(void *, struct sk_buff *, int, struct net_device *, unsigned int);

typedef void (*btf_trace_net_dev_xmit_timeout)(void *, struct net_device *, int);

typedef void (*btf_trace_netif_receive_skb)(void *, struct sk_buff *);

typedef void (*btf_trace_netif_receive_skb_entry)(void *, const struct sk_buff *);

typedef void (*btf_trace_netif_receive_skb_exit)(void *, int);

typedef void (*btf_trace_netif_receive_skb_list_entry)(void *, const struct sk_buff *);

typedef void (*btf_trace_netif_receive_skb_list_exit)(void *, int);

typedef void (*btf_trace_netif_rx)(void *, struct sk_buff *);

typedef void (*btf_trace_netif_rx_entry)(void *, const struct sk_buff *);

typedef void (*btf_trace_netif_rx_exit)(void *, int);

typedef void (*btf_trace_netlink_extack)(void *, const char *);

typedef void (*btf_trace_non_standard_event)(void *, const guid_t *, const guid_t *, const char *, const u8, const u8 *, const u32);

typedef void (*btf_trace_notifier_register)(void *, void *);

typedef void (*btf_trace_notifier_run)(void *, void *);

typedef void (*btf_trace_notifier_unregister)(void *, void *);

typedef void (*btf_trace_oom_score_adj_update)(void *, struct task_struct *);

typedef void (*btf_trace_page_pool_release)(void *, const struct page_pool *, s32, u32, u32);

typedef void (*btf_trace_page_pool_state_hold)(void *, const struct page_pool *, netmem_ref, u32);

typedef void (*btf_trace_page_pool_state_release)(void *, const struct page_pool *, netmem_ref, u32);

typedef void (*btf_trace_page_pool_update_nid)(void *, const struct page_pool *, int);

typedef void (*btf_trace_pelt_cfs_tp)(void *, struct cfs_rq *);

typedef void (*btf_trace_pelt_dl_tp)(void *, struct rq *);

typedef void (*btf_trace_pelt_hw_tp)(void *, struct rq *);

typedef void (*btf_trace_pelt_irq_tp)(void *, struct rq *);

typedef void (*btf_trace_pelt_rt_tp)(void *, struct rq *);

typedef void (*btf_trace_pelt_se_tp)(void *, struct sched_entity *);

typedef void (*btf_trace_percpu_alloc_percpu)(void *, long unsigned int, bool, bool, size_t, size_t, void *, int, void *, size_t, gfp_t);

typedef void (*btf_trace_percpu_alloc_percpu_fail)(void *, bool, bool, size_t, size_t);

typedef void (*btf_trace_percpu_create_chunk)(void *, void *);

typedef void (*btf_trace_percpu_destroy_chunk)(void *, void *);

typedef void (*btf_trace_percpu_free_percpu)(void *, void *, int, void *);

typedef void (*btf_trace_pm_qos_add_request)(void *, s32);

typedef void (*btf_trace_pm_qos_remove_request)(void *, s32);

typedef void (*btf_trace_pm_qos_update_flags)(void *, enum pm_qos_req_action, int, int);

typedef void (*btf_trace_pm_qos_update_request)(void *, s32);

typedef void (*btf_trace_pm_qos_update_target)(void *, enum pm_qos_req_action, int, int);

typedef void (*btf_trace_posix_lock_inode)(void *, struct inode *, struct file_lock *, int);

typedef void (*btf_trace_power_domain_target)(void *, const char *, unsigned int, unsigned int);

typedef void (*btf_trace_powernv_throttle)(void *, int, const char *, int);

typedef void (*btf_trace_pstate_sample)(void *, u32, u32, u32, u32, u64, u64, u64, u32, u32);

typedef void (*btf_trace_purge_vmap_area_lazy)(void *, long unsigned int, long unsigned int, unsigned int);

typedef void (*btf_trace_pwm_apply)(void *, struct pwm_device *, const struct pwm_state *, int);

typedef void (*btf_trace_pwm_get)(void *, struct pwm_device *, const struct pwm_state *, int);

typedef void (*btf_trace_pwm_read_waveform)(void *, struct pwm_device *, void *, int);

typedef void (*btf_trace_pwm_round_waveform_fromhw)(void *, struct pwm_device *, const void *, struct pwm_waveform *, int);

typedef void (*btf_trace_pwm_round_waveform_tohw)(void *, struct pwm_device *, const struct pwm_waveform *, void *, int);

typedef void (*btf_trace_pwm_write_waveform)(void *, struct pwm_device *, const void *, int);

typedef void (*btf_trace_qdisc_create)(void *, const struct Qdisc_ops *, struct net_device *, u32);

typedef void (*btf_trace_qdisc_dequeue)(void *, struct Qdisc *, const struct netdev_queue *, int, struct sk_buff *);

typedef void (*btf_trace_qdisc_destroy)(void *, struct Qdisc *);

typedef void (*btf_trace_qdisc_enqueue)(void *, struct Qdisc *, const struct netdev_queue *, struct sk_buff *);

typedef void (*btf_trace_qdisc_reset)(void *, struct Qdisc *);

typedef void (*btf_trace_rcu_stall_warning)(void *, const char *, const char *);

typedef void (*btf_trace_rcu_utilization)(void *, const char *);

typedef void (*btf_trace_reclaim_retry_zone)(void *, struct zoneref *, int, long unsigned int, long unsigned int, long unsigned int, int, bool);

typedef void (*btf_trace_regcache_drop_region)(void *, struct regmap *, unsigned int, unsigned int);

typedef void (*btf_trace_regcache_sync)(void *, struct regmap *, const char *, const char *);

typedef void (*btf_trace_regmap_async_complete_done)(void *, struct regmap *);

typedef void (*btf_trace_regmap_async_complete_start)(void *, struct regmap *);

typedef void (*btf_trace_regmap_async_io_complete)(void *, struct regmap *);

typedef void (*btf_trace_regmap_async_write_start)(void *, struct regmap *, unsigned int, int);

typedef void (*btf_trace_regmap_bulk_read)(void *, struct regmap *, unsigned int, const void *, int);

typedef void (*btf_trace_regmap_bulk_write)(void *, struct regmap *, unsigned int, const void *, int);

typedef void (*btf_trace_regmap_cache_bypass)(void *, struct regmap *, bool);

typedef void (*btf_trace_regmap_cache_only)(void *, struct regmap *, bool);

typedef void (*btf_trace_regmap_hw_read_done)(void *, struct regmap *, unsigned int, int);

typedef void (*btf_trace_regmap_hw_read_start)(void *, struct regmap *, unsigned int, int);

typedef void (*btf_trace_regmap_hw_write_done)(void *, struct regmap *, unsigned int, int);

typedef void (*btf_trace_regmap_hw_write_start)(void *, struct regmap *, unsigned int, int);

typedef void (*btf_trace_regmap_reg_read)(void *, struct regmap *, unsigned int, unsigned int);

typedef void (*btf_trace_regmap_reg_read_cache)(void *, struct regmap *, unsigned int, unsigned int);

typedef void (*btf_trace_regmap_reg_write)(void *, struct regmap *, unsigned int, unsigned int);

typedef void (*btf_trace_regulator_bypass_disable)(void *, const char *);

typedef void (*btf_trace_regulator_bypass_disable_complete)(void *, const char *);

typedef void (*btf_trace_regulator_bypass_enable)(void *, const char *);

typedef void (*btf_trace_regulator_bypass_enable_complete)(void *, const char *);

typedef void (*btf_trace_regulator_disable)(void *, const char *);

typedef void (*btf_trace_regulator_disable_complete)(void *, const char *);

typedef void (*btf_trace_regulator_enable)(void *, const char *);

typedef void (*btf_trace_regulator_enable_complete)(void *, const char *);

typedef void (*btf_trace_regulator_enable_delay)(void *, const char *);

typedef void (*btf_trace_regulator_set_voltage)(void *, const char *, int, int);

typedef void (*btf_trace_regulator_set_voltage_complete)(void *, const char *, unsigned int);

typedef void (*btf_trace_remove_device_from_group)(void *, int, struct device *);

typedef void (*btf_trace_remove_migration_pmd)(void *, long unsigned int, long unsigned int);

typedef void (*btf_trace_remove_migration_pte)(void *, long unsigned int, long unsigned int, int);

typedef void (*btf_trace_rpm_idle)(void *, struct device *, int);

typedef void (*btf_trace_rpm_resume)(void *, struct device *, int);

typedef void (*btf_trace_rpm_return_int)(void *, struct device *, long unsigned int, int);

typedef void (*btf_trace_rpm_status)(void *, struct device *, enum rpm_status);

typedef void (*btf_trace_rpm_suspend)(void *, struct device *, int);

typedef void (*btf_trace_rpm_usage)(void *, struct device *, int);

typedef void (*btf_trace_rseq_ip_fixup)(void *, long unsigned int, long unsigned int, long unsigned int, long unsigned int);

typedef void (*btf_trace_rseq_update)(void *, struct task_struct *);

typedef void (*btf_trace_rss_stat)(void *, struct mm_struct *, int);

typedef void (*btf_trace_rtc_alarm_irq_enable)(void *, unsigned int, int);

typedef void (*btf_trace_rtc_irq_set_freq)(void *, int, int);

typedef void (*btf_trace_rtc_irq_set_state)(void *, int, int);

typedef void (*btf_trace_rtc_read_alarm)(void *, time64_t, int);

typedef void (*btf_trace_rtc_read_offset)(void *, long int, int);

typedef void (*btf_trace_rtc_read_time)(void *, time64_t, int);

typedef void (*btf_trace_rtc_set_alarm)(void *, time64_t, int);

typedef void (*btf_trace_rtc_set_offset)(void *, long int, int);

typedef void (*btf_trace_rtc_set_time)(void *, time64_t, int);

typedef void (*btf_trace_rtc_timer_dequeue)(void *, struct rtc_timer *);

typedef void (*btf_trace_rtc_timer_enqueue)(void *, struct rtc_timer *);

typedef void (*btf_trace_rtc_timer_fired)(void *, struct rtc_timer *);

typedef void (*btf_trace_rwmmio_post_read)(void *, long unsigned int, long unsigned int, u64, u8, volatile const void *);

typedef void (*btf_trace_rwmmio_post_write)(void *, long unsigned int, long unsigned int, u64, u8, volatile void *);

typedef void (*btf_trace_rwmmio_read)(void *, long unsigned int, long unsigned int, u8, volatile const void *);

typedef void (*btf_trace_rwmmio_write)(void *, long unsigned int, long unsigned int, u64, u8, volatile void *);

typedef void (*btf_trace_sb_clear_inode_writeback)(void *, struct inode *);

typedef void (*btf_trace_sb_mark_inode_writeback)(void *, struct inode *);

typedef void (*btf_trace_sched_compute_energy_tp)(void *, struct task_struct *, int, long unsigned int, long unsigned int, long unsigned int);

typedef void (*btf_trace_sched_cpu_capacity_tp)(void *, struct rq *);

typedef void (*btf_trace_sched_ext_dump)(void *, const char *);

typedef void (*btf_trace_sched_kthread_stop)(void *, struct task_struct *);

typedef void (*btf_trace_sched_kthread_stop_ret)(void *, int);

typedef void (*btf_trace_sched_kthread_work_execute_end)(void *, struct kthread_work *, kthread_work_func_t);

typedef void (*btf_trace_sched_kthread_work_execute_start)(void *, struct kthread_work *);

typedef void (*btf_trace_sched_kthread_work_queue_work)(void *, struct kthread_worker *, struct kthread_work *);

typedef void (*btf_trace_sched_migrate_task)(void *, struct task_struct *, int);

typedef void (*btf_trace_sched_move_numa)(void *, struct task_struct *, int, int);

typedef void (*btf_trace_sched_overutilized_tp)(void *, struct root_domain *, bool);

typedef void (*btf_trace_sched_pi_setprio)(void *, struct task_struct *, struct task_struct *);

typedef void (*btf_trace_sched_prepare_exec)(void *, struct task_struct *, struct linux_binprm *);

typedef void (*btf_trace_sched_process_exec)(void *, struct task_struct *, pid_t, struct linux_binprm *);

typedef void (*btf_trace_sched_process_exit)(void *, struct task_struct *);

typedef void (*btf_trace_sched_process_fork)(void *, struct task_struct *, struct task_struct *);

typedef void (*btf_trace_sched_process_free)(void *, struct task_struct *);

typedef void (*btf_trace_sched_process_hang)(void *, struct task_struct *);

typedef void (*btf_trace_sched_process_wait)(void *, struct pid *);

typedef void (*btf_trace_sched_stat_blocked)(void *, struct task_struct *, u64);

typedef void (*btf_trace_sched_stat_iowait)(void *, struct task_struct *, u64);

typedef void (*btf_trace_sched_stat_runtime)(void *, struct task_struct *, u64);

typedef void (*btf_trace_sched_stat_sleep)(void *, struct task_struct *, u64);

typedef void (*btf_trace_sched_stat_wait)(void *, struct task_struct *, u64);

typedef void (*btf_trace_sched_stick_numa)(void *, struct task_struct *, int, struct task_struct *, int);

typedef void (*btf_trace_sched_swap_numa)(void *, struct task_struct *, int, struct task_struct *, int);

typedef void (*btf_trace_sched_switch)(void *, bool, struct task_struct *, struct task_struct *, unsigned int);

typedef void (*btf_trace_sched_update_nr_running_tp)(void *, struct rq *, int);

typedef void (*btf_trace_sched_util_est_cfs_tp)(void *, struct cfs_rq *);

typedef void (*btf_trace_sched_util_est_se_tp)(void *, struct sched_entity *);

typedef void (*btf_trace_sched_wait_task)(void *, struct task_struct *);

typedef void (*btf_trace_sched_wake_idle_without_ipi)(void *, int);

typedef void (*btf_trace_sched_wakeup)(void *, struct task_struct *);

typedef void (*btf_trace_sched_wakeup_new)(void *, struct task_struct *);

typedef void (*btf_trace_sched_waking)(void *, struct task_struct *);

typedef void (*btf_trace_scsi_dispatch_cmd_done)(void *, struct scsi_cmnd *);

typedef void (*btf_trace_scsi_dispatch_cmd_error)(void *, struct scsi_cmnd *, int);

typedef void (*btf_trace_scsi_dispatch_cmd_start)(void *, struct scsi_cmnd *);

typedef void (*btf_trace_scsi_dispatch_cmd_timeout)(void *, struct scsi_cmnd *);

typedef void (*btf_trace_scsi_eh_wakeup)(void *, struct Scsi_Host *);

typedef void (*btf_trace_scsi_prepare_zone_append)(void *, struct scsi_cmnd *, sector_t, unsigned int);

typedef void (*btf_trace_scsi_zone_wp_update)(void *, struct scsi_cmnd *, sector_t, unsigned int, unsigned int);

typedef void (*btf_trace_selinux_audited)(void *, struct selinux_audit_data *, char *, char *, const char *);

typedef void (*btf_trace_set_migration_pmd)(void *, long unsigned int, long unsigned int);

typedef void (*btf_trace_set_migration_pte)(void *, long unsigned int, long unsigned int, int);

typedef void (*btf_trace_signal_deliver)(void *, int, struct kernel_siginfo *, struct k_sigaction *);

typedef void (*btf_trace_signal_generate)(void *, int, struct kernel_siginfo *, struct task_struct *, int, int);

typedef void (*btf_trace_sk_data_ready)(void *, const struct sock *);

typedef void (*btf_trace_skb_copy_datagram_iovec)(void *, const struct sk_buff *, int);

typedef void (*btf_trace_skip_task_reaping)(void *, int);

typedef void (*btf_trace_smbus_read)(void *, const struct i2c_adapter *, u16, short unsigned int, char, u8, int);

typedef void (*btf_trace_smbus_reply)(void *, const struct i2c_adapter *, u16, short unsigned int, char, u8, int, const union i2c_smbus_data *, int);

typedef void (*btf_trace_smbus_result)(void *, const struct i2c_adapter *, u16, short unsigned int, char, u8, int, int);

typedef void (*btf_trace_smbus_write)(void *, const struct i2c_adapter *, u16, short unsigned int, char, u8, int, const union i2c_smbus_data *);

typedef void (*btf_trace_sock_exceed_buf_limit)(void *, struct sock *, struct proto *, long int, int);

typedef void (*btf_trace_sock_rcvqueue_full)(void *, struct sock *, struct sk_buff *);

typedef void (*btf_trace_sock_recv_length)(void *, struct sock *, int, int);

typedef void (*btf_trace_sock_send_length)(void *, struct sock *, int, int);

typedef void (*btf_trace_softirq_entry)(void *, unsigned int);

typedef void (*btf_trace_softirq_exit)(void *, unsigned int);

typedef void (*btf_trace_softirq_raise)(void *, unsigned int);

typedef void (*btf_trace_spi_controller_busy)(void *, struct spi_controller *);

typedef void (*btf_trace_spi_controller_idle)(void *, struct spi_controller *);

typedef void (*btf_trace_spi_message_done)(void *, struct spi_message *);

typedef void (*btf_trace_spi_message_start)(void *, struct spi_message *);

typedef void (*btf_trace_spi_message_submit)(void *, struct spi_message *);

typedef void (*btf_trace_spi_set_cs)(void *, struct spi_device *, bool);

typedef void (*btf_trace_spi_setup)(void *, struct spi_device *, int);

typedef void (*btf_trace_spi_transfer_start)(void *, struct spi_message *, struct spi_transfer *);

typedef void (*btf_trace_spi_transfer_stop)(void *, struct spi_message *, struct spi_transfer *);

typedef void (*btf_trace_start_task_reaping)(void *, int);

typedef void (*btf_trace_subflow_check_data_avail)(void *, __u8, struct sk_buff *);

typedef void (*btf_trace_suspend_resume)(void *, const char *, int, bool);

typedef void (*btf_trace_swiotlb_bounced)(void *, struct device *, dma_addr_t, size_t);

typedef void (*btf_trace_sys_enter)(void *, struct pt_regs *, long int);

typedef void (*btf_trace_sys_exit)(void *, struct pt_regs *, long int);

typedef void (*btf_trace_task_newtask)(void *, struct task_struct *, long unsigned int);

typedef void (*btf_trace_task_prctl_unknown)(void *, int, long unsigned int, long unsigned int, long unsigned int, long unsigned int);

typedef void (*btf_trace_task_rename)(void *, struct task_struct *, const char *);

typedef void (*btf_trace_tasklet_entry)(void *, struct tasklet_struct *, void *);

typedef void (*btf_trace_tasklet_exit)(void *, struct tasklet_struct *, void *);

typedef void (*btf_trace_tcp_ao_handshake_failure)(void *, const struct sock *, const struct sk_buff *, const __u8, const __u8, const __u8);

typedef void (*btf_trace_tcp_ao_key_not_found)(void *, const struct sock *, const struct sk_buff *, const __u8, const __u8, const __u8);

typedef void (*btf_trace_tcp_ao_mismatch)(void *, const struct sock *, const struct sk_buff *, const __u8, const __u8, const __u8);

typedef void (*btf_trace_tcp_ao_rcv_sne_update)(void *, const struct sock *, __u32);

typedef void (*btf_trace_tcp_ao_rnext_request)(void *, const struct sock *, const struct sk_buff *, const __u8, const __u8, const __u8);

typedef void (*btf_trace_tcp_ao_snd_sne_update)(void *, const struct sock *, __u32);

typedef void (*btf_trace_tcp_ao_synack_no_key)(void *, const struct sock *, const __u8, const __u8);

typedef void (*btf_trace_tcp_ao_wrong_maclen)(void *, const struct sock *, const struct sk_buff *, const __u8, const __u8, const __u8);

typedef void (*btf_trace_tcp_bad_csum)(void *, const struct sk_buff *);

typedef void (*btf_trace_tcp_cong_state_set)(void *, struct sock *, const u8);

typedef void (*btf_trace_tcp_destroy_sock)(void *, struct sock *);

typedef void (*btf_trace_tcp_hash_ao_required)(void *, const struct sock *, const struct sk_buff *);

typedef void (*btf_trace_tcp_hash_bad_header)(void *, const struct sock *, const struct sk_buff *);

typedef void (*btf_trace_tcp_hash_md5_mismatch)(void *, const struct sock *, const struct sk_buff *);

typedef void (*btf_trace_tcp_hash_md5_required)(void *, const struct sock *, const struct sk_buff *);

typedef void (*btf_trace_tcp_hash_md5_unexpected)(void *, const struct sock *, const struct sk_buff *);

typedef void (*btf_trace_tcp_probe)(void *, struct sock *, struct sk_buff *);

typedef void (*btf_trace_tcp_rcv_space_adjust)(void *, struct sock *);

typedef void (*btf_trace_tcp_receive_reset)(void *, struct sock *);

typedef void (*btf_trace_tcp_retransmit_skb)(void *, const struct sock *, const struct sk_buff *);

typedef void (*btf_trace_tcp_retransmit_synack)(void *, const struct sock *, const struct request_sock *);

typedef void (*btf_trace_tcp_send_reset)(void *, const struct sock *, const struct sk_buff *, const enum sk_rst_reason);

typedef void (*btf_trace_test_pages_isolated)(void *, long unsigned int, long unsigned int, long unsigned int);

typedef void (*btf_trace_thermal_power_cpu_get_power_simple)(void *, int, u32);

typedef void (*btf_trace_thermal_power_cpu_limit)(void *, const struct cpumask *, unsigned int, long unsigned int, u32);

typedef void (*btf_trace_thermal_power_devfreq_get_power)(void *, struct thermal_cooling_device *, struct devfreq_dev_status *, long unsigned int, u32);

typedef void (*btf_trace_thermal_power_devfreq_limit)(void *, struct thermal_cooling_device *, long unsigned int, long unsigned int, u32);

typedef void (*btf_trace_thermal_temperature)(void *, struct thermal_zone_device *);

typedef void (*btf_trace_thermal_zone_trip)(void *, struct thermal_zone_device *, int, enum thermal_trip_type);

typedef void (*btf_trace_tick_stop)(void *, int, int);

typedef void (*btf_trace_time_out_leases)(void *, struct inode *, struct file_lease *);

typedef void (*btf_trace_timer_base_idle)(void *, bool, unsigned int);

typedef void (*btf_trace_timer_cancel)(void *, struct timer_list *);

typedef void (*btf_trace_timer_expire_entry)(void *, struct timer_list *, long unsigned int);

typedef void (*btf_trace_timer_expire_exit)(void *, struct timer_list *);

typedef void (*btf_trace_timer_init)(void *, struct timer_list *);

typedef void (*btf_trace_timer_start)(void *, struct timer_list *, long unsigned int);

typedef void (*btf_trace_tlb_flush)(void *, int, long unsigned int);

typedef void (*btf_trace_tls_alert_recv)(void *, const struct sock *, unsigned char, unsigned char);

typedef void (*btf_trace_tls_alert_send)(void *, const struct sock *, unsigned char, unsigned char);

typedef void (*btf_trace_tls_contenttype)(void *, const struct sock *, unsigned char);

typedef void (*btf_trace_tmigr_connect_child_parent)(void *, struct tmigr_group *);

typedef void (*btf_trace_tmigr_connect_cpu_parent)(void *, struct tmigr_cpu *);

typedef void (*btf_trace_tmigr_cpu_active)(void *, struct tmigr_cpu *);

typedef void (*btf_trace_tmigr_cpu_idle)(void *, struct tmigr_cpu *, u64);

typedef void (*btf_trace_tmigr_cpu_new_timer)(void *, struct tmigr_cpu *);

typedef void (*btf_trace_tmigr_cpu_new_timer_idle)(void *, struct tmigr_cpu *, u64);

typedef void (*btf_trace_tmigr_cpu_offline)(void *, struct tmigr_cpu *);

typedef void (*btf_trace_tmigr_cpu_online)(void *, struct tmigr_cpu *);

typedef void (*btf_trace_tmigr_group_set)(void *, struct tmigr_group *);

typedef void (*btf_trace_tmigr_group_set_cpu_active)(void *, struct tmigr_group *, union tmigr_state, u32);

typedef void (*btf_trace_tmigr_group_set_cpu_inactive)(void *, struct tmigr_group *, union tmigr_state, u32);

typedef void (*btf_trace_tmigr_handle_remote)(void *, struct tmigr_group *);

typedef void (*btf_trace_tmigr_handle_remote_cpu)(void *, struct tmigr_cpu *);

typedef void (*btf_trace_tmigr_update_events)(void *, struct tmigr_group *, struct tmigr_group *, union tmigr_state, union tmigr_state, u64);

typedef void (*btf_trace_track_foreign_dirty)(void *, struct folio *, struct bdi_writeback *);

typedef void (*btf_trace_udp_fail_queue_rcv_skb)(void *, int, struct sock *, struct sk_buff *);

typedef void (*btf_trace_unmap)(void *, long unsigned int, size_t, size_t);

typedef void (*btf_trace_user_enter)(void *, int);

typedef void (*btf_trace_user_exit)(void *, int);

typedef void (*btf_trace_vgic_update_irq_pending)(void *, long unsigned int, __u32, bool);

typedef void (*btf_trace_vm_unmapped_area)(void *, long unsigned int, struct vm_unmapped_area_info *);

typedef void (*btf_trace_vma_mas_szero)(void *, struct maple_tree *, long unsigned int, long unsigned int);

typedef void (*btf_trace_vma_store)(void *, struct maple_tree *, struct vm_area_struct *);

typedef void (*btf_trace_wake_reaper)(void *, int);

typedef void (*btf_trace_wakeup_source_activate)(void *, const char *, unsigned int);

typedef void (*btf_trace_wakeup_source_deactivate)(void *, const char *, unsigned int);

typedef void (*btf_trace_watchdog_ping)(void *, struct watchdog_device *, int);

typedef void (*btf_trace_watchdog_set_timeout)(void *, struct watchdog_device *, unsigned int, int);

typedef void (*btf_trace_watchdog_start)(void *, struct watchdog_device *, int);

typedef void (*btf_trace_watchdog_stop)(void *, struct watchdog_device *, int);

typedef void (*btf_trace_wbc_writepage)(void *, struct writeback_control *, struct backing_dev_info *);

typedef void (*btf_trace_wbt_lat)(void *, struct backing_dev_info *, long unsigned int);

typedef void (*btf_trace_wbt_stat)(void *, struct backing_dev_info *, struct blk_rq_stat *);

typedef void (*btf_trace_wbt_step)(void *, struct backing_dev_info *, const char *, int, long unsigned int, unsigned int, unsigned int, unsigned int);

typedef void (*btf_trace_wbt_timer)(void *, struct backing_dev_info *, unsigned int, int, unsigned int);

typedef void (*btf_trace_workqueue_activate_work)(void *, struct work_struct *);

typedef void (*btf_trace_workqueue_execute_end)(void *, struct work_struct *, work_func_t);

typedef void (*btf_trace_workqueue_execute_start)(void *, struct work_struct *);

typedef void (*btf_trace_workqueue_queue_work)(void *, int, struct pool_workqueue *, struct work_struct *);

typedef void (*btf_trace_writeback_bdi_register)(void *, struct backing_dev_info *);

typedef void (*btf_trace_writeback_dirty_folio)(void *, struct folio *, struct address_space *);

typedef void (*btf_trace_writeback_dirty_inode)(void *, struct inode *, int);

typedef void (*btf_trace_writeback_dirty_inode_enqueue)(void *, struct inode *);

typedef void (*btf_trace_writeback_dirty_inode_start)(void *, struct inode *, int);

typedef void (*btf_trace_writeback_exec)(void *, struct bdi_writeback *, struct wb_writeback_work *);

typedef void (*btf_trace_writeback_lazytime)(void *, struct inode *);

typedef void (*btf_trace_writeback_lazytime_iput)(void *, struct inode *);

typedef void (*btf_trace_writeback_mark_inode_dirty)(void *, struct inode *, int);

typedef void (*btf_trace_writeback_pages_written)(void *, long int);

typedef void (*btf_trace_writeback_queue)(void *, struct bdi_writeback *, struct wb_writeback_work *);

typedef void (*btf_trace_writeback_queue_io)(void *, struct bdi_writeback *, struct wb_writeback_work *, long unsigned int, int);

typedef void (*btf_trace_writeback_sb_inodes_requeue)(void *, struct inode *);

typedef void (*btf_trace_writeback_single_inode)(void *, struct inode *, struct writeback_control *, long unsigned int);

typedef void (*btf_trace_writeback_single_inode_start)(void *, struct inode *, struct writeback_control *, long unsigned int);

typedef void (*btf_trace_writeback_start)(void *, struct bdi_writeback *, struct wb_writeback_work *);

typedef void (*btf_trace_writeback_wait)(void *, struct bdi_writeback *, struct wb_writeback_work *);

typedef void (*btf_trace_writeback_wake_background)(void *, struct bdi_writeback *);

typedef void (*btf_trace_writeback_write_inode)(void *, struct inode *, struct writeback_control *);

typedef void (*btf_trace_writeback_write_inode_start)(void *, struct inode *, struct writeback_control *);

typedef void (*btf_trace_writeback_written)(void *, struct bdi_writeback *, struct wb_writeback_work *);

typedef void (*btf_trace_xdp_bulk_tx)(void *, const struct net_device *, int, int, int);

typedef void (*btf_trace_xdp_cpumap_enqueue)(void *, int, unsigned int, unsigned int, int);

typedef void (*btf_trace_xdp_cpumap_kthread)(void *, int, unsigned int, unsigned int, int, struct xdp_cpumap_stats *);

typedef void (*btf_trace_xdp_devmap_xmit)(void *, const struct net_device *, const struct net_device *, int, int, int);

typedef void (*btf_trace_xdp_exception)(void *, const struct net_device *, const struct bpf_prog *, u32);

typedef void (*btf_trace_xdp_redirect)(void *, const struct net_device *, const struct bpf_prog *, const void *, int, enum bpf_map_type, u32, u32);

typedef void (*btf_trace_xdp_redirect_err)(void *, const struct net_device *, const struct bpf_prog *, const void *, int, enum bpf_map_type, u32, u32);

typedef void (*btf_trace_xdp_redirect_map)(void *, const struct net_device *, const struct bpf_prog *, const void *, int, enum bpf_map_type, u32, u32);

typedef void (*btf_trace_xdp_redirect_map_err)(void *, const struct net_device *, const struct bpf_prog *, const void *, int, enum bpf_map_type, u32, u32);

typedef void (*btf_trace_xhci_add_endpoint)(void *, struct xhci_ep_ctx *);

typedef void (*btf_trace_xhci_address_ctrl_ctx)(void *, struct xhci_input_control_ctx *);

typedef void (*btf_trace_xhci_address_ctx)(void *, struct xhci_hcd *, struct xhci_container_ctx *, unsigned int);

typedef void (*btf_trace_xhci_alloc_dev)(void *, struct xhci_slot_ctx *);

typedef void (*btf_trace_xhci_alloc_stream_info_ctx)(void *, struct xhci_stream_info *, unsigned int);

typedef void (*btf_trace_xhci_alloc_virt_device)(void *, struct xhci_virt_device *);

typedef void (*btf_trace_xhci_configure_endpoint)(void *, struct xhci_slot_ctx *);

typedef void (*btf_trace_xhci_configure_endpoint_ctrl_ctx)(void *, struct xhci_input_control_ctx *);

typedef void (*btf_trace_xhci_dbc_alloc_request)(void *, struct dbc_request *);

typedef void (*btf_trace_xhci_dbc_free_request)(void *, struct dbc_request *);

typedef void (*btf_trace_xhci_dbc_gadget_ep_queue)(void *, struct xhci_ring *, struct xhci_generic_trb *, dma_addr_t);

typedef void (*btf_trace_xhci_dbc_giveback_request)(void *, struct dbc_request *);

typedef void (*btf_trace_xhci_dbc_handle_event)(void *, struct xhci_ring *, struct xhci_generic_trb *, dma_addr_t);

typedef void (*btf_trace_xhci_dbc_handle_transfer)(void *, struct xhci_ring *, struct xhci_generic_trb *, dma_addr_t);

typedef void (*btf_trace_xhci_dbc_queue_request)(void *, struct dbc_request *);

typedef void (*btf_trace_xhci_dbg_address)(void *, struct va_format *);

typedef void (*btf_trace_xhci_dbg_cancel_urb)(void *, struct va_format *);

typedef void (*btf_trace_xhci_dbg_context_change)(void *, struct va_format *);

typedef void (*btf_trace_xhci_dbg_init)(void *, struct va_format *);

typedef void (*btf_trace_xhci_dbg_quirks)(void *, struct va_format *);

typedef void (*btf_trace_xhci_dbg_reset_ep)(void *, struct va_format *);

typedef void (*btf_trace_xhci_dbg_ring_expansion)(void *, struct va_format *);

typedef void (*btf_trace_xhci_discover_or_reset_device)(void *, struct xhci_slot_ctx *);

typedef void (*btf_trace_xhci_free_dev)(void *, struct xhci_slot_ctx *);

typedef void (*btf_trace_xhci_free_virt_device)(void *, struct xhci_virt_device *);

typedef void (*btf_trace_xhci_get_port_status)(void *, struct xhci_port *, u32);

typedef void (*btf_trace_xhci_handle_cmd_addr_dev)(void *, struct xhci_slot_ctx *);

typedef void (*btf_trace_xhci_handle_cmd_config_ep)(void *, struct xhci_ep_ctx *);

typedef void (*btf_trace_xhci_handle_cmd_disable_slot)(void *, struct xhci_slot_ctx *);

typedef void (*btf_trace_xhci_handle_cmd_reset_dev)(void *, struct xhci_slot_ctx *);

typedef void (*btf_trace_xhci_handle_cmd_reset_ep)(void *, struct xhci_ep_ctx *);

typedef void (*btf_trace_xhci_handle_cmd_set_deq)(void *, struct xhci_slot_ctx *);

typedef void (*btf_trace_xhci_handle_cmd_set_deq_ep)(void *, struct xhci_ep_ctx *);

typedef void (*btf_trace_xhci_handle_cmd_set_deq_stream)(void *, struct xhci_stream_info *, unsigned int);

typedef void (*btf_trace_xhci_handle_cmd_stop_ep)(void *, struct xhci_ep_ctx *);

typedef void (*btf_trace_xhci_handle_command)(void *, struct xhci_ring *, struct xhci_generic_trb *, dma_addr_t);

typedef void (*btf_trace_xhci_handle_event)(void *, struct xhci_ring *, struct xhci_generic_trb *, dma_addr_t);

typedef void (*btf_trace_xhci_handle_port_status)(void *, struct xhci_port *, u32);

typedef void (*btf_trace_xhci_handle_transfer)(void *, struct xhci_ring *, struct xhci_generic_trb *, dma_addr_t);

typedef void (*btf_trace_xhci_hub_status_data)(void *, struct xhci_port *, u32);

typedef void (*btf_trace_xhci_inc_deq)(void *, struct xhci_ring *);

typedef void (*btf_trace_xhci_inc_enq)(void *, struct xhci_ring *);

typedef void (*btf_trace_xhci_queue_trb)(void *, struct xhci_ring *, struct xhci_generic_trb *, dma_addr_t);

typedef void (*btf_trace_xhci_ring_alloc)(void *, struct xhci_ring *);

typedef void (*btf_trace_xhci_ring_ep_doorbell)(void *, u32, u32);

typedef void (*btf_trace_xhci_ring_expansion)(void *, struct xhci_ring *);

typedef void (*btf_trace_xhci_ring_free)(void *, struct xhci_ring *);

typedef void (*btf_trace_xhci_ring_host_doorbell)(void *, u32, u32);

typedef void (*btf_trace_xhci_setup_addressable_virt_device)(void *, struct xhci_virt_device *);

typedef void (*btf_trace_xhci_setup_device)(void *, struct xhci_virt_device *);

typedef void (*btf_trace_xhci_setup_device_slot)(void *, struct xhci_slot_ctx *);

typedef void (*btf_trace_xhci_stop_device)(void *, struct xhci_virt_device *);

typedef void (*btf_trace_xhci_urb_dequeue)(void *, struct urb *);

typedef void (*btf_trace_xhci_urb_enqueue)(void *, struct urb *);

typedef void (*btf_trace_xhci_urb_giveback)(void *, struct urb *);

typedef int (*cb_t)(struct param *);

typedef void cleanup_cb_t(struct rq_wait *, void *);

typedef int (*cmp_r_func_t)(const void *, const void *, const void *);

typedef void (*companion_fn)(struct pci_dev *, struct usb_hcd *, struct pci_dev *, struct usb_hcd *);

typedef enum trap_behaviour (*complex_condition_check)(struct kvm_vcpu *);

typedef int cont_fn(struct opal_dev *);

typedef void detailed_cb(const struct detailed_timing *, void *);

typedef void * (*devcon_match_fn_t)(const struct fwnode_handle *, const char *, void *);

typedef int (*device_iter_t)(struct device *, void *);

typedef int (*device_match_t)(struct device *, const void *);

typedef int devlink_chunk_fill_t(void *, u8 *, u32, u64, struct netlink_ext_ack *);

typedef int devlink_nl_dump_one_func_t(struct sk_buff *, struct devlink *, struct netlink_callback *, int);

typedef int (*dr_match_t)(struct device *, void *, void *);

typedef int drm_ioctl_compat_t(struct file *, unsigned int, long unsigned int);

typedef bool (*drm_vblank_get_scanout_position_func)(struct drm_crtc *, bool, int *, int *, ktime_t *, ktime_t *, const struct drm_display_mode *);

typedef int (*dummy_ops_test_ret_fn)(struct bpf_dummy_ops_state *, ...);

typedef int (*dynevent_check_arg_fn_t)(void *);

typedef efi_status_t (*efi_exit_boot_map_processing)(struct efi_boot_memmap *, void *);

typedef int (*efi_memattr_perm_setter)(struct mm_struct *, efi_memory_desc_t *, bool);

typedef int (*entry_fn_t)(struct vgic_its *, u32, void *, void *);

typedef void (*ethnl_notify_handler_t)(struct net_device *, unsigned int, const void *);

typedef int (*exit_handle_fn)(struct kvm_vcpu *);

typedef bool (*exit_handler_fn)(struct kvm_vcpu *, u64 *);

typedef void (*exitcall_t)(void);

typedef int (*ext4_mballoc_query_range_fn)(struct super_block *, ext4_group_t, ext4_grpblk_t, ext4_grpblk_t, void *);

typedef void ext4_update_sb_callback(struct ext4_super_block *, const void *);

typedef int filler_t(struct file *, struct folio *);

typedef bool (*filter_func_t)(struct uprobe_consumer *, struct mm_struct *);

typedef void fn_handler_fn(struct vc_data *);

typedef void free_folio_t(struct folio *, long unsigned int);

typedef int (*ftrace_mapper_func)(void *);

typedef access_mask_t get_access_mask_t(const struct landlock_ruleset * const, const u16);

typedef int (*get_char_func)(void);

typedef struct sk_buff * (*gro_receive_sk_t)(struct sock *, struct list_head *, struct sk_buff *);

typedef struct sk_buff * (*gro_receive_t)(struct list_head *, struct sk_buff *);

typedef void (*hcall_t)(struct kvm_cpu_context *);

typedef bool (*hid_usage_cmp_t)(struct hid_usage *, unsigned int, unsigned int);

typedef u32 inet6_ehashfn_t(const struct net *, const struct in6_addr *, const u16, const struct in6_addr *, const __be16);

typedef u32 inet_ehashfn_t(const struct net *, const __be32, const __u16, const __be32, const __be16);

typedef int (*initxattrs)(struct inode *, const struct xattr *, void *);

typedef struct dentry *instantiate_t(struct dentry *, struct task_struct *, const void *);

typedef void (*iomap_punch_t)(struct inode *, loff_t, loff_t, struct iomap *);

typedef int (*ioremap_prot_hook_t)(phys_addr_t, size_t, pgprot_t *);

typedef size_t (*iov_step_f)(void *, size_t, size_t, void *, void *);

typedef size_t (*iov_ustep_f)(void *, size_t, size_t, void *, void *);

typedef int (*iova_bitmap_fn_t)(struct iova_bitmap *, long unsigned int, size_t, void *);

typedef void ip6_icmp_send_t(struct sk_buff *, u8, u8, __u32, const struct in6_addr *, const struct inet6_skb_parm *);

typedef void (*irq_write_msi_msg_t)(struct msi_desc *, struct msi_msg *);

typedef struct its_collection * (*its_cmd_builder_t)(struct its_node *, struct its_cmd_block *, struct its_cmd_desc *);

typedef struct its_vpe * (*its_cmd_vbuilder_t)(struct its_node *, struct its_cmd_block *, struct its_cmd_desc *);

typedef void k_handler_fn(struct vc_data *, unsigned char, char);

typedef void kpti_remap_fn(int, int, phys_addr_t, long unsigned int);

typedef bool (*kunwind_consume_fn)(const struct kunwind_state *, void *);

typedef int (*list_cmp_func_t)(void *, const struct list_head *, const struct list_head *);

typedef enum lru_status (*list_lru_walk_cb)(struct list_head *, struct list_lru_one *, void *);

typedef int mh_filter_t(struct sock *, struct sk_buff *);

typedef void (*move_fn_t)(struct lruvec *, struct folio *);

typedef int (*netlink_filter_fn)(struct sock *, struct sk_buff *, void *);

typedef struct folio *new_folio_t(struct folio *, long unsigned int);

typedef struct ns_common *ns_get_path_helper_t(void *);

typedef int (*objpool_init_obj_cb)(void *, void *);

typedef struct gpio_desc * (*of_find_gpio_quirk)(struct device_node *, const char *, unsigned int, enum of_gpio_flags *);

typedef void (*of_init_fn_1)(struct device_node *);

typedef int (*of_init_fn_1_ret)(struct device_node *);

typedef int (*of_init_fn_2)(struct device_node *, struct device_node *);

typedef int (*parse_pred_fn)(const char *, void *, int, struct filter_parse_error *, struct filter_pred **);

typedef int (*parse_unknown_fn)(char *, char *, const char *, void *);

typedef void (*pci_parity_check_fn_t)(struct pci_dev *);

typedef int (*pcie_callback_t)(struct pcie_device *);

typedef int pcpu_fc_cpu_distance_fn_t(unsigned int, unsigned int);

typedef int pcpu_fc_cpu_to_node_fn_t(int);

typedef void perf_iterate_f(struct perf_event *, void *);

typedef int perf_snapshot_branch_stack_t(struct perf_branch_entry *, unsigned int);

typedef int (*pm_callback_t)(struct device *);

typedef struct rt6_info * (*pol_lookup_t)(struct net *, struct fib6_table *, struct flowi6 *, const struct sk_buff *, int);

typedef int (*pp_nl_fill_cb)(struct sk_buff *, const struct page_pool *, const struct genl_info *);

typedef int (*proc_visitor)(struct task_struct *, void *);

typedef long unsigned int psci_fn(long unsigned int, long unsigned int, long unsigned int, long unsigned int);

typedef int (*psci_initcall_t)(const struct device_node *);

typedef bool pstate_check_t(long unsigned int);

typedef int (*pte_fn_t)(pte_t *, long unsigned int, void *);

typedef int read_block_fn(void *, u8 *, unsigned int, size_t);

typedef int (*reservedmem_of_init_fn)(struct reserved_mem *);

typedef bool (*ring_buffer_cond_fn)(void *);

typedef bool (*sb_for_each_fn)(struct sbitmap *, unsigned int, void *);

typedef int (*sendmsg_func)(struct sock *, struct msghdr *);

typedef void (*serial8250_isa_config_fn)(int, struct uart_port *, u32 *);

typedef int (*set_callee_state_fn)(struct bpf_verifier_env *, struct bpf_func_state *, struct bpf_func_state *, int);

typedef struct scatterlist *sg_alloc_fn(unsigned int, gfp_t);

typedef void sg_free_fn(struct scatterlist *, unsigned int);

typedef void sha1_block_fn(struct sha1_state *, const u8 *, int);

typedef void sha256_block_fn(struct sha256_state *, const u8 *, int);

typedef void sha512_block_fn(struct sha512_state *, const u8 *, int);

typedef bool (*smp_cond_func_t)(int, void *);

typedef int splice_actor(struct pipe_inode_info *, struct pipe_buffer *, struct splice_desc *);

typedef int splice_direct_actor(struct pipe_inode_info *, struct splice_desc *);

typedef void (*swap_r_func_t)(void *, void *, int, const void *);

typedef void (*synth_probe_func_t)(void *, u64 *, unsigned int *);

typedef long int (*syscall_fn_t)(const struct pt_regs *);

typedef int (*task_call_f)(struct task_struct *, void *);

typedef void (*task_work_func_t)(struct callback_head *);

typedef void text_poke_f(void *, void *, size_t, size_t);

typedef int (*tg_visitor)(struct task_group *, void *);

typedef void ttbr_replace_func(phys_addr_t);

typedef struct sock * (*udp_lookup_t)(const struct sk_buff *, __be16, __be16);

typedef bool (*up_f)(struct tmigr_group *, struct tmigr_group *, struct tmigr_walk *);

typedef void (*user_event_func_t)(struct user_event *, struct iov_iter *, void *, bool *);

typedef void (*visitor128_t)(void *, long unsigned int, u64, u64, size_t);

typedef void (*visitor32_t)(void *, long unsigned int, u32, size_t);

typedef void (*visitor64_t)(void *, long unsigned int, u64, size_t);

typedef void (*visitorl_t)(void *, long unsigned int, long unsigned int, size_t);

typedef int wait_bit_action_f(struct wait_bit_key *, int);

typedef int (*wext_ioctl_func)(struct net_device *, struct iwreq *, unsigned int, struct iw_request_info *, iw_handler);

typedef int (*writepage_t)(struct folio *, struct writeback_control *, void *);

typedef void (*xhci_get_quirks_t)(struct device *, struct xhci_hcd *);

struct nf_bridge_frag_data;

struct acpi_device;

struct bpf_iter;

struct creds;

struct fsverity_info;

struct pctldev;


/* BPF kfuncs */
#ifndef BPF_NO_KFUNC_PROTOTYPES
extern void *bpf_arena_alloc_pages(void *p__map, void *addr__ign, u32 page_cnt, int node_id, u64 flags) __weak __ksym;
extern void bpf_arena_free_pages(void *p__map, void *ptr__ign, u32 page_cnt) __weak __ksym;
extern __bpf_fastcall void *bpf_cast_to_kern_ctx(void *obj) __weak __ksym;
extern struct cgroup *bpf_cgroup_acquire(struct cgroup *cgrp) __weak __ksym;
extern struct cgroup *bpf_cgroup_ancestor(struct cgroup *cgrp, int level) __weak __ksym;
extern struct cgroup *bpf_cgroup_from_id(u64 cgid) __weak __ksym;
extern void bpf_cgroup_release(struct cgroup *cgrp) __weak __ksym;
extern int bpf_copy_from_user_str(void *dst, u32 dst__sz, const void *unsafe_ptr__ign, u64 flags) __weak __ksym;
extern struct bpf_cpumask *bpf_cpumask_acquire(struct bpf_cpumask *cpumask) __weak __ksym;
extern bool bpf_cpumask_and(struct bpf_cpumask *dst, const struct cpumask *src1, const struct cpumask *src2) __weak __ksym;
extern u32 bpf_cpumask_any_and_distribute(const struct cpumask *src1, const struct cpumask *src2) __weak __ksym;
extern u32 bpf_cpumask_any_distribute(const struct cpumask *cpumask) __weak __ksym;
extern void bpf_cpumask_clear(struct bpf_cpumask *cpumask) __weak __ksym;
extern void bpf_cpumask_clear_cpu(u32 cpu, struct bpf_cpumask *cpumask) __weak __ksym;
extern void bpf_cpumask_copy(struct bpf_cpumask *dst, const struct cpumask *src) __weak __ksym;
extern struct bpf_cpumask *bpf_cpumask_create(void) __weak __ksym;
extern bool bpf_cpumask_empty(const struct cpumask *cpumask) __weak __ksym;
extern bool bpf_cpumask_equal(const struct cpumask *src1, const struct cpumask *src2) __weak __ksym;
extern u32 bpf_cpumask_first(const struct cpumask *cpumask) __weak __ksym;
extern u32 bpf_cpumask_first_and(const struct cpumask *src1, const struct cpumask *src2) __weak __ksym;
extern u32 bpf_cpumask_first_zero(const struct cpumask *cpumask) __weak __ksym;
extern bool bpf_cpumask_full(const struct cpumask *cpumask) __weak __ksym;
extern bool bpf_cpumask_intersects(const struct cpumask *src1, const struct cpumask *src2) __weak __ksym;
extern void bpf_cpumask_or(struct bpf_cpumask *dst, const struct cpumask *src1, const struct cpumask *src2) __weak __ksym;
extern void bpf_cpumask_release(struct bpf_cpumask *cpumask) __weak __ksym;
extern void bpf_cpumask_set_cpu(u32 cpu, struct bpf_cpumask *cpumask) __weak __ksym;
extern void bpf_cpumask_setall(struct bpf_cpumask *cpumask) __weak __ksym;
extern bool bpf_cpumask_subset(const struct cpumask *src1, const struct cpumask *src2) __weak __ksym;
extern bool bpf_cpumask_test_and_clear_cpu(u32 cpu, struct bpf_cpumask *cpumask) __weak __ksym;
extern bool bpf_cpumask_test_and_set_cpu(u32 cpu, struct bpf_cpumask *cpumask) __weak __ksym;
extern bool bpf_cpumask_test_cpu(u32 cpu, const struct cpumask *cpumask) __weak __ksym;
extern u32 bpf_cpumask_weight(const struct cpumask *cpumask) __weak __ksym;
extern void bpf_cpumask_xor(struct bpf_cpumask *dst, const struct cpumask *src1, const struct cpumask *src2) __weak __ksym;
extern struct bpf_crypto_ctx *bpf_crypto_ctx_acquire(struct bpf_crypto_ctx *ctx) __weak __ksym;
extern struct bpf_crypto_ctx *bpf_crypto_ctx_create(const struct bpf_crypto_params *params, u32 params__sz, int *err) __weak __ksym;
extern void bpf_crypto_ctx_release(struct bpf_crypto_ctx *ctx) __weak __ksym;
extern int bpf_crypto_decrypt(struct bpf_crypto_ctx *ctx, const struct bpf_dynptr *src, const struct bpf_dynptr *dst, const struct bpf_dynptr *siv__nullable) __weak __ksym;
extern int bpf_crypto_encrypt(struct bpf_crypto_ctx *ctx, const struct bpf_dynptr *src, const struct bpf_dynptr *dst, const struct bpf_dynptr *siv__nullable) __weak __ksym;
extern int bpf_dynptr_adjust(const struct bpf_dynptr *p, u32 start, u32 end) __weak __ksym;
extern int bpf_dynptr_clone(const struct bpf_dynptr *p, struct bpf_dynptr *clone__uninit) __weak __ksym;
extern int bpf_dynptr_from_skb(struct __sk_buff *s, u64 flags, struct bpf_dynptr *ptr__uninit) __weak __ksym;
extern int bpf_dynptr_from_xdp(struct xdp_md *x, u64 flags, struct bpf_dynptr *ptr__uninit) __weak __ksym;
extern bool bpf_dynptr_is_null(const struct bpf_dynptr *p) __weak __ksym;
extern bool bpf_dynptr_is_rdonly(const struct bpf_dynptr *p) __weak __ksym;
extern __u32 bpf_dynptr_size(const struct bpf_dynptr *p) __weak __ksym;
extern void *bpf_dynptr_slice(const struct bpf_dynptr *p, u32 offset, void *buffer__opt, u32 buffer__szk) __weak __ksym;
extern void *bpf_dynptr_slice_rdwr(const struct bpf_dynptr *p, u32 offset, void *buffer__opt, u32 buffer__szk) __weak __ksym;
extern int bpf_fentry_test1(int a) __weak __ksym;
extern struct kmem_cache *bpf_get_kmem_cache(u64 addr) __weak __ksym;
extern void bpf_iter_bits_destroy(struct bpf_iter_bits *it) __weak __ksym;
extern int bpf_iter_bits_new(struct bpf_iter_bits *it, const u64 *unsafe_ptr__ign, u32 nr_words) __weak __ksym;
extern int *bpf_iter_bits_next(struct bpf_iter_bits *it) __weak __ksym;
extern void bpf_iter_css_destroy(struct bpf_iter_css *it) __weak __ksym;
extern int bpf_iter_css_new(struct bpf_iter_css *it, struct cgroup_subsys_state *start, unsigned int flags) __weak __ksym;
extern struct cgroup_subsys_state *bpf_iter_css_next(struct bpf_iter_css *it) __weak __ksym;
extern void bpf_iter_css_task_destroy(struct bpf_iter_css_task *it) __weak __ksym;
extern int bpf_iter_css_task_new(struct bpf_iter_css_task *it, struct cgroup_subsys_state *css, unsigned int flags) __weak __ksym;
extern struct task_struct *bpf_iter_css_task_next(struct bpf_iter_css_task *it) __weak __ksym;
extern void bpf_iter_kmem_cache_destroy(struct bpf_iter_kmem_cache *it) __weak __ksym;
extern int bpf_iter_kmem_cache_new(struct bpf_iter_kmem_cache *it) __weak __ksym;
extern struct kmem_cache *bpf_iter_kmem_cache_next(struct bpf_iter_kmem_cache *it) __weak __ksym;
extern void bpf_iter_num_destroy(struct bpf_iter_num *it) __weak __ksym;
extern int bpf_iter_num_new(struct bpf_iter_num *it, int start, int end) __weak __ksym;
extern int *bpf_iter_num_next(struct bpf_iter_num *it) __weak __ksym;
extern void bpf_iter_scx_dsq_destroy(struct bpf_iter_scx_dsq *it) __weak __ksym;
extern int bpf_iter_scx_dsq_new(struct bpf_iter_scx_dsq *it, u64 dsq_id, u64 flags) __weak __ksym;
extern struct task_struct *bpf_iter_scx_dsq_next(struct bpf_iter_scx_dsq *it) __weak __ksym;
extern void bpf_iter_task_destroy(struct bpf_iter_task *it) __weak __ksym;
extern int bpf_iter_task_new(struct bpf_iter_task *it, struct task_struct *task__nullable, unsigned int flags) __weak __ksym;
extern struct task_struct *bpf_iter_task_next(struct bpf_iter_task *it) __weak __ksym;
extern void bpf_iter_task_vma_destroy(struct bpf_iter_task_vma *it) __weak __ksym;
extern int bpf_iter_task_vma_new(struct bpf_iter_task_vma *it, struct task_struct *task, u64 addr) __weak __ksym;
extern struct vm_area_struct *bpf_iter_task_vma_next(struct bpf_iter_task_vma *it) __weak __ksym;
extern void bpf_key_put(struct bpf_key *bkey) __weak __ksym;
extern void bpf_kfunc_call_memb_release(struct prog_test_member *p) __weak __ksym;
extern void bpf_kfunc_call_test_release(struct prog_test_ref_kfunc *p) __weak __ksym;
extern struct bpf_list_node *bpf_list_pop_back(struct bpf_list_head *head) __weak __ksym;
extern struct bpf_list_node *bpf_list_pop_front(struct bpf_list_head *head) __weak __ksym;
extern int bpf_list_push_back_impl(struct bpf_list_head *head, struct bpf_list_node *node, void *meta__ign, u64 off) __weak __ksym;
extern int bpf_list_push_front_impl(struct bpf_list_head *head, struct bpf_list_node *node, void *meta__ign, u64 off) __weak __ksym;
extern void bpf_local_irq_restore(long unsigned int *flags__irq_flag) __weak __ksym;
extern void bpf_local_irq_save(long unsigned int *flags__irq_flag) __weak __ksym;
extern struct bpf_key *bpf_lookup_system_key(u64 id) __weak __ksym;
extern struct bpf_key *bpf_lookup_user_key(u32 serial, u64 flags) __weak __ksym;
extern s64 bpf_map_sum_elem_count(const struct bpf_map *map) __weak __ksym;
extern int bpf_modify_return_test(int a, int *b) __weak __ksym;
extern int bpf_modify_return_test2(int a, int *b, short int c, int d, void *e, char f, int g) __weak __ksym;
extern int bpf_modify_return_test_tp(int nonce) __weak __ksym;
extern void bpf_obj_drop_impl(void *p__alloc, void *meta__ign) __weak __ksym;
extern void *bpf_obj_new_impl(u64 local_type_id__k, void *meta__ign) __weak __ksym;
extern void bpf_percpu_obj_drop_impl(void *p__alloc, void *meta__ign) __weak __ksym;
extern void *bpf_percpu_obj_new_impl(u64 local_type_id__k, void *meta__ign) __weak __ksym;
extern void bpf_preempt_disable(void) __weak __ksym;
extern void bpf_preempt_enable(void) __weak __ksym;
extern int bpf_rbtree_add_impl(struct bpf_rb_root *root, struct bpf_rb_node *node, bool (*less)(struct bpf_rb_node *, const struct bpf_rb_node *), void *meta__ign, u64 off) __weak __ksym;
extern struct bpf_rb_node *bpf_rbtree_first(struct bpf_rb_root *root) __weak __ksym;
extern struct bpf_rb_node *bpf_rbtree_remove(struct bpf_rb_root *root, struct bpf_rb_node *node) __weak __ksym;
extern void bpf_rcu_read_lock(void) __weak __ksym;
extern void bpf_rcu_read_unlock(void) __weak __ksym;
extern __bpf_fastcall void *bpf_rdonly_cast(const void *obj__ign, u32 btf_id__k) __weak __ksym;
extern void *bpf_refcount_acquire_impl(void *p__refcounted_kptr, void *meta__ign) __weak __ksym;
extern int bpf_send_signal_task(struct task_struct *task, int sig, enum pid_type type, u64 value) __weak __ksym;
extern __u64 *bpf_session_cookie(void) __weak __ksym;
extern bool bpf_session_is_return(void) __weak __ksym;
extern int bpf_sk_assign_tcp_reqsk(struct __sk_buff *s, struct sock *sk, struct bpf_tcp_req_attrs *attrs, int attrs__sz) __weak __ksym;
extern int bpf_sock_addr_set_sun_path(struct bpf_sock_addr_kern *sa_kern, const u8 *sun_path, u32 sun_path__sz) __weak __ksym;
extern int bpf_sock_destroy(struct sock_common *sock) __weak __ksym;
extern struct task_struct *bpf_task_acquire(struct task_struct *p) __weak __ksym;
extern struct task_struct *bpf_task_from_pid(s32 pid) __weak __ksym;
extern struct task_struct *bpf_task_from_vpid(s32 vpid) __weak __ksym;
extern struct cgroup *bpf_task_get_cgroup1(struct task_struct *task, int hierarchy_id) __weak __ksym;
extern void bpf_task_release(struct task_struct *p) __weak __ksym;
extern long int bpf_task_under_cgroup(struct task_struct *task, struct cgroup *ancestor) __weak __ksym;
extern void bpf_throw(u64 cookie) __weak __ksym;
extern int bpf_verify_pkcs7_signature(struct bpf_dynptr *data_p, struct bpf_dynptr *sig_p, struct bpf_key *trusted_keyring) __weak __ksym;
extern int bpf_wq_init(struct bpf_wq *wq, void *p__map, unsigned int flags) __weak __ksym;
extern int bpf_wq_set_callback_impl(struct bpf_wq *wq, int (*callback_fn)(void *, int *, void *), unsigned int flags, void *aux__ign) __weak __ksym;
extern int bpf_wq_start(struct bpf_wq *wq, unsigned int flags) __weak __ksym;
extern struct xfrm_state *bpf_xdp_get_xfrm_state(struct xdp_md *ctx, struct bpf_xfrm_state_opts *opts, u32 opts__sz) __weak __ksym;
extern int bpf_xdp_metadata_rx_hash(const struct xdp_md *ctx, u32 *hash, enum xdp_rss_hash_type *rss_type) __weak __ksym;
extern int bpf_xdp_metadata_rx_timestamp(const struct xdp_md *ctx, u64 *timestamp) __weak __ksym;
extern int bpf_xdp_metadata_rx_vlan_tag(const struct xdp_md *ctx, __be16 *vlan_proto, u16 *vlan_tci) __weak __ksym;
extern void bpf_xdp_xfrm_state_release(struct xfrm_state *x) __weak __ksym;
extern void cgroup_rstat_flush(struct cgroup *cgrp) __weak __ksym;
extern void cgroup_rstat_updated(struct cgroup *cgrp, int cpu) __weak __ksym;
extern void crash_kexec(struct pt_regs *regs) __weak __ksym;
extern void cubictcp_acked(struct sock *sk, const struct ack_sample *sample) __weak __ksym;
extern void cubictcp_cong_avoid(struct sock *sk, u32 ack, u32 acked) __weak __ksym;
extern void cubictcp_cwnd_event(struct sock *sk, enum tcp_ca_event event) __weak __ksym;
extern void cubictcp_init(struct sock *sk) __weak __ksym;
extern u32 cubictcp_recalc_ssthresh(struct sock *sk) __weak __ksym;
extern void cubictcp_state(struct sock *sk, u8 new_state) __weak __ksym;
extern bool scx_bpf_consume(u64 dsq_id) __weak __ksym;
extern struct rq *scx_bpf_cpu_rq(s32 cpu) __weak __ksym;
extern u32 scx_bpf_cpuperf_cap(s32 cpu) __weak __ksym;
extern u32 scx_bpf_cpuperf_cur(s32 cpu) __weak __ksym;
extern void scx_bpf_cpuperf_set(s32 cpu, u32 perf) __weak __ksym;
extern s32 scx_bpf_create_dsq(u64 dsq_id, s32 node) __weak __ksym;
extern void scx_bpf_destroy_dsq(u64 dsq_id) __weak __ksym;
extern void scx_bpf_dispatch(struct task_struct *p, u64 dsq_id, u64 slice, u64 enq_flags) __weak __ksym;
extern void scx_bpf_dispatch_cancel(void) __weak __ksym;
extern bool scx_bpf_dispatch_from_dsq(struct bpf_iter_scx_dsq *it__iter, struct task_struct *p, u64 dsq_id, u64 enq_flags) __weak __ksym;
extern void scx_bpf_dispatch_from_dsq_set_slice(struct bpf_iter_scx_dsq *it__iter, u64 slice) __weak __ksym;
extern void scx_bpf_dispatch_from_dsq_set_vtime(struct bpf_iter_scx_dsq *it__iter, u64 vtime) __weak __ksym;
extern u32 scx_bpf_dispatch_nr_slots(void) __weak __ksym;
extern void scx_bpf_dispatch_vtime(struct task_struct *p, u64 dsq_id, u64 slice, u64 vtime, u64 enq_flags) __weak __ksym;
extern bool scx_bpf_dispatch_vtime_from_dsq(struct bpf_iter_scx_dsq *it__iter, struct task_struct *p, u64 dsq_id, u64 enq_flags) __weak __ksym;
extern void scx_bpf_dsq_insert(struct task_struct *p, u64 dsq_id, u64 slice, u64 enq_flags) __weak __ksym;
extern void scx_bpf_dsq_insert_vtime(struct task_struct *p, u64 dsq_id, u64 slice, u64 vtime, u64 enq_flags) __weak __ksym;
extern bool scx_bpf_dsq_move(struct bpf_iter_scx_dsq *it__iter, struct task_struct *p, u64 dsq_id, u64 enq_flags) __weak __ksym;
extern void scx_bpf_dsq_move_set_slice(struct bpf_iter_scx_dsq *it__iter, u64 slice) __weak __ksym;
extern void scx_bpf_dsq_move_set_vtime(struct bpf_iter_scx_dsq *it__iter, u64 vtime) __weak __ksym;
extern bool scx_bpf_dsq_move_to_local(u64 dsq_id) __weak __ksym;
extern bool scx_bpf_dsq_move_vtime(struct bpf_iter_scx_dsq *it__iter, struct task_struct *p, u64 dsq_id, u64 enq_flags) __weak __ksym;
extern s32 scx_bpf_dsq_nr_queued(u64 dsq_id) __weak __ksym;
extern void scx_bpf_dump_bstr(char *fmt, long long unsigned int *data, u32 data__sz) __weak __ksym;
extern void scx_bpf_error_bstr(char *fmt, long long unsigned int *data, u32 data__sz) __weak __ksym;
extern void scx_bpf_exit_bstr(s64 exit_code, char *fmt, long long unsigned int *data, u32 data__sz) __weak __ksym;
extern const struct cpumask *scx_bpf_get_idle_cpumask(void) __weak __ksym;
extern const struct cpumask *scx_bpf_get_idle_smtmask(void) __weak __ksym;
extern const struct cpumask *scx_bpf_get_online_cpumask(void) __weak __ksym;
extern const struct cpumask *scx_bpf_get_possible_cpumask(void) __weak __ksym;
extern void scx_bpf_kick_cpu(s32 cpu, u64 flags) __weak __ksym;
extern u64 scx_bpf_now(void) __weak __ksym;
extern u32 scx_bpf_nr_cpu_ids(void) __weak __ksym;
extern s32 scx_bpf_pick_any_cpu(const struct cpumask *cpus_allowed, u64 flags) __weak __ksym;
extern s32 scx_bpf_pick_idle_cpu(const struct cpumask *cpus_allowed, u64 flags) __weak __ksym;
extern void scx_bpf_put_cpumask(const struct cpumask *cpumask) __weak __ksym;
extern void scx_bpf_put_idle_cpumask(const struct cpumask *idle_mask) __weak __ksym;
extern u32 scx_bpf_reenqueue_local(void) __weak __ksym;
extern s32 scx_bpf_select_cpu_dfl(struct task_struct *p, s32 prev_cpu, u64 wake_flags, bool *is_idle) __weak __ksym;
extern struct cgroup *scx_bpf_task_cgroup(struct task_struct *p) __weak __ksym;
extern s32 scx_bpf_task_cpu(const struct task_struct *p) __weak __ksym;
extern bool scx_bpf_task_running(const struct task_struct *p) __weak __ksym;
extern bool scx_bpf_test_and_clear_cpu_idle(s32 cpu) __weak __ksym;
extern void tcp_cong_avoid_ai(struct tcp_sock *tp, u32 w, u32 acked) __weak __ksym;
extern void tcp_reno_cong_avoid(struct sock *sk, u32 ack, u32 acked) __weak __ksym;
extern u32 tcp_reno_ssthresh(struct sock *sk) __weak __ksym;
extern u32 tcp_reno_undo_cwnd(struct sock *sk) __weak __ksym;
extern u32 tcp_slow_start(struct tcp_sock *tp, u32 acked) __weak __ksym;
#endif

#ifndef BPF_NO_PRESERVE_ACCESS_INDEX
#pragma clang attribute pop
#endif

#endif /* __VMLINUX_H__ */
