From 6bff524dbe27e655482adf0b1ebe31e411a5d78c Mon Sep 17 00:00:00 2001 From: Pat Somaru Date: Fri, 4 Oct 2024 05:31:43 -0400 Subject: [PATCH] generate vmlinux --- backport-scripts/Dockerfile | 4 +- backport-scripts/exec-entrypoint.sh | 12 +- scheds/include/vmlinux/vmlinux-feb245e.h | 76819 +++++++++++++++++++++ scheds/include/vmlinux/vmlinux.h | 2 +- 4 files changed, 76833 insertions(+), 4 deletions(-) create mode 100644 scheds/include/vmlinux/vmlinux-feb245e.h diff --git a/backport-scripts/Dockerfile b/backport-scripts/Dockerfile index 74bf3d5af..b410b463a 100644 --- a/backport-scripts/Dockerfile +++ b/backport-scripts/Dockerfile @@ -14,7 +14,9 @@ RUN apt update && apt install -y build-essential \ binutils-dev \ pkg-config \ git \ - python3-pip \ + python3-pip \ + pahole \ + dwarves \ --no-install-recommends && \ apt -y build-dep linux --no-install-recommends && \ apt clean && rm -rf /var/lib/apt/lists/* diff --git a/backport-scripts/exec-entrypoint.sh b/backport-scripts/exec-entrypoint.sh index 863a630dc..abaada8c9 100755 --- a/backport-scripts/exec-entrypoint.sh +++ b/backport-scripts/exec-entrypoint.sh @@ -31,11 +31,19 @@ cd /sched-ext-linux git checkout "$SHORT_SHA" # this is for backports and mixing new bpf with old kernel -find . -type f -exec sed -i 's/-Werror/-Wno-error/g' {} \; +# we only care about generated vmlinux.h, so make build work. + +echo '' >> /sched-ext.config + +echo 'CONFIG_DEBUG_INFO_DWARF4=y' >> /sched-ext.config +echo 'CONFIG_DEBUG_INFO_BTF=y' >> /sched-ext.config +echo 'CONFIG_DEBUG_INFO=y' >> /sched-ext.config vng -v --kconfig --config /sched-ext.config -make -j "$(nproc)" +make ARCH=x86 KCFLAGS="-fno-pic -fno-stack-protector" -j "$(nproc)" all + +pahole -J /sched-ext-linux/vmlinux bpftool btf dump file "/sched-ext-linux/vmlinux" format c > "/vmlinux-${SHORT_SHA}.h" diff --git a/scheds/include/vmlinux/vmlinux-feb245e.h b/scheds/include/vmlinux/vmlinux-feb245e.h new file mode 100644 index 000000000..c1e597c2a --- /dev/null +++ b/scheds/include/vmlinux/vmlinux-feb245e.h @@ -0,0 +1,76819 @@ +#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 + +enum { + AC97_GENERAL_PCM_OUT = 0, + AC97_GENERAL_STEREO_ENHANCEMENT = 1, + AC97_GENERAL_3D = 2, + AC97_GENERAL_LOUDNESS = 3, + AC97_GENERAL_MONO = 4, + AC97_GENERAL_MIC = 5, + AC97_GENERAL_LOOPBACK = 6, +}; + +enum { + AC97_TUNE_DEFAULT = -1, + AC97_TUNE_NONE = 0, + AC97_TUNE_HP_ONLY = 1, + AC97_TUNE_SWAP_HP = 2, + AC97_TUNE_SWAP_SURROUND = 3, + AC97_TUNE_AD_SHARING = 4, + AC97_TUNE_ALC_JACK = 5, + AC97_TUNE_INV_EAPD = 6, + AC97_TUNE_MUTE_LED = 7, + AC97_TUNE_HP_MUTE_LED = 8, +}; + +enum { + ACPI_BATTERY_ALARM_PRESENT = 0, + ACPI_BATTERY_XINFO_PRESENT = 1, + ACPI_BATTERY_QUIRK_PERCENTAGE_CAPACITY = 2, + ACPI_BATTERY_QUIRK_THINKPAD_MAH = 3, +}; + +enum { + ACPI_GENL_ATTR_UNSPEC = 0, + ACPI_GENL_ATTR_EVENT = 1, + __ACPI_GENL_ATTR_MAX = 2, +}; + +enum { + ACPI_GENL_CMD_UNSPEC = 0, + ACPI_GENL_CMD_EVENT = 1, + __ACPI_GENL_CMD_MAX = 2, +}; + +enum { + ACPI_REFCLASS_LOCAL = 0, + ACPI_REFCLASS_ARG = 1, + ACPI_REFCLASS_REFOF = 2, + ACPI_REFCLASS_INDEX = 3, + ACPI_REFCLASS_TABLE = 4, + ACPI_REFCLASS_NAME = 5, + ACPI_REFCLASS_DEBUG = 6, + ACPI_REFCLASS_MAX = 6, +}; + +enum { + ACPI_RSC_INITGET = 0, + ACPI_RSC_INITSET = 1, + ACPI_RSC_FLAGINIT = 2, + ACPI_RSC_1BITFLAG = 3, + ACPI_RSC_2BITFLAG = 4, + ACPI_RSC_3BITFLAG = 5, + ACPI_RSC_ADDRESS = 6, + ACPI_RSC_BITMASK = 7, + ACPI_RSC_BITMASK16 = 8, + ACPI_RSC_COUNT = 9, + ACPI_RSC_COUNT16 = 10, + ACPI_RSC_COUNT_GPIO_PIN = 11, + ACPI_RSC_COUNT_GPIO_RES = 12, + ACPI_RSC_COUNT_GPIO_VEN = 13, + ACPI_RSC_COUNT_SERIAL_RES = 14, + ACPI_RSC_COUNT_SERIAL_VEN = 15, + ACPI_RSC_DATA8 = 16, + ACPI_RSC_EXIT_EQ = 17, + ACPI_RSC_EXIT_LE = 18, + ACPI_RSC_EXIT_NE = 19, + ACPI_RSC_LENGTH = 20, + ACPI_RSC_MOVE_GPIO_PIN = 21, + ACPI_RSC_MOVE_GPIO_RES = 22, + ACPI_RSC_MOVE_SERIAL_RES = 23, + ACPI_RSC_MOVE_SERIAL_VEN = 24, + ACPI_RSC_MOVE8 = 25, + ACPI_RSC_MOVE16 = 26, + ACPI_RSC_MOVE32 = 27, + ACPI_RSC_MOVE64 = 28, + ACPI_RSC_SET8 = 29, + ACPI_RSC_SOURCE = 30, + ACPI_RSC_SOURCEX = 31, +}; + +enum { + ACTION_FAIL = 0, + ACTION_REPREP = 1, + ACTION_RETRY = 2, + ACTION_DELAYED_RETRY = 3, +}; + +enum { + ACTIVE_LIST = 0, + INACTIVE_LIST = 1, + PINNED_LIST = 2, +}; + +enum { + AC_GRP_AUDIO_FUNCTION = 1, + AC_GRP_MODEM_FUNCTION = 2, +}; + +enum { + AC_JACK_LINE_OUT = 0, + AC_JACK_SPEAKER = 1, + AC_JACK_HP_OUT = 2, + AC_JACK_CD = 3, + AC_JACK_SPDIF_OUT = 4, + AC_JACK_DIG_OTHER_OUT = 5, + AC_JACK_MODEM_LINE_SIDE = 6, + AC_JACK_MODEM_HAND_SIDE = 7, + AC_JACK_LINE_IN = 8, + AC_JACK_AUX = 9, + AC_JACK_MIC_IN = 10, + AC_JACK_TELEPHONY = 11, + AC_JACK_SPDIF_IN = 12, + AC_JACK_DIG_OTHER_IN = 13, + AC_JACK_OTHER = 15, +}; + +enum { + AC_JACK_LOC_EXTERNAL = 0, + AC_JACK_LOC_INTERNAL = 16, + AC_JACK_LOC_SEPARATE = 32, + AC_JACK_LOC_OTHER = 48, +}; + +enum { + AC_JACK_LOC_NONE = 0, + AC_JACK_LOC_REAR = 1, + AC_JACK_LOC_FRONT = 2, + AC_JACK_LOC_LEFT = 3, + AC_JACK_LOC_RIGHT = 4, + AC_JACK_LOC_TOP = 5, + AC_JACK_LOC_BOTTOM = 6, +}; + +enum { + AC_JACK_LOC_REAR_PANEL = 7, + AC_JACK_LOC_DRIVE_BAY = 8, + AC_JACK_LOC_RISER = 23, + AC_JACK_LOC_HDMI = 24, + AC_JACK_LOC_ATAPI = 25, + AC_JACK_LOC_MOBILE_IN = 55, + AC_JACK_LOC_MOBILE_OUT = 56, +}; + +enum { + AC_JACK_PORT_COMPLEX = 0, + AC_JACK_PORT_NONE = 1, + AC_JACK_PORT_FIXED = 2, + AC_JACK_PORT_BOTH = 3, +}; + +enum { + AC_WID_AUD_OUT = 0, + AC_WID_AUD_IN = 1, + AC_WID_AUD_MIX = 2, + AC_WID_AUD_SEL = 3, + AC_WID_PIN = 4, + AC_WID_POWER = 5, + AC_WID_VOL_KNB = 6, + AC_WID_BEEP = 7, + AC_WID_VENDOR = 15, +}; + +enum { + ADVANCED_CONTEXT = 0, + LEGACY_32B_CONTEXT = 1, + ADVANCED_AD_CONTEXT = 2, + LEGACY_64B_CONTEXT = 3, +}; + +enum { + AHCI_MAX_PORTS = 32LL, + AHCI_MAX_CLKS = 5LL, + AHCI_MAX_SG = 168LL, + AHCI_DMA_BOUNDARY = 4294967295LL, + AHCI_MAX_CMDS = 32LL, + AHCI_CMD_SZ = 32LL, + AHCI_CMD_SLOT_SZ = 1024LL, + AHCI_RX_FIS_SZ = 256LL, + AHCI_CMD_TBL_CDB = 64LL, + AHCI_CMD_TBL_HDR_SZ = 128LL, + AHCI_CMD_TBL_SZ = 2816LL, + AHCI_CMD_TBL_AR_SZ = 90112LL, + AHCI_PORT_PRIV_DMA_SZ = 91392LL, + AHCI_PORT_PRIV_FBS_DMA_SZ = 95232LL, + AHCI_IRQ_ON_SG = -2147483648LL, + AHCI_CMD_ATAPI = 32LL, + AHCI_CMD_WRITE = 64LL, + AHCI_CMD_PREFETCH = 128LL, + AHCI_CMD_RESET = 256LL, + AHCI_CMD_CLR_BUSY = 1024LL, + RX_FIS_PIO_SETUP = 32LL, + RX_FIS_D2H_REG = 64LL, + RX_FIS_SDB = 88LL, + RX_FIS_UNK = 96LL, + HOST_CAP = 0LL, + HOST_CTL = 4LL, + HOST_IRQ_STAT = 8LL, + HOST_PORTS_IMPL = 12LL, + HOST_VERSION = 16LL, + HOST_EM_LOC = 28LL, + HOST_EM_CTL = 32LL, + HOST_CAP2 = 36LL, + HOST_RESET = 1LL, + HOST_IRQ_EN = 2LL, + HOST_MRSM = 4LL, + HOST_AHCI_EN = -2147483648LL, + HOST_CAP_SXS = 32LL, + HOST_CAP_EMS = 64LL, + HOST_CAP_CCC = 128LL, + HOST_CAP_PART = 8192LL, + HOST_CAP_SSC = 16384LL, + HOST_CAP_PIO_MULTI = 32768LL, + HOST_CAP_FBS = 65536LL, + HOST_CAP_PMP = 131072LL, + HOST_CAP_ONLY = 262144LL, + HOST_CAP_CLO = 16777216LL, + HOST_CAP_LED = 33554432LL, + HOST_CAP_ALPM = 67108864LL, + HOST_CAP_SSS = 134217728LL, + HOST_CAP_MPS = 268435456LL, + HOST_CAP_SNTF = 536870912LL, + HOST_CAP_NCQ = 1073741824LL, + HOST_CAP_64 = -2147483648LL, + HOST_CAP2_BOH = 1LL, + HOST_CAP2_NVMHCI = 2LL, + HOST_CAP2_APST = 4LL, + HOST_CAP2_SDS = 8LL, + HOST_CAP2_SADM = 16LL, + HOST_CAP2_DESO = 32LL, + PORT_LST_ADDR = 0LL, + PORT_LST_ADDR_HI = 4LL, + PORT_FIS_ADDR = 8LL, + PORT_FIS_ADDR_HI = 12LL, + PORT_IRQ_STAT = 16LL, + PORT_IRQ_MASK = 20LL, + PORT_CMD = 24LL, + PORT_TFDATA = 32LL, + PORT_SIG = 36LL, + PORT_CMD_ISSUE = 56LL, + PORT_SCR_STAT = 40LL, + PORT_SCR_CTL = 44LL, + PORT_SCR_ERR = 48LL, + PORT_SCR_ACT = 52LL, + PORT_SCR_NTF = 60LL, + PORT_FBS = 64LL, + PORT_DEVSLP = 68LL, + PORT_IRQ_COLD_PRES = -2147483648LL, + PORT_IRQ_TF_ERR = 1073741824LL, + PORT_IRQ_HBUS_ERR = 536870912LL, + PORT_IRQ_HBUS_DATA_ERR = 268435456LL, + PORT_IRQ_IF_ERR = 134217728LL, + PORT_IRQ_IF_NONFATAL = 67108864LL, + PORT_IRQ_OVERFLOW = 16777216LL, + PORT_IRQ_BAD_PMP = 8388608LL, + PORT_IRQ_PHYRDY = 4194304LL, + PORT_IRQ_DEV_ILCK = 128LL, + PORT_IRQ_CONNECT = 64LL, + PORT_IRQ_SG_DONE = 32LL, + PORT_IRQ_UNK_FIS = 16LL, + PORT_IRQ_SDB_FIS = 8LL, + PORT_IRQ_DMAS_FIS = 4LL, + PORT_IRQ_PIOS_FIS = 2LL, + PORT_IRQ_D2H_REG_FIS = 1LL, + PORT_IRQ_FREEZE = 683671632LL, + PORT_IRQ_ERROR = 2025848912LL, + DEF_PORT_IRQ = 2025848959LL, + PORT_CMD_ASP = 134217728LL, + PORT_CMD_ALPE = 67108864LL, + PORT_CMD_ATAPI = 16777216LL, + PORT_CMD_FBSCP = 4194304LL, + PORT_CMD_ESP = 2097152LL, + PORT_CMD_HPCP = 262144LL, + PORT_CMD_PMP = 131072LL, + PORT_CMD_LIST_ON = 32768LL, + PORT_CMD_FIS_ON = 16384LL, + PORT_CMD_FIS_RX = 16LL, + PORT_CMD_CLO = 8LL, + PORT_CMD_POWER_ON = 4LL, + PORT_CMD_SPIN_UP = 2LL, + PORT_CMD_START = 1LL, + PORT_CMD_ICC_MASK = -268435456LL, + PORT_CMD_ICC_ACTIVE = 268435456LL, + PORT_CMD_ICC_PARTIAL = 536870912LL, + PORT_CMD_ICC_SLUMBER = 1610612736LL, + PORT_FBS_DWE_OFFSET = 16LL, + PORT_FBS_ADO_OFFSET = 12LL, + PORT_FBS_DEV_OFFSET = 8LL, + PORT_FBS_DEV_MASK = 3840LL, + PORT_FBS_SDE = 4LL, + PORT_FBS_DEC = 2LL, + PORT_FBS_EN = 1LL, + PORT_DEVSLP_DM_OFFSET = 25LL, + PORT_DEVSLP_DM_MASK = 503316480LL, + PORT_DEVSLP_DITO_OFFSET = 15LL, + PORT_DEVSLP_MDAT_OFFSET = 10LL, + PORT_DEVSLP_DETO_OFFSET = 2LL, + PORT_DEVSLP_DSP = 2LL, + PORT_DEVSLP_ADSE = 1LL, + AHCI_HFLAG_NO_NCQ = 1LL, + AHCI_HFLAG_IGN_IRQ_IF_ERR = 2LL, + AHCI_HFLAG_IGN_SERR_INTERNAL = 4LL, + AHCI_HFLAG_32BIT_ONLY = 8LL, + AHCI_HFLAG_MV_PATA = 16LL, + AHCI_HFLAG_NO_MSI = 32LL, + AHCI_HFLAG_NO_PMP = 64LL, + AHCI_HFLAG_SECT255 = 256LL, + AHCI_HFLAG_YES_NCQ = 512LL, + AHCI_HFLAG_NO_SUSPEND = 1024LL, + AHCI_HFLAG_SRST_TOUT_IS_OFFLINE = 2048LL, + AHCI_HFLAG_NO_SNTF = 4096LL, + AHCI_HFLAG_NO_FPDMA_AA = 8192LL, + AHCI_HFLAG_YES_FBS = 16384LL, + AHCI_HFLAG_DELAY_ENGINE = 32768LL, + AHCI_HFLAG_NO_DEVSLP = 131072LL, + AHCI_HFLAG_NO_FBS = 262144LL, + AHCI_HFLAG_MULTI_MSI = 1048576LL, + AHCI_HFLAG_MULTI_MSIX = 2097152LL, + AHCI_HFLAG_WAKE_BEFORE_STOP = 4194304LL, + AHCI_FLAG_COMMON = 393346LL, + ICH_MAP = 144LL, + EM_MAX_SLOTS = 8LL, + EM_MAX_RETRY = 5LL, + EM_CTL_RST = 512LL, + EM_CTL_TM = 256LL, + EM_CTL_MR = 1LL, + EM_CTL_ALHD = 67108864LL, + EM_CTL_XMT = 33554432LL, + EM_CTL_SMB = 16777216LL, + EM_CTL_SGPIO = 524288LL, + EM_CTL_SES = 262144LL, + EM_CTL_SAFTE = 131072LL, + EM_CTL_LED = 65536LL, + EM_MSG_TYPE_LED = 1LL, + EM_MSG_TYPE_SAFTE = 2LL, + EM_MSG_TYPE_SES2 = 4LL, + EM_MSG_TYPE_SGPIO = 8LL, +}; + +enum { + AHCI_PCI_BAR_STA2X11 = 0, + AHCI_PCI_BAR_CAVIUM = 0, + AHCI_PCI_BAR_ENMOTUS = 2, + AHCI_PCI_BAR_STANDARD = 5, +}; + +enum { + ALC260_FIXUP_HP_DC5750 = 0, + ALC260_FIXUP_HP_PIN_0F = 1, + ALC260_FIXUP_COEF = 2, + ALC260_FIXUP_GPIO1 = 3, + ALC260_FIXUP_GPIO1_TOGGLE = 4, + ALC260_FIXUP_REPLACER = 5, + ALC260_FIXUP_HP_B1900 = 6, + ALC260_FIXUP_KN1 = 7, + ALC260_FIXUP_FSC_S7020 = 8, + ALC260_FIXUP_FSC_S7020_JWSE = 9, + ALC260_FIXUP_VAIO_PINS = 10, +}; + +enum { + ALC262_FIXUP_FSC_H270 = 0, + ALC262_FIXUP_FSC_S7110 = 1, + ALC262_FIXUP_HP_Z200 = 2, + ALC262_FIXUP_TYAN = 3, + ALC262_FIXUP_LENOVO_3000 = 4, + ALC262_FIXUP_BENQ = 5, + ALC262_FIXUP_BENQ_T31 = 6, + ALC262_FIXUP_INV_DMIC = 7, + ALC262_FIXUP_INTEL_BAYLEYBAY = 8, +}; + +enum { + ALC268_FIXUP_INV_DMIC = 0, + ALC268_FIXUP_HP_EAPD = 1, + ALC268_FIXUP_SPDIF = 2, +}; + +enum { + ALC269_FIXUP_SONY_VAIO = 0, + ALC275_FIXUP_SONY_VAIO_GPIO2 = 1, + ALC269_FIXUP_DELL_M101Z = 2, + ALC269_FIXUP_SKU_IGNORE = 3, + ALC269_FIXUP_ASUS_G73JW = 4, + ALC269_FIXUP_LENOVO_EAPD = 5, + ALC275_FIXUP_SONY_HWEQ = 6, + ALC275_FIXUP_SONY_DISABLE_AAMIX = 7, + ALC271_FIXUP_DMIC = 8, + ALC269_FIXUP_PCM_44K = 9, + ALC269_FIXUP_STEREO_DMIC = 10, + ALC269_FIXUP_HEADSET_MIC = 11, + ALC269_FIXUP_QUANTA_MUTE = 12, + ALC269_FIXUP_LIFEBOOK = 13, + ALC269_FIXUP_LIFEBOOK_EXTMIC = 14, + ALC269_FIXUP_LIFEBOOK_HP_PIN = 15, + ALC269_FIXUP_LIFEBOOK_NO_HP_TO_LINEOUT = 16, + ALC269_FIXUP_AMIC = 17, + ALC269_FIXUP_DMIC = 18, + ALC269VB_FIXUP_AMIC = 19, + ALC269VB_FIXUP_DMIC = 20, + ALC269_FIXUP_HP_MUTE_LED = 21, + ALC269_FIXUP_HP_MUTE_LED_MIC1 = 22, + ALC269_FIXUP_HP_MUTE_LED_MIC2 = 23, + ALC269_FIXUP_HP_GPIO_LED = 24, + ALC269_FIXUP_HP_GPIO_MIC1_LED = 25, + ALC269_FIXUP_HP_LINE1_MIC1_LED = 26, + ALC269_FIXUP_INV_DMIC = 27, + ALC269_FIXUP_LENOVO_DOCK = 28, + ALC269_FIXUP_NO_SHUTUP = 29, + ALC286_FIXUP_SONY_MIC_NO_PRESENCE = 30, + ALC269_FIXUP_PINCFG_NO_HP_TO_LINEOUT = 31, + ALC269_FIXUP_DELL1_MIC_NO_PRESENCE = 32, + ALC269_FIXUP_DELL2_MIC_NO_PRESENCE = 33, + ALC269_FIXUP_DELL3_MIC_NO_PRESENCE = 34, + ALC269_FIXUP_HEADSET_MODE = 35, + ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC = 36, + ALC269_FIXUP_ASPIRE_HEADSET_MIC = 37, + ALC269_FIXUP_ASUS_X101_FUNC = 38, + ALC269_FIXUP_ASUS_X101_VERB = 39, + ALC269_FIXUP_ASUS_X101 = 40, + ALC271_FIXUP_AMIC_MIC2 = 41, + ALC271_FIXUP_HP_GATE_MIC_JACK = 42, + ALC271_FIXUP_HP_GATE_MIC_JACK_E1_572 = 43, + ALC269_FIXUP_ACER_AC700 = 44, + ALC269_FIXUP_LIMIT_INT_MIC_BOOST = 45, + ALC269VB_FIXUP_ASUS_ZENBOOK = 46, + ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A = 47, + ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED = 48, + ALC269VB_FIXUP_ORDISSIMO_EVE2 = 49, + ALC283_FIXUP_CHROME_BOOK = 50, + ALC283_FIXUP_SENSE_COMBO_JACK = 51, + ALC282_FIXUP_ASUS_TX300 = 52, + ALC283_FIXUP_INT_MIC = 53, + ALC290_FIXUP_MONO_SPEAKERS = 54, + ALC290_FIXUP_MONO_SPEAKERS_HSJACK = 55, + ALC290_FIXUP_SUBWOOFER = 56, + ALC290_FIXUP_SUBWOOFER_HSJACK = 57, + ALC269_FIXUP_THINKPAD_ACPI = 58, + ALC269_FIXUP_DMIC_THINKPAD_ACPI = 59, + ALC255_FIXUP_DELL1_MIC_NO_PRESENCE = 60, + ALC255_FIXUP_DELL2_MIC_NO_PRESENCE = 61, + ALC255_FIXUP_HEADSET_MODE = 62, + ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC = 63, + ALC293_FIXUP_DELL1_MIC_NO_PRESENCE = 64, + ALC292_FIXUP_TPT440_DOCK = 65, + ALC292_FIXUP_TPT440 = 66, + ALC283_FIXUP_BXBT2807_MIC = 67, + ALC255_FIXUP_DELL_WMI_MIC_MUTE_LED = 68, + ALC282_FIXUP_ASPIRE_V5_PINS = 69, + ALC280_FIXUP_HP_GPIO4 = 70, + ALC286_FIXUP_HP_GPIO_LED = 71, + ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY = 72, + ALC280_FIXUP_HP_DOCK_PINS = 73, + ALC280_FIXUP_HP_9480M = 74, + ALC288_FIXUP_DELL_HEADSET_MODE = 75, + ALC288_FIXUP_DELL1_MIC_NO_PRESENCE = 76, + ALC288_FIXUP_DELL_XPS_13_GPIO6 = 77, + ALC288_FIXUP_DELL_XPS_13 = 78, + ALC288_FIXUP_DISABLE_AAMIX = 79, + ALC292_FIXUP_DELL_E7X = 80, + ALC292_FIXUP_DISABLE_AAMIX = 81, + ALC293_FIXUP_DISABLE_AAMIX_MULTIJACK = 82, + ALC298_FIXUP_DELL1_MIC_NO_PRESENCE = 83, + ALC275_FIXUP_DELL_XPS = 84, + ALC256_FIXUP_DELL_XPS_13_HEADPHONE_NOISE = 85, + ALC293_FIXUP_LENOVO_SPK_NOISE = 86, + ALC233_FIXUP_LENOVO_LINE2_MIC_HOTKEY = 87, + ALC255_FIXUP_DELL_SPK_NOISE = 88, + ALC225_FIXUP_DELL1_MIC_NO_PRESENCE = 89, + ALC280_FIXUP_HP_HEADSET_MIC = 90, + ALC221_FIXUP_HP_FRONT_MIC = 91, + ALC292_FIXUP_TPT460 = 92, +}; + +enum { + ALC269_TYPE_ALC269VA = 0, + ALC269_TYPE_ALC269VB = 1, + ALC269_TYPE_ALC269VC = 2, + ALC269_TYPE_ALC269VD = 3, + ALC269_TYPE_ALC280 = 4, + ALC269_TYPE_ALC282 = 5, + ALC269_TYPE_ALC283 = 6, + ALC269_TYPE_ALC284 = 7, + ALC269_TYPE_ALC285 = 8, + ALC269_TYPE_ALC286 = 9, + ALC269_TYPE_ALC298 = 10, + ALC269_TYPE_ALC255 = 11, + ALC269_TYPE_ALC256 = 12, + ALC269_TYPE_ALC225 = 13, + ALC269_TYPE_ALC294 = 14, + ALC269_TYPE_ALC700 = 15, +}; + +enum { + ALC660VD_FIX_ASUS_GPIO1 = 0, + ALC861VD_FIX_DALLAS = 1, +}; + +enum { + ALC662_FIXUP_ASPIRE = 0, + ALC662_FIXUP_LED_GPIO1 = 1, + ALC662_FIXUP_IDEAPAD = 2, + ALC272_FIXUP_MARIO = 3, + ALC662_FIXUP_CZC_P10T = 4, + ALC662_FIXUP_SKU_IGNORE = 5, + ALC662_FIXUP_HP_RP5800 = 6, + ALC662_FIXUP_ASUS_MODE1 = 7, + ALC662_FIXUP_ASUS_MODE2 = 8, + ALC662_FIXUP_ASUS_MODE3 = 9, + ALC662_FIXUP_ASUS_MODE4 = 10, + ALC662_FIXUP_ASUS_MODE5 = 11, + ALC662_FIXUP_ASUS_MODE6 = 12, + ALC662_FIXUP_ASUS_MODE7 = 13, + ALC662_FIXUP_ASUS_MODE8 = 14, + ALC662_FIXUP_NO_JACK_DETECT = 15, + ALC662_FIXUP_ZOTAC_Z68 = 16, + ALC662_FIXUP_INV_DMIC = 17, + ALC662_FIXUP_DELL_MIC_NO_PRESENCE = 18, + ALC668_FIXUP_DELL_MIC_NO_PRESENCE = 19, + ALC662_FIXUP_HEADSET_MODE = 20, + ALC668_FIXUP_HEADSET_MODE = 21, + ALC662_FIXUP_BASS_MODE4_CHMAP = 22, + ALC662_FIXUP_BASS_16 = 23, + ALC662_FIXUP_BASS_1A = 24, + ALC662_FIXUP_BASS_CHMAP = 25, + ALC668_FIXUP_AUTO_MUTE = 26, + ALC668_FIXUP_DELL_DISABLE_AAMIX = 27, + ALC668_FIXUP_DELL_XPS13 = 28, + ALC662_FIXUP_ASUS_Nx50 = 29, + ALC668_FIXUP_ASUS_Nx51 = 30, +}; + +enum { + ALC861_FIXUP_FSC_AMILO_PI1505 = 0, + ALC861_FIXUP_AMP_VREF_0F = 1, + ALC861_FIXUP_NO_JACK_DETECT = 2, + ALC861_FIXUP_ASUS_A6RP = 3, + ALC660_FIXUP_ASUS_W7J = 4, +}; + +enum { + ALC880_FIXUP_GPIO1 = 0, + ALC880_FIXUP_GPIO2 = 1, + ALC880_FIXUP_MEDION_RIM = 2, + ALC880_FIXUP_LG = 3, + ALC880_FIXUP_LG_LW25 = 4, + ALC880_FIXUP_W810 = 5, + ALC880_FIXUP_EAPD_COEF = 6, + ALC880_FIXUP_TCL_S700 = 7, + ALC880_FIXUP_VOL_KNOB = 8, + ALC880_FIXUP_FUJITSU = 9, + ALC880_FIXUP_F1734 = 10, + ALC880_FIXUP_UNIWILL = 11, + ALC880_FIXUP_UNIWILL_DIG = 12, + ALC880_FIXUP_Z71V = 13, + ALC880_FIXUP_ASUS_W5A = 14, + ALC880_FIXUP_3ST_BASE = 15, + ALC880_FIXUP_3ST = 16, + ALC880_FIXUP_3ST_DIG = 17, + ALC880_FIXUP_5ST_BASE = 18, + ALC880_FIXUP_5ST = 19, + ALC880_FIXUP_5ST_DIG = 20, + ALC880_FIXUP_6ST_BASE = 21, + ALC880_FIXUP_6ST = 22, + ALC880_FIXUP_6ST_DIG = 23, + ALC880_FIXUP_6ST_AUTOMUTE = 24, +}; + +enum { + ALC882_FIXUP_ABIT_AW9D_MAX = 0, + ALC882_FIXUP_LENOVO_Y530 = 1, + ALC882_FIXUP_PB_M5210 = 2, + ALC882_FIXUP_ACER_ASPIRE_7736 = 3, + ALC882_FIXUP_ASUS_W90V = 4, + ALC889_FIXUP_CD = 5, + ALC889_FIXUP_FRONT_HP_NO_PRESENCE = 6, + ALC889_FIXUP_VAIO_TT = 7, + ALC888_FIXUP_EEE1601 = 8, + ALC882_FIXUP_EAPD = 9, + ALC883_FIXUP_EAPD = 10, + ALC883_FIXUP_ACER_EAPD = 11, + ALC882_FIXUP_GPIO1 = 12, + ALC882_FIXUP_GPIO2 = 13, + ALC882_FIXUP_GPIO3 = 14, + ALC889_FIXUP_COEF = 15, + ALC882_FIXUP_ASUS_W2JC = 16, + ALC882_FIXUP_ACER_ASPIRE_4930G = 17, + ALC882_FIXUP_ACER_ASPIRE_8930G = 18, + ALC882_FIXUP_ASPIRE_8930G_VERBS = 19, + ALC885_FIXUP_MACPRO_GPIO = 20, + ALC889_FIXUP_DAC_ROUTE = 21, + ALC889_FIXUP_MBP_VREF = 22, + ALC889_FIXUP_IMAC91_VREF = 23, + ALC889_FIXUP_MBA11_VREF = 24, + ALC889_FIXUP_MBA21_VREF = 25, + ALC889_FIXUP_MP11_VREF = 26, + ALC889_FIXUP_MP41_VREF = 27, + ALC882_FIXUP_INV_DMIC = 28, + ALC882_FIXUP_NO_PRIMARY_HP = 29, + ALC887_FIXUP_ASUS_BASS = 30, + ALC887_FIXUP_BASS_CHMAP = 31, +}; + +enum { + ALC_HEADSET_MODE_UNKNOWN = 0, + ALC_HEADSET_MODE_UNPLUGGED = 1, + ALC_HEADSET_MODE_HEADSET = 2, + ALC_HEADSET_MODE_MIC = 3, + ALC_HEADSET_MODE_HEADPHONE = 4, +}; + +enum { + ALC_HEADSET_TYPE_UNKNOWN = 0, + ALC_HEADSET_TYPE_CTIA = 1, + ALC_HEADSET_TYPE_OMTP = 2, +}; + +enum { + ALC_INIT_NONE = 0, + ALC_INIT_DEFAULT = 1, + ALC_INIT_GPIO1 = 2, + ALC_INIT_GPIO2 = 3, + ALC_INIT_GPIO3 = 4, +}; + +enum { + ALC_KEY_MICMUTE_INDEX = 0, +}; + +enum { + ALID_PCMIN = 0, + ALID_PCMOUT = 1, + ALID_MIC = 2, + ALID_AC97SPDIFOUT = 3, + ALID_SPDIFIN = 4, + ALID_SPDIFOUT = 5, + ALID_LAST = 5, +}; + +enum { + AML_FIELD_ACCESS_ANY = 0, + AML_FIELD_ACCESS_BYTE = 1, + AML_FIELD_ACCESS_WORD = 2, + AML_FIELD_ACCESS_DWORD = 3, + AML_FIELD_ACCESS_QWORD = 4, + AML_FIELD_ACCESS_BUFFER = 5, +}; + +enum { + AML_FIELD_ATTRIB_QUICK = 2, + AML_FIELD_ATTRIB_SEND_RCV = 4, + AML_FIELD_ATTRIB_BYTE = 6, + AML_FIELD_ATTRIB_WORD = 8, + AML_FIELD_ATTRIB_BLOCK = 10, + AML_FIELD_ATTRIB_MULTIBYTE = 11, + AML_FIELD_ATTRIB_WORD_CALL = 12, + AML_FIELD_ATTRIB_BLOCK_CALL = 13, + AML_FIELD_ATTRIB_RAW_BYTES = 14, + AML_FIELD_ATTRIB_RAW_PROCESS = 15, +}; + +enum { + AML_FIELD_UPDATE_PRESERVE = 0, + AML_FIELD_UPDATE_WRITE_AS_ONES = 32, + AML_FIELD_UPDATE_WRITE_AS_ZEROS = 64, +}; + +enum { + ATA_EH_SPDN_NCQ_OFF = 1, + ATA_EH_SPDN_SPEED_DOWN = 2, + ATA_EH_SPDN_FALLBACK_TO_PIO = 4, + ATA_EH_SPDN_KEEP_ERRORS = 8, + ATA_EFLAG_IS_IO = 1, + ATA_EFLAG_DUBIOUS_XFER = 2, + ATA_EFLAG_OLD_ER = -2147483648, + ATA_ECAT_NONE = 0, + ATA_ECAT_ATA_BUS = 1, + ATA_ECAT_TOUT_HSM = 2, + ATA_ECAT_UNK_DEV = 3, + ATA_ECAT_DUBIOUS_NONE = 4, + ATA_ECAT_DUBIOUS_ATA_BUS = 5, + ATA_ECAT_DUBIOUS_TOUT_HSM = 6, + ATA_ECAT_DUBIOUS_UNK_DEV = 7, + ATA_ECAT_NR = 8, + ATA_EH_CMD_DFL_TIMEOUT = 5000, + ATA_EH_RESET_COOL_DOWN = 5000, + ATA_EH_PRERESET_TIMEOUT = 10000, + ATA_EH_FASTDRAIN_INTERVAL = 3000, + ATA_EH_UA_TRIES = 5, + ATA_EH_PROBE_TRIAL_INTERVAL = 60000, + ATA_EH_PROBE_TRIALS = 2, +}; + +enum { + ATA_MAX_DEVICES = 2, + ATA_MAX_PRD = 256, + ATA_SECT_SIZE = 512, + ATA_MAX_SECTORS_128 = 128, + ATA_MAX_SECTORS = 256, + ATA_MAX_SECTORS_1024 = 1024, + ATA_MAX_SECTORS_LBA48 = 65535, + ATA_MAX_SECTORS_TAPE = 65535, + ATA_ID_WORDS = 256, + ATA_ID_CONFIG = 0, + ATA_ID_CYLS = 1, + ATA_ID_HEADS = 3, + ATA_ID_SECTORS = 6, + ATA_ID_SERNO = 10, + ATA_ID_BUF_SIZE = 21, + ATA_ID_FW_REV = 23, + ATA_ID_PROD = 27, + ATA_ID_MAX_MULTSECT = 47, + ATA_ID_DWORD_IO = 48, + ATA_ID_CAPABILITY = 49, + ATA_ID_OLD_PIO_MODES = 51, + ATA_ID_OLD_DMA_MODES = 52, + ATA_ID_FIELD_VALID = 53, + ATA_ID_CUR_CYLS = 54, + ATA_ID_CUR_HEADS = 55, + ATA_ID_CUR_SECTORS = 56, + ATA_ID_MULTSECT = 59, + ATA_ID_LBA_CAPACITY = 60, + ATA_ID_SWDMA_MODES = 62, + ATA_ID_MWDMA_MODES = 63, + ATA_ID_PIO_MODES = 64, + ATA_ID_EIDE_DMA_MIN = 65, + ATA_ID_EIDE_DMA_TIME = 66, + ATA_ID_EIDE_PIO = 67, + ATA_ID_EIDE_PIO_IORDY = 68, + ATA_ID_ADDITIONAL_SUPP = 69, + ATA_ID_QUEUE_DEPTH = 75, + ATA_ID_SATA_CAPABILITY = 76, + ATA_ID_SATA_CAPABILITY_2 = 77, + ATA_ID_FEATURE_SUPP = 78, + ATA_ID_MAJOR_VER = 80, + ATA_ID_COMMAND_SET_1 = 82, + ATA_ID_COMMAND_SET_2 = 83, + ATA_ID_CFSSE = 84, + ATA_ID_CFS_ENABLE_1 = 85, + ATA_ID_CFS_ENABLE_2 = 86, + ATA_ID_CSF_DEFAULT = 87, + ATA_ID_UDMA_MODES = 88, + ATA_ID_HW_CONFIG = 93, + ATA_ID_SPG = 98, + ATA_ID_LBA_CAPACITY_2 = 100, + ATA_ID_SECTOR_SIZE = 106, + ATA_ID_WWN = 108, + ATA_ID_LOGICAL_SECTOR_SIZE = 117, + ATA_ID_COMMAND_SET_3 = 119, + ATA_ID_COMMAND_SET_4 = 120, + ATA_ID_LAST_LUN = 126, + ATA_ID_DLF = 128, + ATA_ID_CSFO = 129, + ATA_ID_CFA_POWER = 160, + ATA_ID_CFA_KEY_MGMT = 162, + ATA_ID_CFA_MODES = 163, + ATA_ID_DATA_SET_MGMT = 169, + ATA_ID_ROT_SPEED = 217, + ATA_ID_PIO4 = 2, + ATA_ID_SERNO_LEN = 20, + ATA_ID_FW_REV_LEN = 8, + ATA_ID_PROD_LEN = 40, + ATA_ID_WWN_LEN = 8, + ATA_PCI_CTL_OFS = 2, + ATA_PIO0 = 1, + ATA_PIO1 = 3, + ATA_PIO2 = 7, + ATA_PIO3 = 15, + ATA_PIO4 = 31, + ATA_PIO5 = 63, + ATA_PIO6 = 127, + ATA_PIO4_ONLY = 16, + ATA_SWDMA0 = 1, + ATA_SWDMA1 = 3, + ATA_SWDMA2 = 7, + ATA_SWDMA2_ONLY = 4, + ATA_MWDMA0 = 1, + ATA_MWDMA1 = 3, + ATA_MWDMA2 = 7, + ATA_MWDMA3 = 15, + ATA_MWDMA4 = 31, + ATA_MWDMA12_ONLY = 6, + ATA_MWDMA2_ONLY = 4, + ATA_UDMA0 = 1, + ATA_UDMA1 = 3, + ATA_UDMA2 = 7, + ATA_UDMA3 = 15, + ATA_UDMA4 = 31, + ATA_UDMA5 = 63, + ATA_UDMA6 = 127, + ATA_UDMA7 = 255, + ATA_UDMA24_ONLY = 20, + ATA_UDMA_MASK_40C = 7, + ATA_PRD_SZ = 8, + ATA_PRD_TBL_SZ = 2048, + ATA_PRD_EOT = -2147483648, + ATA_DMA_TABLE_OFS = 4, + ATA_DMA_STATUS = 2, + ATA_DMA_CMD = 0, + ATA_DMA_WR = 8, + ATA_DMA_START = 1, + ATA_DMA_INTR = 4, + ATA_DMA_ERR = 2, + ATA_DMA_ACTIVE = 1, + ATA_HOB = 128, + ATA_NIEN = 2, + ATA_LBA = 64, + ATA_DEV1 = 16, + ATA_DEVICE_OBS = 160, + ATA_DEVCTL_OBS = 8, + ATA_BUSY = 128, + ATA_DRDY = 64, + ATA_DF = 32, + ATA_DSC = 16, + ATA_DRQ = 8, + ATA_CORR = 4, + ATA_SENSE = 2, + ATA_ERR = 1, + ATA_SRST = 4, + ATA_ICRC = 128, + ATA_BBK = 128, + ATA_UNC = 64, + ATA_MC = 32, + ATA_IDNF = 16, + ATA_MCR = 8, + ATA_ABORTED = 4, + ATA_TRK0NF = 2, + ATA_AMNF = 1, + ATAPI_LFS = 240, + ATAPI_EOM = 2, + ATAPI_ILI = 1, + ATAPI_IO = 2, + ATAPI_COD = 1, + ATA_REG_DATA = 0, + ATA_REG_ERR = 1, + ATA_REG_NSECT = 2, + ATA_REG_LBAL = 3, + ATA_REG_LBAM = 4, + ATA_REG_LBAH = 5, + ATA_REG_DEVICE = 6, + ATA_REG_STATUS = 7, + ATA_REG_FEATURE = 1, + ATA_REG_CMD = 7, + ATA_REG_BYTEL = 4, + ATA_REG_BYTEH = 5, + ATA_REG_DEVSEL = 6, + ATA_REG_IRQ = 2, + ATA_CMD_DEV_RESET = 8, + ATA_CMD_CHK_POWER = 229, + ATA_CMD_STANDBY = 226, + ATA_CMD_IDLE = 227, + ATA_CMD_EDD = 144, + ATA_CMD_DOWNLOAD_MICRO = 146, + ATA_CMD_DOWNLOAD_MICRO_DMA = 147, + ATA_CMD_NOP = 0, + ATA_CMD_FLUSH = 231, + ATA_CMD_FLUSH_EXT = 234, + ATA_CMD_ID_ATA = 236, + ATA_CMD_ID_ATAPI = 161, + ATA_CMD_SERVICE = 162, + ATA_CMD_READ = 200, + ATA_CMD_READ_EXT = 37, + ATA_CMD_READ_QUEUED = 38, + ATA_CMD_READ_STREAM_EXT = 43, + ATA_CMD_READ_STREAM_DMA_EXT = 42, + ATA_CMD_WRITE = 202, + ATA_CMD_WRITE_EXT = 53, + ATA_CMD_WRITE_QUEUED = 54, + ATA_CMD_WRITE_STREAM_EXT = 59, + ATA_CMD_WRITE_STREAM_DMA_EXT = 58, + ATA_CMD_WRITE_FUA_EXT = 61, + ATA_CMD_WRITE_QUEUED_FUA_EXT = 62, + ATA_CMD_FPDMA_READ = 96, + ATA_CMD_FPDMA_WRITE = 97, + ATA_CMD_NCQ_NON_DATA = 99, + ATA_CMD_FPDMA_SEND = 100, + ATA_CMD_FPDMA_RECV = 101, + ATA_CMD_PIO_READ = 32, + ATA_CMD_PIO_READ_EXT = 36, + ATA_CMD_PIO_WRITE = 48, + ATA_CMD_PIO_WRITE_EXT = 52, + ATA_CMD_READ_MULTI = 196, + ATA_CMD_READ_MULTI_EXT = 41, + ATA_CMD_WRITE_MULTI = 197, + ATA_CMD_WRITE_MULTI_EXT = 57, + ATA_CMD_WRITE_MULTI_FUA_EXT = 206, + ATA_CMD_SET_FEATURES = 239, + ATA_CMD_SET_MULTI = 198, + ATA_CMD_PACKET = 160, + ATA_CMD_VERIFY = 64, + ATA_CMD_VERIFY_EXT = 66, + ATA_CMD_WRITE_UNCORR_EXT = 69, + ATA_CMD_STANDBYNOW1 = 224, + ATA_CMD_IDLEIMMEDIATE = 225, + ATA_CMD_SLEEP = 230, + ATA_CMD_INIT_DEV_PARAMS = 145, + ATA_CMD_READ_NATIVE_MAX = 248, + ATA_CMD_READ_NATIVE_MAX_EXT = 39, + ATA_CMD_SET_MAX = 249, + ATA_CMD_SET_MAX_EXT = 55, + ATA_CMD_READ_LOG_EXT = 47, + ATA_CMD_WRITE_LOG_EXT = 63, + ATA_CMD_READ_LOG_DMA_EXT = 71, + ATA_CMD_WRITE_LOG_DMA_EXT = 87, + ATA_CMD_TRUSTED_NONDATA = 91, + ATA_CMD_TRUSTED_RCV = 92, + ATA_CMD_TRUSTED_RCV_DMA = 93, + ATA_CMD_TRUSTED_SND = 94, + ATA_CMD_TRUSTED_SND_DMA = 95, + ATA_CMD_PMP_READ = 228, + ATA_CMD_PMP_READ_DMA = 233, + ATA_CMD_PMP_WRITE = 232, + ATA_CMD_PMP_WRITE_DMA = 235, + ATA_CMD_CONF_OVERLAY = 177, + ATA_CMD_SEC_SET_PASS = 241, + ATA_CMD_SEC_UNLOCK = 242, + ATA_CMD_SEC_ERASE_PREP = 243, + ATA_CMD_SEC_ERASE_UNIT = 244, + ATA_CMD_SEC_FREEZE_LOCK = 245, + ATA_CMD_SEC_DISABLE_PASS = 246, + ATA_CMD_CONFIG_STREAM = 81, + ATA_CMD_SMART = 176, + ATA_CMD_MEDIA_LOCK = 222, + ATA_CMD_MEDIA_UNLOCK = 223, + ATA_CMD_DSM = 6, + ATA_CMD_CHK_MED_CRD_TYP = 209, + ATA_CMD_CFA_REQ_EXT_ERR = 3, + ATA_CMD_CFA_WRITE_NE = 56, + ATA_CMD_CFA_TRANS_SECT = 135, + ATA_CMD_CFA_ERASE = 192, + ATA_CMD_CFA_WRITE_MULT_NE = 205, + ATA_CMD_REQ_SENSE_DATA = 11, + ATA_CMD_SANITIZE_DEVICE = 180, + ATA_CMD_ZAC_MGMT_IN = 74, + ATA_CMD_ZAC_MGMT_OUT = 159, + ATA_CMD_RESTORE = 16, + ATA_SUBCMD_FPDMA_RECV_RD_LOG_DMA_EXT = 1, + ATA_SUBCMD_FPDMA_RECV_ZAC_MGMT_IN = 2, + ATA_SUBCMD_FPDMA_SEND_DSM = 0, + ATA_SUBCMD_FPDMA_SEND_WR_LOG_DMA_EXT = 2, + ATA_SUBCMD_NCQ_NON_DATA_ABORT_QUEUE = 0, + ATA_SUBCMD_NCQ_NON_DATA_SET_FEATURES = 5, + ATA_SUBCMD_NCQ_NON_DATA_ZERO_EXT = 6, + ATA_SUBCMD_NCQ_NON_DATA_ZAC_MGMT_OUT = 7, + ATA_SUBCMD_ZAC_MGMT_IN_REPORT_ZONES = 0, + ATA_SUBCMD_ZAC_MGMT_OUT_CLOSE_ZONE = 1, + ATA_SUBCMD_ZAC_MGMT_OUT_FINISH_ZONE = 2, + ATA_SUBCMD_ZAC_MGMT_OUT_OPEN_ZONE = 3, + ATA_SUBCMD_ZAC_MGMT_OUT_RESET_WRITE_POINTER = 4, + ATA_LOG_DIRECTORY = 0, + ATA_LOG_SATA_NCQ = 16, + ATA_LOG_NCQ_NON_DATA = 18, + ATA_LOG_NCQ_SEND_RECV = 19, + ATA_LOG_SATA_ID_DEV_DATA = 48, + ATA_LOG_SATA_SETTINGS = 8, + ATA_LOG_ZONED_INFORMATION = 9, + ATA_LOG_DEVSLP_OFFSET = 48, + ATA_LOG_DEVSLP_SIZE = 8, + ATA_LOG_DEVSLP_MDAT = 0, + ATA_LOG_DEVSLP_MDAT_MASK = 31, + ATA_LOG_DEVSLP_DETO = 1, + ATA_LOG_DEVSLP_VALID = 7, + ATA_LOG_DEVSLP_VALID_MASK = 128, + ATA_LOG_NCQ_SEND_RECV_SUBCMDS_OFFSET = 0, + ATA_LOG_NCQ_SEND_RECV_SUBCMDS_DSM = 1, + ATA_LOG_NCQ_SEND_RECV_DSM_OFFSET = 4, + ATA_LOG_NCQ_SEND_RECV_DSM_TRIM = 1, + ATA_LOG_NCQ_SEND_RECV_RD_LOG_OFFSET = 8, + ATA_LOG_NCQ_SEND_RECV_RD_LOG_SUPPORTED = 1, + ATA_LOG_NCQ_SEND_RECV_WR_LOG_OFFSET = 12, + ATA_LOG_NCQ_SEND_RECV_WR_LOG_SUPPORTED = 1, + ATA_LOG_NCQ_SEND_RECV_ZAC_MGMT_OFFSET = 16, + ATA_LOG_NCQ_SEND_RECV_ZAC_MGMT_OUT_SUPPORTED = 1, + ATA_LOG_NCQ_SEND_RECV_ZAC_MGMT_IN_SUPPORTED = 2, + ATA_LOG_NCQ_SEND_RECV_SIZE = 20, + ATA_LOG_NCQ_NON_DATA_SUBCMDS_OFFSET = 0, + ATA_LOG_NCQ_NON_DATA_ABORT_OFFSET = 0, + ATA_LOG_NCQ_NON_DATA_ABORT_NCQ = 1, + ATA_LOG_NCQ_NON_DATA_ABORT_ALL = 2, + ATA_LOG_NCQ_NON_DATA_ABORT_STREAMING = 4, + ATA_LOG_NCQ_NON_DATA_ABORT_NON_STREAMING = 8, + ATA_LOG_NCQ_NON_DATA_ABORT_SELECTED = 16, + ATA_LOG_NCQ_NON_DATA_ZAC_MGMT_OFFSET = 28, + ATA_LOG_NCQ_NON_DATA_ZAC_MGMT_OUT = 1, + ATA_LOG_NCQ_NON_DATA_SIZE = 64, + ATA_CMD_READ_LONG = 34, + ATA_CMD_READ_LONG_ONCE = 35, + ATA_CMD_WRITE_LONG = 50, + ATA_CMD_WRITE_LONG_ONCE = 51, + SETFEATURES_XFER = 3, + XFER_UDMA_7 = 71, + XFER_UDMA_6 = 70, + XFER_UDMA_5 = 69, + XFER_UDMA_4 = 68, + XFER_UDMA_3 = 67, + XFER_UDMA_2 = 66, + XFER_UDMA_1 = 65, + XFER_UDMA_0 = 64, + XFER_MW_DMA_4 = 36, + XFER_MW_DMA_3 = 35, + XFER_MW_DMA_2 = 34, + XFER_MW_DMA_1 = 33, + XFER_MW_DMA_0 = 32, + XFER_SW_DMA_2 = 18, + XFER_SW_DMA_1 = 17, + XFER_SW_DMA_0 = 16, + XFER_PIO_6 = 14, + XFER_PIO_5 = 13, + XFER_PIO_4 = 12, + XFER_PIO_3 = 11, + XFER_PIO_2 = 10, + XFER_PIO_1 = 9, + XFER_PIO_0 = 8, + XFER_PIO_SLOW = 0, + SETFEATURES_WC_ON = 2, + SETFEATURES_WC_OFF = 130, + SETFEATURES_AAM_ON = 66, + SETFEATURES_AAM_OFF = 194, + SETFEATURES_SPINUP = 7, + SETFEATURES_SPINUP_TIMEOUT = 30000, + SETFEATURES_SATA_ENABLE = 16, + SETFEATURES_SATA_DISABLE = 144, + SATA_FPDMA_OFFSET = 1, + SATA_FPDMA_AA = 2, + SATA_DIPM = 3, + SATA_FPDMA_IN_ORDER = 4, + SATA_AN = 5, + SATA_SSP = 6, + SATA_DEVSLP = 9, + SETFEATURE_SENSE_DATA = 195, + ATA_SET_MAX_ADDR = 0, + ATA_SET_MAX_PASSWD = 1, + ATA_SET_MAX_LOCK = 2, + ATA_SET_MAX_UNLOCK = 3, + ATA_SET_MAX_FREEZE_LOCK = 4, + ATA_DCO_RESTORE = 192, + ATA_DCO_FREEZE_LOCK = 193, + ATA_DCO_IDENTIFY = 194, + ATA_DCO_SET = 195, + ATA_SMART_ENABLE = 216, + ATA_SMART_READ_VALUES = 208, + ATA_SMART_READ_THRESHOLDS = 209, + ATA_DSM_TRIM = 1, + ATA_SMART_LBAM_PASS = 79, + ATA_SMART_LBAH_PASS = 194, + ATAPI_PKT_DMA = 1, + ATAPI_DMADIR = 4, + ATAPI_CDB_LEN = 16, + SATA_PMP_MAX_PORTS = 15, + SATA_PMP_CTRL_PORT = 15, + SATA_PMP_GSCR_DWORDS = 128, + SATA_PMP_GSCR_PROD_ID = 0, + SATA_PMP_GSCR_REV = 1, + SATA_PMP_GSCR_PORT_INFO = 2, + SATA_PMP_GSCR_ERROR = 32, + SATA_PMP_GSCR_ERROR_EN = 33, + SATA_PMP_GSCR_FEAT = 64, + SATA_PMP_GSCR_FEAT_EN = 96, + SATA_PMP_PSCR_STATUS = 0, + SATA_PMP_PSCR_ERROR = 1, + SATA_PMP_PSCR_CONTROL = 2, + SATA_PMP_FEAT_BIST = 1, + SATA_PMP_FEAT_PMREQ = 2, + SATA_PMP_FEAT_DYNSSC = 4, + SATA_PMP_FEAT_NOTIFY = 8, + ATA_CBL_NONE = 0, + ATA_CBL_PATA40 = 1, + ATA_CBL_PATA80 = 2, + ATA_CBL_PATA40_SHORT = 3, + ATA_CBL_PATA_UNK = 4, + ATA_CBL_PATA_IGN = 5, + ATA_CBL_SATA = 6, + SCR_STATUS = 0, + SCR_ERROR = 1, + SCR_CONTROL = 2, + SCR_ACTIVE = 3, + SCR_NOTIFICATION = 4, + SERR_DATA_RECOVERED = 1, + SERR_COMM_RECOVERED = 2, + SERR_DATA = 256, + SERR_PERSISTENT = 512, + SERR_PROTOCOL = 1024, + SERR_INTERNAL = 2048, + SERR_PHYRDY_CHG = 65536, + SERR_PHY_INT_ERR = 131072, + SERR_COMM_WAKE = 262144, + SERR_10B_8B_ERR = 524288, + SERR_DISPARITY = 1048576, + SERR_CRC = 2097152, + SERR_HANDSHAKE = 4194304, + SERR_LINK_SEQ_ERR = 8388608, + SERR_TRANS_ST_ERROR = 16777216, + SERR_UNRECOG_FIS = 33554432, + SERR_DEV_XCHG = 67108864, +}; + +enum { + ATA_MSG_DRV = 1, + ATA_MSG_INFO = 2, + ATA_MSG_PROBE = 4, + ATA_MSG_WARN = 8, + ATA_MSG_MALLOC = 16, + ATA_MSG_CTL = 32, + ATA_MSG_INTR = 64, + ATA_MSG_ERR = 128, +}; + +enum { + ATA_READID_POSTRESET = 1, + ATA_DNXFER_PIO = 0, + ATA_DNXFER_DMA = 1, + ATA_DNXFER_40C = 2, + ATA_DNXFER_FORCE_PIO = 3, + ATA_DNXFER_FORCE_PIO0 = 4, + ATA_DNXFER_QUIET = -2147483648, +}; + +enum { + AUDIT_PRE_PAGE_FAULT = 0, + AUDIT_POST_PAGE_FAULT = 1, + AUDIT_PRE_PTE_WRITE = 2, + AUDIT_POST_PTE_WRITE = 3, + AUDIT_PRE_SYNC = 4, + AUDIT_POST_SYNC = 5, +}; + +enum { + AUTO_PIN_LINE_OUT = 0, + AUTO_PIN_SPEAKER_OUT = 1, + AUTO_PIN_HP_OUT = 2, +}; + +enum { + AUTO_PIN_MIC = 0, + AUTO_PIN_LINE_IN = 1, + AUTO_PIN_CD = 2, + AUTO_PIN_AUX = 3, + AUTO_PIN_LAST = 4, +}; + +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 { + AZX_DRIVER_ICH = 0, + AZX_DRIVER_PCH = 1, + AZX_DRIVER_SCH = 2, + AZX_DRIVER_HDMI = 3, + AZX_DRIVER_ATI = 4, + AZX_DRIVER_ATIHDMI = 5, + AZX_DRIVER_ATIHDMI_NS = 6, + AZX_DRIVER_VIA = 7, + AZX_DRIVER_SIS = 8, + AZX_DRIVER_ULI = 9, + AZX_DRIVER_NVIDIA = 10, + AZX_DRIVER_TERA = 11, + AZX_DRIVER_CTX = 12, + AZX_DRIVER_CTHDA = 13, + AZX_DRIVER_CMEDIA = 14, + AZX_DRIVER_GENERIC = 15, + AZX_NUM_DRIVERS = 16, +}; + +enum { + AZX_SNOOP_TYPE_NONE = 0, + AZX_SNOOP_TYPE_SCH = 1, + AZX_SNOOP_TYPE_ATI = 2, + AZX_SNOOP_TYPE_NVIDIA = 3, +}; + +enum { + BAD_NO_PRIMARY_DAC = 65536, + BAD_NO_DAC = 16384, + BAD_MULTI_IO = 288, + BAD_NO_EXTRA_DAC = 258, + BAD_NO_EXTRA_SURR_DAC = 257, + BAD_SHARED_SURROUND = 256, + BAD_NO_INDEP_HP = 16, + BAD_SHARED_CLFE = 16, + BAD_SHARED_EXTRA_SURROUND = 16, + BAD_SHARED_VOL = 16, +}; + +enum { + BDX_PCI_UNCORE_HA = 0, + BDX_PCI_UNCORE_IMC = 1, + BDX_PCI_UNCORE_IRP = 2, + BDX_PCI_UNCORE_QPI = 3, + BDX_PCI_UNCORE_R2PCIE = 4, + BDX_PCI_UNCORE_R3QPI = 5, +}; + +enum { + BIAS = 2147483648, +}; + +enum { + BLKCIPHER_WALK_PHYS = 1, + BLKCIPHER_WALK_SLOW = 2, + BLKCIPHER_WALK_COPY = 4, + BLKCIPHER_WALK_DIFF = 8, +}; + +enum { + BLKPREP_OK = 0, + BLKPREP_KILL = 1, + BLKPREP_DEFER = 2, + BLKPREP_INVALID = 3, +}; + +enum { + BLK_MQ_REQ_NOWAIT = 1, + BLK_MQ_REQ_RESERVED = 2, +}; + +enum { + BLK_MQ_RQ_QUEUE_OK = 0, + BLK_MQ_RQ_QUEUE_BUSY = 1, + BLK_MQ_RQ_QUEUE_ERROR = 2, + BLK_MQ_F_SHOULD_MERGE = 1, + BLK_MQ_F_TAG_SHARED = 2, + BLK_MQ_F_SG_MERGE = 4, + BLK_MQ_F_DEFER_ISSUE = 16, + BLK_MQ_F_ALLOC_POLICY_START_BIT = 8, + BLK_MQ_F_ALLOC_POLICY_BITS = 1, + BLK_MQ_S_STOPPED = 0, + BLK_MQ_S_TAG_ACTIVE = 1, + BLK_MQ_MAX_DEPTH = 10240, + BLK_MQ_CPU_WORK_BATCH = 8, +}; + +enum { + BLK_MQ_TAG_CACHE_MIN = 1, + BLK_MQ_TAG_CACHE_MAX = 64, +}; + +enum { + BLK_MQ_TAG_FAIL = 4294967295, + BLK_MQ_TAG_MIN = 1, + BLK_MQ_TAG_MAX = 4294967294, +}; + +enum { + BLK_MQ_UNIQUE_TAG_BITS = 16, + BLK_MQ_UNIQUE_TAG_MASK = 65535, +}; + +enum { + BLK_RW_ASYNC = 0, + BLK_RW_SYNC = 1, +}; + +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 { + BSG_F_BLOCK = 1, +}; + +enum { + BT_WAIT_QUEUES = 8, + BT_WAIT_BATCH = 8, +}; + +enum { + Blktrace_setup = 1, + Blktrace_running = 2, + Blktrace_stopped = 3, +}; + +enum { + CB_IDLE = 0, + CB_PENDING = 1, + CB_REPLAY = 2, +}; + +enum { + CFTYPE_ONLY_ON_ROOT = 1, + CFTYPE_NOT_ON_ROOT = 2, + CFTYPE_NO_PREFIX = 8, + CFTYPE_WORLD_WRITABLE = 16, + __CFTYPE_ONLY_ON_DFL = 65536, + __CFTYPE_NOT_ON_DFL = 131072, +}; + +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, +}; + +enum { + CGRP_ROOT_NOPREFIX = 2, + CGRP_ROOT_XATTR = 4, +}; + +enum { + CHAINIV_STATE_INUSE = 0, +}; + +enum { + CMCI_STORM_NONE = 0, + CMCI_STORM_ACTIVE = 1, + CMCI_STORM_SUBSIDED = 2, +}; + +enum { + CM_ASL_WLAN = 0, + CM_ASL_BLUETOOTH = 1, + CM_ASL_IRDA = 2, + CM_ASL_1394 = 3, + CM_ASL_CAMERA = 4, + CM_ASL_TV = 5, + CM_ASL_GPS = 6, + CM_ASL_DVDROM = 7, + CM_ASL_DISPLAYSWITCH = 8, + CM_ASL_PANELBRIGHT = 9, + CM_ASL_BIOSFLASH = 10, + CM_ASL_ACPIFLASH = 11, + CM_ASL_CPUFV = 12, + CM_ASL_CPUTEMPERATURE = 13, + CM_ASL_FANCPU = 14, + CM_ASL_FANCHASSIS = 15, + CM_ASL_USBPORT1 = 16, + CM_ASL_USBPORT2 = 17, + CM_ASL_USBPORT3 = 18, + CM_ASL_MODEM = 19, + CM_ASL_CARDREADER = 20, + CM_ASL_3G = 21, + CM_ASL_WIMAX = 22, + CM_ASL_HWCF = 23, + CM_ASL_LID = 24, + CM_ASL_TYPE = 25, + CM_ASL_PANELPOWER = 26, + CM_ASL_TPD = 27, +}; + +enum { + CPU_PRI_PERF = 20, + CPU_PRI_WORKQUEUE_UP = 5, + CPU_PRI_WORKQUEUE_DOWN = -5, +}; + +enum { + CRYPTOA_UNSPEC = 0, + CRYPTOA_ALG = 1, + CRYPTOA_TYPE = 2, + CRYPTOA_U32 = 3, + __CRYPTOA_MAX = 4, +}; + +enum { + CRYPTO_AUTHENC_KEYA_UNSPEC = 0, + CRYPTO_AUTHENC_KEYA_PARAM = 1, +}; + +enum { + CRYPTO_MSG_ALG_REQUEST = 0, + CRYPTO_MSG_ALG_REGISTER = 1, + CRYPTO_MSG_ALG_UNREGISTER = 2, + CRYPTO_MSG_TMPL_REGISTER = 3, + CRYPTO_MSG_TMPL_UNREGISTER = 4, +}; + +enum { + CSD_FLAG_LOCK = 1, + CSD_FLAG_SYNCHRONOUS = 2, +}; + +enum { + CSS_NO_REF = 1, + CSS_ONLINE = 2, + CSS_RELEASED = 4, + CSS_VISIBLE = 8, +}; + +enum { + CTL_KERN = 1, + CTL_VM = 2, + CTL_NET = 3, + CTL_PROC = 4, + CTL_FS = 5, + CTL_DEBUG = 6, + CTL_DEV = 7, + CTL_BUS = 8, + CTL_ABI = 9, + CTL_CPU = 10, + CTL_ARLAN = 254, + CTL_S390DBF = 5677, + CTL_SUNRPC = 7249, + CTL_PM = 9899, + CTL_FRV = 9898, +}; + +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_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_MAX = 8, +}; + +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_MAX = 10, +}; + +enum { + D0TIM = 128, + D1TIM = 132, + PM = 7, + MDM = 768, + UDM = 458752, + PPE = 1073741824, + USD = -2147483648, +}; + +enum { + DESC_TSS = 9, + DESC_LDT = 2, + DESCTYPE_S = 16, +}; + +enum { + DEVICE_INTEL = 0, + DEVICE_INTEL_ICH4 = 1, + DEVICE_SIS = 2, + DEVICE_ALI = 3, + DEVICE_NFORCE = 4, +}; + +enum { + DIO_LOCKING = 1, + DIO_SKIP_HOLES = 2, + DIO_ASYNC_EXTEND = 4, + DIO_SKIP_DIO_COUNT = 8, +}; + +enum { + DISABLE_ASL_WLAN = 1, + DISABLE_ASL_BLUETOOTH = 2, + DISABLE_ASL_IRDA = 4, + DISABLE_ASL_CAMERA = 8, + DISABLE_ASL_TV = 16, + DISABLE_ASL_GPS = 32, + DISABLE_ASL_DISPLAYSWITCH = 64, + DISABLE_ASL_MODEM = 128, + DISABLE_ASL_CARDREADER = 256, + DISABLE_ASL_3G = 512, + DISABLE_ASL_WIMAX = 1024, + DISABLE_ASL_HWCF = 2048, +}; + +enum { + DISCOVERED = 16, + EXPLORED = 32, + FALLTHROUGH = 1, + BRANCH = 2, +}; + +enum { + DISK_EVENT_MEDIA_CHANGE = 1, + DISK_EVENT_EJECT_REQUEST = 2, +}; + +enum { + DM_VERSION_CMD = 0, + DM_REMOVE_ALL_CMD = 1, + DM_LIST_DEVICES_CMD = 2, + DM_DEV_CREATE_CMD = 3, + DM_DEV_REMOVE_CMD = 4, + DM_DEV_RENAME_CMD = 5, + DM_DEV_SUSPEND_CMD = 6, + DM_DEV_STATUS_CMD = 7, + DM_DEV_WAIT_CMD = 8, + DM_TABLE_LOAD_CMD = 9, + DM_TABLE_CLEAR_CMD = 10, + DM_TABLE_DEPS_CMD = 11, + DM_TABLE_STATUS_CMD = 12, + DM_LIST_VERSIONS_CMD = 13, + DM_TARGET_MSG_CMD = 14, + DM_DEV_SET_GEOMETRY_CMD = 15, +}; + +enum { + DOS_EXTENDED_PARTITION = 5, + LINUX_EXTENDED_PARTITION = 133, + WIN98_EXTENDED_PARTITION = 15, + SUN_WHOLE_DISK = 5, + LINUX_SWAP_PARTITION = 130, + 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 { + 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 { + DUMP_PREFIX_NONE = 0, + DUMP_PREFIX_ADDRESS = 1, + DUMP_PREFIX_OFFSET = 2, +}; + +enum { + EC_FLAGS_QUERY_PENDING = 0, + EC_FLAGS_QUERY_GUARDING = 1, + EC_FLAGS_GPE_HANDLER_INSTALLED = 2, + EC_FLAGS_EC_HANDLER_INSTALLED = 3, + EC_FLAGS_STARTED = 4, + EC_FLAGS_STOPPED = 5, + EC_FLAGS_COMMAND_STORM = 6, +}; + +enum { + EDAC_REPORTING_ENABLED = 0, + EDAC_REPORTING_DISABLED = 1, + EDAC_REPORTING_FORCE = 2, +}; + +enum { + ELV_MQUEUE_MAY = 0, + ELV_MQUEUE_NO = 1, + ELV_MQUEUE_MUST = 2, +}; + +enum { + EMULATE = 0, + NATIVE = 1, + NONE = 2, +}; + +enum { + ENABLE = 0, + DISABLE = 1, +}; + +enum { + ERASE = 0, + WERASE = 1, + KILL = 2, +}; + +enum { + ESnormal = 0, + ESesc = 1, + ESsquare = 2, + ESgetpars = 3, + ESfunckey = 4, + EShash = 5, + ESsetG0 = 6, + ESsetG1 = 7, + ESpercent = 8, + ESignore = 9, + ESnonstd = 10, + ESpalette = 11, + ESosc = 12, +}; + +enum { + ETH_RSS_HASH_TOP_BIT = 0, + ETH_RSS_HASH_XOR_BIT = 1, + ETH_RSS_HASH_FUNCS_COUNT = 2, +}; + +enum { + EVENT_FILE_FL_ENABLED = 1, + EVENT_FILE_FL_RECORDED_CMD = 2, + EVENT_FILE_FL_FILTERED = 4, + EVENT_FILE_FL_NO_SET_FILTER = 8, + EVENT_FILE_FL_SOFT_MODE = 16, + EVENT_FILE_FL_SOFT_DISABLED = 32, + EVENT_FILE_FL_TRIGGER_MODE = 64, + EVENT_FILE_FL_TRIGGER_COND = 128, + EVENT_FILE_FL_PID_FILTER = 256, +}; + +enum { + EVENT_FILE_FL_ENABLED_BIT = 0, + EVENT_FILE_FL_RECORDED_CMD_BIT = 1, + EVENT_FILE_FL_FILTERED_BIT = 2, + EVENT_FILE_FL_NO_SET_FILTER_BIT = 3, + EVENT_FILE_FL_SOFT_MODE_BIT = 4, + EVENT_FILE_FL_SOFT_DISABLED_BIT = 5, + EVENT_FILE_FL_TRIGGER_MODE_BIT = 6, + EVENT_FILE_FL_TRIGGER_COND_BIT = 7, + EVENT_FILE_FL_PID_FILTER_BIT = 8, +}; + +enum { + EXTRA_REG_NHMEX_M_FILTER = 0, + EXTRA_REG_NHMEX_M_DSP = 1, + EXTRA_REG_NHMEX_M_ISS = 2, + EXTRA_REG_NHMEX_M_MAP = 3, + EXTRA_REG_NHMEX_M_MSC_THR = 4, + EXTRA_REG_NHMEX_M_PGT = 5, + EXTRA_REG_NHMEX_M_PLD = 6, + EXTRA_REG_NHMEX_M_ZDP_CTL_FVC = 7, +}; + +enum { + Enabled = 0, + Magic = 1, +}; + +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 { + FETCH_MTD_reg = 0, + FETCH_MTD_stack = 1, + FETCH_MTD_retval = 2, + FETCH_MTD_memory = 3, + FETCH_MTD_symbol = 4, + FETCH_MTD_deref = 5, + FETCH_MTD_bitfield = 6, + FETCH_MTD_file_offset = 7, + FETCH_MTD_END = 8, +}; + +enum { + FILE_CREATED = 1, + FILE_OPENED = 2, +}; + +enum { + FILTER_OTHER = 0, + FILTER_STATIC_STRING = 1, + FILTER_DYN_STRING = 2, + FILTER_PTR_STRING = 3, + FILTER_TRACE_FN = 4, + FILTER_COMM = 5, + FILTER_CPU = 6, +}; + +enum { + FILT_ERR_NONE = 0, + FILT_ERR_INVALID_OP = 1, + FILT_ERR_UNBALANCED_PAREN = 2, + FILT_ERR_TOO_MANY_OPERANDS = 3, + FILT_ERR_OPERAND_TOO_LONG = 4, + FILT_ERR_FIELD_NOT_FOUND = 5, + FILT_ERR_ILLEGAL_FIELD_OP = 6, + FILT_ERR_ILLEGAL_INTVAL = 7, + FILT_ERR_BAD_SUBSYS_FILTER = 8, + FILT_ERR_TOO_MANY_PREDS = 9, + FILT_ERR_MISSING_FIELD = 10, + FILT_ERR_INVALID_FILTER = 11, + FILT_ERR_IP_FIELD_ONLY = 12, + FILT_ERR_ILLEGAL_NOT_OP = 13, +}; + +enum { + FLAGS_FILL_FULL = 268435456, + FLAGS_FILL_START = 536870912, + FLAGS_FILL_END = 805306368, +}; + +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_MAX = 19, +}; + +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, +}; + +enum { + FTRACE_ITER_FILTER = 1, + FTRACE_ITER_NOTRACE = 2, + FTRACE_ITER_PRINTALL = 4, + FTRACE_ITER_DO_HASH = 8, + FTRACE_ITER_HASH = 16, + FTRACE_ITER_ENABLED = 32, +}; + +enum { + FTRACE_OPS_FL_ENABLED = 1, + FTRACE_OPS_FL_DYNAMIC = 2, + FTRACE_OPS_FL_PER_CPU = 4, + FTRACE_OPS_FL_SAVE_REGS = 8, + FTRACE_OPS_FL_SAVE_REGS_IF_SUPPORTED = 16, + FTRACE_OPS_FL_RECURSION_SAFE = 32, + FTRACE_OPS_FL_STUB = 64, + FTRACE_OPS_FL_INITIALIZED = 128, + FTRACE_OPS_FL_DELETED = 256, + FTRACE_OPS_FL_ADDING = 512, + FTRACE_OPS_FL_REMOVING = 1024, + FTRACE_OPS_FL_MODIFYING = 2048, + FTRACE_OPS_FL_ALLOC_TRAMP = 4096, + FTRACE_OPS_FL_IPMODIFY = 8192, + FTRACE_OPS_FL_PID = 16384, + FTRACE_OPS_FL_RCU = 32768, +}; + +enum { + FTRACE_UPDATE_CALLS = 1, + FTRACE_DISABLE_CALLS = 2, + FTRACE_UPDATE_TRACE_FUNC = 4, + FTRACE_START_FUNC_RET = 8, + FTRACE_STOP_FUNC_RET = 16, +}; + +enum { + FTRACE_UPDATE_IGNORE = 0, + FTRACE_UPDATE_MAKE_CALL = 1, + FTRACE_UPDATE_MODIFY_CALL = 2, + FTRACE_UPDATE_MAKE_NOP = 3, +}; + +enum { + FUSE_I_ADVISE_RDPLUS = 0, + FUSE_I_INIT_RDPLUS = 1, + FUSE_I_SIZE_UNSTABLE = 2, +}; + +enum { + FW_STATUS_LOADING = 0, + FW_STATUS_DONE = 1, + FW_STATUS_ABORT = 2, +}; + +enum { + GATE_INTERRUPT = 14, + GATE_TRAP = 15, + GATE_CALL = 12, + GATE_TASK = 5, +}; + +enum { + GP_IDLE = 0, + GP_PENDING = 1, + GP_PASSED = 2, +}; + +enum { + HDA_CTL_WIDGET_VOL = 0, + HDA_CTL_WIDGET_MUTE = 1, + HDA_CTL_BIND_MUTE = 2, +}; + +enum { + HDA_DEV_CORE = 0, + HDA_DEV_LEGACY = 1, + HDA_DEV_ASOC = 2, +}; + +enum { + HDA_DIG_NONE = 0, + HDA_DIG_EXCLUSIVE = 1, + HDA_DIG_ANALOG_DUP = 2, +}; + +enum { + HDA_FIXUP_ACT_PRE_PROBE = 0, + HDA_FIXUP_ACT_PROBE = 1, + HDA_FIXUP_ACT_INIT = 2, + HDA_FIXUP_ACT_BUILD = 3, + HDA_FIXUP_ACT_FREE = 4, +}; + +enum { + HDA_FIXUP_INVALID = 0, + HDA_FIXUP_PINS = 1, + HDA_FIXUP_VERBS = 2, + HDA_FIXUP_FUNC = 3, + HDA_FIXUP_PINCTLS = 4, +}; + +enum { + HDA_FRONT = 0, + HDA_REAR = 1, + HDA_CLFE = 2, + HDA_SIDE = 3, +}; + +enum { + HDA_GEN_PCM_ACT_OPEN = 0, + HDA_GEN_PCM_ACT_PREPARE = 1, + HDA_GEN_PCM_ACT_CLEANUP = 2, + HDA_GEN_PCM_ACT_CLOSE = 3, +}; + +enum { + HDA_HINT_STEREO_MIX_DISABLE = 0, + HDA_HINT_STEREO_MIX_ENABLE = 1, + HDA_HINT_STEREO_MIX_AUTO = 2, +}; + +enum { + HDA_INPUT = 0, + HDA_OUTPUT = 1, +}; + +enum { + HDA_JACK_NOT_PRESENT = 0, + HDA_JACK_PRESENT = 1, + HDA_JACK_PHANTOM = 2, +}; + +enum { + HDA_PCM_TYPE_AUDIO = 0, + HDA_PCM_TYPE_SPDIF = 1, + HDA_PCM_TYPE_HDMI = 2, + HDA_PCM_TYPE_MODEM = 3, + HDA_PCM_NTYPES = 4, +}; + +enum { + HDA_VMUTE_OFF = 0, + HDA_VMUTE_ON = 1, + HDA_VMUTE_FOLLOW_MASTER = 2, +}; + +enum { + HIBERNATION_INVALID = 0, + HIBERNATION_PLATFORM = 1, + HIBERNATION_SHUTDOWN = 2, + HIBERNATION_REBOOT = 3, + HIBERNATION_SUSPEND = 4, + __HIBERNATION_AFTER_LAST = 5, +}; + +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 { + HP_THREAD_NONE = 0, + HP_THREAD_ACTIVE = 1, + HP_THREAD_PARKED = 2, +}; + +enum { + HSWEP_PCI_UNCORE_HA = 0, + HSWEP_PCI_UNCORE_IMC = 1, + HSWEP_PCI_UNCORE_IRP = 2, + HSWEP_PCI_UNCORE_QPI = 3, + HSWEP_PCI_UNCORE_R2PCIE = 4, + HSWEP_PCI_UNCORE_R3QPI = 5, +}; + +enum { + HUGETLB_SHMFS_INODE = 1, + HUGETLB_ANONHUGE_INODE = 2, +}; + +enum { + HURR_SCALABILTY = 0, + HURR_RIOIB = 2, + COMPAT_CALGARY = 4, + ALT_CALGARY = 5, +}; + +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_4 = 4, + HW_BREAKPOINT_LEN_8 = 8, +}; + +enum { + ICHD_PCMIN = 0, + ICHD_PCMOUT = 1, + ICHD_MIC = 2, + ICHD_MIC2 = 3, + ICHD_PCM2IN = 4, + ICHD_SPBAR = 5, + ICHD_LAST = 5, +}; + +enum { + ICH_REG_ALI_SCR = 0, + ICH_REG_ALI_SSR = 4, + ICH_REG_ALI_DMACR = 8, + ICH_REG_ALI_FIFOCR1 = 12, + ICH_REG_ALI_INTERFACECR = 16, + ICH_REG_ALI_INTERRUPTCR = 20, + ICH_REG_ALI_INTERRUPTSR = 24, + ICH_REG_ALI_FIFOCR2 = 28, + ICH_REG_ALI_CPR = 32, + ICH_REG_ALI_CPR_ADDR = 34, + ICH_REG_ALI_SPR = 36, + ICH_REG_ALI_SPR_ADDR = 38, + ICH_REG_ALI_FIFOCR3 = 44, + ICH_REG_ALI_TTSR = 48, + ICH_REG_ALI_RTSR = 52, + ICH_REG_ALI_CSPSR = 56, + ICH_REG_ALI_CAS = 60, + ICH_REG_ALI_HWVOL = 240, + ICH_REG_ALI_I2SCR = 244, + ICH_REG_ALI_SPDIFCSR = 248, + ICH_REG_ALI_SPDIFICS = 252, +}; + +enum { + ICH_REG_OFF_BDBAR = 0, + ICH_REG_OFF_CIV = 4, + ICH_REG_OFF_LVI = 5, + ICH_REG_OFF_SR = 6, + ICH_REG_OFF_PICB = 8, + ICH_REG_OFF_PIV = 10, + ICH_REG_OFF_CR = 11, +}; + +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_MAX = 6, +}; + +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_MAX = 28, +}; + +enum { + ICQ_EXITED = 4, +}; + +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_MAX = 9, +}; + +enum { + IFLA_BRIDGE_FLAGS = 0, + IFLA_BRIDGE_MODE = 1, + IFLA_BRIDGE_VLAN_INFO = 2, + __IFLA_BRIDGE_MAX = 3, +}; + +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_MAX = 27, +}; + +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_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_STATS_UNSPEC = 0, + IFLA_STATS_LINK_64 = 1, + IFLA_STATS_LINK_XSTATS = 2, + __IFLA_STATS_MAX = 3, +}; + +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_MAX = 43, +}; + +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_MAX = 7, +}; + +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_MAX = 12, +}; + +enum { + 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, +}; + +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 { + 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_FRAG_FIRST_IN = 1, + INET_FRAG_LAST_IN = 2, + INET_FRAG_COMPLETE = 4, +}; + +enum { + INPUT_PIN_ATTR_UNUSED = 0, + INPUT_PIN_ATTR_INT = 1, + INPUT_PIN_ATTR_DOCK = 2, + INPUT_PIN_ATTR_NORMAL = 3, + INPUT_PIN_ATTR_REAR = 4, + INPUT_PIN_ATTR_FRONT = 5, + INPUT_PIN_ATTR_LAST = 5, +}; + +enum { + INTERCEPT_INTR = 0, + INTERCEPT_NMI = 1, + INTERCEPT_SMI = 2, + INTERCEPT_INIT = 3, + INTERCEPT_VINTR = 4, + INTERCEPT_SELECTIVE_CR0 = 5, + INTERCEPT_STORE_IDTR = 6, + INTERCEPT_STORE_GDTR = 7, + INTERCEPT_STORE_LDTR = 8, + INTERCEPT_STORE_TR = 9, + INTERCEPT_LOAD_IDTR = 10, + INTERCEPT_LOAD_GDTR = 11, + INTERCEPT_LOAD_LDTR = 12, + INTERCEPT_LOAD_TR = 13, + INTERCEPT_RDTSC = 14, + INTERCEPT_RDPMC = 15, + INTERCEPT_PUSHF = 16, + INTERCEPT_POPF = 17, + INTERCEPT_CPUID = 18, + INTERCEPT_RSM = 19, + INTERCEPT_IRET = 20, + INTERCEPT_INTn = 21, + INTERCEPT_INVD = 22, + INTERCEPT_PAUSE = 23, + INTERCEPT_HLT = 24, + INTERCEPT_INVLPG = 25, + INTERCEPT_INVLPGA = 26, + INTERCEPT_IOIO_PROT = 27, + INTERCEPT_MSR_PROT = 28, + INTERCEPT_TASK_SWITCH = 29, + INTERCEPT_FERR_FREEZE = 30, + INTERCEPT_SHUTDOWN = 31, + INTERCEPT_VMRUN = 32, + INTERCEPT_VMMCALL = 33, + INTERCEPT_VMLOAD = 34, + INTERCEPT_VMSAVE = 35, + INTERCEPT_STGI = 36, + INTERCEPT_CLGI = 37, + INTERCEPT_SKINIT = 38, + INTERCEPT_RDTSCP = 39, + INTERCEPT_ICEBP = 40, + INTERCEPT_WBINVD = 41, + INTERCEPT_MONITOR = 42, + INTERCEPT_MWAIT = 43, + INTERCEPT_MWAIT_COND = 44, + INTERCEPT_XSETBV = 45, +}; + +enum { + IOCB_CMD_PREAD = 0, + IOCB_CMD_PWRITE = 1, + IOCB_CMD_FSYNC = 2, + IOCB_CMD_FDSYNC = 3, + IOCB_CMD_NOOP = 6, + IOCB_CMD_PREADV = 7, + IOCB_CMD_PWRITEV = 8, +}; + +enum { + IOPRIO_CLASS_NONE = 0, + IOPRIO_CLASS_RT = 1, + IOPRIO_CLASS_BE = 2, + IOPRIO_CLASS_IDLE = 3, +}; + +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, +}; + +enum { + IP6_FH_F_FRAG = 1, + IP6_FH_F_AUTH = 2, + IP6_FH_F_SKIP_RH = 4, +}; + +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_SCTP = 132, + IPPROTO_UDPLITE = 136, + IPPROTO_MPLS = 137, + IPPROTO_RAW = 255, + IPPROTO_MAX = 256, +}; + +enum { + IPSTATS_MIB_NUM = 0, + IPSTATS_MIB_INPKTS = 1, + IPSTATS_MIB_INOCTETS = 2, + IPSTATS_MIB_INDELIVERS = 3, + IPSTATS_MIB_OUTFORWDATAGRAMS = 4, + IPSTATS_MIB_OUTPKTS = 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_MAX = 36, +}; + +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_MAX = 32, +}; + +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, +}; + +enum { + IRQC_IS_HARDIRQ = 0, + IRQC_IS_NESTED = 1, +}; + +enum { + IRQD_TRIGGER_MASK = 15, + IRQD_SETAFFINITY_PENDING = 256, + IRQD_NO_BALANCING = 1024, + IRQD_PER_CPU = 2048, + IRQD_AFFINITY_SET = 4096, + IRQD_LEVEL = 8192, + IRQD_WAKEUP_STATE = 16384, + IRQD_MOVE_PCNTXT = 32768, + IRQD_IRQ_DISABLED = 65536, + IRQD_IRQ_MASKED = 131072, + IRQD_IRQ_INPROGRESS = 262144, + IRQD_WAKEUP_ARMED = 524288, + IRQD_FORWARDED_TO_VCPU = 1048576, +}; + +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, +}; + +enum { + IRQTF_RUNTHREAD = 0, + IRQTF_WARNED = 1, + IRQTF_AFFINITY = 2, + IRQTF_FORCED_THREAD = 3, +}; + +enum { + IRQ_DOMAIN_FLAG_HIERARCHY = 1, + IRQ_DOMAIN_FLAG_AUTO_RECURSIVE = 2, + IRQ_DOMAIN_FLAG_IPI_PER_CPU = 4, + IRQ_DOMAIN_FLAG_IPI_SINGLE = 8, + IRQ_DOMAIN_FLAG_NONCORE = 65536, +}; + +enum { + IRQ_SET_MASK_OK = 0, + IRQ_SET_MASK_OK_NOCOPY = 1, + IRQ_SET_MASK_OK_DONE = 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_MOVE_PCNTXT = 16384, + IRQ_NESTED_THREAD = 32768, + IRQ_NOTHREAD = 65536, + IRQ_PER_CPU_DEVID = 131072, + IRQ_IS_POLLED = 262144, + IRQ_DISABLE_UNLAZY = 524288, +}; + +enum { + ITER_IOVEC = 0, + ITER_KVEC = 2, + ITER_BVEC = 4, +}; + +enum { + IVBEP_PCI_UNCORE_HA = 0, + IVBEP_PCI_UNCORE_IMC = 1, + IVBEP_PCI_UNCORE_IRP = 2, + IVBEP_PCI_UNCORE_QPI = 3, + IVBEP_PCI_UNCORE_R2PCIE = 4, + IVBEP_PCI_UNCORE_R3QPI = 5, +}; + +enum { + JL_STATE_START = 0, + JL_STATE_NO_UPDATE = 1, + JL_STATE_UPDATE = 2, +}; + +enum { + KERNEL_PARAM_FL_UNSAFE = 1, +}; + +enum { + KERNEL_PARAM_OPS_FL_NOARG = 1, +}; + +enum { + KERN_OSTYPE = 1, + KERN_OSRELEASE = 2, + KERN_OSREV = 3, + KERN_VERSION = 4, + KERN_SECUREMASK = 5, + KERN_PROF = 6, + KERN_NODENAME = 7, + KERN_DOMAINNAME = 8, + KERN_PANIC = 15, + KERN_REALROOTDEV = 16, + KERN_SPARC_REBOOT = 21, + KERN_CTLALTDEL = 22, + KERN_PRINTK = 23, + KERN_NAMETRANS = 24, + KERN_PPC_HTABRECLAIM = 25, + KERN_PPC_ZEROPAGED = 26, + KERN_PPC_POWERSAVE_NAP = 27, + KERN_MODPROBE = 28, + KERN_SG_BIG_BUFF = 29, + KERN_ACCT = 30, + KERN_PPC_L2CR = 31, + KERN_RTSIGNR = 32, + KERN_RTSIGMAX = 33, + KERN_SHMMAX = 34, + KERN_MSGMAX = 35, + KERN_MSGMNB = 36, + KERN_MSGPOOL = 37, + KERN_SYSRQ = 38, + KERN_MAX_THREADS = 39, + KERN_RANDOM = 40, + KERN_SHMALL = 41, + KERN_MSGMNI = 42, + KERN_SEM = 43, + KERN_SPARC_STOP_A = 44, + KERN_SHMMNI = 45, + KERN_OVERFLOWUID = 46, + KERN_OVERFLOWGID = 47, + KERN_SHMPATH = 48, + KERN_HOTPLUG = 49, + KERN_IEEE_EMULATION_WARNINGS = 50, + KERN_S390_USER_DEBUG_LOGGING = 51, + KERN_CORE_USES_PID = 52, + KERN_TAINTED = 53, + KERN_CADPID = 54, + KERN_PIDMAX = 55, + KERN_CORE_PATTERN = 56, + KERN_PANIC_ON_OOPS = 57, + KERN_HPPA_PWRSW = 58, + KERN_HPPA_UNALIGNED = 59, + KERN_PRINTK_RATELIMIT = 60, + KERN_PRINTK_RATELIMIT_BURST = 61, + KERN_PTY = 62, + KERN_NGROUPS_MAX = 63, + KERN_SPARC_SCONS_PWROFF = 64, + KERN_HZ_TIMER = 65, + KERN_UNKNOWN_NMI_PANIC = 66, + KERN_BOOTLOADER_TYPE = 67, + KERN_RANDOMIZE = 68, + KERN_SETUID_DUMPABLE = 69, + KERN_SPIN_RETRY = 70, + KERN_ACPI_VIDEO_FLAGS = 71, + KERN_IA64_UNALIGNED = 72, + KERN_COMPAT_LOG = 73, + KERN_MAX_LOCK_DEPTH = 74, + KERN_NMI_WATCHDOG = 75, + KERN_PANIC_ON_NMI = 76, + KERN_PANIC_ON_WARN = 77, +}; + +enum { + KNL_PCI_UNCORE_MC_UCLK = 0, + KNL_PCI_UNCORE_MC_DCLK = 1, + KNL_PCI_UNCORE_EDC_UCLK = 2, + KNL_PCI_UNCORE_EDC_ECLK = 3, + KNL_PCI_UNCORE_M2PCIE = 4, + KNL_PCI_UNCORE_IRP = 5, +}; + +enum { + KVM_DEBUGREG_BP_ENABLED = 1, + KVM_DEBUGREG_WONT_EXIT = 2, + KVM_DEBUGREG_RELOAD = 4, +}; + +enum { + LAST_NORM = 0, + LAST_ROOT = 1, + LAST_DOT = 2, + LAST_DOTDOT = 3, + LAST_BIND = 4, +}; + +enum { + LBR_FORMAT_32 = 0, + LBR_FORMAT_LIP = 1, + LBR_FORMAT_EIP = 2, + LBR_FORMAT_EIP_FLAGS = 3, + LBR_FORMAT_EIP_FLAGS2 = 4, + LBR_FORMAT_INFO = 5, + LBR_FORMAT_TIME = 6, + LBR_FORMAT_MAX_KNOWN = 6, +}; + +enum { + LBR_NONE = 0, + LBR_VALID = 1, +}; + +enum { + LIBATA_MAX_PRD = 128, + LIBATA_DUMB_MAX_PRD = 64, + ATA_DEF_QUEUE = 1, + ATA_MAX_QUEUE = 32, + ATA_TAG_INTERNAL = 31, + ATA_SHORT_PAUSE = 16, + ATAPI_MAX_DRAIN = 16384, + ATA_ALL_DEVICES = 3, + ATA_SHT_EMULATED = 1, + ATA_SHT_THIS_ID = -1, + ATA_SHT_USE_CLUSTERING = 1, + ATA_TFLAG_LBA48 = 1, + ATA_TFLAG_ISADDR = 2, + ATA_TFLAG_DEVICE = 4, + ATA_TFLAG_WRITE = 8, + ATA_TFLAG_LBA = 16, + ATA_TFLAG_FUA = 32, + ATA_TFLAG_POLLING = 64, + ATA_PROT_FLAG_PIO = 1, + ATA_PROT_FLAG_DMA = 2, + ATA_PROT_FLAG_DATA = 3, + ATA_PROT_FLAG_NCQ = 4, + ATA_PROT_FLAG_ATAPI = 8, + ATA_DFLAG_LBA = 1, + ATA_DFLAG_LBA48 = 2, + ATA_DFLAG_CDB_INTR = 4, + ATA_DFLAG_NCQ = 8, + ATA_DFLAG_FLUSH_EXT = 16, + ATA_DFLAG_ACPI_PENDING = 32, + ATA_DFLAG_ACPI_FAILED = 64, + ATA_DFLAG_AN = 128, + ATA_DFLAG_DMADIR = 1024, + ATA_DFLAG_CFG_MASK = 4095, + ATA_DFLAG_PIO = 4096, + ATA_DFLAG_NCQ_OFF = 8192, + ATA_DFLAG_SLEEPING = 32768, + ATA_DFLAG_DUBIOUS_XFER = 65536, + ATA_DFLAG_NO_UNLOAD = 131072, + ATA_DFLAG_UNLOCK_HPA = 262144, + ATA_DFLAG_NCQ_SEND_RECV = 524288, + ATA_DFLAG_INIT_MASK = 16777215, + ATA_DFLAG_DETACH = 16777216, + ATA_DFLAG_DETACHED = 33554432, + ATA_DFLAG_DA = 67108864, + ATA_DFLAG_DEVSLP = 134217728, + ATA_DFLAG_ACPI_DISABLED = 268435456, + ATA_DFLAG_D_SENSE = 536870912, + ATA_DFLAG_ZAC = 1073741824, + ATA_DEV_UNKNOWN = 0, + ATA_DEV_ATA = 1, + ATA_DEV_ATA_UNSUP = 2, + ATA_DEV_ATAPI = 3, + ATA_DEV_ATAPI_UNSUP = 4, + ATA_DEV_PMP = 5, + ATA_DEV_PMP_UNSUP = 6, + ATA_DEV_SEMB = 7, + ATA_DEV_SEMB_UNSUP = 8, + ATA_DEV_ZAC = 9, + ATA_DEV_ZAC_UNSUP = 10, + ATA_DEV_NONE = 11, + ATA_LFLAG_NO_HRST = 2, + ATA_LFLAG_NO_SRST = 4, + ATA_LFLAG_ASSUME_ATA = 8, + ATA_LFLAG_ASSUME_SEMB = 16, + ATA_LFLAG_ASSUME_CLASS = 24, + ATA_LFLAG_NO_RETRY = 32, + ATA_LFLAG_DISABLED = 64, + ATA_LFLAG_SW_ACTIVITY = 128, + ATA_LFLAG_NO_LPM = 256, + ATA_LFLAG_RST_ONCE = 512, + ATA_LFLAG_CHANGED = 1024, + ATA_LFLAG_NO_DB_DELAY = 2048, + ATA_FLAG_SLAVE_POSS = 1, + ATA_FLAG_SATA = 2, + ATA_FLAG_NO_LOG_PAGE = 32, + ATA_FLAG_NO_ATAPI = 64, + ATA_FLAG_PIO_DMA = 128, + ATA_FLAG_PIO_LBA48 = 256, + ATA_FLAG_PIO_POLLING = 512, + ATA_FLAG_NCQ = 1024, + ATA_FLAG_NO_POWEROFF_SPINDOWN = 2048, + ATA_FLAG_NO_HIBERNATE_SPINDOWN = 4096, + ATA_FLAG_DEBUGMSG = 8192, + ATA_FLAG_FPDMA_AA = 16384, + ATA_FLAG_IGN_SIMPLEX = 32768, + ATA_FLAG_NO_IORDY = 65536, + ATA_FLAG_ACPI_SATA = 131072, + ATA_FLAG_AN = 262144, + ATA_FLAG_PMP = 524288, + ATA_FLAG_FPDMA_AUX = 1048576, + ATA_FLAG_EM = 2097152, + ATA_FLAG_SW_ACTIVITY = 4194304, + ATA_FLAG_NO_DIPM = 8388608, + ATA_FLAG_SAS_HOST = 16777216, + ATA_PFLAG_EH_PENDING = 1, + ATA_PFLAG_EH_IN_PROGRESS = 2, + ATA_PFLAG_FROZEN = 4, + ATA_PFLAG_RECOVERED = 8, + ATA_PFLAG_LOADING = 16, + ATA_PFLAG_SCSI_HOTPLUG = 64, + ATA_PFLAG_INITIALIZING = 128, + ATA_PFLAG_RESETTING = 256, + ATA_PFLAG_UNLOADING = 512, + ATA_PFLAG_UNLOADED = 1024, + ATA_PFLAG_SUSPENDED = 131072, + ATA_PFLAG_PM_PENDING = 262144, + ATA_PFLAG_INIT_GTM_VALID = 524288, + ATA_PFLAG_PIO32 = 1048576, + ATA_PFLAG_PIO32CHANGE = 2097152, + ATA_PFLAG_EXTERNAL = 4194304, + ATA_QCFLAG_ACTIVE = 1, + ATA_QCFLAG_DMAMAP = 2, + ATA_QCFLAG_IO = 8, + ATA_QCFLAG_RESULT_TF = 16, + ATA_QCFLAG_CLEAR_EXCL = 32, + ATA_QCFLAG_QUIET = 64, + ATA_QCFLAG_RETRY = 128, + ATA_QCFLAG_FAILED = 65536, + ATA_QCFLAG_SENSE_VALID = 131072, + ATA_QCFLAG_EH_SCHEDULED = 262144, + ATA_HOST_SIMPLEX = 1, + ATA_HOST_STARTED = 2, + ATA_HOST_PARALLEL_SCAN = 4, + ATA_HOST_IGNORE_ATA = 8, + ATA_TMOUT_BOOT = 30000, + ATA_TMOUT_BOOT_QUICK = 7000, + ATA_TMOUT_INTERNAL_QUICK = 5000, + ATA_TMOUT_MAX_PARK = 30000, + ATA_TMOUT_FF_WAIT_LONG = 2000, + ATA_TMOUT_FF_WAIT = 800, + ATA_WAIT_AFTER_RESET = 150, + ATA_TMOUT_PMP_SRST_WAIT = 5000, + ATA_TMOUT_SPURIOUS_PHY = 10000, + BUS_UNKNOWN = 0, + BUS_DMA = 1, + BUS_IDLE = 2, + BUS_NOINTR = 3, + BUS_NODATA = 4, + BUS_TIMER = 5, + BUS_PIO = 6, + BUS_EDD = 7, + BUS_IDENTIFY = 8, + BUS_PACKET = 9, + PORT_UNKNOWN = 0, + PORT_ENABLED = 1, + PORT_DISABLED = 2, + ATA_NR_PIO_MODES = 7, + ATA_NR_MWDMA_MODES = 5, + ATA_NR_UDMA_MODES = 8, + ATA_SHIFT_PIO = 0, + ATA_SHIFT_MWDMA = 7, + ATA_SHIFT_UDMA = 12, + ATA_DMA_PAD_SZ = 4, + ATA_ERING_SIZE = 32, + ATA_DEFER_LINK = 1, + ATA_DEFER_PORT = 2, + ATA_EH_DESC_LEN = 80, + ATA_EH_REVALIDATE = 1, + ATA_EH_SOFTRESET = 2, + ATA_EH_HARDRESET = 4, + ATA_EH_RESET = 6, + ATA_EH_ENABLE_LINK = 8, + ATA_EH_PARK = 32, + ATA_EH_PERDEV_MASK = 33, + ATA_EH_ALL_ACTIONS = 15, + ATA_EHI_HOTPLUGGED = 1, + ATA_EHI_NO_AUTOPSY = 4, + ATA_EHI_QUIET = 8, + ATA_EHI_NO_RECOVERY = 16, + ATA_EHI_DID_SOFTRESET = 65536, + ATA_EHI_DID_HARDRESET = 131072, + ATA_EHI_PRINTINFO = 262144, + ATA_EHI_SETMODE = 524288, + ATA_EHI_POST_SETMODE = 1048576, + ATA_EHI_DID_RESET = 196608, + ATA_EHI_TO_SLAVE_MASK = 12, + ATA_EH_MAX_TRIES = 5, + ATA_LINK_RESUME_TRIES = 5, + ATA_PROBE_MAX_TRIES = 3, + ATA_EH_DEV_TRIES = 3, + ATA_EH_PMP_TRIES = 5, + ATA_EH_PMP_LINK_TRIES = 3, + SATA_PMP_RW_TIMEOUT = 3000, + ATA_EH_CMD_TIMEOUT_TABLE_SIZE = 6, + ATA_HORKAGE_DIAGNOSTIC = 1, + ATA_HORKAGE_NODMA = 2, + ATA_HORKAGE_NONCQ = 4, + ATA_HORKAGE_MAX_SEC_128 = 8, + ATA_HORKAGE_BROKEN_HPA = 16, + ATA_HORKAGE_DISABLE = 32, + ATA_HORKAGE_HPA_SIZE = 64, + ATA_HORKAGE_IVB = 256, + ATA_HORKAGE_STUCK_ERR = 512, + ATA_HORKAGE_BRIDGE_OK = 1024, + ATA_HORKAGE_ATAPI_MOD16_DMA = 2048, + ATA_HORKAGE_FIRMWARE_WARN = 4096, + ATA_HORKAGE_1_5_GBPS = 8192, + ATA_HORKAGE_NOSETXFER = 16384, + ATA_HORKAGE_BROKEN_FPDMA_AA = 32768, + ATA_HORKAGE_DUMP_ID = 65536, + ATA_HORKAGE_MAX_SEC_LBA48 = 131072, + ATA_HORKAGE_ATAPI_DMADIR = 262144, + ATA_HORKAGE_NO_NCQ_TRIM = 524288, + ATA_HORKAGE_NOLPM = 1048576, + ATA_HORKAGE_WD_BROKEN_LPM = 2097152, + ATA_HORKAGE_ZERO_AFTER_TRIM = 4194304, + ATA_HORKAGE_NO_NCQ_LOG = 8388608, + ATA_HORKAGE_NOTRIM = 16777216, + ATA_HORKAGE_MAX_SEC_1024 = 33554432, + ATA_DMA_MASK_ATA = 1, + ATA_DMA_MASK_ATAPI = 2, + ATA_DMA_MASK_CFA = 4, + ATAPI_READ = 0, + ATAPI_WRITE = 1, + ATAPI_READ_CD = 2, + ATAPI_PASS_THRU = 3, + ATAPI_MISC = 4, + ATA_TIMING_SETUP = 1, + ATA_TIMING_ACT8B = 2, + ATA_TIMING_REC8B = 4, + ATA_TIMING_CYC8B = 8, + ATA_TIMING_8BIT = 14, + ATA_TIMING_ACTIVE = 16, + ATA_TIMING_RECOVER = 32, + ATA_TIMING_DMACK_HOLD = 64, + ATA_TIMING_CYCLE = 128, + ATA_TIMING_UDMA = 256, + ATA_TIMING_ALL = 511, + ATA_ACPI_FILTER_SETXFER = 1, + ATA_ACPI_FILTER_LOCK = 2, + ATA_ACPI_FILTER_DIPM = 4, + ATA_ACPI_FILTER_FPDMA_OFFSET = 8, + ATA_ACPI_FILTER_FPDMA_AA = 16, + ATA_ACPI_FILTER_DEFAULT = 7, +}; + +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_PAWSPASSIVEREJECTED = 14, + LINUX_MIB_PAWSACTIVEREJECTED = 15, + LINUX_MIB_PAWSESTABREJECTED = 16, + LINUX_MIB_DELAYEDACKS = 17, + LINUX_MIB_DELAYEDACKLOCKED = 18, + LINUX_MIB_DELAYEDACKLOST = 19, + LINUX_MIB_LISTENOVERFLOWS = 20, + LINUX_MIB_LISTENDROPS = 21, + LINUX_MIB_TCPPREQUEUED = 22, + LINUX_MIB_TCPDIRECTCOPYFROMBACKLOG = 23, + LINUX_MIB_TCPDIRECTCOPYFROMPREQUEUE = 24, + LINUX_MIB_TCPPREQUEUEDROPPED = 25, + LINUX_MIB_TCPHPHITS = 26, + LINUX_MIB_TCPHPHITSTOUSER = 27, + LINUX_MIB_TCPPUREACKS = 28, + LINUX_MIB_TCPHPACKS = 29, + LINUX_MIB_TCPRENORECOVERY = 30, + LINUX_MIB_TCPSACKRECOVERY = 31, + LINUX_MIB_TCPSACKRENEGING = 32, + LINUX_MIB_TCPFACKREORDER = 33, + LINUX_MIB_TCPSACKREORDER = 34, + LINUX_MIB_TCPRENOREORDER = 35, + LINUX_MIB_TCPTSREORDER = 36, + LINUX_MIB_TCPFULLUNDO = 37, + LINUX_MIB_TCPPARTIALUNDO = 38, + LINUX_MIB_TCPDSACKUNDO = 39, + LINUX_MIB_TCPLOSSUNDO = 40, + LINUX_MIB_TCPLOSTRETRANSMIT = 41, + LINUX_MIB_TCPRENOFAILURES = 42, + LINUX_MIB_TCPSACKFAILURES = 43, + LINUX_MIB_TCPLOSSFAILURES = 44, + LINUX_MIB_TCPFASTRETRANS = 45, + LINUX_MIB_TCPFORWARDRETRANS = 46, + LINUX_MIB_TCPSLOWSTARTRETRANS = 47, + LINUX_MIB_TCPTIMEOUTS = 48, + LINUX_MIB_TCPLOSSPROBES = 49, + LINUX_MIB_TCPLOSSPROBERECOVERY = 50, + LINUX_MIB_TCPRENORECOVERYFAIL = 51, + LINUX_MIB_TCPSACKRECOVERYFAIL = 52, + LINUX_MIB_TCPSCHEDULERFAILED = 53, + LINUX_MIB_TCPRCVCOLLAPSED = 54, + LINUX_MIB_TCPDSACKOLDSENT = 55, + LINUX_MIB_TCPDSACKOFOSENT = 56, + LINUX_MIB_TCPDSACKRECV = 57, + LINUX_MIB_TCPDSACKOFORECV = 58, + LINUX_MIB_TCPABORTONDATA = 59, + LINUX_MIB_TCPABORTONCLOSE = 60, + LINUX_MIB_TCPABORTONMEMORY = 61, + LINUX_MIB_TCPABORTONTIMEOUT = 62, + LINUX_MIB_TCPABORTONLINGER = 63, + LINUX_MIB_TCPABORTFAILED = 64, + LINUX_MIB_TCPMEMORYPRESSURES = 65, + LINUX_MIB_TCPSACKDISCARD = 66, + LINUX_MIB_TCPDSACKIGNOREDOLD = 67, + LINUX_MIB_TCPDSACKIGNOREDNOUNDO = 68, + LINUX_MIB_TCPSPURIOUSRTOS = 69, + LINUX_MIB_TCPMD5NOTFOUND = 70, + LINUX_MIB_TCPMD5UNEXPECTED = 71, + LINUX_MIB_SACKSHIFTED = 72, + LINUX_MIB_SACKMERGED = 73, + LINUX_MIB_SACKSHIFTFALLBACK = 74, + LINUX_MIB_TCPBACKLOGDROP = 75, + LINUX_MIB_TCPMINTTLDROP = 76, + LINUX_MIB_TCPDEFERACCEPTDROP = 77, + LINUX_MIB_IPRPFILTER = 78, + LINUX_MIB_TCPTIMEWAITOVERFLOW = 79, + LINUX_MIB_TCPREQQFULLDOCOOKIES = 80, + LINUX_MIB_TCPREQQFULLDROP = 81, + LINUX_MIB_TCPRETRANSFAIL = 82, + LINUX_MIB_TCPRCVCOALESCE = 83, + LINUX_MIB_TCPOFOQUEUE = 84, + LINUX_MIB_TCPOFODROP = 85, + LINUX_MIB_TCPOFOMERGE = 86, + LINUX_MIB_TCPCHALLENGEACK = 87, + LINUX_MIB_TCPSYNCHALLENGE = 88, + LINUX_MIB_TCPFASTOPENACTIVE = 89, + LINUX_MIB_TCPFASTOPENACTIVEFAIL = 90, + LINUX_MIB_TCPFASTOPENPASSIVE = 91, + LINUX_MIB_TCPFASTOPENPASSIVEFAIL = 92, + LINUX_MIB_TCPFASTOPENLISTENOVERFLOW = 93, + LINUX_MIB_TCPFASTOPENCOOKIEREQD = 94, + LINUX_MIB_TCPSPURIOUS_RTX_HOSTQUEUES = 95, + LINUX_MIB_BUSYPOLLRXPACKETS = 96, + LINUX_MIB_TCPAUTOCORKING = 97, + LINUX_MIB_TCPFROMZEROWINDOWADV = 98, + LINUX_MIB_TCPTOZEROWINDOWADV = 99, + LINUX_MIB_TCPWANTZEROWINDOWADV = 100, + LINUX_MIB_TCPSYNRETRANS = 101, + LINUX_MIB_TCPORIGDATASENT = 102, + LINUX_MIB_TCPHYSTARTTRAINDETECT = 103, + LINUX_MIB_TCPHYSTARTTRAINCWND = 104, + LINUX_MIB_TCPHYSTARTDELAYDETECT = 105, + LINUX_MIB_TCPHYSTARTDELAYCWND = 106, + LINUX_MIB_TCPACKSKIPPEDSYNRECV = 107, + LINUX_MIB_TCPACKSKIPPEDPAWS = 108, + LINUX_MIB_TCPACKSKIPPEDSEQ = 109, + LINUX_MIB_TCPACKSKIPPEDFINWAIT2 = 110, + LINUX_MIB_TCPACKSKIPPEDTIMEWAIT = 111, + LINUX_MIB_TCPACKSKIPPEDCHALLENGE = 112, + LINUX_MIB_TCPWINPROBE = 113, + LINUX_MIB_TCPKEEPALIVE = 114, + LINUX_MIB_TCPMTUPFAIL = 115, + LINUX_MIB_TCPMTUPSUCCESS = 116, + __LINUX_MIB_MAX = 117, +}; + +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_XFRMMAX = 29, +}; + +enum { + LO_FLAGS_READ_ONLY = 1, + LO_FLAGS_AUTOCLEAR = 4, + LO_FLAGS_PARTSCAN = 8, + LO_FLAGS_DIRECT_IO = 16, +}; + +enum { + Lo_unbound = 0, + Lo_bound = 1, + Lo_rundown = 2, +}; + +enum { + MATCH_MTR = 0, + MATCH_MEQ = 1, + MATCH_MLE = 2, + MATCH_MLT = 3, + MATCH_MGE = 4, + MATCH_MGT = 5, +}; + +enum { + MAX_IORES_LEVEL = 5, +}; + +enum { + MAX_OPT_ARGS = 3, +}; + +enum { + MEMBLOCK_NONE = 0, + MEMBLOCK_HOTPLUG = 1, + MEMBLOCK_MIRROR = 2, + MEMBLOCK_NOMAP = 4, +}; + +enum { + MEMORY_HOTPLUG_MIN_BOOTMEM_TYPE = 12, + SECTION_INFO = 12, + MIX_SECTION_INFO = 13, + NODE_INFO = 14, + MEMORY_HOTPLUG_MAX_BOOTMEM_TYPE = 14, +}; + +enum { + MEMREMAP_WB = 1, + MEMREMAP_WT = 2, + MEMREMAP_WC = 4, +}; + +enum { + MEMTYPE_EXACT_MATCH = 0, + MEMTYPE_END_MATCH = 1, +}; + +enum { + MFC_STATIC = 1, +}; + +enum { + MIGRATE_UNMOVABLE = 0, + MIGRATE_MOVABLE = 1, + MIGRATE_RECLAIMABLE = 2, + MIGRATE_PCPTYPES = 3, + MIGRATE_HIGHATOMIC = 3, + MIGRATE_ISOLATE = 4, + MIGRATE_TYPES = 5, +}; + +enum { + MIPI_DCS_NOP = 0, + MIPI_DCS_SOFT_RESET = 1, + MIPI_DCS_GET_DISPLAY_ID = 4, + 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_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_AREA = 48, + 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_READ_MEMORY_CONTINUE = 62, + 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_DDB_CONTINUE = 168, +}; + +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_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_SET_MAXIMUM_RETURN_PACKET_SIZE = 55, + MIPI_DSI_END_OF_TRANSMISSION = 8, + MIPI_DSI_NULL_PACKET = 9, + MIPI_DSI_BLANKING_PACKET = 25, + MIPI_DSI_GENERIC_LONG_WRITE = 41, + MIPI_DSI_DCS_LONG_WRITE = 57, + 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 { + MMOP_OFFLINE = -1, + MMOP_ONLINE_KEEP = 0, + MMOP_ONLINE_KERNEL = 1, + MMOP_ONLINE_MOVABLE = 2, +}; + +enum { + MM_FILEPAGES = 0, + MM_ANONPAGES = 1, + MM_SWAPENTS = 2, + MM_SHMEMPAGES = 3, + NR_MM_COUNTERS = 4, +}; + +enum { + MODE_640x480 = 0, + MODE_800x600 = 1, + MODE_1024x768 = 2, +}; + +enum { + MPOL_DEFAULT = 0, + MPOL_PREFERRED = 1, + MPOL_BIND = 2, + MPOL_INTERLEAVE = 3, + MPOL_LOCAL = 4, + MPOL_MAX = 5, +}; + +enum { + MSI_FLAG_USE_DEF_DOM_OPS = 1, + MSI_FLAG_USE_DEF_CHIP_OPS = 2, + MSI_FLAG_IDENTITY_MAP = 4, + MSI_FLAG_MULTI_PCI_MSI = 8, + MSI_FLAG_PCI_MSIX = 16, +}; + +enum { + M_I17 = 0, + M_I20 = 1, + M_I20_SR = 2, + M_I24 = 3, + M_I24_8_1 = 4, + M_I24_10_1 = 5, + M_I27_11_1 = 6, + M_MINI = 7, + M_MINI_3_1 = 8, + M_MINI_4_1 = 9, + M_MB = 10, + M_MB_2 = 11, + M_MB_3 = 12, + M_MB_5_1 = 13, + M_MB_6_1 = 14, + M_MB_7_1 = 15, + M_MB_SR = 16, + M_MBA = 17, + M_MBA_3 = 18, + M_MBP = 19, + M_MBP_2 = 20, + M_MBP_2_2 = 21, + M_MBP_SR = 22, + M_MBP_4 = 23, + M_MBP_5_1 = 24, + M_MBP_5_2 = 25, + M_MBP_5_3 = 26, + M_MBP_6_1 = 27, + M_MBP_6_2 = 28, + M_MBP_7_1 = 29, + M_MBP_8_2 = 30, + M_UNKNOWN = 31, +}; + +enum { + NAPI_STATE_SCHED = 0, + NAPI_STATE_DISABLE = 1, + NAPI_STATE_NPSVC = 2, + NAPI_STATE_HASHED = 3, + NAPI_STATE_NO_BUSY_POLL = 4, +}; + +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_MAX = 11, +}; + +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_MAX = 19, +}; + +enum { + NEIGH_ARP_TABLE = 0, + NEIGH_ND_TABLE = 1, + NEIGH_DN_TABLE = 2, + NEIGH_NR_TABLES = 3, + NEIGH_LINK_TABLE = 3, +}; + +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_GC_STALETIME = 7, + NEIGH_VAR_QUEUE_LEN_BYTES = 8, + NEIGH_VAR_PROXY_QLEN = 9, + NEIGH_VAR_ANYCAST_DELAY = 10, + NEIGH_VAR_PROXY_DELAY = 11, + NEIGH_VAR_LOCKTIME = 12, + NEIGH_VAR_QUEUE_LEN = 13, + NEIGH_VAR_RETRANS_TIME_MS = 14, + NEIGH_VAR_BASE_REACHABLE_TIME_MS = 15, + NEIGH_VAR_GC_INTERVAL = 16, + NEIGH_VAR_GC_THRESH1 = 17, + NEIGH_VAR_GC_THRESH2 = 18, + NEIGH_VAR_GC_THRESH3 = 19, + NEIGH_VAR_MAX = 20, +}; + +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_MAX = 7, +}; + +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, + NETIF_F_LLTX_BIT = 12, + NETIF_F_NETNS_LOCAL_BIT = 13, + NETIF_F_GRO_BIT = 14, + NETIF_F_LRO_BIT = 15, + NETIF_F_GSO_SHIFT = 16, + NETIF_F_TSO_BIT = 16, + NETIF_F_UFO_BIT = 17, + NETIF_F_GSO_ROBUST_BIT = 18, + NETIF_F_TSO_ECN_BIT = 19, + NETIF_F_TSO_MANGLEID_BIT = 20, + NETIF_F_TSO6_BIT = 21, + NETIF_F_FSO_BIT = 22, + NETIF_F_GSO_GRE_BIT = 23, + NETIF_F_GSO_GRE_CSUM_BIT = 24, + NETIF_F_GSO_IPXIP4_BIT = 25, + NETIF_F_GSO_IPXIP6_BIT = 26, + NETIF_F_GSO_UDP_TUNNEL_BIT = 27, + NETIF_F_GSO_UDP_TUNNEL_CSUM_BIT = 28, + NETIF_F_GSO_PARTIAL_BIT = 29, + NETIF_F_GSO_TUNNEL_REMCSUM_BIT = 30, + NETIF_F_GSO_LAST = 30, + NETIF_F_FCOE_CRC_BIT = 31, + NETIF_F_SCTP_CRC_BIT = 32, + NETIF_F_FCOE_MTU_BIT = 33, + NETIF_F_NTUPLE_BIT = 34, + NETIF_F_RXHASH_BIT = 35, + NETIF_F_RXCSUM_BIT = 36, + NETIF_F_NOCACHE_COPY_BIT = 37, + NETIF_F_LOOPBACK_BIT = 38, + NETIF_F_RXFCS_BIT = 39, + NETIF_F_RXALL_BIT = 40, + NETIF_F_HW_VLAN_STAG_TX_BIT = 41, + NETIF_F_HW_VLAN_STAG_RX_BIT = 42, + NETIF_F_HW_VLAN_STAG_FILTER_BIT = 43, + NETIF_F_HW_L2FW_DOFFLOAD_BIT = 44, + NETIF_F_BUSY_POLL_BIT = 45, + NETIF_F_HW_TC_BIT = 46, + NETDEV_FEATURE_COUNT = 47, +}; + +enum { + NETLINK_UNCONNECTED = 0, + NETLINK_CONNECTED = 1, +}; + +enum { + NETNSA_NONE = 0, + NETNSA_NSID = 1, + NETNSA_PID = 2, + NETNSA_FD = 3, + __NETNSA_MAX = 4, +}; + +enum { + NFPROTO_UNSPEC = 0, + NFPROTO_INET = 1, + NFPROTO_IPV4 = 2, + NFPROTO_ARP = 3, + NFPROTO_NETDEV = 5, + NFPROTO_BRIDGE = 7, + NFPROTO_IPV6 = 10, + NFPROTO_DECNET = 12, + NFPROTO_NUMPROTO = 13, +}; + +enum { + NID_PATH_VOL_CTL = 0, + NID_PATH_MUTE_CTL = 1, + NID_PATH_BOOST_CTL = 2, + NID_PATH_NUM_CTLS = 3, +}; + +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_COMPAT = 9, + NLA_NUL_STRING = 10, + NLA_BINARY = 11, + NLA_S8 = 12, + NLA_S16 = 13, + NLA_S32 = 14, + NLA_S64 = 15, + __NLA_TYPE_MAX = 16, +}; + +enum { + NMI_LOCAL = 0, + NMI_UNKNOWN = 1, + NMI_SERR = 2, + NMI_IO_CHECK = 3, + NMI_MAX = 4, +}; + +enum { + NONE_FORCE_HPET_RESUME = 0, + OLD_ICH_FORCE_HPET_RESUME = 1, + ICH_FORCE_HPET_RESUME = 2, + VT8237_FORCE_HPET_RESUME = 3, + NVIDIA_FORCE_HPET_RESUME = 4, + ATI_FORCE_HPET_RESUME = 5, +}; + +enum { + NO_SIZE = 0, + SIZE_STD = 1, + SIZE_PERCENT = 2, +}; + +enum { + NVD_PCMIN = 0, + NVD_PCMOUT = 1, + NVD_MIC = 2, + NVD_SPBAR = 3, + NVD_LAST = 3, +}; + +enum { + OPT_FD = 0, + OPT_ROOTMODE = 1, + OPT_USER_ID = 2, + OPT_GROUP_ID = 3, + OPT_DEFAULT_PERMISSIONS = 4, + OPT_ALLOW_OTHER = 5, + OPT_MAX_READ = 6, + OPT_BLKSIZE = 7, + OPT_ERR = 8, +}; + +enum { + OPT_LOWERDIR = 0, + OPT_UPPERDIR = 1, + OPT_WORKDIR = 2, + OPT_DEFAULT_PERMISSIONS___2 = 3, + OPT_ERR___2 = 4, +}; + +enum { + OUTSIDE_GUEST_MODE = 0, + IN_GUEST_MODE = 1, + EXITING_GUEST_MODE = 2, + READING_SHADOW_PAGE_TABLES = 3, +}; + +enum { + OVERRIDE_NONE = 0, + OVERRIDE_BASE = 1, + OVERRIDE_STRIDE = 2, + OVERRIDE_HEIGHT = 4, + OVERRIDE_WIDTH = 8, +}; + +enum { + Opt_block = 0, + Opt_check_r = 1, + Opt_check_s = 2, + Opt_cruft = 3, + Opt_gid = 4, + Opt_ignore = 5, + Opt_iocharset = 6, + Opt_map_a = 7, + Opt_map_n = 8, + Opt_map_o = 9, + Opt_mode = 10, + Opt_nojoliet = 11, + Opt_norock = 12, + Opt_sb = 13, + Opt_session = 14, + Opt_uid = 15, + Opt_unhide = 16, + Opt_utf8 = 17, + Opt_err = 18, + Opt_nocompress = 19, + Opt_hide = 20, + Opt_showassoc = 21, + Opt_dmode = 22, + Opt_overriderockperm = 23, +}; + +enum { + Opt_debug = 0, + Opt_dfltuid = 1, + Opt_dfltgid = 2, + Opt_afid = 3, + Opt_uname = 4, + Opt_remotename = 5, + Opt_cache = 6, + Opt_cachetag = 7, + Opt_nodevmap = 8, + Opt_cache_loose = 9, + Opt_fscache = 10, + Opt_mmap = 11, + Opt_access = 12, + Opt_posixacl = 13, + Opt_err___2 = 14, +}; + +enum { + Opt_gid___2 = 0, + Opt_hidepid = 1, + Opt_err___3 = 2, +}; + +enum { + Opt_mode___2 = 0, + Opt_err___4 = 1, +}; + +enum { + Opt_msize = 0, + Opt_trans = 1, + Opt_legacy = 2, + Opt_version = 3, + Opt_err___5 = 4, +}; + +enum { + Opt_port = 0, + Opt_rfdno = 1, + Opt_wfdno = 2, + Opt_err___6 = 3, + Opt_privport = 4, +}; + +enum { + Opt_size = 0, + Opt_nr_inodes = 1, + Opt_mode___3 = 2, + Opt_uid___2 = 3, + Opt_gid___3 = 4, + Opt_pagesize = 5, + Opt_min_size = 6, + Opt_err___7 = 7, +}; + +enum { + Opt_uid___3 = 0, + Opt_gid___4 = 1, + Opt_mode___4 = 2, + Opt_ptmxmode = 3, + Opt_newinstance = 4, + Opt_max = 5, + Opt_err___8 = 6, +}; + +enum { + Opt_uid___4 = 0, + Opt_gid___5 = 1, + Opt_mode___5 = 2, + Opt_err___9 = 3, +}; + +enum { + PAT_UC = 0, + PAT_WC = 1, + PAT_WT = 4, + PAT_WP = 5, + PAT_WB = 6, + PAT_UC_MINUS = 7, +}; + +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_BRIDGE_RESOURCES = 7, + PCI_BRIDGE_RESOURCE_END = 10, + PCI_NUM_RESOURCES = 11, + DEVICE_COUNT_RESOURCE = 11, +}; + +enum { + PCMCIA_IOPORT_0 = 0, + PCMCIA_IOPORT_1 = 1, + PCMCIA_IOMEM_0 = 2, + PCMCIA_IOMEM_1 = 3, + PCMCIA_IOMEM_2 = 4, + PCMCIA_IOMEM_3 = 5, + PCMCIA_NUM_RESOURCES = 6, +}; + +enum { + PERCPU_REF_INIT_ATOMIC = 1, + PERCPU_REF_INIT_DEAD = 2, +}; + +enum { + PERF_TXN_ELISION = 1ULL, + PERF_TXN_TRANSACTION = 2ULL, + PERF_TXN_SYNC = 4ULL, + PERF_TXN_ASYNC = 8ULL, + PERF_TXN_RETRY = 16ULL, + PERF_TXN_CONFLICT = 32ULL, + PERF_TXN_CAPACITY_WRITE = 64ULL, + PERF_TXN_CAPACITY_READ = 128ULL, + PERF_TXN_MAX = 256ULL, + PERF_TXN_ABORT_MASK = 18446744069414584320ULL, + PERF_TXN_ABORT_SHIFT = 32ULL, +}; + +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 { + PIIX_IOCFG = 84, + ICH5_PMR = 144, + ICH5_PCS = 146, + PIIX_SIDPR_BAR = 5, + PIIX_SIDPR_LEN = 16, + PIIX_SIDPR_IDX = 0, + PIIX_SIDPR_DATA = 4, + PIIX_FLAG_CHECKINTR = 268435456, + PIIX_FLAG_SIDPR = 536870912, + PIIX_PATA_FLAGS = 1, + PIIX_SATA_FLAGS = 268435458, + PIIX_FLAG_PIO16 = 1073741824, + PIIX_80C_PRI = 48, + PIIX_80C_SEC = 192, + P0 = 0, + P1 = 1, + P2 = 2, + P3 = 3, + IDE = -1, + NA = -2, + RV = -3, + PIIX_AHCI_DEVICE = 6, + PIIX_HOST_BROKEN_SUSPEND = 16777216, +}; + +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 { + PM_QOS_RESERVED = 0, + PM_QOS_CPU_DMA_LATENCY = 1, + PM_QOS_NETWORK_LATENCY = 2, + PM_QOS_NETWORK_THROUGHPUT = 3, + PM_QOS_MEMORY_BANDWIDTH = 4, + PM_QOS_NUM_CLASSES = 5, +}; + +enum { + POOL_DISASSOCIATED = 4, + WORKER_DIE = 2, + WORKER_IDLE = 4, + WORKER_PREP = 8, + WORKER_CPU_INTENSIVE = 64, + WORKER_UNBOUND = 128, + WORKER_REBOUND = 256, + WORKER_NOT_RUNNING = 456, + 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 = 24, +}; + +enum { + POS_FIX_AUTO = 0, + POS_FIX_LPIB = 1, + POS_FIX_POSBUF = 2, + POS_FIX_VIACOMBO = 3, + POS_FIX_COMBO = 4, +}; + +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_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 { + PROBE_TEST_FUNC = 1, + PROBE_TEST_DATA = 2, +}; + +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, +}; + +enum { + PWIDX_ADC = 0, + PWIDX_FRONT = 1, + PWIDX_CLFE = 2, + PWIDX_SURR = 3, + PWIDX_MIC = 4, + PWIDX_SIZE = 5, +}; + +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 { + QI_FREE = 0, + QI_IN_USE = 1, + QI_DONE = 2, + QI_ABORT = 3, +}; + +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 { + RB_CTX_NMI = 0, + RB_CTX_IRQ = 1, + RB_CTX_SOFTIRQ = 2, + RB_CTX_NORMAL = 3, + RB_CTX_MAX = 4, +}; + +enum { + RB_LEN_TIME_EXTEND = 8, + RB_LEN_TIME_STAMP = 16, +}; + +enum { + REGION_INTERSECTS = 0, + REGION_DISJOINT = 1, + REGION_MIXED = 2, +}; + +enum { + REG_OP_ISFREE = 0, + REG_OP_ALLOC = 1, + REG_OP_RELEASE = 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 { + RET_MMIO_PF_EMULATE = 1, + RET_MMIO_PF_INVALID = 2, + RET_MMIO_PF_RETRY = 0, + RET_MMIO_PF_BUG = -1, +}; + +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_MAX = 17, +}; + +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_GETMULTICAST = 58, + 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_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_MAX = 95, +}; + +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 { + Root_NFS = 255, + Root_RAM0 = 1048576, + Root_RAM1 = 1048577, + Root_FD0 = 2097152, + Root_HDA1 = 3145729, + Root_HDA2 = 3145730, + Root_SDA1 = 8388609, + Root_SDA2 = 8388610, + Root_HDC1 = 23068673, + Root_SR0 = 11534336, +}; + +enum { + Rworksched = 1, + Rpending = 2, + Wworksched = 4, + Wpending = 8, +}; + +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_DEVINFO_GLOBAL = 0, + SCSI_DEVINFO_SPI = 1, +}; + +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 { + SKBTX_HW_TSTAMP = 1, + SKBTX_SW_TSTAMP = 2, + SKBTX_IN_PROGRESS = 4, + SKBTX_DEV_ZEROCOPY = 8, + SKBTX_WIFI_STATUS = 16, + SKBTX_SHARED_FRAG = 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_UDP = 2, + SKB_GSO_DODGY = 4, + SKB_GSO_TCP_ECN = 8, + SKB_GSO_TCP_FIXEDID = 16, + SKB_GSO_TCPV6 = 32, + SKB_GSO_FCOE = 64, + SKB_GSO_GRE = 128, + SKB_GSO_GRE_CSUM = 256, + SKB_GSO_IPXIP4 = 512, + SKB_GSO_IPXIP6 = 1024, + SKB_GSO_UDP_TUNNEL = 2048, + SKB_GSO_UDP_TUNNEL_CSUM = 4096, + SKB_GSO_PARTIAL = 8192, + SKB_GSO_TUNNEL_REMCSUM = 16384, +}; + +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 { + SMP_OK = 0, + SMP_NO_CONFIG = 1, + SMP_NO_APIC = 2, + SMP_FORCE_UP = 3, +}; + +enum { + SNBEP_PCI_QPI_PORT0_FILTER = 0, + SNBEP_PCI_QPI_PORT1_FILTER = 1, + HSWEP_PCI_PCU_3 = 2, +}; + +enum { + SNBEP_PCI_UNCORE_HA = 0, + SNBEP_PCI_UNCORE_IMC = 1, + SNBEP_PCI_UNCORE_QPI = 2, + SNBEP_PCI_UNCORE_R2PCIE = 3, + SNBEP_PCI_UNCORE_R3QPI = 4, +}; + +enum { + SNB_PCI_UNCORE_IMC = 0, +}; + +enum { + SNDRV_CHMAP_UNKNOWN = 0, + SNDRV_CHMAP_NA = 1, + SNDRV_CHMAP_MONO = 2, + SNDRV_CHMAP_FL = 3, + SNDRV_CHMAP_FR = 4, + SNDRV_CHMAP_RL = 5, + SNDRV_CHMAP_RR = 6, + SNDRV_CHMAP_FC = 7, + SNDRV_CHMAP_LFE = 8, + SNDRV_CHMAP_SL = 9, + SNDRV_CHMAP_SR = 10, + SNDRV_CHMAP_RC = 11, + SNDRV_CHMAP_FLC = 12, + SNDRV_CHMAP_FRC = 13, + SNDRV_CHMAP_RLC = 14, + SNDRV_CHMAP_RRC = 15, + SNDRV_CHMAP_FLW = 16, + SNDRV_CHMAP_FRW = 17, + SNDRV_CHMAP_FLH = 18, + SNDRV_CHMAP_FCH = 19, + SNDRV_CHMAP_FRH = 20, + SNDRV_CHMAP_TC = 21, + SNDRV_CHMAP_TFL = 22, + SNDRV_CHMAP_TFR = 23, + SNDRV_CHMAP_TFC = 24, + SNDRV_CHMAP_TRL = 25, + SNDRV_CHMAP_TRR = 26, + SNDRV_CHMAP_TRC = 27, + SNDRV_CHMAP_TFLC = 28, + SNDRV_CHMAP_TFRC = 29, + SNDRV_CHMAP_TSL = 30, + SNDRV_CHMAP_TSR = 31, + SNDRV_CHMAP_LLFE = 32, + SNDRV_CHMAP_RLFE = 33, + SNDRV_CHMAP_BC = 34, + SNDRV_CHMAP_BLC = 35, + SNDRV_CHMAP_BRC = 36, + SNDRV_CHMAP_LAST = 36, +}; + +enum { + SNDRV_CTL_IOCTL_ELEM_LIST32 = 3225965840, + SNDRV_CTL_IOCTL_ELEM_INFO32 = 3239073041, + SNDRV_CTL_IOCTL_ELEM_READ32 = 3267646738, + SNDRV_CTL_IOCTL_ELEM_WRITE32 = 3267646739, + SNDRV_CTL_IOCTL_ELEM_ADD32 = 3239073047, + SNDRV_CTL_IOCTL_ELEM_REPLACE32 = 3239073048, +}; + +enum { + SNDRV_CTL_TLV_OP_READ = 0, + SNDRV_CTL_TLV_OP_WRITE = 1, + SNDRV_CTL_TLV_OP_CMD = -1, +}; + +enum { + SNDRV_HWDEP_IFACE_OPL2 = 0, + SNDRV_HWDEP_IFACE_OPL3 = 1, + SNDRV_HWDEP_IFACE_OPL4 = 2, + SNDRV_HWDEP_IFACE_SB16CSP = 3, + SNDRV_HWDEP_IFACE_EMU10K1 = 4, + SNDRV_HWDEP_IFACE_YSS225 = 5, + SNDRV_HWDEP_IFACE_ICS2115 = 6, + SNDRV_HWDEP_IFACE_SSCAPE = 7, + SNDRV_HWDEP_IFACE_VX = 8, + SNDRV_HWDEP_IFACE_MIXART = 9, + SNDRV_HWDEP_IFACE_USX2Y = 10, + SNDRV_HWDEP_IFACE_EMUX_WAVETABLE = 11, + SNDRV_HWDEP_IFACE_BLUETOOTH = 12, + SNDRV_HWDEP_IFACE_USX2Y_PCM = 13, + SNDRV_HWDEP_IFACE_PCXHR = 14, + SNDRV_HWDEP_IFACE_SB_RC = 15, + SNDRV_HWDEP_IFACE_HDA = 16, + SNDRV_HWDEP_IFACE_USB_STREAM = 17, + SNDRV_HWDEP_IFACE_FW_DICE = 18, + SNDRV_HWDEP_IFACE_FW_FIREWORKS = 19, + SNDRV_HWDEP_IFACE_FW_BEBOB = 20, + SNDRV_HWDEP_IFACE_FW_OXFW = 21, + SNDRV_HWDEP_IFACE_FW_DIGI00X = 22, + SNDRV_HWDEP_IFACE_FW_TASCAM = 23, + SNDRV_HWDEP_IFACE_LAST = 23, +}; + +enum { + SNDRV_HWDEP_IOCTL_DSP_LOAD32 = 1079003139, +}; + +enum { + SNDRV_PCM_AUDIO_TSTAMP_TYPE_COMPAT = 0, + SNDRV_PCM_AUDIO_TSTAMP_TYPE_DEFAULT = 1, + SNDRV_PCM_AUDIO_TSTAMP_TYPE_LINK = 2, + SNDRV_PCM_AUDIO_TSTAMP_TYPE_LINK_ABSOLUTE = 3, + SNDRV_PCM_AUDIO_TSTAMP_TYPE_LINK_ESTIMATED = 4, + SNDRV_PCM_AUDIO_TSTAMP_TYPE_LINK_SYNCHRONIZED = 5, + SNDRV_PCM_AUDIO_TSTAMP_TYPE_LAST = 5, +}; + +enum { + SNDRV_PCM_CLASS_GENERIC = 0, + SNDRV_PCM_CLASS_MULTI = 1, + SNDRV_PCM_CLASS_MODEM = 2, + SNDRV_PCM_CLASS_DIGITIZER = 3, + SNDRV_PCM_CLASS_LAST = 3, +}; + +enum { + SNDRV_PCM_IOCTL_HW_REFINE32 = 3260825872, + SNDRV_PCM_IOCTL_HW_PARAMS32 = 3260825873, + SNDRV_PCM_IOCTL_SW_PARAMS32 = 3228057875, + SNDRV_PCM_IOCTL_STATUS32 = 2154578208, + SNDRV_PCM_IOCTL_STATUS_EXT32 = 3228320036, + SNDRV_PCM_IOCTL_DELAY32 = 2147762465, + SNDRV_PCM_IOCTL_CHANNEL_INFO32 = 2148548914, + SNDRV_PCM_IOCTL_REWIND32 = 1074020678, + SNDRV_PCM_IOCTL_FORWARD32 = 1074020681, + SNDRV_PCM_IOCTL_WRITEI_FRAMES32 = 1074544976, + SNDRV_PCM_IOCTL_READI_FRAMES32 = 2148286801, + SNDRV_PCM_IOCTL_WRITEN_FRAMES32 = 1074544978, + SNDRV_PCM_IOCTL_READN_FRAMES32 = 2148286803, + SNDRV_PCM_IOCTL_SYNC_PTR32 = 3229892899, +}; + +enum { + SNDRV_PCM_MMAP_OFFSET_DATA = 0, + SNDRV_PCM_MMAP_OFFSET_STATUS = 2147483648, + SNDRV_PCM_MMAP_OFFSET_CONTROL = 2164260864, +}; + +enum { + SNDRV_PCM_STREAM_PLAYBACK = 0, + SNDRV_PCM_STREAM_CAPTURE = 1, + SNDRV_PCM_STREAM_LAST = 1, +}; + +enum { + SNDRV_PCM_TSTAMP_NONE = 0, + SNDRV_PCM_TSTAMP_ENABLE = 1, + SNDRV_PCM_TSTAMP_LAST = 1, +}; + +enum { + SNDRV_PCM_TSTAMP_TYPE_GETTIMEOFDAY = 0, + SNDRV_PCM_TSTAMP_TYPE_MONOTONIC = 1, + SNDRV_PCM_TSTAMP_TYPE_MONOTONIC_RAW = 2, + SNDRV_PCM_TSTAMP_TYPE_LAST = 2, +}; + +enum { + SNDRV_SEQ_IOCTL_CREATE_PORT32 = 3231994656, + SNDRV_SEQ_IOCTL_DELETE_PORT32 = 1084511009, + SNDRV_SEQ_IOCTL_GET_PORT_INFO32 = 3231994658, + SNDRV_SEQ_IOCTL_SET_PORT_INFO32 = 1084511011, + SNDRV_SEQ_IOCTL_QUERY_NEXT_PORT32 = 3231994706, +}; + +enum { + SNDRV_TIMER_CLASS_NONE = -1, + SNDRV_TIMER_CLASS_SLAVE = 0, + SNDRV_TIMER_CLASS_GLOBAL = 1, + SNDRV_TIMER_CLASS_CARD = 2, + SNDRV_TIMER_CLASS_PCM = 3, + SNDRV_TIMER_CLASS_LAST = 3, +}; + +enum { + SNDRV_TIMER_EVENT_RESOLUTION = 0, + SNDRV_TIMER_EVENT_TICK = 1, + SNDRV_TIMER_EVENT_START = 2, + SNDRV_TIMER_EVENT_STOP = 3, + SNDRV_TIMER_EVENT_CONTINUE = 4, + SNDRV_TIMER_EVENT_PAUSE = 5, + SNDRV_TIMER_EVENT_EARLY = 6, + SNDRV_TIMER_EVENT_SUSPEND = 7, + SNDRV_TIMER_EVENT_RESUME = 8, + SNDRV_TIMER_EVENT_MSTART = 12, + SNDRV_TIMER_EVENT_MSTOP = 13, + SNDRV_TIMER_EVENT_MCONTINUE = 14, + SNDRV_TIMER_EVENT_MPAUSE = 15, + SNDRV_TIMER_EVENT_MSUSPEND = 17, + SNDRV_TIMER_EVENT_MRESUME = 18, +}; + +enum { + SNDRV_TIMER_IOCTL_GPARAMS32 = 1077695492, + SNDRV_TIMER_IOCTL_INFO32 = 2162185233, + SNDRV_TIMER_IOCTL_STATUS32 = 1079530516, +}; + +enum { + SNDRV_TIMER_IOCTL_START_OLD = 21536, + SNDRV_TIMER_IOCTL_STOP_OLD = 21537, + SNDRV_TIMER_IOCTL_CONTINUE_OLD = 21538, + SNDRV_TIMER_IOCTL_PAUSE_OLD = 21539, +}; + +enum { + SNDRV_TIMER_SCLASS_NONE = 0, + SNDRV_TIMER_SCLASS_APPLICATION = 1, + SNDRV_TIMER_SCLASS_SEQUENCER = 2, + SNDRV_TIMER_SCLASS_OSS_SEQUENCER = 3, + SNDRV_TIMER_SCLASS_LAST = 3, +}; + +enum { + SND_CTL_SUBDEV_PCM = 0, + SND_CTL_SUBDEV_RAWMIDI = 1, + SND_CTL_SUBDEV_ITEMS = 2, +}; + +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_LAST = 2048, + SOF_TIMESTAMPING_MASK = 4095, +}; + +enum { + SPI_BLIST_NOIUS = 1, +}; + +enum { + SR_DMAR_FECTL_REG = 0, + SR_DMAR_FEDATA_REG = 1, + SR_DMAR_FEADDR_REG = 2, + SR_DMAR_FEUADDR_REG = 3, + MAX_SR_DMAR_REGS = 4, +}; + +enum { + STREAM_MULTI_OUT = 0, + STREAM_INDEP_HP = 1, +}; + +enum { + SWP_USED = 1, + SWP_WRITEOK = 2, + SWP_DISCARDABLE = 4, + SWP_DISCARDING = 8, + SWP_SOLIDSTATE = 16, + SWP_CONTINUED = 32, + SWP_BLKDEV = 64, + SWP_FILE = 128, + SWP_AREA_DISCARD = 256, + SWP_PAGE_DISCARD = 512, + SWP_SCANNING = 1024, +}; + +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_SWITCH_CALL = 0, + TASK_SWITCH_IRET = 1, + TASK_SWITCH_JMP = 2, + TASK_SWITCH_GATE = 3, +}; + +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_MAX = 6, +}; + +enum { + TCA_EMATCH_TREE_UNSPEC = 0, + TCA_EMATCH_TREE_HDR = 1, + TCA_EMATCH_TREE_LIST = 2, + __TCA_EMATCH_TREE_MAX = 3, +}; + +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_MAX = 7, +}; + +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_MAX = 10, +}; + +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, +}; + +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_MAX_STATES = 13, +}; + +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_NO_QUEUE = 0, + TCP_RECV_QUEUE = 1, + TCP_SEND_QUEUE = 2, + TCP_QUEUES_NR = 3, +}; + +enum { + TEST_NONE = 0, + TEST_CORE = 1, + TEST_CPUS = 2, + TEST_PLATFORM = 3, + TEST_DEVICES = 4, + TEST_FREEZER = 5, + __TEST_AFTER_LAST = 6, +}; + +enum { + THERMAL_GENL_ATTR_UNSPEC = 0, + THERMAL_GENL_ATTR_EVENT = 1, + __THERMAL_GENL_ATTR_MAX = 2, +}; + +enum { + THERMAL_GENL_CMD_UNSPEC = 0, + THERMAL_GENL_CMD_EVENT = 1, + __THERMAL_GENL_CMD_MAX = 2, +}; + +enum { + TRACE_ARRAY_FL_GLOBAL = 1, +}; + +enum { + TRACE_BUFFER_BIT = 0, + TRACE_BUFFER_NMI_BIT = 1, + TRACE_BUFFER_IRQ_BIT = 2, + TRACE_BUFFER_SIRQ_BIT = 3, + TRACE_FTRACE_BIT = 4, + TRACE_FTRACE_NMI_BIT = 5, + TRACE_FTRACE_IRQ_BIT = 6, + TRACE_FTRACE_SIRQ_BIT = 7, + TRACE_INTERNAL_BIT = 8, + TRACE_INTERNAL_NMI_BIT = 9, + TRACE_INTERNAL_IRQ_BIT = 10, + TRACE_INTERNAL_SIRQ_BIT = 11, + TRACE_BRANCH_BIT = 12, + TRACE_IRQ_BIT = 13, +}; + +enum { + TRACE_EVENT_FL_FILTERED = 1, + TRACE_EVENT_FL_CAP_ANY = 2, + TRACE_EVENT_FL_NO_SET_FILTER = 4, + TRACE_EVENT_FL_IGNORE_ENABLE = 8, + TRACE_EVENT_FL_WAS_ENABLED = 16, + TRACE_EVENT_FL_TRACEPOINT = 32, + TRACE_EVENT_FL_KPROBE = 64, + TRACE_EVENT_FL_UPROBE = 128, +}; + +enum { + TRACE_EVENT_FL_FILTERED_BIT = 0, + TRACE_EVENT_FL_CAP_ANY_BIT = 1, + TRACE_EVENT_FL_NO_SET_FILTER_BIT = 2, + TRACE_EVENT_FL_IGNORE_ENABLE_BIT = 3, + TRACE_EVENT_FL_WAS_ENABLED_BIT = 4, + TRACE_EVENT_FL_TRACEPOINT_BIT = 5, + TRACE_EVENT_FL_KPROBE_BIT = 6, + TRACE_EVENT_FL_UPROBE_BIT = 7, +}; + +enum { + TRACE_FUNC_OPT_STACK = 1, +}; + +enum { + TRACE_NOP_OPT_ACCEPT = 1, + TRACE_NOP_OPT_REFUSE = 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 { + TSK_TRACE_FL_TRACE = 1, + TSK_TRACE_FL_GRAPH = 2, +}; + +enum { + TSK_TRACE_FL_TRACE_BIT = 0, + TSK_TRACE_FL_GRAPH_BIT = 1, +}; + +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_MAX = 9, +}; + +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 { + VCPU_SREG_ES = 0, + VCPU_SREG_CS = 1, + VCPU_SREG_SS = 2, + VCPU_SREG_DS = 3, + VCPU_SREG_FS = 4, + VCPU_SREG_GS = 5, + VCPU_SREG_TR = 6, + VCPU_SREG_LDTR = 7, +}; + +enum { + VERBOSE_STATUS = 1, +}; + +enum { + VIA_STRFILT_CNT_SHIFT = 16, + VIA_STRFILT_FAIL = 32768, + VIA_STRFILT_ENABLE = 16384, + VIA_RAWBITS_ENABLE = 8192, + VIA_RNG_ENABLE = 64, + VIA_NOISESRC1 = 256, + VIA_NOISESRC2 = 512, + VIA_XSTORE_CNT_MASK = 15, + VIA_RNG_CHUNK_8 = 0, + VIA_RNG_CHUNK_4 = 1, + VIA_RNG_CHUNK_4_MASK = 4294967295, + VIA_RNG_CHUNK_2 = 2, + VIA_RNG_CHUNK_2_MASK = 65535, + VIA_RNG_CHUNK_1 = 3, + VIA_RNG_CHUNK_1_MASK = 255, +}; + +enum { + VMCB_INTERCEPTS = 0, + VMCB_PERM_MAP = 1, + VMCB_ASID = 2, + VMCB_INTR = 3, + VMCB_NPT = 4, + VMCB_CR = 5, + VMCB_DR = 6, + VMCB_DT = 7, + VMCB_SEG = 8, + VMCB_CR2 = 9, + VMCB_LBR = 10, + VMCB_AVIC = 11, + VMCB_DIRTY_MAX = 12, +}; + +enum { + VP_MSIX_CONFIG_VECTOR = 0, + VP_MSIX_VQ_VECTOR = 1, +}; + +enum { + WALK_GET = 1, + WALK_PUT = 2, +}; + +enum { + WORK_STRUCT_PENDING_BIT = 0LL, + WORK_STRUCT_DELAYED_BIT = 1LL, + WORK_STRUCT_PWQ_BIT = 2LL, + WORK_STRUCT_LINKED_BIT = 3LL, + WORK_STRUCT_COLOR_SHIFT = 4LL, + WORK_STRUCT_COLOR_BITS = 4LL, + WORK_STRUCT_PENDING = 1LL, + WORK_STRUCT_DELAYED = 2LL, + WORK_STRUCT_PWQ = 4LL, + WORK_STRUCT_LINKED = 8LL, + WORK_STRUCT_STATIC = 0LL, + WORK_NR_COLORS = 15LL, + WORK_NO_COLOR = 15LL, + WORK_CPU_UNBOUND = 64LL, + WORK_STRUCT_FLAG_BITS = 8LL, + WORK_OFFQ_FLAG_BASE = 4LL, + __WORK_OFFQ_CANCELING = 4LL, + WORK_OFFQ_CANCELING = 16LL, + WORK_OFFQ_FLAG_BITS = 1LL, + WORK_OFFQ_POOL_SHIFT = 5LL, + WORK_OFFQ_LEFT = 59LL, + WORK_OFFQ_POOL_BITS = 31LL, + WORK_OFFQ_POOL_NONE = 2147483647LL, + WORK_STRUCT_FLAG_MASK = 255LL, + WORK_STRUCT_WQ_DATA_MASK = -256LL, + WORK_STRUCT_NO_POOL = 68719476704LL, + WORK_BUSY_PENDING = 1LL, + WORK_BUSY_RUNNING = 2LL, + WORKER_DESC_LEN = 24LL, +}; + +enum { + 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_DRAINING = 65536, + __WQ_ORDERED = 131072, + __WQ_LEGACY = 262144, + WQ_MAX_ACTIVE = 512, + WQ_MAX_UNBOUND_PER_CPU = 4, + WQ_DFL_ACTIVE = 256, +}; + +enum { + X86_BR_NONE = 0, + X86_BR_USER = 1, + X86_BR_KERNEL = 2, + X86_BR_CALL = 4, + X86_BR_RET = 8, + X86_BR_SYSCALL = 16, + X86_BR_SYSRET = 32, + X86_BR_INT = 64, + X86_BR_IRET = 128, + X86_BR_JCC = 256, + X86_BR_JMP = 512, + X86_BR_IRQ = 1024, + X86_BR_IND_CALL = 2048, + X86_BR_ABORT = 4096, + X86_BR_IN_TX = 8192, + X86_BR_NO_TX = 16384, + X86_BR_ZERO_CALL = 32768, + X86_BR_CALL_STACK = 65536, + X86_BR_IND_JMP = 131072, +}; + +enum { + X86_IRQ_ALLOC_CONTIGUOUS_VECTORS = 1, +}; + +enum { + X86_PERF_KFREE_SHARED = 0, + X86_PERF_KFREE_EXCL = 1, + X86_PERF_KFREE_MAX = 2, +}; + +enum { + X86_TRAP_DE = 0, + X86_TRAP_DB = 1, + X86_TRAP_NMI = 2, + X86_TRAP_BP = 3, + X86_TRAP_OF = 4, + X86_TRAP_BR = 5, + X86_TRAP_UD = 6, + X86_TRAP_NM = 7, + X86_TRAP_DF = 8, + X86_TRAP_OLD_MF = 9, + X86_TRAP_TS = 10, + X86_TRAP_NP = 11, + X86_TRAP_SS = 12, + X86_TRAP_GP = 13, + X86_TRAP_PF = 14, + X86_TRAP_SPURIOUS = 15, + X86_TRAP_MF = 16, + X86_TRAP_AC = 17, + X86_TRAP_MC = 18, + X86_TRAP_XF = 19, + X86_TRAP_IRET = 32, +}; + +enum { + XFRM_LOOKUP_ICMP = 1, + XFRM_LOOKUP_QUEUE = 2, + XFRM_LOOKUP_KEEP_DST_REF = 4, +}; + +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 { + ZONELIST_FALLBACK = 0, + ZONELIST_NOFALLBACK = 1, + MAX_ZONELISTS = 2, +}; + +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_MOVE_PCNTXT = 16384, + _IRQ_NO_BALANCING = 8192, + _IRQ_NESTED_THREAD = 32768, + _IRQ_PER_CPU_DEVID = 131072, + _IRQ_IS_POLLED = 262144, + _IRQ_DISABLE_UNLAZY = 524288, + _IRQF_MODIFY_MASK = 1048335, +}; + +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_ARRAY_MAX = 6, + ND_OPT_ROUTE_INFO = 24, + ND_OPT_RDNSS = 25, + ND_OPT_DNSSL = 31, + __ND_OPT_MAX = 32, +}; + +enum { + __PERCPU_REF_ATOMIC = 1, + __PERCPU_REF_DEAD = 2, + __PERCPU_REF_ATOMIC_DEAD = 3, + __PERCPU_REF_FLAG_BITS = 2, +}; + +enum { + __SCHED_FEAT_GENTLE_FAIR_SLEEPERS = 0, + __SCHED_FEAT_START_DEBIT = 1, + __SCHED_FEAT_NEXT_BUDDY = 2, + __SCHED_FEAT_LAST_BUDDY = 3, + __SCHED_FEAT_CACHE_HOT_BUDDY = 4, + __SCHED_FEAT_WAKEUP_PREEMPTION = 5, + __SCHED_FEAT_HRTICK = 6, + __SCHED_FEAT_DOUBLE_TICK = 7, + __SCHED_FEAT_LB_BIAS = 8, + __SCHED_FEAT_NONTASK_CAPACITY = 9, + __SCHED_FEAT_TTWU_QUEUE = 10, + __SCHED_FEAT_RT_PUSH_IPI = 11, + __SCHED_FEAT_FORCE_SD_OVERLAP = 12, + __SCHED_FEAT_RT_RUNTIME_SHARE = 13, + __SCHED_FEAT_LB_MIN = 14, + __SCHED_FEAT_ATTACH_AGE_LOAD = 15, + __SCHED_FEAT_NR = 16, +}; + +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 { + st_wordstart = 0, + st_wordcmp = 1, + st_wordskip = 2, +}; + +enum { + sysctl_hung_task_timeout_secs = 0, +}; + +enum { + x86_lbr_exclusive_lbr = 0, + x86_lbr_exclusive_bts = 1, + x86_lbr_exclusive_pt = 2, + x86_lbr_exclusive_max = 3, +}; + +typedef enum { + OSL_GLOBAL_LOCK_HANDLER = 0, + OSL_NOTIFY_HANDLER = 1, + OSL_GPE_HANDLER = 2, + OSL_DEBUGGER_MAIN_THREAD = 3, + OSL_DEBUGGER_EXEC_THREAD = 4, + OSL_EC_POLL_HANDLER = 5, + OSL_EC_BURST_HANDLER = 6, +} acpi_execute_type; + +typedef enum { + ACPI_IMODE_LOAD_PASS1 = 1, + ACPI_IMODE_LOAD_PASS2 = 2, + ACPI_IMODE_EXECUTE = 3, +} acpi_interpreter_mode; + +typedef enum { + ACPI_TRACE_AML_METHOD = 0, + ACPI_TRACE_AML_OPCODE = 1, + ACPI_TRACE_AML_REGION = 2, +} acpi_trace_event_type; + +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_CPU_EXCLUSIVE = 5, + FILE_MEM_EXCLUSIVE = 6, + FILE_MEM_HARDWALL = 7, + FILE_SCHED_LOAD_BALANCE = 8, + FILE_SCHED_RELAX_DOMAIN_LEVEL = 9, + FILE_MEMORY_PRESSURE_ENABLED = 10, + FILE_MEMORY_PRESSURE = 11, + FILE_SPREAD_PAGE = 12, + FILE_SPREAD_SLAB = 13, +} 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 { + 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 { + PAGE_KEEP = 0, + PAGE_ACTIVATE = 1, + PAGE_SUCCESS = 2, + PAGE_CLEAN = 3, +} pageout_t; + +typedef enum { + PHY_INTERFACE_MODE_NA = 0, + PHY_INTERFACE_MODE_MII = 1, + PHY_INTERFACE_MODE_GMII = 2, + PHY_INTERFACE_MODE_SGMII = 3, + PHY_INTERFACE_MODE_TBI = 4, + PHY_INTERFACE_MODE_REVMII = 5, + PHY_INTERFACE_MODE_RMII = 6, + PHY_INTERFACE_MODE_RGMII = 7, + PHY_INTERFACE_MODE_RGMII_ID = 8, + PHY_INTERFACE_MODE_RGMII_RXID = 9, + PHY_INTERFACE_MODE_RGMII_TXID = 10, + PHY_INTERFACE_MODE_RTBI = 11, + PHY_INTERFACE_MODE_SMII = 12, + PHY_INTERFACE_MODE_XGMII = 13, + PHY_INTERFACE_MODE_MOCA = 14, + PHY_INTERFACE_MODE_QSGMII = 15, + PHY_INTERFACE_MODE_MAX = 16, +} phy_interface_t; + +typedef enum { + PSMOUSE_BAD_DATA = 0, + PSMOUSE_GOOD_DATA = 1, + PSMOUSE_FULL_PACKET = 2, +} psmouse_ret_t; + +typedef enum { + SS_FREE = 0, + SS_UNCONNECTED = 1, + SS_CONNECTING = 2, + SS_CONNECTED = 3, + SS_DISCONNECTING = 4, +} socket_state; + +typedef enum { + STATUSTYPE_INFO = 0, + STATUSTYPE_TABLE = 1, +} status_type_t; + +typedef enum { + VIDEO_FORMAT_4_3 = 0, + VIDEO_FORMAT_16_9 = 1, + VIDEO_FORMAT_221_1 = 2, +} video_format_t; + +enum KTHREAD_BITS { + KTHREAD_IS_PER_CPU = 0, + KTHREAD_SHOULD_STOP = 1, + KTHREAD_SHOULD_PARK = 2, + KTHREAD_IS_PARKED = 3, +}; + +enum P4_ESCR_EMASKS { + P4_EVENT_TC_DELIVER_MODE__DD = 512, + P4_EVENT_TC_DELIVER_MODE__DB = 1024, + P4_EVENT_TC_DELIVER_MODE__DI = 2048, + P4_EVENT_TC_DELIVER_MODE__BD = 4096, + P4_EVENT_TC_DELIVER_MODE__BB = 8192, + P4_EVENT_TC_DELIVER_MODE__BI = 16384, + P4_EVENT_TC_DELIVER_MODE__ID = 32768, + P4_EVENT_BPU_FETCH_REQUEST__TCMISS = 512, + P4_EVENT_ITLB_REFERENCE__HIT = 512, + P4_EVENT_ITLB_REFERENCE__MISS = 1024, + P4_EVENT_ITLB_REFERENCE__HIT_UK = 2048, + P4_EVENT_MEMORY_CANCEL__ST_RB_FULL = 2048, + P4_EVENT_MEMORY_CANCEL__64K_CONF = 4096, + P4_EVENT_MEMORY_COMPLETE__LSC = 512, + P4_EVENT_MEMORY_COMPLETE__SSC = 1024, + P4_EVENT_LOAD_PORT_REPLAY__SPLIT_LD = 1024, + P4_EVENT_STORE_PORT_REPLAY__SPLIT_ST = 1024, + P4_EVENT_MOB_LOAD_REPLAY__NO_STA = 1024, + P4_EVENT_MOB_LOAD_REPLAY__NO_STD = 4096, + P4_EVENT_MOB_LOAD_REPLAY__PARTIAL_DATA = 8192, + P4_EVENT_MOB_LOAD_REPLAY__UNALGN_ADDR = 16384, + P4_EVENT_PAGE_WALK_TYPE__DTMISS = 512, + P4_EVENT_PAGE_WALK_TYPE__ITMISS = 1024, + P4_EVENT_BSQ_CACHE_REFERENCE__RD_2ndL_HITS = 512, + P4_EVENT_BSQ_CACHE_REFERENCE__RD_2ndL_HITE = 1024, + P4_EVENT_BSQ_CACHE_REFERENCE__RD_2ndL_HITM = 2048, + P4_EVENT_BSQ_CACHE_REFERENCE__RD_3rdL_HITS = 4096, + P4_EVENT_BSQ_CACHE_REFERENCE__RD_3rdL_HITE = 8192, + P4_EVENT_BSQ_CACHE_REFERENCE__RD_3rdL_HITM = 16384, + P4_EVENT_BSQ_CACHE_REFERENCE__RD_2ndL_MISS = 131072, + P4_EVENT_BSQ_CACHE_REFERENCE__RD_3rdL_MISS = 262144, + P4_EVENT_BSQ_CACHE_REFERENCE__WR_2ndL_MISS = 524288, + P4_EVENT_IOQ_ALLOCATION__DEFAULT = 512, + P4_EVENT_IOQ_ALLOCATION__ALL_READ = 16384, + P4_EVENT_IOQ_ALLOCATION__ALL_WRITE = 32768, + P4_EVENT_IOQ_ALLOCATION__MEM_UC = 65536, + P4_EVENT_IOQ_ALLOCATION__MEM_WC = 131072, + P4_EVENT_IOQ_ALLOCATION__MEM_WT = 262144, + P4_EVENT_IOQ_ALLOCATION__MEM_WP = 524288, + P4_EVENT_IOQ_ALLOCATION__MEM_WB = 1048576, + P4_EVENT_IOQ_ALLOCATION__OWN = 4194304, + P4_EVENT_IOQ_ALLOCATION__OTHER = 8388608, + P4_EVENT_IOQ_ALLOCATION__PREFETCH = 16777216, + P4_EVENT_IOQ_ACTIVE_ENTRIES__DEFAULT = 512, + P4_EVENT_IOQ_ACTIVE_ENTRIES__ALL_READ = 16384, + P4_EVENT_IOQ_ACTIVE_ENTRIES__ALL_WRITE = 32768, + P4_EVENT_IOQ_ACTIVE_ENTRIES__MEM_UC = 65536, + P4_EVENT_IOQ_ACTIVE_ENTRIES__MEM_WC = 131072, + P4_EVENT_IOQ_ACTIVE_ENTRIES__MEM_WT = 262144, + P4_EVENT_IOQ_ACTIVE_ENTRIES__MEM_WP = 524288, + P4_EVENT_IOQ_ACTIVE_ENTRIES__MEM_WB = 1048576, + P4_EVENT_IOQ_ACTIVE_ENTRIES__OWN = 4194304, + P4_EVENT_IOQ_ACTIVE_ENTRIES__OTHER = 8388608, + P4_EVENT_IOQ_ACTIVE_ENTRIES__PREFETCH = 16777216, + P4_EVENT_FSB_DATA_ACTIVITY__DRDY_DRV = 512, + P4_EVENT_FSB_DATA_ACTIVITY__DRDY_OWN = 1024, + P4_EVENT_FSB_DATA_ACTIVITY__DRDY_OTHER = 2048, + P4_EVENT_FSB_DATA_ACTIVITY__DBSY_DRV = 4096, + P4_EVENT_FSB_DATA_ACTIVITY__DBSY_OWN = 8192, + P4_EVENT_FSB_DATA_ACTIVITY__DBSY_OTHER = 16384, + P4_EVENT_BSQ_ALLOCATION__REQ_TYPE0 = 512, + P4_EVENT_BSQ_ALLOCATION__REQ_TYPE1 = 1024, + P4_EVENT_BSQ_ALLOCATION__REQ_LEN0 = 2048, + P4_EVENT_BSQ_ALLOCATION__REQ_LEN1 = 4096, + P4_EVENT_BSQ_ALLOCATION__REQ_IO_TYPE = 16384, + P4_EVENT_BSQ_ALLOCATION__REQ_LOCK_TYPE = 32768, + P4_EVENT_BSQ_ALLOCATION__REQ_CACHE_TYPE = 65536, + P4_EVENT_BSQ_ALLOCATION__REQ_SPLIT_TYPE = 131072, + P4_EVENT_BSQ_ALLOCATION__REQ_DEM_TYPE = 262144, + P4_EVENT_BSQ_ALLOCATION__REQ_ORD_TYPE = 524288, + P4_EVENT_BSQ_ALLOCATION__MEM_TYPE0 = 1048576, + P4_EVENT_BSQ_ALLOCATION__MEM_TYPE1 = 2097152, + P4_EVENT_BSQ_ALLOCATION__MEM_TYPE2 = 4194304, + P4_EVENT_BSQ_ACTIVE_ENTRIES__REQ_TYPE0 = 512, + P4_EVENT_BSQ_ACTIVE_ENTRIES__REQ_TYPE1 = 1024, + P4_EVENT_BSQ_ACTIVE_ENTRIES__REQ_LEN0 = 2048, + P4_EVENT_BSQ_ACTIVE_ENTRIES__REQ_LEN1 = 4096, + P4_EVENT_BSQ_ACTIVE_ENTRIES__REQ_IO_TYPE = 16384, + P4_EVENT_BSQ_ACTIVE_ENTRIES__REQ_LOCK_TYPE = 32768, + P4_EVENT_BSQ_ACTIVE_ENTRIES__REQ_CACHE_TYPE = 65536, + P4_EVENT_BSQ_ACTIVE_ENTRIES__REQ_SPLIT_TYPE = 131072, + P4_EVENT_BSQ_ACTIVE_ENTRIES__REQ_DEM_TYPE = 262144, + P4_EVENT_BSQ_ACTIVE_ENTRIES__REQ_ORD_TYPE = 524288, + P4_EVENT_BSQ_ACTIVE_ENTRIES__MEM_TYPE0 = 1048576, + P4_EVENT_BSQ_ACTIVE_ENTRIES__MEM_TYPE1 = 2097152, + P4_EVENT_BSQ_ACTIVE_ENTRIES__MEM_TYPE2 = 4194304, + P4_EVENT_SSE_INPUT_ASSIST__ALL = 16777216, + P4_EVENT_PACKED_SP_UOP__ALL = 16777216, + P4_EVENT_PACKED_DP_UOP__ALL = 16777216, + P4_EVENT_SCALAR_SP_UOP__ALL = 16777216, + P4_EVENT_SCALAR_DP_UOP__ALL = 16777216, + P4_EVENT_64BIT_MMX_UOP__ALL = 16777216, + P4_EVENT_128BIT_MMX_UOP__ALL = 16777216, + P4_EVENT_X87_FP_UOP__ALL = 16777216, + P4_EVENT_TC_MISC__FLUSH = 8192, + P4_EVENT_GLOBAL_POWER_EVENTS__RUNNING = 512, + P4_EVENT_TC_MS_XFER__CISC = 512, + P4_EVENT_UOP_QUEUE_WRITES__FROM_TC_BUILD = 512, + P4_EVENT_UOP_QUEUE_WRITES__FROM_TC_DELIVER = 1024, + P4_EVENT_UOP_QUEUE_WRITES__FROM_ROM = 2048, + P4_EVENT_RETIRED_MISPRED_BRANCH_TYPE__CONDITIONAL = 1024, + P4_EVENT_RETIRED_MISPRED_BRANCH_TYPE__CALL = 2048, + P4_EVENT_RETIRED_MISPRED_BRANCH_TYPE__RETURN = 4096, + P4_EVENT_RETIRED_MISPRED_BRANCH_TYPE__INDIRECT = 8192, + P4_EVENT_RETIRED_BRANCH_TYPE__CONDITIONAL = 1024, + P4_EVENT_RETIRED_BRANCH_TYPE__CALL = 2048, + P4_EVENT_RETIRED_BRANCH_TYPE__RETURN = 4096, + P4_EVENT_RETIRED_BRANCH_TYPE__INDIRECT = 8192, + P4_EVENT_RESOURCE_STALL__SBFULL = 16384, + P4_EVENT_WC_BUFFER__WCB_EVICTS = 512, + P4_EVENT_WC_BUFFER__WCB_FULL_EVICTS = 1024, + P4_EVENT_FRONT_END_EVENT__NBOGUS = 512, + P4_EVENT_FRONT_END_EVENT__BOGUS = 1024, + P4_EVENT_EXECUTION_EVENT__NBOGUS0 = 512, + P4_EVENT_EXECUTION_EVENT__NBOGUS1 = 1024, + P4_EVENT_EXECUTION_EVENT__NBOGUS2 = 2048, + P4_EVENT_EXECUTION_EVENT__NBOGUS3 = 4096, + P4_EVENT_EXECUTION_EVENT__BOGUS0 = 8192, + P4_EVENT_EXECUTION_EVENT__BOGUS1 = 16384, + P4_EVENT_EXECUTION_EVENT__BOGUS2 = 32768, + P4_EVENT_EXECUTION_EVENT__BOGUS3 = 65536, + P4_EVENT_REPLAY_EVENT__NBOGUS = 512, + P4_EVENT_REPLAY_EVENT__BOGUS = 1024, + P4_EVENT_INSTR_RETIRED__NBOGUSNTAG = 512, + P4_EVENT_INSTR_RETIRED__NBOGUSTAG = 1024, + P4_EVENT_INSTR_RETIRED__BOGUSNTAG = 2048, + P4_EVENT_INSTR_RETIRED__BOGUSTAG = 4096, + P4_EVENT_UOPS_RETIRED__NBOGUS = 512, + P4_EVENT_UOPS_RETIRED__BOGUS = 1024, + P4_EVENT_UOP_TYPE__TAGLOADS = 1024, + P4_EVENT_UOP_TYPE__TAGSTORES = 2048, + P4_EVENT_BRANCH_RETIRED__MMNP = 512, + P4_EVENT_BRANCH_RETIRED__MMNM = 1024, + P4_EVENT_BRANCH_RETIRED__MMTP = 2048, + P4_EVENT_BRANCH_RETIRED__MMTM = 4096, + P4_EVENT_MISPRED_BRANCH_RETIRED__NBOGUS = 512, + P4_EVENT_X87_ASSIST__FPSU = 512, + P4_EVENT_X87_ASSIST__FPSO = 1024, + P4_EVENT_X87_ASSIST__POAO = 2048, + P4_EVENT_X87_ASSIST__POAU = 4096, + P4_EVENT_X87_ASSIST__PREA = 8192, + P4_EVENT_MACHINE_CLEAR__CLEAR = 512, + P4_EVENT_MACHINE_CLEAR__MOCLEAR = 1024, + P4_EVENT_MACHINE_CLEAR__SMCLEAR = 2048, + P4_EVENT_INSTR_COMPLETED__NBOGUS = 512, + P4_EVENT_INSTR_COMPLETED__BOGUS = 1024, +}; + +enum P4_EVENTS { + P4_EVENT_TC_DELIVER_MODE = 0, + P4_EVENT_BPU_FETCH_REQUEST = 1, + P4_EVENT_ITLB_REFERENCE = 2, + P4_EVENT_MEMORY_CANCEL = 3, + P4_EVENT_MEMORY_COMPLETE = 4, + P4_EVENT_LOAD_PORT_REPLAY = 5, + P4_EVENT_STORE_PORT_REPLAY = 6, + P4_EVENT_MOB_LOAD_REPLAY = 7, + P4_EVENT_PAGE_WALK_TYPE = 8, + P4_EVENT_BSQ_CACHE_REFERENCE = 9, + P4_EVENT_IOQ_ALLOCATION = 10, + P4_EVENT_IOQ_ACTIVE_ENTRIES = 11, + P4_EVENT_FSB_DATA_ACTIVITY = 12, + P4_EVENT_BSQ_ALLOCATION = 13, + P4_EVENT_BSQ_ACTIVE_ENTRIES = 14, + P4_EVENT_SSE_INPUT_ASSIST = 15, + P4_EVENT_PACKED_SP_UOP = 16, + P4_EVENT_PACKED_DP_UOP = 17, + P4_EVENT_SCALAR_SP_UOP = 18, + P4_EVENT_SCALAR_DP_UOP = 19, + P4_EVENT_64BIT_MMX_UOP = 20, + P4_EVENT_128BIT_MMX_UOP = 21, + P4_EVENT_X87_FP_UOP = 22, + P4_EVENT_TC_MISC = 23, + P4_EVENT_GLOBAL_POWER_EVENTS = 24, + P4_EVENT_TC_MS_XFER = 25, + P4_EVENT_UOP_QUEUE_WRITES = 26, + P4_EVENT_RETIRED_MISPRED_BRANCH_TYPE = 27, + P4_EVENT_RETIRED_BRANCH_TYPE = 28, + P4_EVENT_RESOURCE_STALL = 29, + P4_EVENT_WC_BUFFER = 30, + P4_EVENT_B2B_CYCLES = 31, + P4_EVENT_BNR = 32, + P4_EVENT_SNOOP = 33, + P4_EVENT_RESPONSE = 34, + P4_EVENT_FRONT_END_EVENT = 35, + P4_EVENT_EXECUTION_EVENT = 36, + P4_EVENT_REPLAY_EVENT = 37, + P4_EVENT_INSTR_RETIRED = 38, + P4_EVENT_UOPS_RETIRED = 39, + P4_EVENT_UOP_TYPE = 40, + P4_EVENT_BRANCH_RETIRED = 41, + P4_EVENT_MISPRED_BRANCH_RETIRED = 42, + P4_EVENT_X87_ASSIST = 43, + P4_EVENT_MACHINE_CLEAR = 44, + P4_EVENT_INSTR_COMPLETED = 45, +}; + +enum P4_EVENT_OPCODES { + P4_EVENT_TC_DELIVER_MODE_OPCODE = 257, + P4_EVENT_BPU_FETCH_REQUEST_OPCODE = 768, + P4_EVENT_ITLB_REFERENCE_OPCODE = 6147, + P4_EVENT_MEMORY_CANCEL_OPCODE = 517, + P4_EVENT_MEMORY_COMPLETE_OPCODE = 2050, + P4_EVENT_LOAD_PORT_REPLAY_OPCODE = 1026, + P4_EVENT_STORE_PORT_REPLAY_OPCODE = 1282, + P4_EVENT_MOB_LOAD_REPLAY_OPCODE = 770, + P4_EVENT_PAGE_WALK_TYPE_OPCODE = 260, + P4_EVENT_BSQ_CACHE_REFERENCE_OPCODE = 3079, + P4_EVENT_IOQ_ALLOCATION_OPCODE = 774, + P4_EVENT_IOQ_ACTIVE_ENTRIES_OPCODE = 6662, + P4_EVENT_FSB_DATA_ACTIVITY_OPCODE = 5894, + P4_EVENT_BSQ_ALLOCATION_OPCODE = 1287, + P4_EVENT_BSQ_ACTIVE_ENTRIES_OPCODE = 1543, + P4_EVENT_SSE_INPUT_ASSIST_OPCODE = 13313, + P4_EVENT_PACKED_SP_UOP_OPCODE = 2049, + P4_EVENT_PACKED_DP_UOP_OPCODE = 3073, + P4_EVENT_SCALAR_SP_UOP_OPCODE = 2561, + P4_EVENT_SCALAR_DP_UOP_OPCODE = 3585, + P4_EVENT_64BIT_MMX_UOP_OPCODE = 513, + P4_EVENT_128BIT_MMX_UOP_OPCODE = 6657, + P4_EVENT_X87_FP_UOP_OPCODE = 1025, + P4_EVENT_TC_MISC_OPCODE = 1537, + P4_EVENT_GLOBAL_POWER_EVENTS_OPCODE = 4870, + P4_EVENT_TC_MS_XFER_OPCODE = 1280, + P4_EVENT_UOP_QUEUE_WRITES_OPCODE = 2304, + P4_EVENT_RETIRED_MISPRED_BRANCH_TYPE_OPCODE = 1282, + P4_EVENT_RETIRED_BRANCH_TYPE_OPCODE = 1026, + P4_EVENT_RESOURCE_STALL_OPCODE = 257, + P4_EVENT_WC_BUFFER_OPCODE = 1285, + P4_EVENT_B2B_CYCLES_OPCODE = 5635, + P4_EVENT_BNR_OPCODE = 2051, + P4_EVENT_SNOOP_OPCODE = 1539, + P4_EVENT_RESPONSE_OPCODE = 1027, + P4_EVENT_FRONT_END_EVENT_OPCODE = 2053, + P4_EVENT_EXECUTION_EVENT_OPCODE = 3077, + P4_EVENT_REPLAY_EVENT_OPCODE = 2309, + P4_EVENT_INSTR_RETIRED_OPCODE = 516, + P4_EVENT_UOPS_RETIRED_OPCODE = 260, + P4_EVENT_UOP_TYPE_OPCODE = 514, + P4_EVENT_BRANCH_RETIRED_OPCODE = 1541, + P4_EVENT_MISPRED_BRANCH_RETIRED_OPCODE = 772, + P4_EVENT_X87_ASSIST_OPCODE = 773, + P4_EVENT_MACHINE_CLEAR_OPCODE = 517, + P4_EVENT_INSTR_COMPLETED_OPCODE = 1796, +}; + +enum P4_PEBS_METRIC { + P4_PEBS_METRIC__none = 0, + P4_PEBS_METRIC__1stl_cache_load_miss_retired = 1, + P4_PEBS_METRIC__2ndl_cache_load_miss_retired = 2, + P4_PEBS_METRIC__dtlb_load_miss_retired = 3, + P4_PEBS_METRIC__dtlb_store_miss_retired = 4, + P4_PEBS_METRIC__dtlb_all_miss_retired = 5, + P4_PEBS_METRIC__tagged_mispred_branch = 6, + P4_PEBS_METRIC__mob_load_replay_retired = 7, + P4_PEBS_METRIC__split_load_retired = 8, + P4_PEBS_METRIC__split_store_retired = 9, + P4_PEBS_METRIC__max = 10, +}; + +enum SS4_PACKET_ID { + SS4_PACKET_ID_IDLE = 0, + SS4_PACKET_ID_ONE = 1, + SS4_PACKET_ID_TWO = 2, + SS4_PACKET_ID_MULTI = 3, +}; + +enum V7_PACKET_ID { + V7_PACKET_ID_IDLE = 0, + V7_PACKET_ID_TWO = 1, + V7_PACKET_ID_MULTI = 2, + V7_PACKET_ID_NEW = 3, + V7_PACKET_ID_UNKNOWN = 4, +}; + +enum _cache_type { + CTYPE_NULL = 0, + CTYPE_DATA = 1, + CTYPE_INST = 2, + CTYPE_UNIFIED = 3, +}; + +enum ac97_pcm_cfg { + AC97_PCM_CFG_FRONT = 2, + AC97_PCM_CFG_REAR = 10, + AC97_PCM_CFG_LFE = 11, + AC97_PCM_CFG_40 = 4, + AC97_PCM_CFG_51 = 6, + AC97_PCM_CFG_SPDIF = 20, +}; + +enum acpi_attr_enum { + ACPI_ATTR_LABEL_SHOW = 0, + ACPI_ATTR_INDEX_SHOW = 1, +}; + +enum acpi_backlight_type { + acpi_backlight_undef = -1, + acpi_backlight_none = 0, + acpi_backlight_video = 1, + acpi_backlight_vendor = 2, + acpi_backlight_native = 3, +}; + +enum acpi_blacklist_predicates { + all_versions = 0, + less_than_or_equal = 1, + equal = 2, + greater_than_or_equal = 3, +}; + +enum acpi_bus_device_type { + ACPI_BUS_TYPE_DEVICE = 0, + ACPI_BUS_TYPE_POWER = 1, + ACPI_BUS_TYPE_PROCESSOR = 2, + ACPI_BUS_TYPE_THERMAL = 3, + ACPI_BUS_TYPE_POWER_BUTTON = 4, + ACPI_BUS_TYPE_SLEEP_BUTTON = 5, + ACPI_BUS_DEVICE_TYPE_COUNT = 6, +}; + +enum acpi_dmar_scope_type { + ACPI_DMAR_SCOPE_TYPE_NOT_USED = 0, + ACPI_DMAR_SCOPE_TYPE_ENDPOINT = 1, + ACPI_DMAR_SCOPE_TYPE_BRIDGE = 2, + ACPI_DMAR_SCOPE_TYPE_IOAPIC = 3, + ACPI_DMAR_SCOPE_TYPE_HPET = 4, + ACPI_DMAR_SCOPE_TYPE_NAMESPACE = 5, + ACPI_DMAR_SCOPE_TYPE_RESERVED = 6, +}; + +enum acpi_dmar_type { + ACPI_DMAR_TYPE_HARDWARE_UNIT = 0, + ACPI_DMAR_TYPE_RESERVED_MEMORY = 1, + ACPI_DMAR_TYPE_ROOT_ATS = 2, + ACPI_DMAR_TYPE_HARDWARE_AFFINITY = 3, + ACPI_DMAR_TYPE_NAMESPACE = 4, + ACPI_DMAR_TYPE_RESERVED = 5, +}; + +enum acpi_irq_model_id { + ACPI_IRQ_MODEL_PIC = 0, + ACPI_IRQ_MODEL_IOAPIC = 1, + ACPI_IRQ_MODEL_IOSAPIC = 2, + ACPI_IRQ_MODEL_PLATFORM = 3, + ACPI_IRQ_MODEL_GIC = 4, + ACPI_IRQ_MODEL_COUNT = 5, +}; + +enum acpi_madt_type { + ACPI_MADT_TYPE_LOCAL_APIC = 0, + ACPI_MADT_TYPE_IO_APIC = 1, + ACPI_MADT_TYPE_INTERRUPT_OVERRIDE = 2, + ACPI_MADT_TYPE_NMI_SOURCE = 3, + ACPI_MADT_TYPE_LOCAL_APIC_NMI = 4, + ACPI_MADT_TYPE_LOCAL_APIC_OVERRIDE = 5, + ACPI_MADT_TYPE_IO_SAPIC = 6, + ACPI_MADT_TYPE_LOCAL_SAPIC = 7, + ACPI_MADT_TYPE_INTERRUPT_SOURCE = 8, + ACPI_MADT_TYPE_LOCAL_X2APIC = 9, + ACPI_MADT_TYPE_LOCAL_X2APIC_NMI = 10, + ACPI_MADT_TYPE_GENERIC_INTERRUPT = 11, + ACPI_MADT_TYPE_GENERIC_DISTRIBUTOR = 12, + ACPI_MADT_TYPE_GENERIC_MSI_FRAME = 13, + ACPI_MADT_TYPE_GENERIC_REDISTRIBUTOR = 14, + ACPI_MADT_TYPE_GENERIC_TRANSLATOR = 15, + ACPI_MADT_TYPE_RESERVED = 16, +}; + +enum acpi_return_package_types { + ACPI_PTYPE1_FIXED = 1, + ACPI_PTYPE1_VAR = 2, + ACPI_PTYPE1_OPTION = 3, + ACPI_PTYPE2 = 4, + ACPI_PTYPE2_COUNT = 5, + ACPI_PTYPE2_PKG_COUNT = 6, + ACPI_PTYPE2_FIXED = 7, + ACPI_PTYPE2_MIN = 8, + ACPI_PTYPE2_REV_FIXED = 9, + ACPI_PTYPE2_FIX_VAR = 10, + ACPI_PTYPE2_VAR_VAR = 11, + ACPI_PTYPE2_UUID_PAIR = 12, + ACPI_PTYPE_CUSTOM = 13, +}; + +enum acpi_srat_type { + ACPI_SRAT_TYPE_CPU_AFFINITY = 0, + ACPI_SRAT_TYPE_MEMORY_AFFINITY = 1, + ACPI_SRAT_TYPE_X2APIC_CPU_AFFINITY = 2, + ACPI_SRAT_TYPE_GICC_AFFINITY = 3, + ACPI_SRAT_TYPE_RESERVED = 4, +}; + +enum actions { + REGISTER = 0, + DEREGISTER = 1, + CPU_DONT_CARE = 2, +}; + +enum alarmtimer_restart { + ALARMTIMER_NORESTART = 0, + ALARMTIMER_RESTART = 1, +}; + +enum alarmtimer_type { + ALARM_REALTIME = 0, + ALARM_BOOTTIME = 1, + ALARM_NUMTYPE = 2, +}; + +enum align_flags { + ALIGN_VA_32 = 1, + ALIGN_VA_64 = 2, +}; + +enum amd_core_mca_blocks { + SMCA_LS = 0, + SMCA_IF = 1, + SMCA_L2_CACHE = 2, + SMCA_DE = 3, + RES = 4, + SMCA_EX = 5, + SMCA_FP = 6, + SMCA_L3_CACHE = 7, + N_CORE_MCA_BLOCKS = 8, +}; + +enum amd_df_mca_blocks { + SMCA_CS = 0, + SMCA_PIE = 1, + N_DF_BLOCKS = 2, +}; + +enum amd_ip_types { + SMCA_F17H_CORE = 0, + SMCA_DF = 1, + SMCA_UMC = 2, + SMCA_PB = 3, + SMCA_PSP = 4, + SMCA_SMU = 5, + N_AMD_IP_TYPES = 6, +}; + +enum aper_size_type { + U8_APER_SIZE = 0, + U16_APER_SIZE = 1, + U32_APER_SIZE = 2, + LVL2_APER_SIZE = 3, + FIXED_APER_SIZE = 4, +}; + +enum array_state { + clear = 0, + inactive = 1, + suspended = 2, + readonly = 3, + read_auto = 4, + clean = 5, + active = 6, + write_pending = 7, + active_idle = 8, + bad_word = 9, +}; + +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 ata_completion_errors { + AC_ERR_DEV = 1, + AC_ERR_HSM = 2, + AC_ERR_TIMEOUT = 4, + AC_ERR_MEDIA = 8, + AC_ERR_ATA_BUS = 16, + AC_ERR_HOST_BUS = 32, + AC_ERR_SYSTEM = 64, + AC_ERR_INVALID = 128, + AC_ERR_OTHER = 256, + AC_ERR_NODEV_HINT = 512, + AC_ERR_NCQ = 1024, +}; + +enum ata_dev_iter_mode { + ATA_DITER_ENABLED = 0, + ATA_DITER_ENABLED_REVERSE = 1, + ATA_DITER_ALL = 2, + ATA_DITER_ALL_REVERSE = 3, +}; + +enum ata_link_iter_mode { + ATA_LITER_EDGE = 0, + ATA_LITER_HOST_FIRST = 1, + ATA_LITER_PMP_FIRST = 2, +}; + +enum ata_lpm_hints { + ATA_LPM_EMPTY = 1, + ATA_LPM_HIPM = 2, + ATA_LPM_WAKE_ONLY = 4, +}; + +enum ata_lpm_policy { + ATA_LPM_UNKNOWN = 0, + ATA_LPM_MAX_POWER = 1, + ATA_LPM_MED_POWER = 2, + ATA_LPM_MIN_POWER = 3, +}; + +enum ata_tf_protocols { + ATA_PROT_UNKNOWN = 0, + ATA_PROT_NODATA = 1, + ATA_PROT_PIO = 2, + ATA_PROT_DMA = 3, + ATA_PROT_NCQ = 4, + ATAPI_PROT_NODATA = 5, + ATAPI_PROT_PIO = 6, + ATAPI_PROT_DMA = 7, +}; + +enum ata_xfer_mask { + ATA_MASK_PIO = 127, + ATA_MASK_MWDMA = 3968, + ATA_MASK_UDMA = 1044480, +}; + +enum audit_state { + AUDIT_DISABLED = 0, + AUDIT_BUILD_CONTEXT = 1, + AUDIT_RECORD_CONTEXT = 2, +}; + +enum avic_ipi_failure_cause { + AVIC_IPI_FAILURE_INVALID_INT_TYPE = 0, + AVIC_IPI_FAILURE_TARGET_NOT_RUNNING = 1, + AVIC_IPI_FAILURE_INVALID_TARGET = 2, + AVIC_IPI_FAILURE_INVALID_BACKING_PAGE = 3, +}; + +enum backlight_notification { + BACKLIGHT_REGISTERED = 0, + BACKLIGHT_UNREGISTERED = 1, +}; + +enum backlight_type { + BACKLIGHT_RAW = 1, + BACKLIGHT_PLATFORM = 2, + BACKLIGHT_FIRMWARE = 3, + BACKLIGHT_TYPE_MAX = 4, +}; + +enum backlight_update_reason { + BACKLIGHT_UPDATE_HOTKEY = 0, + BACKLIGHT_UPDATE_SYSFS = 1, +}; + +enum bh_state_bits { + BH_Uptodate = 0, + BH_Dirty = 1, + BH_Lock = 2, + BH_Req = 3, + BH_Uptodate_Lock = 4, + BH_Mapped = 5, + BH_New = 6, + BH_Async_Read = 7, + BH_Async_Write = 8, + BH_Delay = 9, + BH_Boundary = 10, + BH_Write_EIO = 11, + BH_Unwritten = 12, + BH_Quiet = 13, + BH_Meta = 14, + BH_Prio = 15, + BH_Defer_Completion = 16, + BH_PrivateStart = 17, +}; + +enum bip_flags { + BIP_BLOCK_INTEGRITY = 1, + BIP_MAPPED_INTEGRITY = 2, + BIP_CTRL_NOCHECK = 4, + BIP_DISK_NOCHECK = 8, + BIP_IP_CHECKSUM = 16, +}; + +enum bitmap_page_attr { + BITMAP_PAGE_DIRTY = 0, + BITMAP_PAGE_PENDING = 1, + BITMAP_PAGE_NEEDWRITE = 2, +}; + +enum bitmap_state { + BITMAP_STALE = 1, + BITMAP_WRITE_ERROR = 2, + BITMAP_HOSTENDIAN = 15, +}; + +enum blk_default_limits { + BLK_MAX_SEGMENTS = 128, + BLK_SAFE_MAX_SECTORS = 255, + BLK_DEF_MAX_SECTORS = 2560, + BLK_MAX_SEGMENT_SIZE = 65536, + BLK_SEG_BOUNDARY_MASK = 4294967295, +}; + +enum blk_eh_timer_return { + BLK_EH_NOT_HANDLED = 0, + BLK_EH_HANDLED = 1, + BLK_EH_RESET_TIMER = 2, +}; + +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, +}; + +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, +}; + +enum board_ids { + board_ahci = 0, + board_ahci_ign_iferr = 1, + board_ahci_nomsi = 2, + board_ahci_noncq = 3, + board_ahci_nosntf = 4, + board_ahci_yes_fbs = 5, + board_ahci_avn = 6, + board_ahci_mcp65 = 7, + board_ahci_mcp77 = 8, + board_ahci_mcp89 = 9, + board_ahci_mv = 10, + board_ahci_sb600 = 11, + board_ahci_sb700 = 12, + board_ahci_vt8251 = 13, + board_ahci_mcp_linux = 7, + board_ahci_mcp67 = 7, + board_ahci_mcp73 = 7, + board_ahci_mcp79 = 8, +}; + +enum bochs_types { + BOCHS_QEMU_STDVGA = 0, + BOCHS_UNKNOWN = 1, +}; + +enum bp_type_idx { + TYPE_INST = 0, + TYPE_DATA = 0, + TYPE_MAX = 1, +}; + +enum bpf_access_type { + BPF_READ = 1, + BPF_WRITE = 2, +}; + +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_STACK = 4, + ARG_PTR_TO_RAW_STACK = 5, + ARG_CONST_STACK_SIZE = 6, + ARG_CONST_STACK_SIZE_OR_ZERO = 7, + ARG_PTR_TO_CTX = 8, + ARG_ANYTHING = 9, +}; + +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, +}; + +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_MAX_ID = 31, +}; + +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, +}; + +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, +}; + +enum bpf_reg_type { + NOT_INIT = 0, + UNKNOWN_VALUE = 1, + PTR_TO_CTX = 2, + CONST_PTR_TO_MAP = 3, + PTR_TO_MAP_VALUE = 4, + PTR_TO_MAP_VALUE_OR_NULL = 5, + FRAME_PTR = 6, + PTR_TO_STACK = 7, + CONST_IMM = 8, + PTR_TO_PACKET = 9, + PTR_TO_PACKET_END = 10, +}; + +enum bpf_return_type { + RET_INTEGER = 0, + RET_VOID = 1, + RET_PTR_TO_MAP_VALUE_OR_NULL = 2, +}; + +enum bpf_stack_slot_type { + STACK_INVALID = 0, + STACK_SPILL = 1, + STACK_MISC = 2, +}; + +enum bpf_type { + BPF_TYPE_UNSPEC = 0, + BPF_TYPE_PROG = 1, + BPF_TYPE_MAP = 2, +}; + +enum bug_trap_type { + BUG_TRAP_TYPE_NONE = 0, + BUG_TRAP_TYPE_WARN = 1, + BUG_TRAP_TYPE_BUG = 2, +}; + +enum cache_type { + CACHE_TYPE_NOCACHE = 0, + CACHE_TYPE_INST = 1, + CACHE_TYPE_DATA = 2, + CACHE_TYPE_SEPARATE = 3, + CACHE_TYPE_UNIFIED = 4, +}; + +enum cea_speaker_placement { + FL = 1, + FC = 2, + FR = 4, + FLC = 8, + FRC = 16, + RL = 32, + RC = 64, + RR = 128, + RLC = 256, + RRC = 512, + LFE = 1024, + FLW = 2048, + FRW = 4096, + FLH = 8192, + FCH = 16384, + FRH = 32768, + TC = 65536, +}; + +enum cfqq_state_flags { + CFQ_CFQQ_FLAG_on_rr = 0, + CFQ_CFQQ_FLAG_wait_request = 1, + CFQ_CFQQ_FLAG_must_dispatch = 2, + CFQ_CFQQ_FLAG_must_alloc_slice = 3, + CFQ_CFQQ_FLAG_fifo_expire = 4, + CFQ_CFQQ_FLAG_idle_window = 5, + CFQ_CFQQ_FLAG_prio_changed = 6, + CFQ_CFQQ_FLAG_slice_new = 7, + CFQ_CFQQ_FLAG_sync = 8, + CFQ_CFQQ_FLAG_coop = 9, + CFQ_CFQQ_FLAG_split_coop = 10, + CFQ_CFQQ_FLAG_deep = 11, + CFQ_CFQQ_FLAG_wait_busy = 12, +}; + +enum cgroup_filetype { + CGROUP_FILE_PROCS = 0, + CGROUP_FILE_TASKS = 1, +}; + +enum cgroup_subsys_id { + cpuset_cgrp_id = 0, + cpu_cgrp_id = 1, + cpuacct_cgrp_id = 2, + freezer_cgrp_id = 3, + CGROUP_SUBSYS_COUNT = 4, +}; + +enum chipset_type { + NOT_SUPPORTED = 0, + SUPPORTED = 1, +}; + +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 compact_result { + COMPACT_NOT_SUITABLE_ZONE = 0, + COMPACT_SKIPPED = 1, + COMPACT_DEFERRED = 2, + COMPACT_INACTIVE = 2, + COMPACT_NO_SUITABLE_PAGE = 3, + COMPACT_CONTINUE = 4, + COMPACT_COMPLETE = 5, + COMPACT_PARTIAL_SKIPPED = 6, + COMPACT_CONTENDED = 7, + COMPACT_PARTIAL = 8, +}; + +enum compound_dtor_id { + NULL_COMPOUND_DTOR = 0, + COMPOUND_PAGE_DTOR = 1, + HUGETLB_PAGE_DTOR = 2, + NR_COMPOUND_DTORS = 3, +}; + +enum context { + IN_KERNEL = 1, + IN_USER = 2, + IN_KERNEL_RECOV = 3, +}; + +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_IDLE = 0, + CPU_NOT_IDLE = 1, + CPU_NEWLY_IDLE = 2, + CPU_MAX_IDLE_TYPES = 3, +}; + +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 cpuacct_usage_index { + CPUACCT_USAGE_USER = 0, + CPUACCT_USAGE_SYSTEM = 1, + CPUACCT_USAGE_NRUSAGE = 2, +}; + +enum cpuhp_state { + CPUHP_OFFLINE = 0, + CPUHP_CREATE_THREADS = 1, + CPUHP_NOTIFY_PREPARE = 2, + CPUHP_BRINGUP_CPU = 3, + CPUHP_AP_IDLE_DEAD = 4, + CPUHP_AP_OFFLINE = 5, + CPUHP_AP_SCHED_STARTING = 6, + CPUHP_AP_NOTIFY_STARTING = 7, + CPUHP_AP_ONLINE = 8, + CPUHP_TEARDOWN_CPU = 9, + CPUHP_AP_ONLINE_IDLE = 10, + CPUHP_AP_SMPBOOT_THREADS = 11, + CPUHP_AP_NOTIFY_ONLINE = 12, + CPUHP_AP_ONLINE_DYN = 13, + CPUHP_AP_ONLINE_DYN_END = 43, + CPUHP_AP_ACTIVE = 44, + CPUHP_ONLINE = 45, +}; + +enum cpuid_leafs { + CPUID_1_EDX = 0, + CPUID_8000_0001_EDX = 1, + CPUID_8086_0001_EDX = 2, + CPUID_LNX_1 = 3, + CPUID_1_ECX = 4, + CPUID_C000_0001_EDX = 5, + CPUID_8000_0001_ECX = 6, + CPUID_LNX_2 = 7, + CPUID_LNX_3 = 8, + CPUID_7_0_EBX = 9, + CPUID_D_1_EAX = 10, + CPUID_F_0_EDX = 11, + CPUID_F_1_EDX = 12, + CPUID_8000_0008_EBX = 13, + CPUID_6_EAX = 14, + CPUID_8000_000A_EDX = 15, + CPUID_7_ECX = 16, + CPUID_8000_0007_EBX = 17, +}; + +enum cpuid_regs { + CR_EAX = 0, + CR_ECX = 1, + CR_EDX = 2, + CR_EBX = 3, +}; + +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_MAX = 10, +}; + +enum ctx_state { + CONTEXT_DISABLED = -1, + CONTEXT_KERNEL = 0, + CONTEXT_USER = 1, + CONTEXT_GUEST = 2, +}; + +enum d_walk_ret { + D_WALK_CONTINUE = 0, + D_WALK_QUIT = 1, + D_WALK_NORETRY = 2, + D_WALK_SKIP = 3, +}; + +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 = 13, + DCCP_PASSIVE_CLOSEREQ = 14, + DCCP_MAX_STATES = 15, +}; + +enum dentry_d_lock_class { + DENTRY_D_LOCK_NORMAL = 0, + DENTRY_D_LOCK_NESTED = 1, +}; + +enum dev_dma_attr { + DEV_DMA_NOT_SUPPORTED = 0, + DEV_DMA_NON_COHERENT = 1, + DEV_DMA_COHERENT = 2, +}; + +enum dev_pm_qos_req_type { + DEV_PM_QOS_RESUME_LATENCY = 1, + DEV_PM_QOS_LATENCY_TOLERANCE = 2, + DEV_PM_QOS_FLAGS = 3, +}; + +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_MAX = 5, +}; + +enum die_val { + DIE_OOPS = 1, + DIE_INT3 = 2, + DIE_DEBUG = 3, + DIE_PANIC = 4, + DIE_NMI = 5, + DIE_DIE = 6, + DIE_KERNELDEBUG = 7, + DIE_TRAP = 8, + DIE_GPF = 9, + DIE_CALL = 10, + DIE_PAGE_FAULT = 11, + DIE_NMIUNKNOWN = 12, +}; + +enum dm_io_mem_type { + DM_IO_PAGE_LIST = 0, + DM_IO_BIO = 1, + DM_IO_VMA = 2, + DM_IO_KMEM = 3, +}; + +enum dm_raid1_error { + DM_RAID1_WRITE_ERROR = 0, + DM_RAID1_FLUSH_ERROR = 1, + DM_RAID1_SYNC_ERROR = 2, + DM_RAID1_READ_ERROR = 3, +}; + +enum dm_rh_region_states { + DM_RH_CLEAN = 1, + DM_RH_DIRTY = 2, + DM_RH_NOSYNC = 4, + DM_RH_RECOVERING = 8, +}; + +enum dma_attr { + DMA_ATTR_WRITE_BARRIER = 0, + DMA_ATTR_WEAK_ORDERING = 1, + DMA_ATTR_WRITE_COMBINE = 2, + DMA_ATTR_NON_CONSISTENT = 3, + DMA_ATTR_NO_KERNEL_MAPPING = 4, + DMA_ATTR_SKIP_CPU_SYNC = 5, + DMA_ATTR_FORCE_CONTIGUOUS = 6, + DMA_ATTR_ALLOC_SINGLE_PAGES = 7, + DMA_ATTR_MAX = 8, +}; + +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, +}; + +enum dma_data_direction { + DMA_BIDIRECTIONAL = 0, + DMA_TO_DEVICE = 1, + DMA_FROM_DEVICE = 2, + DMA_NONE = 3, +}; + +enum dma_residue_granularity { + DMA_RESIDUE_GRANULARITY_DESCRIPTOR = 0, + DMA_RESIDUE_GRANULARITY_SEGMENT = 1, + DMA_RESIDUE_GRANULARITY_BURST = 2, +}; + +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, +}; + +enum dma_status { + DMA_COMPLETE = 0, + DMA_IN_PROGRESS = 1, + DMA_PAUSED = 2, + DMA_ERROR = 3, +}; + +enum dma_sync_target { + SYNC_FOR_CPU = 0, + SYNC_FOR_DEVICE = 1, +}; + +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_SG = 8, + DMA_PRIVATE = 9, + DMA_ASYNC_TX = 10, + DMA_SLAVE = 11, + DMA_CYCLIC = 12, + DMA_INTERLEAVE = 13, + DMA_TX_TYPE_END = 14, +}; + +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, +}; + +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_SYS_VENDOR = 4, + DMI_PRODUCT_NAME = 5, + DMI_PRODUCT_VERSION = 6, + DMI_PRODUCT_SERIAL = 7, + DMI_PRODUCT_UUID = 8, + DMI_BOARD_VENDOR = 9, + DMI_BOARD_NAME = 10, + DMI_BOARD_VERSION = 11, + DMI_BOARD_SERIAL = 12, + DMI_BOARD_ASSET_TAG = 13, + DMI_CHASSIS_VENDOR = 14, + DMI_CHASSIS_TYPE = 15, + DMI_CHASSIS_VERSION = 16, + DMI_CHASSIS_SERIAL = 17, + DMI_CHASSIS_ASSET_TAG = 18, + DMI_STRING_MAX = 19, +}; + +enum dock_callback_type { + DOCK_CALL_HANDLER = 0, + DOCK_CALL_FIXUP = 1, + DOCK_CALL_UEVENT = 2, +}; + +enum dpio_channel { + DPIO_CH0 = 0, + DPIO_CH1 = 1, +}; + +enum dpio_phy { + DPIO_PHY0 = 0, + DPIO_PHY1 = 1, +}; + +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 drm_connector_force { + DRM_FORCE_UNSPECIFIED = 0, + DRM_FORCE_OFF = 1, + DRM_FORCE_ON = 2, + DRM_FORCE_ON_DIGITAL = 3, +}; + +enum drm_connector_status { + connector_status_connected = 1, + connector_status_disconnected = 2, + connector_status_unknown = 3, +}; + +enum drm_ctx_flags { + _DRM_CONTEXT_PRESERVED = 1, + _DRM_CONTEXT_2DONLY = 2, +}; + +enum drm_dma_flags { + _DRM_DMA_BLOCK = 1, + _DRM_DMA_WHILE_LOCKED = 2, + _DRM_DMA_PRIORITY = 4, + _DRM_DMA_WAIT = 16, + _DRM_DMA_SMALLER_OK = 32, + _DRM_DMA_LARGER_OK = 64, +}; + +enum drm_dp_dual_mode_type { + DRM_DP_DUAL_MODE_NONE = 0, + DRM_DP_DUAL_MODE_UNKNOWN = 1, + DRM_DP_DUAL_MODE_TYPE1_DVI = 2, + DRM_DP_DUAL_MODE_TYPE1_HDMI = 3, + DRM_DP_DUAL_MODE_TYPE2_DVI = 4, + DRM_DP_DUAL_MODE_TYPE2_HDMI = 5, +}; + +enum drm_global_types { + DRM_GLOBAL_TTM_MEM = 0, + DRM_GLOBAL_TTM_BO = 1, + DRM_GLOBAL_TTM_OBJECT = 2, + DRM_GLOBAL_NUM = 3, +}; + +enum drm_lock_flags { + _DRM_LOCK_READY = 1, + _DRM_LOCK_QUIESCENT = 2, + _DRM_LOCK_FLUSH = 4, + _DRM_LOCK_FLUSH_ALL = 8, + _DRM_HALT_ALL_QUEUES = 16, + _DRM_HALT_CUR_QUEUES = 32, +}; + +enum drm_map_flags { + _DRM_RESTRICTED = 1, + _DRM_READ_ONLY = 2, + _DRM_LOCKED = 4, + _DRM_KERNEL = 8, + _DRM_WRITE_COMBINING = 16, + _DRM_CONTAINS_LOCK = 32, + _DRM_REMOVABLE = 64, + _DRM_DRIVER = 128, +}; + +enum drm_map_type { + _DRM_FRAME_BUFFER = 0, + _DRM_REGISTERS = 1, + _DRM_SHM = 2, + _DRM_AGP = 3, + _DRM_SCATTER_GATHER = 4, + _DRM_CONSISTENT = 5, +}; + +enum drm_minor_type { + DRM_MINOR_LEGACY = 0, + DRM_MINOR_CONTROL = 1, + DRM_MINOR_RENDER = 2, + DRM_MINOR_CNT = 3, +}; + +enum drm_mm_allocator_flags { + DRM_MM_CREATE_DEFAULT = 0, + DRM_MM_CREATE_TOP = 1, +}; + +enum drm_mm_search_flags { + DRM_MM_SEARCH_DEFAULT = 0, + DRM_MM_SEARCH_BEST = 1, + DRM_MM_SEARCH_BELOW = 2, +}; + +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_STALE = -3, + MODE_BAD = -2, + MODE_ERROR = -1, +}; + +enum drm_plane_type { + DRM_PLANE_TYPE_OVERLAY = 0, + DRM_PLANE_TYPE_PRIMARY = 1, + DRM_PLANE_TYPE_CURSOR = 2, +}; + +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 drrs_refresh_rate_type { + DRRS_HIGH_RR = 0, + DRRS_LOW_RR = 1, + DRRS_MAX_RR = 2, +}; + +enum drrs_support_type { + DRRS_NOT_SUPPORTED = 0, + STATIC_DRRS_SUPPORT = 1, + SEAMLESS_DRRS_SUPPORT = 2, +}; + +enum ec_command { + ACPI_EC_COMMAND_READ = 128, + ACPI_EC_COMMAND_WRITE = 129, + ACPI_EC_BURST_ENABLE = 130, + ACPI_EC_BURST_DISABLE = 131, + ACPI_EC_COMMAND_QUERY = 132, +}; + +enum emulation_result { + EMULATE_DONE = 0, + EMULATE_USER_EXIT = 1, + EMULATE_FAIL = 2, +}; + +enum enable_type { + undefined = -1, + user_disabled = 0, + auto_disabled = 1, + user_enabled = 2, + auto_enabled = 3, +}; + +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_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_LAST = 39, +}; + +enum ethtool_phys_id_state { + ETHTOOL_ID_INACTIVE = 0, + ETHTOOL_ID_ACTIVE = 1, + ETHTOOL_ID_ON = 2, + ETHTOOL_ID_OFF = 3, +}; + +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, +}; + +enum evdev_clock_type { + EV_CLK_REAL = 0, + EV_CLK_MONO = 1, + EV_CLK_BOOT = 2, + EV_CLK_MAX = 3, +}; + +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, +}; + +enum event_type_t { + EVENT_FLEXIBLE = 1, + EVENT_PINNED = 2, + EVENT_TIME = 4, + EVENT_ALL = 3, +}; + +enum events { + THERMAL_AUX0 = 0, + THERMAL_AUX1 = 1, + THERMAL_CRITICAL = 2, + THERMAL_DEV_FAULT = 3, +}; + +enum exception { + EXCP_CONTEXT = 1, + NO_EXCP = 2, +}; + +enum extra_reg_type { + EXTRA_REG_NONE = -1, + EXTRA_REG_RSP_0 = 0, + EXTRA_REG_RSP_1 = 1, + EXTRA_REG_LBR = 2, + EXTRA_REG_LDLAT = 3, + EXTRA_REG_FE = 4, + EXTRA_REG_MAX = 5, +}; + +enum faulttype { + DMA_REMAP = 0, + INTR_REMAP = 1, + UNKNOWN = 2, +}; + +enum fb_op_origin { + ORIGIN_GTT = 0, + ORIGIN_CPU = 1, + ORIGIN_CS = 2, + ORIGIN_FLIP = 3, + ORIGIN_DIRTYFB = 4, +}; + +enum fbq_type { + regular = 0, + remote = 1, + all = 2, +}; + +enum fence_flag_bits { + FENCE_FLAG_SIGNALED_BIT = 0, + FENCE_FLAG_ENABLE_SIGNAL_BIT = 1, + FENCE_FLAG_USER_BITS = 2, +}; + +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_LUSTRE = 151, + FILEID_INVALID = 255, +}; + +enum file_time_flags { + S_ATIME = 1, + S_MTIME = 2, + S_CTIME = 4, + S_VERSION = 8, +}; + +enum filter_op_ids { + OP_OR = 0, + OP_AND = 1, + OP_GLOB = 2, + OP_NE = 3, + OP_EQ = 4, + OP_LT = 5, + OP_LE = 6, + OP_GT = 7, + OP_GE = 8, + OP_BAND = 9, + OP_NOT = 10, + OP_NONE = 11, + OP_OPEN_PAREN = 12, +}; + +enum fixed_addresses { + VSYSCALL_PAGE = 511, + FIX_DBGP_BASE = 512, + FIX_EARLYCON_MEM_BASE = 513, + FIX_OHCI1394_BASE = 514, + FIX_APIC_BASE = 515, + FIX_IO_APIC_BASE_0 = 516, + FIX_IO_APIC_BASE_END = 643, + FIX_RO_IDT = 644, + FIX_PARAVIRT_BOOTMAP = 645, + FIX_TEXT_POKE1 = 646, + FIX_TEXT_POKE0 = 647, + __end_of_permanent_fixed_addresses = 648, + FIX_BTMAP_END = 1024, + FIX_BTMAP_BEGIN = 1535, + __end_of_fixed_addresses = 1536, +}; + +enum flag_bits { + Faulty = 0, + In_sync = 1, + Bitmap_sync = 2, + WriteMostly = 3, + AutoDetected = 4, + Blocked = 5, + WriteErrorSeen = 6, + FaultRecorded = 7, + BlockedBadBlocks = 8, + WantReplacement = 9, + Replacement = 10, + Candidate = 11, + Journal = 12, + ClusterRemove = 13, +}; + +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_ETH_ADDRS = 5, + FLOW_DISSECTOR_KEY_TIPC_ADDRS = 6, + FLOW_DISSECTOR_KEY_VLANID = 7, + FLOW_DISSECTOR_KEY_FLOW_LABEL = 8, + FLOW_DISSECTOR_KEY_GRE_KEYID = 9, + FLOW_DISSECTOR_KEY_MPLS_ENTROPY = 10, + FLOW_DISSECTOR_KEY_MAX = 11, +}; + +enum forcewake_domain_id { + FW_DOMAIN_ID_RENDER = 0, + FW_DOMAIN_ID_BLITTER = 1, + FW_DOMAIN_ID_MEDIA = 2, + FW_DOMAIN_ID_COUNT = 3, +}; + +enum forcewake_domains { + FORCEWAKE_RENDER = 1, + FORCEWAKE_BLITTER = 2, + FORCEWAKE_MEDIA = 4, + FORCEWAKE_ALL = 7, +}; + +enum format_type { + FORMAT_TYPE_NONE = 0, + FORMAT_TYPE_WIDTH = 1, + FORMAT_TYPE_PRECISION = 2, + FORMAT_TYPE_CHAR = 3, + FORMAT_TYPE_STR = 4, + FORMAT_TYPE_PTR = 5, + FORMAT_TYPE_PERCENT_CHAR = 6, + FORMAT_TYPE_INVALID = 7, + FORMAT_TYPE_LONG_LONG = 8, + FORMAT_TYPE_ULONG = 9, + FORMAT_TYPE_LONG = 10, + FORMAT_TYPE_UBYTE = 11, + FORMAT_TYPE_BYTE = 12, + FORMAT_TYPE_USHORT = 13, + FORMAT_TYPE_SHORT = 14, + FORMAT_TYPE_UINT = 15, + FORMAT_TYPE_INT = 16, + FORMAT_TYPE_SIZE_T = 17, + FORMAT_TYPE_PTRDIFF = 18, +}; + +enum freeze_state { + FREEZE_STATE_NONE = 0, + FREEZE_STATE_ENTER = 1, + FREEZE_STATE_WAKE = 2, +}; + +enum freezer_state_flags { + CGROUP_FREEZER_ONLINE = 1, + CGROUP_FREEZING_SELF = 2, + CGROUP_FREEZING_PARENT = 4, + CGROUP_FROZEN = 8, + CGROUP_FREEZING = 6, +}; + +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, +}; + +enum fuse_notify_code { + FUSE_NOTIFY_POLL = 1, + FUSE_NOTIFY_INVAL_INODE = 2, + FUSE_NOTIFY_INVAL_ENTRY = 3, + FUSE_NOTIFY_STORE = 4, + FUSE_NOTIFY_RETRIEVE = 5, + FUSE_NOTIFY_DELETE = 6, + FUSE_NOTIFY_CODE_MAX = 7, +}; + +enum fuse_opcode { + FUSE_LOOKUP = 1, + FUSE_FORGET = 2, + FUSE_GETATTR = 3, + FUSE_SETATTR = 4, + FUSE_READLINK = 5, + FUSE_SYMLINK = 6, + FUSE_MKNOD = 8, + FUSE_MKDIR = 9, + FUSE_UNLINK = 10, + FUSE_RMDIR = 11, + FUSE_RENAME = 12, + FUSE_LINK = 13, + FUSE_OPEN = 14, + FUSE_READ = 15, + FUSE_WRITE = 16, + FUSE_STATFS = 17, + FUSE_RELEASE = 18, + FUSE_FSYNC = 20, + FUSE_SETXATTR = 21, + FUSE_GETXATTR = 22, + FUSE_LISTXATTR = 23, + FUSE_REMOVEXATTR = 24, + FUSE_FLUSH = 25, + FUSE_INIT = 26, + FUSE_OPENDIR = 27, + FUSE_READDIR = 28, + FUSE_RELEASEDIR = 29, + FUSE_FSYNCDIR = 30, + FUSE_GETLK = 31, + FUSE_SETLK = 32, + FUSE_SETLKW = 33, + FUSE_ACCESS = 34, + FUSE_CREATE = 35, + FUSE_INTERRUPT = 36, + FUSE_BMAP = 37, + FUSE_DESTROY = 38, + FUSE_IOCTL = 39, + FUSE_POLL = 40, + FUSE_NOTIFY_REPLY = 41, + FUSE_BATCH_FORGET = 42, + FUSE_FALLOCATE = 43, + FUSE_READDIRPLUS = 44, + FUSE_RENAME2 = 45, + FUSE_LSEEK = 46, + CUSE_INIT = 4096, +}; + +enum fuse_req_flag { + FR_ISREPLY = 0, + FR_FORCE = 1, + FR_BACKGROUND = 2, + FR_WAITING = 3, + FR_ABORTED = 4, + FR_INTERRUPTED = 5, + FR_LOCKED = 6, + FR_PENDING = 7, + FR_SENT = 8, + FR_FINISHED = 9, + FR_PRIVATE = 10, +}; + +enum fwnode_type { + FWNODE_INVALID = 0, + FWNODE_OF = 1, + FWNODE_ACPI = 2, + FWNODE_ACPI_DATA = 3, + FWNODE_PDATA = 4, + FWNODE_IRQCHIP = 5, +}; + +enum genphy_driver { + GENPHY_DRV_1G = 0, + GENPHY_DRV_10G = 1, + GENPHY_DRV_MAX = 2, +}; + +enum gpiod_flags { + GPIOD_ASIS = 0, + GPIOD_IN = 1, + GPIOD_OUT_LOW = 3, + GPIOD_OUT_HIGH = 7, +}; + +enum gro_result { + GRO_MERGED = 0, + GRO_MERGED_FREE = 1, + GRO_HELD = 2, + GRO_NORMAL = 3, + GRO_DROP = 4, +}; + +typedef enum gro_result gro_result_t; + +enum group_type { + group_other = 0, + group_imbalanced = 1, + group_overloaded = 2, +}; + +enum guc2host_status { + GUC2HOST_STATUS_SUCCESS = 4026531840, + GUC2HOST_STATUS_ALLOCATE_DOORBELL_FAIL = 4026531856, + GUC2HOST_STATUS_DEALLOCATE_DOORBELL_FAIL = 4026531872, + GUC2HOST_STATUS_GENERIC_FAIL = 4026593280, +}; + +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_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_ADOBE_YCC_601 = 3, + HDMI_EXTENDED_COLORIMETRY_ADOBE_RGB = 4, + HDMI_EXTENDED_COLORIMETRY_BT2020_CONST_LUM = 5, + HDMI_EXTENDED_COLORIMETRY_BT2020 = 6, + HDMI_EXTENDED_COLORIMETRY_RESERVED = 7, +}; + +enum hdmi_force_audio { + HDMI_AUDIO_OFF_DVI = -2, + HDMI_AUDIO_OFF = -1, + HDMI_AUDIO_AUTO = 0, + HDMI_AUDIO_ON = 1, +}; + +enum hdmi_infoframe_type { + HDMI_INFOFRAME_TYPE_VENDOR = 129, + HDMI_INFOFRAME_TYPE_AVI = 130, + HDMI_INFOFRAME_TYPE_SPD = 131, + HDMI_INFOFRAME_TYPE_AUDIO = 132, +}; + +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_RESERVED = 3, +}; + +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 host2guc_action { + HOST2GUC_ACTION_DEFAULT = 0, + HOST2GUC_ACTION_SAMPLE_FORCEWAKE = 6, + HOST2GUC_ACTION_ALLOCATE_DOORBELL = 16, + HOST2GUC_ACTION_DEALLOCATE_DOORBELL = 32, + HOST2GUC_ACTION_ENTER_S_STATE = 1281, + HOST2GUC_ACTION_EXIT_S_STATE = 1282, + HOST2GUC_ACTION_SLPC_REQUEST = 12291, + HOST2GUC_ACTION_LIMIT = 12292, +}; + +enum hpd_pin { + HPD_NONE = 0, + HPD_TV = 0, + HPD_CRT = 1, + HPD_SDVO_B = 2, + HPD_SDVO_C = 3, + HPD_PORT_A = 4, + HPD_PORT_B = 5, + HPD_PORT_C = 6, + HPD_PORT_D = 7, + HPD_PORT_E = 8, + HPD_NUM_PINS = 9, +}; + +enum hrtimer_base_type { + HRTIMER_BASE_MONOTONIC = 0, + HRTIMER_BASE_REALTIME = 1, + HRTIMER_BASE_BOOTTIME = 2, + HRTIMER_BASE_TAI = 3, + HRTIMER_MAX_CLOCK_BASES = 4, +}; + +enum hrtimer_mode { + HRTIMER_MODE_ABS = 0, + HRTIMER_MODE_REL = 1, + HRTIMER_MODE_PINNED = 2, + HRTIMER_MODE_ABS_PINNED = 2, + HRTIMER_MODE_REL_PINNED = 3, +}; + +enum hrtimer_restart { + HRTIMER_NORESTART = 0, + HRTIMER_RESTART = 1, +}; + +enum hsm_task_states { + HSM_ST_IDLE = 0, + HSM_ST_FIRST = 1, + HSM_ST = 2, + HSM_ST_LAST = 3, + HSM_ST_ERR = 4, +}; + +enum hv_message_type { + HVMSG_NONE = 0, + HVMSG_UNMAPPED_GPA = 2147483648, + HVMSG_GPA_INTERCEPT = 2147483649, + HVMSG_TIMER_EXPIRED = 2147483664, + HVMSG_INVALID_VP_REGISTER_VALUE = 2147483680, + HVMSG_UNRECOVERABLE_EXCEPTION = 2147483681, + HVMSG_UNSUPPORTED_FEATURE = 2147483682, + HVMSG_EVENTLOG_BUFFERCOMPLETE = 2147483712, + HVMSG_X64_IOPORT_INTERCEPT = 2147549184, + HVMSG_X64_MSR_INTERCEPT = 2147549185, + HVMSG_X64_CPUID_INTERCEPT = 2147549186, + HVMSG_X64_EXCEPTION_INTERCEPT = 2147549187, + HVMSG_X64_APIC_EOI = 2147549188, + HVMSG_X64_LEGACY_FP_ERROR = 2147549189, +}; + +enum hw_event_mc_err_type { + HW_EVENT_ERR_CORRECTED = 0, + HW_EVENT_ERR_UNCORRECTED = 1, + HW_EVENT_ERR_FATAL = 2, + HW_EVENT_ERR_INFO = 3, +}; + +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, +}; + +enum hwtstamp_tx_types { + HWTSTAMP_TX_OFF = 0, + HWTSTAMP_TX_ON = 1, + HWTSTAMP_TX_ONESTEP_SYNC = 2, +}; + +enum i915_cache_level { + I915_CACHE_NONE = 0, + I915_CACHE_LLC = 1, + I915_CACHE_L3_LLC = 2, + I915_CACHE_WT = 3, +}; + +enum i915_ggtt_view_type { + I915_GGTT_VIEW_NORMAL = 0, + I915_GGTT_VIEW_ROTATED = 1, + I915_GGTT_VIEW_PARTIAL = 2, +}; + +enum ibs_states { + IBS_ENABLED = 0, + IBS_STARTED = 1, + IBS_STOPPING = 2, + IBS_STOPPED = 3, + IBS_MAX_STATES = 4, +}; + +enum idle_boot_override { + IDLE_NO_OVERRIDE = 0, + IDLE_HALT = 1, + IDLE_NOMWAIT = 2, + IDLE_POLL = 3, +}; + +enum ii_ids { + II_MEM = 0, + II_RESV = 1, + II_IO = 2, + II_GEN = 3, +}; + +enum inet_csk_ack_state_t { + ICSK_ACK_SCHED = 1, + ICSK_ACK_TIMER = 2, + ICSK_ACK_PUSHED = 4, + ICSK_ACK_PUSHED2 = 8, +}; + +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 intel_ddb_partitioning { + INTEL_DDB_PART_1_2 = 0, + INTEL_DDB_PART_5_6 = 1, +}; + +enum intel_display_power_domain { + POWER_DOMAIN_PIPE_A = 0, + POWER_DOMAIN_PIPE_B = 1, + POWER_DOMAIN_PIPE_C = 2, + POWER_DOMAIN_PIPE_A_PANEL_FITTER = 3, + POWER_DOMAIN_PIPE_B_PANEL_FITTER = 4, + POWER_DOMAIN_PIPE_C_PANEL_FITTER = 5, + POWER_DOMAIN_TRANSCODER_A = 6, + POWER_DOMAIN_TRANSCODER_B = 7, + POWER_DOMAIN_TRANSCODER_C = 8, + POWER_DOMAIN_TRANSCODER_EDP = 9, + POWER_DOMAIN_TRANSCODER_DSI_A = 10, + POWER_DOMAIN_TRANSCODER_DSI_C = 11, + POWER_DOMAIN_PORT_DDI_A_LANES = 12, + POWER_DOMAIN_PORT_DDI_B_LANES = 13, + POWER_DOMAIN_PORT_DDI_C_LANES = 14, + POWER_DOMAIN_PORT_DDI_D_LANES = 15, + POWER_DOMAIN_PORT_DDI_E_LANES = 16, + POWER_DOMAIN_PORT_DSI = 17, + POWER_DOMAIN_PORT_CRT = 18, + POWER_DOMAIN_PORT_OTHER = 19, + POWER_DOMAIN_VGA = 20, + POWER_DOMAIN_AUDIO = 21, + POWER_DOMAIN_PLLS = 22, + POWER_DOMAIN_AUX_A = 23, + POWER_DOMAIN_AUX_B = 24, + POWER_DOMAIN_AUX_C = 25, + POWER_DOMAIN_AUX_D = 26, + POWER_DOMAIN_GMBUS = 27, + POWER_DOMAIN_MODESET = 28, + POWER_DOMAIN_INIT = 29, + POWER_DOMAIN_NUM = 30, +}; + +enum intel_dpll_id { + DPLL_ID_PRIVATE = -1, + DPLL_ID_PCH_PLL_A = 0, + DPLL_ID_PCH_PLL_B = 1, + DPLL_ID_WRPLL1 = 0, + DPLL_ID_WRPLL2 = 1, + DPLL_ID_SPLL = 2, + DPLL_ID_LCPLL_810 = 3, + DPLL_ID_LCPLL_1350 = 4, + DPLL_ID_LCPLL_2700 = 5, + DPLL_ID_SKL_DPLL0 = 0, + DPLL_ID_SKL_DPLL1 = 1, + DPLL_ID_SKL_DPLL2 = 2, + DPLL_ID_SKL_DPLL3 = 3, +}; + +enum intel_engine_id { + RCS = 0, + BCS = 1, + VCS = 2, + VCS2 = 3, + VECS = 4, +}; + +enum intel_excl_state_type { + INTEL_EXCL_UNUSED = 0, + INTEL_EXCL_SHARED = 1, + INTEL_EXCL_EXCLUSIVE = 2, +}; + +enum intel_guc_fw_status { + GUC_FIRMWARE_FAIL = -1, + GUC_FIRMWARE_NONE = 0, + GUC_FIRMWARE_PENDING = 1, + GUC_FIRMWARE_SUCCESS = 2, +}; + +enum intel_output_type { + INTEL_OUTPUT_UNUSED = 0, + INTEL_OUTPUT_ANALOG = 1, + INTEL_OUTPUT_DVO = 2, + INTEL_OUTPUT_SDVO = 3, + INTEL_OUTPUT_LVDS = 4, + INTEL_OUTPUT_TVOUT = 5, + INTEL_OUTPUT_HDMI = 6, + INTEL_OUTPUT_DISPLAYPORT = 7, + INTEL_OUTPUT_EDP = 8, + INTEL_OUTPUT_DSI = 9, + INTEL_OUTPUT_UNKNOWN = 10, + INTEL_OUTPUT_DP_MST = 11, +}; + +enum intel_pch { + PCH_NONE = 0, + PCH_IBX = 1, + PCH_CPT = 2, + PCH_LPT = 3, + PCH_SPT = 4, + PCH_NOP = 5, +}; + +enum intel_pipe_crc_object { + PIPE_CRC_OBJECT_PIPE = 0, +}; + +enum intel_pipe_crc_source { + INTEL_PIPE_CRC_SOURCE_NONE = 0, + INTEL_PIPE_CRC_SOURCE_PLANE1 = 1, + INTEL_PIPE_CRC_SOURCE_PLANE2 = 2, + INTEL_PIPE_CRC_SOURCE_PF = 3, + INTEL_PIPE_CRC_SOURCE_PIPE = 4, + INTEL_PIPE_CRC_SOURCE_TV = 5, + INTEL_PIPE_CRC_SOURCE_DP_B = 6, + INTEL_PIPE_CRC_SOURCE_DP_C = 7, + INTEL_PIPE_CRC_SOURCE_DP_D = 8, + INTEL_PIPE_CRC_SOURCE_AUTO = 9, + INTEL_PIPE_CRC_SOURCE_MAX = 10, +}; + +enum intel_ring_hangcheck_action { + HANGCHECK_IDLE = 0, + HANGCHECK_WAIT = 1, + HANGCHECK_ACTIVE = 2, + HANGCHECK_KICK = 3, + HANGCHECK_HUNG = 4, +}; + +enum intel_sbi_destination { + SBI_ICLK = 0, + SBI_MPHY = 1, +}; + +enum ioapic_domain_type { + IOAPIC_DOMAIN_INVALID = 0, + IOAPIC_DOMAIN_LEGACY = 1, + IOAPIC_DOMAIN_STRICT = 2, + IOAPIC_DOMAIN_DYNAMIC = 3, +}; + +enum ioapic_irq_destination_types { + dest_Fixed = 0, + dest_LowestPrio = 1, + dest_SMI = 2, + dest__reserved_1 = 3, + dest_NMI = 4, + dest_INIT = 5, + dest__reserved_2 = 6, + dest_ExtINT = 7, +}; + +enum iommu_attr { + DOMAIN_ATTR_GEOMETRY = 0, + DOMAIN_ATTR_PAGING = 1, + DOMAIN_ATTR_WINDOWS = 2, + DOMAIN_ATTR_FSL_PAMU_STASH = 3, + DOMAIN_ATTR_FSL_PAMU_ENABLE = 4, + DOMAIN_ATTR_FSL_PAMUV1 = 5, + DOMAIN_ATTR_NESTING = 6, + DOMAIN_ATTR_MAX = 7, +}; + +enum iommu_cap { + IOMMU_CAP_CACHE_COHERENCY = 0, + IOMMU_CAP_INTR_REMAP = 1, + IOMMU_CAP_NOEXEC = 2, +}; + +enum iommu_init_state { + IOMMU_START_STATE = 0, + IOMMU_IVRS_DETECTED = 1, + IOMMU_ACPI_FINISHED = 2, + IOMMU_ENABLED = 3, + IOMMU_PCI_INIT = 4, + IOMMU_INTERRUPTS_EN = 5, + IOMMU_DMA_OPS = 6, + IOMMU_INITIALIZED = 7, + IOMMU_NOT_FOUND = 8, + IOMMU_INIT_ERROR = 9, +}; + +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 irq_alloc_type { + X86_IRQ_ALLOC_TYPE_IOAPIC = 1, + X86_IRQ_ALLOC_TYPE_HPET = 2, + X86_IRQ_ALLOC_TYPE_MSI = 3, + X86_IRQ_ALLOC_TYPE_MSIX = 4, + X86_IRQ_ALLOC_TYPE_DMAR = 5, + X86_IRQ_ALLOC_TYPE_UV = 6, +}; + +enum irq_domain_bus_token { + DOMAIN_BUS_ANY = 0, + DOMAIN_BUS_WIRED = 1, + DOMAIN_BUS_PCI_MSI = 2, + DOMAIN_BUS_PLATFORM_MSI = 3, + DOMAIN_BUS_NEXUS = 4, + DOMAIN_BUS_IPI = 5, + DOMAIN_BUS_FSL_MC_MSI = 6, +}; + +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 irq_remap_cap { + IRQ_POSTING_CAP = 0, +}; + +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 isofs_file_format { + isofs_file_normal = 0, + isofs_file_sparse = 1, + isofs_file_compressed = 2, +}; + +enum jump_label_type { + JUMP_LABEL_NOP = 0, + JUMP_LABEL_JMP = 1, +}; + +enum kcore_type { + KCORE_TEXT = 0, + KCORE_VMALLOC = 1, + KCORE_RAM = 2, + KCORE_VMEMMAP = 3, + KCORE_OTHER = 4, +}; + +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_MAX_ID = 6, +}; + +enum kernfs_node_flag { + KERNFS_ACTIVATED = 16, + KERNFS_NS = 32, + KERNFS_HAS_SEQ_SHOW = 64, + KERNFS_HAS_MMAP = 128, + KERNFS_LOCKDEP = 256, + KERNFS_SUICIDAL = 1024, + KERNFS_SUICIDED = 2048, + KERNFS_EMPTY_DIR = 4096, +}; + +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, +}; + +enum kmsg_dump_reason { + KMSG_DUMP_UNDEF = 0, + KMSG_DUMP_PANIC = 1, + KMSG_DUMP_OOPS = 2, + KMSG_DUMP_EMERG = 3, + KMSG_DUMP_RESTART = 4, + KMSG_DUMP_HALT = 5, + KMSG_DUMP_POWEROFF = 6, +}; + +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_MAX = 6, +}; + +enum kprobe_slot_state { + SLOT_CLEAN = 0, + SLOT_DIRTY = 1, + SLOT_USED = 2, +}; + +enum kvm_bus { + KVM_MMIO_BUS = 0, + KVM_PIO_BUS = 1, + KVM_VIRTIO_CCW_NOTIFY_BUS = 2, + KVM_FAST_MMIO_BUS = 3, + KVM_NR_BUSES = 4, +}; + +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_MAX = 8, +}; + +enum kvm_mr_change { + KVM_MR_CREATE = 0, + KVM_MR_DELETE = 1, + KVM_MR_MOVE = 2, + KVM_MR_FLAGS_ONLY = 3, +}; + +enum kvm_page_track_mode { + KVM_PAGE_TRACK_WRITE = 0, + KVM_PAGE_TRACK_MAX = 1, +}; + +enum kvm_reg { + VCPU_REGS_RAX = 0, + VCPU_REGS_RCX = 1, + VCPU_REGS_RDX = 2, + VCPU_REGS_RBX = 3, + VCPU_REGS_RSP = 4, + VCPU_REGS_RBP = 5, + VCPU_REGS_RSI = 6, + VCPU_REGS_RDI = 7, + VCPU_REGS_R8 = 8, + VCPU_REGS_R9 = 9, + VCPU_REGS_R10 = 10, + VCPU_REGS_R11 = 11, + VCPU_REGS_R12 = 12, + VCPU_REGS_R13 = 13, + VCPU_REGS_R14 = 14, + VCPU_REGS_R15 = 15, + VCPU_REGS_RIP = 16, + NR_VCPU_REGS = 17, +}; + +enum kvm_reg_ex { + VCPU_EXREG_PDPTR = 17, + VCPU_EXREG_CR3 = 18, + VCPU_EXREG_RFLAGS = 19, + VCPU_EXREG_SEGMENTS = 20, +}; + +enum kvm_stat_kind { + KVM_STAT_VM = 0, + KVM_STAT_VCPU = 1, +}; + +enum led_brightness { + LED_OFF = 0, + LED_HALF = 127, + LED_FULL = 255, +}; + +enum link_m_n_set { + M1_N1 = 0, + M2_N2 = 1, +}; + +enum ll_ids { + LL_RESV = 0, + LL_L1 = 1, + LL_L2 = 2, + LL_LG = 3, +}; + +enum lockdep_ok { + LOCKDEP_STILL_OK = 0, + LOCKDEP_NOW_UNRELIABLE = 1, +}; + +enum log_flags { + LOG_NOCONS = 1, + LOG_NEWLINE = 2, + LOG_PREFIX = 4, + LOG_CONT = 8, +}; + +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, +}; + +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_MAX = 5, +}; + +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_MAX = 8, +}; + +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_MAX = 8, +}; + +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 mapping_flags { + AS_EIO = 26, + AS_ENOSPC = 27, + AS_MM_ALL_LOCKS = 28, + AS_UNEVICTABLE = 29, + AS_EXITING = 30, +}; + +enum mcp_flags { + MCP_TIMESTAMP = 1, + MCP_UC = 2, + MCP_DONTLOG = 4, +}; + +enum mem_cgroup_events_index { + MEM_CGROUP_EVENTS_PGPGIN = 0, + MEM_CGROUP_EVENTS_PGPGOUT = 1, + MEM_CGROUP_EVENTS_PGFAULT = 2, + MEM_CGROUP_EVENTS_PGMAJFAULT = 3, + MEM_CGROUP_EVENTS_NSTATS = 4, + MEMCG_LOW = 4, + MEMCG_HIGH = 5, + MEMCG_MAX = 6, + MEMCG_OOM = 7, + MEMCG_NR_EVENTS = 8, +}; + +enum mem_cgroup_stat_index { + MEM_CGROUP_STAT_CACHE = 0, + MEM_CGROUP_STAT_RSS = 1, + MEM_CGROUP_STAT_RSS_HUGE = 2, + MEM_CGROUP_STAT_FILE_MAPPED = 3, + MEM_CGROUP_STAT_DIRTY = 4, + MEM_CGROUP_STAT_WRITEBACK = 5, + MEM_CGROUP_STAT_SWAP = 6, + MEM_CGROUP_STAT_NSTATS = 7, + MEMCG_KERNEL_STACK = 7, + MEMCG_SLAB_RECLAIMABLE = 8, + MEMCG_SLAB_UNRECLAIMABLE = 9, + MEMCG_SOCK = 10, + MEMCG_NR_STAT = 11, +}; + +enum membarrier_cmd { + MEMBARRIER_CMD_QUERY = 0, + MEMBARRIER_CMD_SHARED = 1, +}; + +enum memmap_context { + MEMMAP_EARLY = 0, + MEMMAP_HOTPLUG = 1, +}; + +enum mf_flags { + MF_COUNT_INCREASED = 1, + MF_ACTION_REQUIRED = 2, + MF_MUST_KILL = 4, + MF_SOFT_OFFLINE = 8, +}; + +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_CMA = 6, + MR_TYPES = 7, +}; + +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 mipi_seq { + MIPI_SEQ_END = 0, + MIPI_SEQ_ASSERT_RESET = 1, + MIPI_SEQ_INIT_OTP = 2, + MIPI_SEQ_DISPLAY_ON = 3, + MIPI_SEQ_DISPLAY_OFF = 4, + MIPI_SEQ_DEASSERT_RESET = 5, + MIPI_SEQ_BACKLIGHT_ON = 6, + MIPI_SEQ_BACKLIGHT_OFF = 7, + MIPI_SEQ_TEAR_ON = 8, + MIPI_SEQ_TEAR_OFF = 9, + MIPI_SEQ_POWER_ON = 10, + MIPI_SEQ_POWER_OFF = 11, + MIPI_SEQ_MAX = 12, +}; + +enum mipi_seq_element { + MIPI_SEQ_ELEM_END = 0, + MIPI_SEQ_ELEM_SEND_PKT = 1, + MIPI_SEQ_ELEM_DELAY = 2, + MIPI_SEQ_ELEM_GPIO = 3, + MIPI_SEQ_ELEM_I2C = 4, + MIPI_SEQ_ELEM_SPI = 5, + MIPI_SEQ_ELEM_PMIC = 6, + MIPI_SEQ_ELEM_MAX = 7, +}; + +enum mminit_level { + MMINIT_WARNING = 0, + MMINIT_VERIFY = 1, + MMINIT_TRACE = 2, +}; + +enum mode_set_atomic { + LEAVE_ATOMIC_MODE_SET = 0, + ENTER_ATOMIC_MODE_SET = 1, +}; + +enum modeset_restore { + MODESET_ON_LID_OPEN = 0, + MODESET_DONE = 1, + MODESET_SUSPENDED = 2, +}; + +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 move_type { + MOVE_DOWN = 0, + MOVE_UP_FROM_LEFT = 1, + MOVE_UP_FROM_RIGHT = 2, +}; + +enum mp_irq_source_types { + mp_INT = 0, + mp_NMI = 1, + mp_SMI = 2, + mp_ExtINT = 3, +}; + +enum mpol_rebind_step { + MPOL_REBIND_ONCE = 0, + MPOL_REBIND_STEP1 = 1, + MPOL_REBIND_STEP2 = 2, + MPOL_REBIND_NSTEP = 3, +}; + +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 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 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_IPVLAN_MASTER = 262144, + IFF_IPVLAN_SLAVE = 524288, + IFF_L3MDEV_MASTER = 1048576, + IFF_NO_QUEUE = 2097152, + IFF_OPENVSWITCH = 4194304, + IFF_L3MDEV_SLAVE = 8388608, + IFF_TEAM = 16777216, + IFF_RXFH_CONFIGURED = 33554432, + IFF_PHONY_HEADROOM = 67108864, + IFF_MACSEC = 134217728, +}; + +enum netdev_queue_state_t { + __QUEUE_STATE_DRV_XOFF = 0, + __QUEUE_STATE_STACK_XOFF = 1, + __QUEUE_STATE_FROZEN = 2, +}; + +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, +}; + +enum netdev_tx { + __NETDEV_TX_MIN = -2147483648, + NETDEV_TX_OK = 0, + NETDEV_TX_BUSY = 16, +}; + +typedef enum netdev_tx netdev_tx_t; + +enum netevent_notif_type { + NETEVENT_NEIGH_UPDATE = 1, + NETEVENT_REDIRECT = 2, +}; + +enum netlink_skb_flags { + NETLINK_SKB_MMAPED = 1, + NETLINK_SKB_TX = 2, + NETLINK_SKB_DELIVERED = 4, + NETLINK_SKB_DST = 8, +}; + +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, +}; + +enum nmi_states { + NMI_NOT_RUNNING = 0, + NMI_EXECUTING = 1, + NMI_LATCHED = 2, +}; + +typedef enum nmi_states pto_T__; + +enum node_states { + N_POSSIBLE = 0, + N_ONLINE = 1, + N_NORMAL_MEMORY = 2, + N_HIGH_MEMORY = 2, + N_MEMORY = 2, + N_CPU = 3, + NR_NODE_STATES = 4, +}; + +enum numa_topology_type { + NUMA_DIRECT = 0, + NUMA_GLUELESS_MESH = 1, + NUMA_BACKPLANE = 2, +}; + +enum oom_constraint { + CONSTRAINT_NONE = 0, + CONSTRAINT_CPUSET = 1, + CONSTRAINT_MEMORY_POLICY = 2, + CONSTRAINT_MEMCG = 3, +}; + +enum oom_scan_t { + OOM_SCAN_OK = 0, + OOM_SCAN_CONTINUE = 1, + OOM_SCAN_ABORT = 2, + OOM_SCAN_SELECT = 3, +}; + +enum ovl_path_type { + __OVL_PATH_PURE = 1, + __OVL_PATH_UPPER = 2, + __OVL_PATH_MERGE = 4, +}; + +enum p9_cache_modes { + CACHE_NONE = 0, + CACHE_MMAP = 1, + CACHE_LOOSE = 2, + CACHE_FSCACHE = 3, +}; + +enum p9_msg_t { + P9_TLERROR = 6, + P9_RLERROR = 7, + P9_TSTATFS = 8, + P9_RSTATFS = 9, + P9_TLOPEN = 12, + P9_RLOPEN = 13, + P9_TLCREATE = 14, + P9_RLCREATE = 15, + P9_TSYMLINK = 16, + P9_RSYMLINK = 17, + P9_TMKNOD = 18, + P9_RMKNOD = 19, + P9_TRENAME = 20, + P9_RRENAME = 21, + P9_TREADLINK = 22, + P9_RREADLINK = 23, + P9_TGETATTR = 24, + P9_RGETATTR = 25, + P9_TSETATTR = 26, + P9_RSETATTR = 27, + P9_TXATTRWALK = 30, + P9_RXATTRWALK = 31, + P9_TXATTRCREATE = 32, + P9_RXATTRCREATE = 33, + P9_TREADDIR = 40, + P9_RREADDIR = 41, + P9_TFSYNC = 50, + P9_RFSYNC = 51, + P9_TLOCK = 52, + P9_RLOCK = 53, + P9_TGETLOCK = 54, + P9_RGETLOCK = 55, + P9_TLINK = 70, + P9_RLINK = 71, + P9_TMKDIR = 72, + P9_RMKDIR = 73, + P9_TRENAMEAT = 74, + P9_RRENAMEAT = 75, + P9_TUNLINKAT = 76, + P9_RUNLINKAT = 77, + P9_TVERSION = 100, + P9_RVERSION = 101, + P9_TAUTH = 102, + P9_RAUTH = 103, + P9_TATTACH = 104, + P9_RATTACH = 105, + P9_TERROR = 106, + P9_RERROR = 107, + P9_TFLUSH = 108, + P9_RFLUSH = 109, + P9_TWALK = 110, + P9_RWALK = 111, + P9_TOPEN = 112, + P9_ROPEN = 113, + P9_TCREATE = 114, + P9_RCREATE = 115, + P9_TREAD = 116, + P9_RREAD = 117, + P9_TWRITE = 118, + P9_RWRITE = 119, + P9_TCLUNK = 120, + P9_RCLUNK = 121, + P9_TREMOVE = 122, + P9_RREMOVE = 123, + P9_TSTAT = 124, + P9_RSTAT = 125, + P9_TWSTAT = 126, + P9_RWSTAT = 127, +}; + +enum p9_open_mode_t { + P9_OREAD = 0, + P9_OWRITE = 1, + P9_ORDWR = 2, + P9_OEXEC = 3, + P9_OTRUNC = 16, + P9_OREXEC = 32, + P9_ORCLOSE = 64, + P9_OAPPEND = 128, + P9_OEXCL = 4096, +}; + +enum p9_perm_t { + P9_DMDIR = 2147483648, + P9_DMAPPEND = 1073741824, + P9_DMEXCL = 536870912, + P9_DMMOUNT = 268435456, + P9_DMAUTH = 134217728, + P9_DMTMP = 67108864, + P9_DMSYMLINK = 33554432, + P9_DMLINK = 16777216, + P9_DMDEVICE = 8388608, + P9_DMNAMEDPIPE = 2097152, + P9_DMSOCKET = 1048576, + P9_DMSETUID = 524288, + P9_DMSETGID = 262144, + P9_DMSETVTX = 65536, +}; + +enum p9_proto_versions { + p9_proto_legacy = 0, + p9_proto_2000u = 1, + p9_proto_2000L = 2, +}; + +enum p9_req_status_t { + REQ_STATUS_IDLE = 0, + REQ_STATUS_ALLOC = 1, + REQ_STATUS_UNSENT = 2, + REQ_STATUS_SENT = 3, + REQ_STATUS_RCVD = 4, + REQ_STATUS_FLSHD = 5, + REQ_STATUS_ERROR = 6, +}; + +enum p9_session_flags { + V9FS_PROTO_2000U = 1, + V9FS_PROTO_2000L = 2, + V9FS_ACCESS_SINGLE = 4, + V9FS_ACCESS_USER = 8, + V9FS_ACCESS_CLIENT = 16, + V9FS_POSIX_ACL = 32, +}; + +enum p9_trans_status { + Connected = 0, + BeginDisconnect = 1, + Disconnected = 2, + Hung = 3, +}; + +enum page_cache_mode { + _PAGE_CACHE_MODE_WB = 0, + _PAGE_CACHE_MODE_WC = 1, + _PAGE_CACHE_MODE_UC_MINUS = 2, + _PAGE_CACHE_MODE_UC = 3, + _PAGE_CACHE_MODE_WT = 4, + _PAGE_CACHE_MODE_WP = 5, + _PAGE_CACHE_MODE_NUM = 8, +}; + +enum page_references { + PAGEREF_RECLAIM = 0, + PAGEREF_RECLAIM_CLEAN = 1, + PAGEREF_KEEP = 2, + PAGEREF_ACTIVATE = 3, +}; + +enum pageblock_bits { + PB_migrate = 0, + PB_migrate_end = 2, + PB_migrate_skip = 3, + NR_PAGEBLOCK_BITS = 4, +}; + +enum pageflags { + PG_locked = 0, + PG_error = 1, + PG_referenced = 2, + PG_uptodate = 3, + PG_dirty = 4, + PG_lru = 5, + PG_active = 6, + PG_slab = 7, + PG_owner_priv_1 = 8, + PG_arch_1 = 9, + PG_reserved = 10, + PG_private = 11, + PG_private_2 = 12, + PG_writeback = 13, + PG_head = 14, + PG_swapcache = 15, + PG_mappedtodisk = 16, + PG_reclaim = 17, + PG_swapbacked = 18, + PG_unevictable = 19, + PG_mlocked = 20, + PG_uncached = 21, + __NR_PAGEFLAGS = 22, + PG_checked = 8, + PG_fscache = 12, + PG_pinned = 8, + PG_savepinned = 4, + PG_foreign = 8, + PG_slob_free = 11, + PG_double_map = 12, +}; + +enum paravirt_lazy_mode { + PARAVIRT_LAZY_NONE = 0, + PARAVIRT_LAZY_MMU = 1, + PARAVIRT_LAZY_CPU = 2, +}; + +typedef enum paravirt_lazy_mode pto_T_____2; + +enum pci_bar_type { + pci_bar_unknown = 0, + pci_bar_io = 1, + pci_bar_mem32 = 2, + pci_bar_mem64 = 3, +}; + +enum pci_bf_sort_state { + pci_bf_sort_default = 0, + pci_force_nobf = 1, + pci_force_bf = 2, + pci_dmi_bf = 3, +}; + +enum pci_board_num_t { + pbn_default = 0, + pbn_b0_1_115200 = 1, + pbn_b0_2_115200 = 2, + pbn_b0_4_115200 = 3, + pbn_b0_5_115200 = 4, + pbn_b0_8_115200 = 5, + pbn_b0_1_921600 = 6, + pbn_b0_2_921600 = 7, + pbn_b0_4_921600 = 8, + pbn_b0_2_1130000 = 9, + pbn_b0_4_1152000 = 10, + pbn_b0_2_1152000_200 = 11, + pbn_b0_4_1152000_200 = 12, + pbn_b0_8_1152000_200 = 13, + pbn_b0_2_1843200 = 14, + pbn_b0_4_1843200 = 15, + pbn_b0_2_1843200_200 = 16, + pbn_b0_4_1843200_200 = 17, + pbn_b0_8_1843200_200 = 18, + pbn_b0_1_4000000 = 19, + pbn_b0_bt_1_115200 = 20, + pbn_b0_bt_2_115200 = 21, + pbn_b0_bt_4_115200 = 22, + pbn_b0_bt_8_115200 = 23, + pbn_b0_bt_1_460800 = 24, + pbn_b0_bt_2_460800 = 25, + pbn_b0_bt_4_460800 = 26, + pbn_b0_bt_1_921600 = 27, + pbn_b0_bt_2_921600 = 28, + pbn_b0_bt_4_921600 = 29, + pbn_b0_bt_8_921600 = 30, + pbn_b1_1_115200 = 31, + pbn_b1_2_115200 = 32, + pbn_b1_4_115200 = 33, + pbn_b1_8_115200 = 34, + pbn_b1_16_115200 = 35, + pbn_b1_1_921600 = 36, + pbn_b1_2_921600 = 37, + pbn_b1_4_921600 = 38, + pbn_b1_8_921600 = 39, + pbn_b1_2_1250000 = 40, + pbn_b1_bt_1_115200 = 41, + pbn_b1_bt_2_115200 = 42, + pbn_b1_bt_4_115200 = 43, + pbn_b1_bt_2_921600 = 44, + pbn_b1_1_1382400 = 45, + pbn_b1_2_1382400 = 46, + pbn_b1_4_1382400 = 47, + pbn_b1_8_1382400 = 48, + pbn_b2_1_115200 = 49, + pbn_b2_2_115200 = 50, + pbn_b2_4_115200 = 51, + pbn_b2_8_115200 = 52, + pbn_b2_1_460800 = 53, + pbn_b2_4_460800 = 54, + pbn_b2_8_460800 = 55, + pbn_b2_16_460800 = 56, + pbn_b2_1_921600 = 57, + pbn_b2_4_921600 = 58, + pbn_b2_8_921600 = 59, + pbn_b2_8_1152000 = 60, + pbn_b2_bt_1_115200 = 61, + pbn_b2_bt_2_115200 = 62, + pbn_b2_bt_4_115200 = 63, + pbn_b2_bt_2_921600 = 64, + pbn_b2_bt_4_921600 = 65, + pbn_b3_2_115200 = 66, + pbn_b3_4_115200 = 67, + pbn_b3_8_115200 = 68, + pbn_b4_bt_2_921600 = 69, + pbn_b4_bt_4_921600 = 70, + pbn_b4_bt_8_921600 = 71, + pbn_panacom = 72, + pbn_panacom2 = 73, + pbn_panacom4 = 74, + pbn_plx_romulus = 75, + pbn_endrun_2_4000000 = 76, + pbn_oxsemi = 77, + pbn_oxsemi_1_4000000 = 78, + pbn_oxsemi_2_4000000 = 79, + pbn_oxsemi_4_4000000 = 80, + pbn_oxsemi_8_4000000 = 81, + pbn_intel_i960 = 82, + pbn_sgi_ioc3 = 83, + pbn_computone_4 = 84, + pbn_computone_6 = 85, + pbn_computone_8 = 86, + pbn_sbsxrsio = 87, + pbn_exar_XR17C152 = 88, + pbn_exar_XR17C154 = 89, + pbn_exar_XR17C158 = 90, + pbn_exar_XR17V352 = 91, + pbn_exar_XR17V354 = 92, + pbn_exar_XR17V358 = 93, + pbn_exar_XR17V4358 = 94, + pbn_exar_XR17V8358 = 95, + pbn_exar_ibm_saturn = 96, + pbn_pasemi_1682M = 97, + pbn_ni8430_2 = 98, + pbn_ni8430_4 = 99, + pbn_ni8430_8 = 100, + pbn_ni8430_16 = 101, + pbn_ADDIDATA_PCIe_1_3906250 = 102, + pbn_ADDIDATA_PCIe_2_3906250 = 103, + pbn_ADDIDATA_PCIe_4_3906250 = 104, + pbn_ADDIDATA_PCIe_8_3906250 = 105, + pbn_ce4100_1_115200 = 106, + pbn_byt = 107, + pbn_qrk = 108, + pbn_omegapci = 109, + pbn_NETMOS9900_2s_115200 = 110, + pbn_brcm_trumanage = 111, + pbn_fintek_4 = 112, + pbn_fintek_8 = 113, + pbn_fintek_12 = 114, + pbn_wch382_2 = 115, + pbn_wch384_4 = 116, + pbn_pericom_PI7C9X7951 = 117, + pbn_pericom_PI7C9X7952 = 118, + pbn_pericom_PI7C9X7954 = 119, + pbn_pericom_PI7C9X7958 = 120, +}; + +enum pci_bus_flags { + PCI_BUS_FLAGS_NO_MSI = 1, + PCI_BUS_FLAGS_NO_MMRBC = 2, +}; + +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, + PCI_SPEED_UNKNOWN = 255, +}; + +enum pci_channel_state { + pci_channel_io_normal = 1, + pci_channel_io_frozen = 2, + pci_channel_io_perm_failure = 3, +}; + +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, +}; + +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_irq_reroute_variant { + INTEL_IRQ_REROUTE_VARIANT = 1, + MAX_IRQ_REROUTE_VARIANTS = 3, +}; + +enum pci_lost_interrupt_reason { + PCI_LOST_IRQ_NO_INFORMATION = 0, + PCI_LOST_IRQ_DISABLE_MSI = 1, + PCI_LOST_IRQ_DISABLE_MSIX = 2, + PCI_LOST_IRQ_DISABLE_ACPI = 3, +}; + +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 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 pcpu_fc { + PCPU_FC_AUTO = 0, + PCPU_FC_EMBED = 1, + PCPU_FC_PAGE = 2, + PCPU_FC_NR = 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_MAX = 65536, +}; + +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_MAX_SHIFT = 16, +}; + +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_cstate_core_events { + PERF_CSTATE_CORE_C1_RES = 0, + PERF_CSTATE_CORE_C3_RES = 1, + PERF_CSTATE_CORE_C6_RES = 2, + PERF_CSTATE_CORE_C7_RES = 3, + PERF_CSTATE_CORE_EVENT_MAX = 4, +}; + +enum perf_cstate_pkg_events { + PERF_CSTATE_PKG_C2_RES = 0, + PERF_CSTATE_PKG_C3_RES = 1, + PERF_CSTATE_PKG_C6_RES = 2, + PERF_CSTATE_PKG_C7_RES = 3, + PERF_CSTATE_PKG_C8_RES = 4, + PERF_CSTATE_PKG_C9_RES = 5, + PERF_CSTATE_PKG_C10_RES = 6, + PERF_CSTATE_PKG_EVENT_MAX = 7, +}; + +enum perf_event_active_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_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_MAX = 16, +}; + +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_MAX = 524288, +}; + +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_MAX = 16, +}; + +enum perf_event_x86_regs { + PERF_REG_X86_AX = 0, + PERF_REG_X86_BX = 1, + PERF_REG_X86_CX = 2, + PERF_REG_X86_DX = 3, + PERF_REG_X86_SI = 4, + PERF_REG_X86_DI = 5, + PERF_REG_X86_BP = 6, + PERF_REG_X86_SP = 7, + PERF_REG_X86_IP = 8, + PERF_REG_X86_FLAGS = 9, + PERF_REG_X86_CS = 10, + PERF_REG_X86_SS = 11, + PERF_REG_X86_DS = 12, + PERF_REG_X86_ES = 13, + PERF_REG_X86_FS = 14, + PERF_REG_X86_GS = 15, + PERF_REG_X86_R8 = 16, + PERF_REG_X86_R9 = 17, + PERF_REG_X86_R10 = 18, + PERF_REG_X86_R11 = 19, + PERF_REG_X86_R12 = 20, + PERF_REG_X86_R13 = 21, + PERF_REG_X86_R14 = 22, + PERF_REG_X86_R15 = 23, + PERF_REG_X86_32_MAX = 16, + PERF_REG_X86_64_MAX = 24, +}; + +enum perf_group_flag { + PERF_GROUP_SOFTWARE = 1, +}; + +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_msr_id { + PERF_MSR_TSC = 0, + PERF_MSR_APERF = 1, + PERF_MSR_MPERF = 2, + PERF_MSR_PPERF = 3, + PERF_MSR_SMI = 4, + PERF_MSR_PTSC = 5, + PERF_MSR_IRPERF = 6, + PERF_MSR_EVENT_MAX = 7, +}; + +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_MAX = 11, +}; + +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 pg_level { + PG_LEVEL_NONE = 0, + PG_LEVEL_4K = 1, + PG_LEVEL_2M = 2, + PG_LEVEL_1G = 3, + PG_LEVEL_NUM = 4, +}; + +enum phy_state { + PHY_DOWN = 0, + PHY_STARTING = 1, + PHY_READY = 2, + PHY_PENDING = 3, + PHY_UP = 4, + PHY_AN = 5, + PHY_RUNNING = 6, + PHY_NOLINK = 7, + PHY_FORCING = 8, + PHY_CHANGELINK = 9, + PHY_HALTED = 10, + PHY_RESUMING = 11, +}; + +enum pid_type { + PIDTYPE_PID = 0, + PIDTYPE_PGID = 1, + PIDTYPE_SID = 2, + PIDTYPE_MAX = 3, +}; + +enum piix_controller_ids { + piix_pata_mwdma = 0, + piix_pata_33 = 1, + ich_pata_33 = 2, + ich_pata_66 = 3, + ich_pata_100 = 4, + ich_pata_100_nomwdma1 = 5, + ich5_sata = 6, + ich6_sata = 7, + ich6m_sata = 8, + ich8_sata = 9, + ich8_2port_sata = 10, + ich8m_apple_sata = 11, + tolapai_sata = 12, + piix_pata_vmw = 13, + ich8_sata_snb = 14, + ich8_2port_sata_snb = 15, + ich8_2port_sata_byt = 16, +}; + +enum pipe { + INVALID_PIPE = -1, + PIPE_A = 0, + PIPE_B = 1, + PIPE_C = 2, + _PIPE_EDP = 3, + I915_MAX_PIPES = 3, +}; + +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 plane { + PLANE_A = 0, + PLANE_B = 1, + PLANE_C = 2, + PLANE_CURSOR = 3, + I915_MAX_PLANES = 4, +}; + +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, + PM_QOS_SUM = 3, +}; + +enum pmc_type { + KVM_PMC_GP = 0, + KVM_PMC_FIXED = 1, +}; + +enum pme_suspend_level { + PME_SUSPEND_NONE = 0, + PME_SUSPEND_WAKEUP = 1, + PME_SUSPEND_NOIRQ = 2, +}; + +enum pool_type { + POOL_IS_UNDEFINED = 0, + POOL_IS_WC = 2, + POOL_IS_UC = 4, + POOL_IS_CACHED = 8, + POOL_IS_WC_DMA32 = 18, + POOL_IS_UC_DMA32 = 20, + POOL_IS_CACHED_DMA32 = 24, +}; + +enum port { + PORT_A = 0, + PORT_B = 1, + PORT_C = 2, + PORT_D = 3, + PORT_E = 4, + I915_MAX_PORTS = 5, +}; + +enum positive_aop_returns { + AOP_WRITEPAGE_ACTIVATE = 524288, + AOP_TRUNCATED_PAGE = 524289, +}; + +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_HEALTH = 2, + POWER_SUPPLY_PROP_PRESENT = 3, + POWER_SUPPLY_PROP_ONLINE = 4, + POWER_SUPPLY_PROP_AUTHENTIC = 5, + POWER_SUPPLY_PROP_TECHNOLOGY = 6, + POWER_SUPPLY_PROP_CYCLE_COUNT = 7, + POWER_SUPPLY_PROP_VOLTAGE_MAX = 8, + POWER_SUPPLY_PROP_VOLTAGE_MIN = 9, + POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN = 10, + POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN = 11, + POWER_SUPPLY_PROP_VOLTAGE_NOW = 12, + POWER_SUPPLY_PROP_VOLTAGE_AVG = 13, + POWER_SUPPLY_PROP_VOLTAGE_OCV = 14, + POWER_SUPPLY_PROP_VOLTAGE_BOOT = 15, + POWER_SUPPLY_PROP_CURRENT_MAX = 16, + POWER_SUPPLY_PROP_CURRENT_NOW = 17, + POWER_SUPPLY_PROP_CURRENT_AVG = 18, + POWER_SUPPLY_PROP_CURRENT_BOOT = 19, + POWER_SUPPLY_PROP_POWER_NOW = 20, + POWER_SUPPLY_PROP_POWER_AVG = 21, + POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN = 22, + POWER_SUPPLY_PROP_CHARGE_EMPTY_DESIGN = 23, + POWER_SUPPLY_PROP_CHARGE_FULL = 24, + POWER_SUPPLY_PROP_CHARGE_EMPTY = 25, + POWER_SUPPLY_PROP_CHARGE_NOW = 26, + POWER_SUPPLY_PROP_CHARGE_AVG = 27, + POWER_SUPPLY_PROP_CHARGE_COUNTER = 28, + POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT = 29, + POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX = 30, + POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE = 31, + POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX = 32, + POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT = 33, + POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT_MAX = 34, + POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT = 35, + POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN = 36, + POWER_SUPPLY_PROP_ENERGY_EMPTY_DESIGN = 37, + POWER_SUPPLY_PROP_ENERGY_FULL = 38, + POWER_SUPPLY_PROP_ENERGY_EMPTY = 39, + POWER_SUPPLY_PROP_ENERGY_NOW = 40, + POWER_SUPPLY_PROP_ENERGY_AVG = 41, + POWER_SUPPLY_PROP_CAPACITY = 42, + POWER_SUPPLY_PROP_CAPACITY_ALERT_MIN = 43, + POWER_SUPPLY_PROP_CAPACITY_ALERT_MAX = 44, + POWER_SUPPLY_PROP_CAPACITY_LEVEL = 45, + POWER_SUPPLY_PROP_TEMP = 46, + POWER_SUPPLY_PROP_TEMP_MAX = 47, + POWER_SUPPLY_PROP_TEMP_MIN = 48, + POWER_SUPPLY_PROP_TEMP_ALERT_MIN = 49, + POWER_SUPPLY_PROP_TEMP_ALERT_MAX = 50, + POWER_SUPPLY_PROP_TEMP_AMBIENT = 51, + POWER_SUPPLY_PROP_TEMP_AMBIENT_ALERT_MIN = 52, + POWER_SUPPLY_PROP_TEMP_AMBIENT_ALERT_MAX = 53, + POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW = 54, + POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG = 55, + POWER_SUPPLY_PROP_TIME_TO_FULL_NOW = 56, + POWER_SUPPLY_PROP_TIME_TO_FULL_AVG = 57, + POWER_SUPPLY_PROP_TYPE = 58, + POWER_SUPPLY_PROP_SCOPE = 59, + POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT = 60, + POWER_SUPPLY_PROP_CALIBRATE = 61, + POWER_SUPPLY_PROP_MODEL_NAME = 62, + POWER_SUPPLY_PROP_MANUFACTURER = 63, + POWER_SUPPLY_PROP_SERIAL_NUMBER = 64, +}; + +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, +}; + +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 print_line_t { + TRACE_TYPE_PARTIAL_LINE = 0, + TRACE_TYPE_HANDLED = 1, + TRACE_TYPE_UNHANDLED = 2, + TRACE_TYPE_NO_CONSUME = 3, +}; + +enum probe_type { + PROBE_DEFAULT_STRATEGY = 0, + PROBE_PREFER_ASYNCHRONOUS = 1, + PROBE_FORCE_SYNCHRONOUS = 2, +}; + +enum proc_cn_mcast_op { + PROC_CN_MCAST_LISTEN = 1, + PROC_CN_MCAST_IGNORE = 2, +}; + +enum profile_type { + PROFILE_TASK_EXIT = 0, + PROFILE_MUNMAP = 1, +}; + +enum psmouse_scale { + PSMOUSE_SCALE11 = 0, + PSMOUSE_SCALE21 = 1, +}; + +enum psmouse_state { + PSMOUSE_IGNORE = 0, + PSMOUSE_INITIALIZING = 1, + PSMOUSE_RESYNCING = 2, + PSMOUSE_CMD_MODE = 3, + PSMOUSE_ACTIVATED = 4, +}; + +enum psmouse_type { + PSMOUSE_NONE = 0, + PSMOUSE_PS2 = 1, + PSMOUSE_PS2PP = 2, + PSMOUSE_THINKPS = 3, + PSMOUSE_GENPS = 4, + PSMOUSE_IMPS = 5, + PSMOUSE_IMEX = 6, + PSMOUSE_SYNAPTICS = 7, + PSMOUSE_ALPS = 8, + PSMOUSE_LIFEBOOK = 9, + PSMOUSE_TRACKPOINT = 10, + PSMOUSE_TOUCHKIT_PS2 = 11, + PSMOUSE_CORTRON = 12, + PSMOUSE_HGPK = 13, + PSMOUSE_ELANTECH = 14, + PSMOUSE_FSP = 15, + PSMOUSE_SYNAPTICS_RELATIVE = 16, + PSMOUSE_CYPRESS = 17, + PSMOUSE_FOCALTECH = 18, + PSMOUSE_VMMOUSE = 19, + PSMOUSE_BYD = 20, + PSMOUSE_AUTO = 21, +}; + +enum psr_lines_to_wait { + PSR_0_LINES_TO_WAIT = 0, + PSR_1_LINE_TO_WAIT = 1, + PSR_4_LINES_TO_WAIT = 2, + PSR_8_LINES_TO_WAIT = 3, +}; + +enum pt_capabilities { + PT_CAP_max_subleaf = 0, + PT_CAP_cr3_filtering = 1, + PT_CAP_psb_cyc = 2, + PT_CAP_ip_filtering = 3, + PT_CAP_mtc = 4, + PT_CAP_topa_output = 5, + PT_CAP_topa_multiple_entries = 6, + PT_CAP_single_range_output = 7, + PT_CAP_payloads_lip = 8, + PT_CAP_num_address_ranges = 9, + PT_CAP_mtc_periods = 10, + PT_CAP_cycle_thresholds = 11, + PT_CAP_psb_periods = 12, +}; + +enum ptp_clock_events { + PTP_CLOCK_ALARM = 0, + PTP_CLOCK_EXTTS = 1, + PTP_CLOCK_PPS = 2, + PTP_CLOCK_PPSUSR = 3, +}; + +enum ptp_pin_function { + PTP_PF_NONE = 0, + PTP_PF_EXTTS = 1, + PTP_PF_PEROUT = 2, + PTP_PF_PHYSYNC = 3, +}; + +enum punit_power_well { + PUNIT_POWER_WELL_RENDER = 0, + PUNIT_POWER_WELL_MEDIA = 1, + PUNIT_POWER_WELL_DISP2D = 3, + PUNIT_POWER_WELL_DPIO_CMN_BC = 5, + PUNIT_POWER_WELL_DPIO_TX_B_LANES_01 = 6, + PUNIT_POWER_WELL_DPIO_TX_B_LANES_23 = 7, + PUNIT_POWER_WELL_DPIO_TX_C_LANES_01 = 8, + PUNIT_POWER_WELL_DPIO_TX_C_LANES_23 = 9, + PUNIT_POWER_WELL_DPIO_RX0 = 10, + PUNIT_POWER_WELL_DPIO_RX1 = 11, + PUNIT_POWER_WELL_DPIO_CMN_D = 12, + PUNIT_POWER_WELL_ALWAYS_ON = 13, +}; + +enum pwm_polarity { + PWM_POLARITY_NORMAL = 0, + PWM_POLARITY_INVERSED = 1, +}; + +enum qdisc___state_t { + __QDISC___STATE_RUNNING = 1, +}; + +enum qdisc_state_t { + __QDISC_STATE_SCHED = 0, + __QDISC_STATE_DEACTIVATED = 1, + __QDISC_STATE_THROTTLED = 2, +}; + +enum quota_type { + USRQUOTA = 0, + GRPQUOTA = 1, + PRJQUOTA = 2, +}; + +enum rcu_sync_type { + RCU_SYNC = 0, + RCU_SCHED_SYNC = 1, + RCU_BH_SYNC = 2, +}; + +enum rcutorture_type { + RCU_FLAVOR = 0, + RCU_BH_FLAVOR = 1, + RCU_SCHED_FLAVOR = 2, + RCU_TASKS_FLAVOR = 3, + SRCU_FLAVOR = 4, + INVALID_RCU_FLAVOR = 5, +}; + +enum reboot_mode { + 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 reg_arg_type { + SRC_OP = 0, + DST_OP = 1, + DST_OP_NO_MARK = 2, +}; + +enum regcache_type { + REGCACHE_NONE = 0, + REGCACHE_RBTREE = 1, + REGCACHE_COMPRESSED = 2, + REGCACHE_FLAT = 3, +}; + +enum regex_type { + MATCH_FULL = 0, + MATCH_FRONT_ONLY = 1, + MATCH_MIDDLE_ONLY = 2, + MATCH_END_ONLY = 3, +}; + +enum regmap_endian { + REGMAP_ENDIAN_DEFAULT = 0, + REGMAP_ENDIAN_BIG = 1, + REGMAP_ENDIAN_LITTLE = 2, + REGMAP_ENDIAN_NATIVE = 3, +}; + +enum release_type { + leaf_only = 0, + whole_subtree = 1, +}; + +enum rfkill_type { + RFKILL_TYPE_ALL = 0, + RFKILL_TYPE_WLAN = 1, + RFKILL_TYPE_BLUETOOTH = 2, + RFKILL_TYPE_UWB = 3, + RFKILL_TYPE_WIMAX = 4, + RFKILL_TYPE_WWAN = 5, + RFKILL_TYPE_GPS = 6, + RFKILL_TYPE_FM = 7, + RFKILL_TYPE_NFC = 8, + NUM_RFKILL_TYPES = 9, +}; + +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 rmid_recycle_state { + RMID_YOUNG = 0, + RMID_AVAILABLE = 1, + RMID_DIRTY = 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 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_ACTIVE = 0, + RPM_RESUMING = 1, + RPM_SUSPENDED = 2, + RPM_SUSPENDING = 3, +}; + +enum rq_atomic_flags { + REQ_ATOM_COMPLETE = 0, + REQ_ATOM_STARTED = 1, +}; + +enum rq_cmd_type_bits { + REQ_TYPE_FS = 1, + REQ_TYPE_BLOCK_PC = 2, + REQ_TYPE_DRV_PRIV = 3, +}; + +enum rq_flag_bits { + __REQ_WRITE = 0, + __REQ_FAILFAST_DEV = 1, + __REQ_FAILFAST_TRANSPORT = 2, + __REQ_FAILFAST_DRIVER = 3, + __REQ_SYNC = 4, + __REQ_META = 5, + __REQ_PRIO = 6, + __REQ_DISCARD = 7, + __REQ_SECURE = 8, + __REQ_WRITE_SAME = 9, + __REQ_NOIDLE = 10, + __REQ_INTEGRITY = 11, + __REQ_FUA = 12, + __REQ_FLUSH = 13, + __REQ_RAHEAD = 14, + __REQ_THROTTLED = 15, + __REQ_SORTED = 16, + __REQ_SOFTBARRIER = 17, + __REQ_NOMERGE = 18, + __REQ_STARTED = 19, + __REQ_DONTPREP = 20, + __REQ_QUEUED = 21, + __REQ_ELVPRIV = 22, + __REQ_FAILED = 23, + __REQ_QUIET = 24, + __REQ_PREEMPT = 25, + __REQ_ALLOCED = 26, + __REQ_COPY_USER = 27, + __REQ_FLUSH_SEQ = 28, + __REQ_IO_STAT = 29, + __REQ_MIXED_MERGE = 30, + __REQ_PM = 31, + __REQ_HASHED = 32, + __REQ_MQ_INFLIGHT = 33, + __REQ_NR_BITS = 34, +}; + +enum rq_nohz_flag_bits { + NOHZ_TICK_STOPPED = 0, + NOHZ_BALANCE_KICK = 1, +}; + +enum rrrr_ids { + R4_GEN = 0, + R4_RD = 1, + R4_WR = 2, + R4_DRD = 3, + R4_DWR = 4, + R4_IRD = 5, + R4_PREF = 6, + R4_EVICT = 7, + R4_SNOOP = 8, +}; + +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_MAX = 25, +}; + +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_MAX = 29, +}; + +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 scan_balance { + SCAN_EQUAL = 0, + SCAN_FRACT = 1, + SCAN_ANON = 2, + SCAN_FILE = 3, +}; + +enum sched_tunable_scaling { + SCHED_TUNABLESCALING_NONE = 0, + SCHED_TUNABLESCALING_LOG = 1, + SCHED_TUNABLESCALING_LINEAR = 2, + SCHED_TUNABLESCALING_END = 3, +}; + +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_FIRST = 1, + SDEV_EVT_LAST = 7, + SDEV_EVT_MAXBITS = 8, +}; + +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_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_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_DEL = 4, +}; + +enum scsi_timeouts { + SCSI_DEFAULT_EH_TIMEOUT = 10000, +}; + +enum sctp_msg_flags { + MSG_NOTIFICATION = 32768, +}; + +enum sd_dif_target_protection_types { + SD_DIF_TYPE0_PROTECTION = 0, + SD_DIF_TYPE1_PROTECTION = 1, + SD_DIF_TYPE2_PROTECTION = 2, + SD_DIF_TYPE3_PROTECTION = 3, +}; + +enum segment_cache_field { + SEG_FIELD_SEL = 0, + SEG_FIELD_BASE = 1, + SEG_FIELD_LIMIT = 2, + SEG_FIELD_AR = 3, + SEG_FIELD_NR = 4, +}; + +enum seqno_fence_condition { + SEQNO_FENCE_WAIT_GEQUAL = 0, + SEQNO_FENCE_WAIT_NONZERO = 1, +}; + +enum ser { + SER_REQUIRED = 1, + NO_SER = 2, +}; + +enum serio_event_type { + SERIO_RESCAN_PORT = 0, + SERIO_RECONNECT_PORT = 1, + SERIO_RECONNECT_SUBTREE = 2, + SERIO_REGISTER_PORT = 3, + SERIO_ATTACH_DRIVER = 4, +}; + +enum severity_level { + MCE_NO_SEVERITY = 0, + MCE_DEFERRED_SEVERITY = 1, + MCE_UCNA_SEVERITY = 1, + MCE_KEEP_SEVERITY = 2, + MCE_SOME_SEVERITY = 3, + MCE_AO_SEVERITY = 4, + MCE_UC_SEVERITY = 5, + MCE_AR_SEVERITY = 6, + MCE_PANIC_SEVERITY = 7, +}; + +enum sgp_type { + SGP_READ = 0, + SGP_CACHE = 1, + SGP_WRITE = 2, + SGP_FALLOC = 3, +}; + +enum skb_free_reason { + SKB_REASON_CONSUMED = 0, + SKB_REASON_DROPPED = 1, +}; + +enum skl_disp_power_wells { + SKL_DISP_PW_MISC_IO = 0, + SKL_DISP_PW_DDI_A_E = 1, + SKL_DISP_PW_DDI_B = 2, + SKL_DISP_PW_DDI_C = 3, + SKL_DISP_PW_DDI_D = 4, + SKL_DISP_PW_1 = 14, + SKL_DISP_PW_2 = 15, + SKL_DISP_PW_ALWAYS_ON = 16, + SKL_DISP_PW_DC_OFF = 17, +}; + +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_modes { + M_NONE = 0, + M_PARTIAL = 1, + M_FULL = 2, + M_FREE = 3, +}; + +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, + PARTIAL_NODE = 2, + UP = 3, + FULL = 4, +}; + +enum slow_d_compare { + D_COMP_OK = 0, + D_COMP_NOMATCH = 1, + D_COMP_SEQRETRY = 2, +}; + +enum smbios_attr_enum { + SMBIOS_ATTR_NONE = 0, + SMBIOS_ATTR_LABEL_SHOW = 1, + SMBIOS_ATTR_INSTANCE_SHOW = 2, +}; + +enum snd_device_state { + SNDRV_DEV_BUILD = 0, + SNDRV_DEV_REGISTERED = 1, + SNDRV_DEV_DISCONNECTED = 2, +}; + +enum snd_device_type { + SNDRV_DEV_LOWLEVEL = 0, + SNDRV_DEV_CONTROL = 1, + SNDRV_DEV_INFO = 2, + SNDRV_DEV_BUS = 3, + SNDRV_DEV_CODEC = 4, + SNDRV_DEV_PCM = 5, + SNDRV_DEV_COMPRESS = 6, + SNDRV_DEV_RAWMIDI = 7, + SNDRV_DEV_TIMER = 8, + SNDRV_DEV_SEQUENCER = 9, + SNDRV_DEV_HWDEP = 10, + SNDRV_DEV_JACK = 11, +}; + +enum snd_jack_types { + SND_JACK_HEADPHONE = 1, + SND_JACK_MICROPHONE = 2, + SND_JACK_HEADSET = 3, + SND_JACK_LINEOUT = 4, + SND_JACK_MECHANICAL = 8, + SND_JACK_VIDEOOUT = 16, + SND_JACK_AVOUT = 20, + SND_JACK_LINEIN = 32, + SND_JACK_BTN_0 = 16384, + SND_JACK_BTN_1 = 8192, + SND_JACK_BTN_2 = 4096, + SND_JACK_BTN_3 = 2048, + SND_JACK_BTN_4 = 1024, + SND_JACK_BTN_5 = 512, +}; + +enum snd_pcm_plugin_action { + INIT = 0, + PREPARE = 1, +}; + +enum sndrv_ctl_event_type { + SNDRV_CTL_EVENT_ELEM = 0, + SNDRV_CTL_EVENT_LAST = 0, +}; + +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_QUEUE_SHRUNK = 14, + SOCK_MEMALLOC = 15, + SOCK_TIMESTAMPING_RX_SOFTWARE = 16, + SOCK_FASYNC = 17, + SOCK_RXQ_OVFL = 18, + SOCK_ZEROCOPY = 19, + SOCK_WIFI_STATUS = 20, + SOCK_NOFCS = 21, + SOCK_FILTER_LOCKED = 22, + SOCK_SELECT_ERR_QUEUE = 23, + SOCK_RCU_FREE = 24, +}; + +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 spi_compare_returns { + SPI_COMPARE_SUCCESS = 0, + SPI_COMPARE_FAILURE = 1, + SPI_COMPARE_SKIP_TEST = 2, +}; + +enum spi_signal_type { + SPI_SIGNAL_UNKNOWN = 1, + SPI_SIGNAL_SE = 2, + SPI_SIGNAL_LVD = 3, + SPI_SIGNAL_HVD = 4, +}; + +enum stack_type { + STACK_IS_UNKNOWN = 0, + STACK_IS_NORMAL = 1, + STACK_IS_EXCEPTION = 2, + STACK_IS_IRQ = 3, +}; + +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 string_size_units { + STRING_UNITS_10 = 0, + STRING_UNITS_2 = 1, +}; + +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 suspend_mode { + PRESUSPEND = 0, + PRESUSPEND_UNDO = 1, + POSTSUSPEND = 2, +}; + +enum suspend_stat_step { + SUSPEND_FREEZE = 1, + SUSPEND_PREPARE = 2, + SUSPEND_SUSPEND = 3, + SUSPEND_SUSPEND_LATE = 4, + SUSPEND_SUSPEND_NOIRQ = 5, + SUSPEND_RESUME_NOIRQ = 6, + SUSPEND_RESUME_EARLY = 7, + SUSPEND_RESUME = 8, +}; + +enum sw_activity { + OFF = 0, + BLINK_ON = 1, + BLINK_OFF = 2, +}; + +enum switchdev_attr_id { + SWITCHDEV_ATTR_ID_UNDEFINED = 0, + SWITCHDEV_ATTR_ID_PORT_PARENT_ID = 1, + SWITCHDEV_ATTR_ID_PORT_STP_STATE = 2, + SWITCHDEV_ATTR_ID_PORT_BRIDGE_FLAGS = 3, + SWITCHDEV_ATTR_ID_BRIDGE_AGEING_TIME = 4, + SWITCHDEV_ATTR_ID_BRIDGE_VLAN_FILTERING = 5, +}; + +enum sync { + DEFAULTSYNC = 0, + NOSYNC = 1, + FORCESYNC = 2, +}; + +enum system_states { + SYSTEM_BOOTING = 0, + SYSTEM_RUNNING = 1, + SYSTEM_HALT = 2, + SYSTEM_POWER_OFF = 3, + SYSTEM_RESTART = 4, +}; + +enum tc_clsu32_command { + TC_CLSU32_NEW_KNODE = 0, + TC_CLSU32_REPLACE_KNODE = 1, + TC_CLSU32_DELETE_KNODE = 2, + TC_CLSU32_NEW_HNODE = 3, + TC_CLSU32_REPLACE_HNODE = 4, + TC_CLSU32_DELETE_HNODE = 5, +}; + +enum tc_fl_command { + TC_CLSFLOWER_REPLACE = 0, + TC_CLSFLOWER_DESTROY = 1, + TC_CLSFLOWER_STATS = 2, +}; + +enum tc_link_layer { + TC_LINKLAYER_UNAWARE = 0, + TC_LINKLAYER_ETHERNET = 1, + TC_LINKLAYER_ATM = 2, +}; + +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, + CA_EVENT_DELAYED_ACK = 6, + CA_EVENT_NON_DELAYED_ACK = 7, +}; + +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_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_seq_states { + TCP_SEQ_STATE_LISTENING = 0, + TCP_SEQ_STATE_ESTABLISHED = 1, +}; + +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 thermal_device_mode { + THERMAL_DEVICE_DISABLED = 0, + THERMAL_DEVICE_ENABLED = 1, +}; + +enum thermal_trend { + THERMAL_TREND_STABLE = 0, + THERMAL_TREND_RAISING = 1, + THERMAL_TREND_DROPPING = 2, + THERMAL_TREND_RAISE_FULL = 3, + THERMAL_TREND_DROP_FULL = 4, +}; + +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, +}; + +enum tick_device_mode { + TICKDEV_MODE_PERIODIC = 0, + TICKDEV_MODE_ONESHOT = 1, +}; + +enum tick_nohz_mode { + NOHZ_MODE_INACTIVE = 0, + NOHZ_MODE_LOWRES = 1, + NOHZ_MODE_HIGHRES = 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, + NR_TLB_FLUSH_REASONS = 5, +}; + +enum tlb_infos { + ENTRIES = 0, + NR_INFO = 1, +}; + +enum tpacket_versions { + TPACKET_V1 = 0, + TPACKET_V2 = 1, + TPACKET_V3 = 2, +}; + +enum trace_flag_type { + TRACE_FLAG_IRQS_OFF = 1, + TRACE_FLAG_IRQS_NOSUPPORT = 2, + TRACE_FLAG_NEED_RESCHED = 4, + TRACE_FLAG_HARDIRQ = 8, + TRACE_FLAG_SOFTIRQ = 16, + TRACE_FLAG_PREEMPT_RESCHED = 32, + TRACE_FLAG_NMI = 64, +}; + +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_PRINTK_BIT = 8, + TRACE_ITER_ANNOTATE_BIT = 9, + TRACE_ITER_USERSTACKTRACE_BIT = 10, + TRACE_ITER_SYM_USEROBJ_BIT = 11, + TRACE_ITER_PRINTK_MSGONLY_BIT = 12, + TRACE_ITER_CONTEXT_INFO_BIT = 13, + TRACE_ITER_LATENCY_FMT_BIT = 14, + TRACE_ITER_RECORD_CMD_BIT = 15, + TRACE_ITER_OVERWRITE_BIT = 16, + TRACE_ITER_STOP_ON_FREE_BIT = 17, + TRACE_ITER_IRQ_INFO_BIT = 18, + TRACE_ITER_MARKERS_BIT = 19, + TRACE_ITER_EVENT_FORK_BIT = 20, + TRACE_ITER_FUNCTION_BIT = 21, + TRACE_ITER_DISPLAY_GRAPH_BIT = 22, + TRACE_ITER_STACKTRACE_BIT = 23, + TRACE_ITER_LAST_BIT = 24, +}; + +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_PRINTK = 256, + TRACE_ITER_ANNOTATE = 512, + TRACE_ITER_USERSTACKTRACE = 1024, + TRACE_ITER_SYM_USEROBJ = 2048, + TRACE_ITER_PRINTK_MSGONLY = 4096, + TRACE_ITER_CONTEXT_INFO = 8192, + TRACE_ITER_LATENCY_FMT = 16384, + TRACE_ITER_RECORD_CMD = 32768, + TRACE_ITER_OVERWRITE = 65536, + TRACE_ITER_STOP_ON_FREE = 131072, + TRACE_ITER_IRQ_INFO = 262144, + TRACE_ITER_MARKERS = 524288, + TRACE_ITER_EVENT_FORK = 1048576, + TRACE_ITER_FUNCTION = 2097152, + TRACE_ITER_DISPLAY_GRAPH = 4194304, + TRACE_ITER_STACKTRACE = 8388608, +}; + +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_USER_STACK = 12, + TRACE_BLK = 13, + TRACE_BPUTS = 14, + __TRACE_LAST_TYPE = 15, +}; + +enum track_item { + TRACK_ALLOC = 0, + TRACK_FREE = 1, +}; + +enum transcoder { + TRANSCODER_A = 0, + TRANSCODER_B = 1, + TRANSCODER_C = 2, + TRANSCODER_EDP = 3, + TRANSCODER_DSI_A = 4, + TRANSCODER_DSI_C = 5, + I915_MAX_TRANSCODERS = 6, +}; + +enum tsq_flags { + 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, +}; + +enum tt_ids { + TT_INSTR = 0, + TT_DATA = 1, + TT_GEN = 2, + TT_RESV = 3, +}; + +enum ttm_bo_type { + ttm_bo_type_device = 0, + ttm_bo_type_kernel = 1, + ttm_bo_type_sg = 2, +}; + +enum ttm_caching_state { + tt_uncached = 0, + tt_wc = 1, + tt_cached = 2, +}; + +enum ttm_object_type { + ttm_fence_type = 0, + ttm_buffer_type = 1, + ttm_lock_type = 2, + ttm_prime_type = 3, + ttm_driver_type0 = 256, + ttm_driver_type1 = 257, + ttm_driver_type2 = 258, + ttm_driver_type3 = 259, + ttm_driver_type4 = 260, + ttm_driver_type5 = 261, +}; + +enum ttm_ref_type { + TTM_REF_USAGE = 0, + TTM_REF_SYNCCPU_READ = 1, + TTM_REF_SYNCCPU_WRITE = 2, + TTM_REF_NUM = 3, +}; + +enum ttu_flags { + TTU_UNMAP = 1, + TTU_MIGRATION = 2, + TTU_MUNLOCK = 4, + TTU_LZFREE = 8, + TTU_SPLIT_HUGE_PMD = 16, + TTU_IGNORE_MLOCK = 256, + TTU_IGNORE_ACCESS = 512, + TTU_IGNORE_HWPOISON = 1024, + TTU_BATCH_FLUSH = 2048, + TTU_RMAP_LOCKED = 4096, +}; + +enum tunable_id { + ETHTOOL_ID_UNSPEC = 0, + ETHTOOL_RX_COPYBREAK = 1, + ETHTOOL_TX_COPYBREAK = 2, + __ETHTOOL_TUNABLE_COUNT = 3, +}; + +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 tv_margin { + TV_MARGIN_LEFT = 0, + TV_MARGIN_TOP = 1, + TV_MARGIN_RIGHT = 2, + TV_MARGIN_BOTTOM = 3, +}; + +enum uart_pm_state { + UART_PM_STATE_ON = 0, + UART_PM_STATE_OFF = 3, + UART_PM_STATE_UNDEFINED = 4, +}; + +enum ucode_state { + UCODE_ERROR = 0, + UCODE_OK = 1, + UCODE_NFOUND = 2, +}; + +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 utf16_endian { + UTF16_HOST_ENDIAN = 0, + UTF16_LITTLE_ENDIAN = 1, + UTF16_BIG_ENDIAN = 2, +}; + +enum uts_proc { + UTS_PROC_OSTYPE = 0, + UTS_PROC_OSRELEASE = 1, + UTS_PROC_VERSION = 2, + UTS_PROC_HOSTNAME = 3, + UTS_PROC_DOMAINNAME = 4, +}; + +enum uv_system_type { + UV_NONE = 0, + UV_LEGACY_APIC = 1, + UV_X2APIC = 2, + UV_NON_UNIQUE_APIC = 3, +}; + +enum v4l2_preemphasis { + V4L2_PREEMPHASIS_DISABLED = 0, + V4L2_PREEMPHASIS_50_uS = 1, + V4L2_PREEMPHASIS_75_uS = 2, +}; + +enum vga_switcheroo_handler_flags_t { + VGA_SWITCHEROO_CAN_SWITCH_DDC = 1, + VGA_SWITCHEROO_NEEDS_EDP_CONFIG = 2, +}; + +enum vga_switcheroo_state { + VGA_SWITCHEROO_OFF = 0, + VGA_SWITCHEROO_ON = 1, + VGA_SWITCHEROO_NOT_FOUND = 2, +}; + +enum vgt_g2v_type { + VGT_G2V_PPGTT_L3_PAGE_TABLE_CREATE = 2, + VGT_G2V_PPGTT_L3_PAGE_TABLE_DESTROY = 3, + VGT_G2V_PPGTT_L4_PAGE_TABLE_CREATE = 4, + VGT_G2V_PPGTT_L4_PAGE_TABLE_DESTROY = 5, + VGT_G2V_EXECLIST_CONTEXT_CREATE = 6, + VGT_G2V_EXECLIST_CONTEXT_DESTROY = 7, + VGT_G2V_MAX = 8, +}; + +enum virtio_gpu_ctrl_type { + VIRTIO_GPU_UNDEFINED = 0, + VIRTIO_GPU_CMD_GET_DISPLAY_INFO = 256, + VIRTIO_GPU_CMD_RESOURCE_CREATE_2D = 257, + VIRTIO_GPU_CMD_RESOURCE_UNREF = 258, + VIRTIO_GPU_CMD_SET_SCANOUT = 259, + VIRTIO_GPU_CMD_RESOURCE_FLUSH = 260, + VIRTIO_GPU_CMD_TRANSFER_TO_HOST_2D = 261, + VIRTIO_GPU_CMD_RESOURCE_ATTACH_BACKING = 262, + VIRTIO_GPU_CMD_RESOURCE_DETACH_BACKING = 263, + VIRTIO_GPU_CMD_GET_CAPSET_INFO = 264, + VIRTIO_GPU_CMD_GET_CAPSET = 265, + VIRTIO_GPU_CMD_CTX_CREATE = 512, + VIRTIO_GPU_CMD_CTX_DESTROY = 513, + VIRTIO_GPU_CMD_CTX_ATTACH_RESOURCE = 514, + VIRTIO_GPU_CMD_CTX_DETACH_RESOURCE = 515, + VIRTIO_GPU_CMD_RESOURCE_CREATE_3D = 516, + VIRTIO_GPU_CMD_TRANSFER_TO_HOST_3D = 517, + VIRTIO_GPU_CMD_TRANSFER_FROM_HOST_3D = 518, + VIRTIO_GPU_CMD_SUBMIT_3D = 519, + VIRTIO_GPU_CMD_UPDATE_CURSOR = 768, + VIRTIO_GPU_CMD_MOVE_CURSOR = 769, + VIRTIO_GPU_RESP_OK_NODATA = 4352, + VIRTIO_GPU_RESP_OK_DISPLAY_INFO = 4353, + VIRTIO_GPU_RESP_OK_CAPSET_INFO = 4354, + VIRTIO_GPU_RESP_OK_CAPSET = 4355, + VIRTIO_GPU_RESP_ERR_UNSPEC = 4608, + VIRTIO_GPU_RESP_ERR_OUT_OF_MEMORY = 4609, + VIRTIO_GPU_RESP_ERR_INVALID_SCANOUT_ID = 4610, + VIRTIO_GPU_RESP_ERR_INVALID_RESOURCE_ID = 4611, + VIRTIO_GPU_RESP_ERR_INVALID_CONTEXT_ID = 4612, + VIRTIO_GPU_RESP_ERR_INVALID_PARAMETER = 4613, +}; + +enum virtio_gpu_formats { + VIRTIO_GPU_FORMAT_B8G8R8A8_UNORM = 1, + VIRTIO_GPU_FORMAT_B8G8R8X8_UNORM = 2, + VIRTIO_GPU_FORMAT_A8R8G8B8_UNORM = 3, + VIRTIO_GPU_FORMAT_X8R8G8B8_UNORM = 4, + VIRTIO_GPU_FORMAT_R8G8B8A8_UNORM = 67, + VIRTIO_GPU_FORMAT_X8B8G8R8_UNORM = 68, + VIRTIO_GPU_FORMAT_A8B8G8R8_UNORM = 121, + VIRTIO_GPU_FORMAT_R8G8B8X8_UNORM = 134, +}; + +enum vlv_wm_level { + VLV_WM_LEVEL_PM2 = 0, + VLV_WM_LEVEL_PM5 = 1, + VLV_WM_LEVEL_DDR_DVFS = 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, + PGFREE = 8, + PGACTIVATE = 9, + PGDEACTIVATE = 10, + PGFAULT = 11, + PGMAJFAULT = 12, + PGLAZYFREED = 13, + PGREFILL_DMA = 14, + PGREFILL_DMA32 = 15, + PGREFILL_NORMAL = 16, + PGREFILL_MOVABLE = 17, + PGSTEAL_KSWAPD_DMA = 18, + PGSTEAL_KSWAPD_DMA32 = 19, + PGSTEAL_KSWAPD_NORMAL = 20, + PGSTEAL_KSWAPD_MOVABLE = 21, + PGSTEAL_DIRECT_DMA = 22, + PGSTEAL_DIRECT_DMA32 = 23, + PGSTEAL_DIRECT_NORMAL = 24, + PGSTEAL_DIRECT_MOVABLE = 25, + PGSCAN_KSWAPD_DMA = 26, + PGSCAN_KSWAPD_DMA32 = 27, + PGSCAN_KSWAPD_NORMAL = 28, + PGSCAN_KSWAPD_MOVABLE = 29, + PGSCAN_DIRECT_DMA = 30, + PGSCAN_DIRECT_DMA32 = 31, + PGSCAN_DIRECT_NORMAL = 32, + PGSCAN_DIRECT_MOVABLE = 33, + PGSCAN_DIRECT_THROTTLE = 34, + PGSCAN_ZONE_RECLAIM_FAILED = 35, + PGINODESTEAL = 36, + SLABS_SCANNED = 37, + KSWAPD_INODESTEAL = 38, + KSWAPD_LOW_WMARK_HIT_QUICKLY = 39, + KSWAPD_HIGH_WMARK_HIT_QUICKLY = 40, + PAGEOUTRUN = 41, + ALLOCSTALL = 42, + PGROTATED = 43, + DROP_PAGECACHE = 44, + DROP_SLAB = 45, + PGMIGRATE_SUCCESS = 46, + PGMIGRATE_FAIL = 47, + COMPACTMIGRATE_SCANNED = 48, + COMPACTFREE_SCANNED = 49, + COMPACTISOLATED = 50, + COMPACTSTALL = 51, + COMPACTFAIL = 52, + COMPACTSUCCESS = 53, + KCOMPACTD_WAKE = 54, + HTLB_BUDDY_PGALLOC = 55, + HTLB_BUDDY_PGALLOC_FAIL = 56, + UNEVICTABLE_PGCULLED = 57, + UNEVICTABLE_PGSCANNED = 58, + UNEVICTABLE_PGRESCUED = 59, + UNEVICTABLE_PGMLOCKED = 60, + UNEVICTABLE_PGMUNLOCKED = 61, + UNEVICTABLE_PGCLEARED = 62, + UNEVICTABLE_PGSTRANDED = 63, + BALLOON_INFLATE = 64, + BALLOON_DEFLATE = 65, + BALLOON_MIGRATE = 66, + NR_VM_EVENT_ITEMS = 67, +}; + +enum vm_instruction_error_number { + VMXERR_VMCALL_IN_VMX_ROOT_OPERATION = 1, + VMXERR_VMCLEAR_INVALID_ADDRESS = 2, + VMXERR_VMCLEAR_VMXON_POINTER = 3, + VMXERR_VMLAUNCH_NONCLEAR_VMCS = 4, + VMXERR_VMRESUME_NONLAUNCHED_VMCS = 5, + VMXERR_VMRESUME_AFTER_VMXOFF = 6, + VMXERR_ENTRY_INVALID_CONTROL_FIELD = 7, + VMXERR_ENTRY_INVALID_HOST_STATE_FIELD = 8, + VMXERR_VMPTRLD_INVALID_ADDRESS = 9, + VMXERR_VMPTRLD_VMXON_POINTER = 10, + VMXERR_VMPTRLD_INCORRECT_VMCS_REVISION_ID = 11, + VMXERR_UNSUPPORTED_VMCS_COMPONENT = 12, + VMXERR_VMWRITE_READ_ONLY_VMCS_COMPONENT = 13, + VMXERR_VMXON_IN_VMX_ROOT_OPERATION = 15, + VMXERR_ENTRY_INVALID_EXECUTIVE_VMCS_POINTER = 16, + VMXERR_ENTRY_NONLAUNCHED_EXECUTIVE_VMCS = 17, + VMXERR_ENTRY_EXECUTIVE_VMCS_POINTER_NOT_VMXON_POINTER = 18, + VMXERR_VMCALL_NONCLEAR_VMCS = 19, + VMXERR_VMCALL_INVALID_VM_EXIT_CONTROL_FIELDS = 20, + VMXERR_VMCALL_INCORRECT_MSEG_REVISION_ID = 22, + VMXERR_VMXOFF_UNDER_DUAL_MONITOR_TREATMENT_OF_SMIS_AND_SMM = 23, + VMXERR_VMCALL_INVALID_SMM_MONITOR_FEATURES = 24, + VMXERR_ENTRY_INVALID_VM_EXECUTION_CONTROL_FIELDS_IN_EXECUTIVE_VMCS = 25, + VMXERR_ENTRY_EVENTS_BLOCKED_BY_MOV_SS = 26, + VMXERR_INVALID_OPERAND_TO_INVEPT_INVVPID = 28, +}; + +enum vma_resv_mode { + VMA_NEEDS_RESV = 0, + VMA_COMMIT_RESV = 1, + VMA_END_RESV = 2, +}; + +enum vmcs_field { + VIRTUAL_PROCESSOR_ID = 0, + POSTED_INTR_NV = 2, + GUEST_ES_SELECTOR = 2048, + GUEST_CS_SELECTOR = 2050, + GUEST_SS_SELECTOR = 2052, + GUEST_DS_SELECTOR = 2054, + GUEST_FS_SELECTOR = 2056, + GUEST_GS_SELECTOR = 2058, + GUEST_LDTR_SELECTOR = 2060, + GUEST_TR_SELECTOR = 2062, + GUEST_INTR_STATUS = 2064, + GUEST_PML_INDEX = 2066, + HOST_ES_SELECTOR = 3072, + HOST_CS_SELECTOR = 3074, + HOST_SS_SELECTOR = 3076, + HOST_DS_SELECTOR = 3078, + HOST_FS_SELECTOR = 3080, + HOST_GS_SELECTOR = 3082, + HOST_TR_SELECTOR = 3084, + IO_BITMAP_A = 8192, + IO_BITMAP_A_HIGH = 8193, + IO_BITMAP_B = 8194, + IO_BITMAP_B_HIGH = 8195, + MSR_BITMAP = 8196, + MSR_BITMAP_HIGH = 8197, + VM_EXIT_MSR_STORE_ADDR = 8198, + VM_EXIT_MSR_STORE_ADDR_HIGH = 8199, + VM_EXIT_MSR_LOAD_ADDR = 8200, + VM_EXIT_MSR_LOAD_ADDR_HIGH = 8201, + VM_ENTRY_MSR_LOAD_ADDR = 8202, + VM_ENTRY_MSR_LOAD_ADDR_HIGH = 8203, + PML_ADDRESS = 8206, + PML_ADDRESS_HIGH = 8207, + TSC_OFFSET = 8208, + TSC_OFFSET_HIGH = 8209, + VIRTUAL_APIC_PAGE_ADDR = 8210, + VIRTUAL_APIC_PAGE_ADDR_HIGH = 8211, + APIC_ACCESS_ADDR = 8212, + APIC_ACCESS_ADDR_HIGH = 8213, + POSTED_INTR_DESC_ADDR = 8214, + POSTED_INTR_DESC_ADDR_HIGH = 8215, + EPT_POINTER = 8218, + EPT_POINTER_HIGH = 8219, + EOI_EXIT_BITMAP0 = 8220, + EOI_EXIT_BITMAP0_HIGH = 8221, + EOI_EXIT_BITMAP1 = 8222, + EOI_EXIT_BITMAP1_HIGH = 8223, + EOI_EXIT_BITMAP2 = 8224, + EOI_EXIT_BITMAP2_HIGH = 8225, + EOI_EXIT_BITMAP3 = 8226, + EOI_EXIT_BITMAP3_HIGH = 8227, + VMREAD_BITMAP = 8230, + VMWRITE_BITMAP = 8232, + XSS_EXIT_BITMAP = 8236, + XSS_EXIT_BITMAP_HIGH = 8237, + TSC_MULTIPLIER = 8242, + TSC_MULTIPLIER_HIGH = 8243, + GUEST_PHYSICAL_ADDRESS = 9216, + GUEST_PHYSICAL_ADDRESS_HIGH = 9217, + VMCS_LINK_POINTER = 10240, + VMCS_LINK_POINTER_HIGH = 10241, + GUEST_IA32_DEBUGCTL = 10242, + GUEST_IA32_DEBUGCTL_HIGH = 10243, + GUEST_IA32_PAT = 10244, + GUEST_IA32_PAT_HIGH = 10245, + GUEST_IA32_EFER = 10246, + GUEST_IA32_EFER_HIGH = 10247, + GUEST_IA32_PERF_GLOBAL_CTRL = 10248, + GUEST_IA32_PERF_GLOBAL_CTRL_HIGH = 10249, + GUEST_PDPTR0 = 10250, + GUEST_PDPTR0_HIGH = 10251, + GUEST_PDPTR1 = 10252, + GUEST_PDPTR1_HIGH = 10253, + GUEST_PDPTR2 = 10254, + GUEST_PDPTR2_HIGH = 10255, + GUEST_PDPTR3 = 10256, + GUEST_PDPTR3_HIGH = 10257, + GUEST_BNDCFGS = 10258, + GUEST_BNDCFGS_HIGH = 10259, + HOST_IA32_PAT = 11264, + HOST_IA32_PAT_HIGH = 11265, + HOST_IA32_EFER = 11266, + HOST_IA32_EFER_HIGH = 11267, + HOST_IA32_PERF_GLOBAL_CTRL = 11268, + HOST_IA32_PERF_GLOBAL_CTRL_HIGH = 11269, + PIN_BASED_VM_EXEC_CONTROL = 16384, + CPU_BASED_VM_EXEC_CONTROL = 16386, + EXCEPTION_BITMAP = 16388, + PAGE_FAULT_ERROR_CODE_MASK = 16390, + PAGE_FAULT_ERROR_CODE_MATCH = 16392, + CR3_TARGET_COUNT = 16394, + VM_EXIT_CONTROLS = 16396, + VM_EXIT_MSR_STORE_COUNT = 16398, + VM_EXIT_MSR_LOAD_COUNT = 16400, + VM_ENTRY_CONTROLS = 16402, + VM_ENTRY_MSR_LOAD_COUNT = 16404, + VM_ENTRY_INTR_INFO_FIELD = 16406, + VM_ENTRY_EXCEPTION_ERROR_CODE = 16408, + VM_ENTRY_INSTRUCTION_LEN = 16410, + TPR_THRESHOLD = 16412, + SECONDARY_VM_EXEC_CONTROL = 16414, + PLE_GAP = 16416, + PLE_WINDOW = 16418, + VM_INSTRUCTION_ERROR = 17408, + VM_EXIT_REASON = 17410, + VM_EXIT_INTR_INFO = 17412, + VM_EXIT_INTR_ERROR_CODE = 17414, + IDT_VECTORING_INFO_FIELD = 17416, + IDT_VECTORING_ERROR_CODE = 17418, + VM_EXIT_INSTRUCTION_LEN = 17420, + VMX_INSTRUCTION_INFO = 17422, + GUEST_ES_LIMIT = 18432, + GUEST_CS_LIMIT = 18434, + GUEST_SS_LIMIT = 18436, + GUEST_DS_LIMIT = 18438, + GUEST_FS_LIMIT = 18440, + GUEST_GS_LIMIT = 18442, + GUEST_LDTR_LIMIT = 18444, + GUEST_TR_LIMIT = 18446, + GUEST_GDTR_LIMIT = 18448, + GUEST_IDTR_LIMIT = 18450, + GUEST_ES_AR_BYTES = 18452, + GUEST_CS_AR_BYTES = 18454, + GUEST_SS_AR_BYTES = 18456, + GUEST_DS_AR_BYTES = 18458, + GUEST_FS_AR_BYTES = 18460, + GUEST_GS_AR_BYTES = 18462, + GUEST_LDTR_AR_BYTES = 18464, + GUEST_TR_AR_BYTES = 18466, + GUEST_INTERRUPTIBILITY_INFO = 18468, + GUEST_ACTIVITY_STATE = 18470, + GUEST_SYSENTER_CS = 18474, + VMX_PREEMPTION_TIMER_VALUE = 18478, + HOST_IA32_SYSENTER_CS = 19456, + CR0_GUEST_HOST_MASK = 24576, + CR4_GUEST_HOST_MASK = 24578, + CR0_READ_SHADOW = 24580, + CR4_READ_SHADOW = 24582, + CR3_TARGET_VALUE0 = 24584, + CR3_TARGET_VALUE1 = 24586, + CR3_TARGET_VALUE2 = 24588, + CR3_TARGET_VALUE3 = 24590, + EXIT_QUALIFICATION = 25600, + GUEST_LINEAR_ADDRESS = 25610, + GUEST_CR0 = 26624, + GUEST_CR3 = 26626, + GUEST_CR4 = 26628, + GUEST_ES_BASE = 26630, + GUEST_CS_BASE = 26632, + GUEST_SS_BASE = 26634, + GUEST_DS_BASE = 26636, + GUEST_FS_BASE = 26638, + GUEST_GS_BASE = 26640, + GUEST_LDTR_BASE = 26642, + GUEST_TR_BASE = 26644, + GUEST_GDTR_BASE = 26646, + GUEST_IDTR_BASE = 26648, + GUEST_DR7 = 26650, + GUEST_RSP = 26652, + GUEST_RIP = 26654, + GUEST_RFLAGS = 26656, + GUEST_PENDING_DBG_EXCEPTIONS = 26658, + GUEST_SYSENTER_ESP = 26660, + GUEST_SYSENTER_EIP = 26662, + HOST_CR0 = 27648, + HOST_CR3 = 27650, + HOST_CR4 = 27652, + HOST_FS_BASE = 27654, + HOST_GS_BASE = 27656, + HOST_TR_BASE = 27658, + HOST_GDTR_BASE = 27660, + HOST_IDTR_BASE = 27662, + HOST_IA32_SYSENTER_ESP = 27664, + HOST_IA32_SYSENTER_EIP = 27666, + HOST_RSP = 27668, + HOST_RIP = 27670, +}; + +enum vmcs_field_type { + VMCS_FIELD_TYPE_U16 = 0, + VMCS_FIELD_TYPE_U64 = 1, + VMCS_FIELD_TYPE_U32 = 2, + VMCS_FIELD_TYPE_NATURAL_WIDTH = 3, +}; + +enum walk_return { + WALK_PRED_ABORT = 0, + WALK_PRED_PARENT = 1, + WALK_PRED_DEFAULT = 2, +}; + +enum wb_congested_state { + WB_async_congested = 0, + WB_sync_congested = 1, +}; + +enum wb_reason { + WB_REASON_BACKGROUND = 0, + WB_REASON_TRY_TO_FREE_PAGES = 1, + WB_REASON_SYNC = 2, + WB_REASON_PERIODIC = 3, + WB_REASON_LAPTOP_TIMER = 4, + WB_REASON_FREE_MORE_MEM = 5, + WB_REASON_FS_FREE_SPACE = 6, + WB_REASON_FORKER_THREAD = 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, +}; + +enum what { + 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_COREDUMP = 1073741824, + PROC_EVENT_EXIT = 2147483648, +}; + +enum wl_class_t { + BE_WORKLOAD = 0, + RT_WORKLOAD = 1, + IDLE_WORKLOAD = 2, + CFQ_PRIO_NR = 3, +}; + +enum wl_type_t { + ASYNC_WORKLOAD = 0, + SYNC_NOIDLE_WORKLOAD = 1, + SYNC_WORKLOAD = 2, +}; + +enum writeback_stat_item { + NR_DIRTY_THRESHOLD = 0, + NR_DIRTY_BG_THRESHOLD = 1, + NR_VM_WRITEBACK_STAT_ITEMS = 2, +}; + +enum writeback_sync_modes { + WB_SYNC_NONE = 0, + WB_SYNC_ALL = 1, +}; + +enum x86_hardware_subarch { + X86_SUBARCH_PC = 0, + X86_SUBARCH_LGUEST = 1, + X86_SUBARCH_XEN = 2, + X86_SUBARCH_INTEL_MID = 3, + X86_SUBARCH_CE4100 = 4, + X86_NR_SUBARCHS = 5, +}; + +enum x86_intercept { + x86_intercept_none = 0, + x86_intercept_cr_read = 1, + x86_intercept_cr_write = 2, + x86_intercept_clts = 3, + x86_intercept_lmsw = 4, + x86_intercept_smsw = 5, + x86_intercept_dr_read = 6, + x86_intercept_dr_write = 7, + x86_intercept_lidt = 8, + x86_intercept_sidt = 9, + x86_intercept_lgdt = 10, + x86_intercept_sgdt = 11, + x86_intercept_lldt = 12, + x86_intercept_sldt = 13, + x86_intercept_ltr = 14, + x86_intercept_str = 15, + x86_intercept_rdtsc = 16, + x86_intercept_rdpmc = 17, + x86_intercept_pushf = 18, + x86_intercept_popf = 19, + x86_intercept_cpuid = 20, + x86_intercept_rsm = 21, + x86_intercept_iret = 22, + x86_intercept_intn = 23, + x86_intercept_invd = 24, + x86_intercept_pause = 25, + x86_intercept_hlt = 26, + x86_intercept_invlpg = 27, + x86_intercept_invlpga = 28, + x86_intercept_vmrun = 29, + x86_intercept_vmload = 30, + x86_intercept_vmsave = 31, + x86_intercept_vmmcall = 32, + x86_intercept_stgi = 33, + x86_intercept_clgi = 34, + x86_intercept_skinit = 35, + x86_intercept_rdtscp = 36, + x86_intercept_icebp = 37, + x86_intercept_wbinvd = 38, + x86_intercept_monitor = 39, + x86_intercept_mwait = 40, + x86_intercept_rdmsr = 41, + x86_intercept_wrmsr = 42, + x86_intercept_in = 43, + x86_intercept_ins = 44, + x86_intercept_out = 45, + x86_intercept_outs = 46, + nr_x86_intercepts = 47, +}; + +enum x86_intercept_stage { + X86_ICTP_NONE = 0, + X86_ICPT_PRE_EXCEPT = 1, + X86_ICPT_POST_EXCEPT = 2, + X86_ICPT_POST_MEMACCESS = 3, +}; + +enum x86_pf_error_code { + PF_PROT = 1, + PF_WRITE = 2, + PF_USER = 4, + PF_RSVD = 8, + PF_INSTR = 16, + PF_PK = 32, +}; + +enum x86_regset { + REGSET_GENERAL = 0, + REGSET_FP = 1, + REGSET_XFP = 2, + REGSET_IOPERM64 = 2, + REGSET_XSTATE = 3, + REGSET_TLS = 4, + REGSET_IOPERM32 = 5, +}; + +enum x86_transfer_type { + X86_TRANSFER_NONE = 0, + X86_TRANSFER_CALL_JMP = 1, + X86_TRANSFER_RET = 2, + X86_TRANSFER_TASK_SWITCH = 3, +}; + +enum x86emul_mode { + X86EMUL_MODE_REAL = 0, + X86EMUL_MODE_VM86 = 1, + X86EMUL_MODE_PROT16 = 2, + X86EMUL_MODE_PROT32 = 3, + X86EMUL_MODE_PROT64 = 4, +}; + +enum xen_domain_type { + XEN_NATIVE = 0, + XEN_PV_DOMAIN = 1, + XEN_HVM_DOMAIN = 2, +}; + +enum xfeature { + XFEATURE_FP = 0, + XFEATURE_SSE = 1, + XFEATURE_YMM = 2, + XFEATURE_BNDREGS = 3, + XFEATURE_BNDCSR = 4, + XFEATURE_OPMASK = 5, + XFEATURE_ZMM_Hi256 = 6, + XFEATURE_Hi16_ZMM = 7, + XFEATURE_PT_UNIMPLEMENTED_SO_FAR = 8, + XFEATURE_PKRU = 9, + XFEATURE_MAX = 10, +}; + +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 zone_flags { + ZONE_RECLAIM_LOCKED = 0, + ZONE_OOM_LOCKED = 1, + ZONE_CONGESTED = 2, + ZONE_DIRTY = 3, + ZONE_WRITEBACK = 4, + ZONE_FAIR_DEPLETED = 5, +}; + +enum zone_stat_item { + NR_FREE_PAGES = 0, + NR_ALLOC_BATCH = 1, + NR_LRU_BASE = 2, + NR_INACTIVE_ANON = 2, + NR_ACTIVE_ANON = 3, + NR_INACTIVE_FILE = 4, + NR_ACTIVE_FILE = 5, + NR_UNEVICTABLE = 6, + NR_MLOCK = 7, + NR_ANON_PAGES = 8, + NR_FILE_MAPPED = 9, + NR_FILE_PAGES = 10, + NR_FILE_DIRTY = 11, + NR_WRITEBACK = 12, + NR_SLAB_RECLAIMABLE = 13, + NR_SLAB_UNRECLAIMABLE = 14, + NR_PAGETABLE = 15, + NR_KERNEL_STACK = 16, + NR_UNSTABLE_NFS = 17, + NR_BOUNCE = 18, + NR_VMSCAN_WRITE = 19, + NR_VMSCAN_IMMEDIATE = 20, + NR_WRITEBACK_TEMP = 21, + NR_ISOLATED_ANON = 22, + NR_ISOLATED_FILE = 23, + NR_SHMEM = 24, + NR_DIRTIED = 25, + NR_WRITTEN = 26, + NR_PAGES_SCANNED = 27, + NUMA_HIT = 28, + NUMA_MISS = 29, + NUMA_FOREIGN = 30, + NUMA_INTERLEAVE_HIT = 31, + NUMA_LOCAL = 32, + NUMA_OTHER = 33, + WORKINGSET_REFAULT = 34, + WORKINGSET_ACTIVATE = 35, + WORKINGSET_NODERECLAIM = 36, + NR_ANON_TRANSPARENT_HUGEPAGES = 37, + NR_FREE_CMA_PAGES = 38, + NR_VM_ZONE_STAT_ITEMS = 39, +}; + +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, + NR_WMARK = 3, +}; + +typedef _Bool bool; + +typedef bool pto_T_____3; + +typedef char acpi_bus_id[8]; + +typedef char acpi_device_class[20]; + +typedef char acpi_device_name[40]; + +typedef char *acpi_string; + +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_timer_t; + +typedef int __s32; + +typedef __kernel_clockid_t clockid_t; + +typedef int 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_time_t; + +typedef s32 compat_timer_t; + +typedef s32 dma_cookie_t; + +typedef int insn_value_t; + +typedef __s32 int32_t; + +typedef int32_t key_serial_t; + +typedef __kernel_key_t key_t; + +typedef __kernel_mqd_t mqd_t; + +typedef int pao_T__; + +typedef s32 pao_T_____2; + +typedef int pci_power_t; + +typedef __kernel_pid_t pid_t; + +typedef int pto_T_____4; + +typedef int snd_ctl_elem_iface_t; + +typedef int snd_ctl_elem_type_t; + +typedef int snd_pcm_access_t; + +typedef int snd_pcm_format_t; + +typedef int snd_pcm_hw_param_t; + +typedef int snd_pcm_state_t; + +typedef int snd_pcm_subformat_t; + +typedef int snd_seq_client_type_t; + +typedef int suspend_state_t; + +typedef __kernel_timer_t timer_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_ptrdiff_t; + +typedef __kernel_long_t __kernel_ssize_t; + +typedef __kernel_long_t __kernel_suseconds_t; + +typedef __kernel_long_t __kernel_time_t; + +typedef __kernel_clock_t clock_t; + +typedef __kernel_off_t off_t; + +typedef long int pao_T_____3; + +typedef __kernel_ptrdiff_t ptrdiff_t; + +typedef long int snd_pcm_sframes_t; + +typedef __kernel_ssize_t ssize_t; + +typedef __kernel_suseconds_t suseconds_t; + +typedef __kernel_time_t time_t; + +typedef long long int __s64; + +typedef __s64 Elf64_Sxword; + +typedef long long int __kernel_loff_t; + +typedef long long int s64; + +typedef s64 compat_loff_t; + +typedef s64 compat_s64; + +typedef __s64 int64_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 __addrpair; + +typedef __u64 __be64; + +typedef __u64 __le64; + +typedef __u64 __virtio64; + +typedef long long unsigned int u64; + +typedef u64 acpi_io_address; + +typedef u64 acpi_physical_address; + +typedef u64 acpi_size; + +typedef u64 async_cookie_t; + +typedef u64 compat_u64; + +typedef u64 cputime64_t; + +typedef u64 cycle_t; + +typedef long long unsigned int cycles_t; + +typedef u64 dma_addr_t; + +typedef u64 efi_physical_addr_t; + +typedef __u64 uint64_t; + +typedef uint64_t gen8_pde_t; + +typedef uint64_t gen8_ppgtt_pdpe_t; + +typedef uint64_t gen8_ppgtt_pml4e_t; + +typedef uint64_t gen8_pte_t; + +typedef u64 gfn_t; + +typedef u64 gpa_t; + +typedef u64 hfn_t; + +typedef u64 hpa_t; + +typedef u64 jump_label_t; + +typedef hfn_t kvm_pfn_t; + +typedef u64 natural_width; + +typedef u64 netdev_features_t; + +typedef u64 pao_T_____4; + +typedef u64 pci_bus_addr_t; + +typedef u64 phys_addr_t; + +typedef u64 pto_T_____5; + +typedef phys_addr_t resource_size_t; + +typedef __u64 u_int64_t; + +typedef uint64_t vli_type; + +typedef long unsigned int __kernel_ulong_t; + +typedef __kernel_ulong_t __kernel_ino_t; + +typedef long unsigned int __kernel_old_dev_t; + +typedef __kernel_ulong_t __kernel_size_t; + +typedef long unsigned int acpi_bus_address; + +typedef __kernel_ulong_t aio_context_t; + +typedef long unsigned int blkcnt_t; + +typedef long unsigned int cputime_t; + +typedef long unsigned int efi_status_t; + +typedef long unsigned int elf_greg_t; + +typedef elf_greg_t elf_gregset_t[27]; + +typedef long unsigned int gtod_long_t; + +typedef long unsigned int gva_t; + +typedef __kernel_ino_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 long unsigned int mce_banks_t[1]; + +typedef long unsigned int old_sigset_t; + +typedef long unsigned int pao_T_____5; + +typedef long unsigned int perf_trace_t[256]; + +typedef long unsigned int pgdval_t; + +typedef long unsigned int pgprotval_t; + +typedef long unsigned int pmdval_t; + +typedef long unsigned int pteval_t; + +typedef long unsigned int pto_T_____6; + +typedef long unsigned int pudval_t; + +typedef long unsigned int sector_t; + +typedef sector_t region_t; + +typedef __kernel_size_t size_t; + +typedef long unsigned int snd_pcm_uframes_t; + +typedef long unsigned int uLong; + +typedef long unsigned int u_long; + +typedef long unsigned int uintptr_t; + +typedef long unsigned int ulong; + +typedef long unsigned int vm_flags_t; + +typedef short int __s16; + +typedef __s16 int16_t; + +typedef short int s16; + +typedef short unsigned int __u16; + +typedef __u16 Elf32_Half; + +typedef __u16 Elf64_Half; + +typedef __u16 __be16; + +typedef short unsigned int u16; + +typedef u16 __compat_gid_t; + +typedef u16 __compat_uid_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 __u16 __le16; + +typedef __u16 __sum16; + +typedef __u16 __virtio16; + +typedef u16 acpi_rs_length; + +typedef __u16 bitmap_counter_t; + +typedef __u16 comp_t; + +typedef u16 compat_dev_t; + +typedef u16 compat_ipc_pid_t; + +typedef u16 compat_mode_t; + +typedef u16 compat_nlink_t; + +typedef u16 efi_char16_t; + +typedef u16 hda_nid_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 __kernel_sa_family_t sa_family_t; + +typedef short unsigned int u_short; + +typedef u16 ucs2_char_t; + +typedef __u16 uint16_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 int8_t; + +typedef signed char s8; + +typedef s8 pto_T_____7; + +typedef unsigned char Byte; + +typedef unsigned char __u8; + +typedef unsigned char u8; + +typedef u8 acpi_adr_space_type; + +typedef u8 acpi_owner_id; + +typedef unsigned char cc_t; + +typedef unsigned char cisdata_t; + +typedef u8 efi_bool_t; + +typedef unsigned char insn_byte_t; + +typedef u8 kprobe_opcode_t; + +typedef __u8 mtrr_type; + +typedef unsigned char pto_T_____8; + +typedef u8 pto_T_____9; + +typedef unsigned char snd_seq_event_type_t; + +typedef unsigned char u_char; + +typedef __u8 u_int8_t; + +typedef __u8 uint8_t; + +typedef __u8 virtio_net_ctrl_ack; + +typedef unsigned int __u32; + +typedef __u32 Elf32_Addr; + +typedef __u32 Elf32_Off; + +typedef __u32 Elf32_Word; + +typedef __u32 Elf64_Word; + +typedef __u32 __be32; + +typedef unsigned int u32; + +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_uid32_t; + +typedef unsigned int __kernel_uid_t; + +typedef __u32 __le32; + +typedef __u32 __portpair; + +typedef __u32 __virtio32; + +typedef __u32 __wsum; + +typedef unsigned int abstime_t; + +typedef u32 acpi_event_status; + +typedef u32 acpi_mutex_handle; + +typedef u32 acpi_name; + +typedef u32 acpi_object_type; + +typedef u32 acpi_rsdesc_size; + +typedef u32 acpi_status; + +typedef unsigned int blk_qc_t; + +typedef __u32 comp2_t; + +typedef u32 compat_ulong_t; + +typedef compat_ulong_t compat_aio_context_t; + +typedef u32 compat_caddr_t; + +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_uptr_t; + +typedef __kernel_dev_t dev_t; + +typedef __u32 uint32_t; + +typedef uint32_t drbg_flag_t; + +typedef unsigned int drm_context_t; + +typedef unsigned int drm_drawable_t; + +typedef unsigned int drm_magic_t; + +typedef unsigned int fmode_t; + +typedef uint32_t gen6_pte_t; + +typedef unsigned int gfp_t; + +typedef __kernel_gid32_t gid_t; + +typedef unsigned int insn_attr_t; + +typedef unsigned int isolate_mode_t; + +typedef uint32_t key_perm_t; + +typedef __u32 nlink_t; + +typedef u32 note_buf_t[92]; + +typedef unsigned int pao_T_____6; + +typedef u32 pao_T_____7; + +typedef unsigned int pci_channel_state_t; + +typedef unsigned int pci_ers_result_t; + +typedef unsigned int pcie_reset_state_t; + +typedef u32 phandle; + +typedef u32 phys_cpuid_t; + +typedef __kernel_uid32_t projid_t; + +typedef unsigned int pto_T_____10; + +typedef __u32 pto_T_____11; + +typedef u32 pto_T_____12; + +typedef __kernel_uid32_t qid_t; + +typedef unsigned int reltime_t; + +typedef unsigned int sk_buff_data_t; + +typedef unsigned int snd_seq_tick_time_t; + +typedef unsigned int speed_t; + +typedef unsigned int sse128_t[4]; + +typedef u32 string; + +typedef u32 string_size; + +typedef unsigned int t_key; + +typedef unsigned int tcflag_t; + +typedef unsigned int uInt; + +typedef unsigned int u_int; + +typedef __u32 u_int32_t; + +typedef __kernel_uid32_t uid_t; + +typedef unsigned int uint; + +typedef u32 unicode_t; + +typedef unsigned int upf_t; + +typedef unsigned int upstat_t; + +struct list_head { + struct list_head *next; + struct list_head *prev; +}; + +struct dentry; + +typedef struct { + struct list_head list; + long unsigned int flags; + int offset; + int size; + char *magic; + char *mask; + char *interpreter; + char *name; + struct dentry *dentry; +} Node; + +struct page; + +typedef struct { + struct page *v; +} Sector; + +typedef struct { + long unsigned int fds_bits[16]; +} __kernel_fd_set; + +typedef struct { + int val[2]; +} __kernel_fsid_t; + +typedef struct { + long int counter; +} atomic64_t; + +typedef atomic64_t atomic_long_t; + +typedef struct { + int counter; +} atomic_t; + +typedef struct { + __be64 a; + __be64 b; +} be128; + +typedef struct { + unsigned int interval; + unsigned int timeout; +} cisco_proto; + +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 signature; + u32 revision; + u32 headersize; + u32 crc32; + u32 reserved; +} efi_table_hdr_t; + +typedef void *efi_handle_t; + +typedef struct { + __u8 b[16]; +} uuid_le; + +typedef uuid_le efi_guid_t; + +typedef 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 *); + void *create_event; + void *set_timer; + void *wait_for_event; + void *signal_event; + void *close_event; + 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 *); + void *locate_device_path; + efi_status_t (*install_configuration_table)(efi_guid_t *, void *); + void *load_image; + void *start_image; + void *exit; + void *unload_image; + efi_status_t (*exit_boot_services)(efi_handle_t, long unsigned int); + void *get_next_monotonic_count; + void *stall; + void *set_watchdog_timer; + void *connect_controller; + void *disconnect_controller; + void *open_protocol; + void *close_protocol; + void *open_protocol_information; + void *protocols_per_handle; + void *locate_handle_buffer; + efi_status_t (*locate_protocol)(efi_guid_t *, void *, void **); + void *install_multiple_protocol_interfaces; + void *uninstall_multiple_protocol_interfaces; + void *calculate_crc32; + void *copy_mem; + void *set_mem; + void *create_event_ex; +} efi_boot_services_t; + +typedef struct { + u64 length; + u64 data; +} efi_capsule_block_desc_t; + +typedef struct { + efi_guid_t guid; + u32 headersize; + u32 flags; + u32 imagesize; +} efi_capsule_header_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 struct { + efi_guid_t guid; + const char *name; + long unsigned int *ptr; +} efi_config_table_type_t; + +typedef struct { + u32 type; + u32 pad; + u64 phys_addr; + u64 virt_addr; + u64 num_pages; + u64 attribute; +} efi_memory_desc_t; + +typedef struct { + u32 version; + u32 num_entries; + u32 desc_size; + u32 reserved; + efi_memory_desc_t entry[0]; +} efi_memory_attributes_table_t; + +typedef struct { + u32 version; + u32 length; + u64 memory_protection_attribute; +} efi_properties_table_t; + +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 struct { + efi_table_hdr_t hdr; + u64 get_time; + u64 set_time; + u64 get_wakeup_time; + u64 set_wakeup_time; + u64 set_virtual_address_map; + u64 convert_pointer; + u64 get_variable; + u64 get_next_variable; + u64 set_variable; + u64 get_next_high_mono_count; + u64 reset_system; + u64 update_capsule; + u64 query_capsule_caps; + u64 query_variable_info; +} efi_runtime_services_64_t; + +typedef struct { + efi_table_hdr_t hdr; + void *get_time; + void *set_time; + void *get_wakeup_time; + void *set_wakeup_time; + void *set_virtual_address_map; + void *convert_pointer; + void *get_variable; + void *get_next_variable; + void *set_variable; + void *get_next_high_mono_count; + void *reset_system; + void *update_capsule; + void *query_capsule_caps; + void *query_variable_info; +} 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; + +typedef struct { + efi_table_hdr_t hdr; + u64 fw_vendor; + u32 fw_revision; + u32 __pad1; + u64 con_in_handle; + u64 con_in; + u64 con_out_handle; + u64 con_out; + u64 stderr_handle; + u64 stderr; + u64 runtime; + u64 boottime; + u32 nr_tables; + u32 __pad2; + u64 tables; +} efi_system_table_64_t; + +typedef struct { + efi_table_hdr_t hdr; + long unsigned int fw_vendor; + u32 fw_revision; + long unsigned int con_in_handle; + long unsigned int con_in; + long unsigned int con_out_handle; + long unsigned int 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_t; + +typedef struct { + u32 resolution; + u32 accuracy; + u8 sets_to_zero; +} efi_time_cap_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 __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 { + int preload; +} fpu_switch_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 struct { + uint32_t reg; +} i915_reg_t; + +typedef struct { + int dot_limit; + int p2_slow; + int p2_fast; +} intel_p2_t; + +typedef struct { + int min; + int max; +} intel_range_t; + +typedef struct { + unsigned int __softirq_pending; + unsigned int __nmi_count; + unsigned int apic_timer_irqs; + unsigned int irq_spurious_count; + unsigned int icr_read_retry_count; + unsigned int kvm_posted_intr_ipis; + unsigned int kvm_posted_intr_wakeup_ipis; + unsigned int x86_platform_ipis; + unsigned int apic_perf_irqs; + unsigned int apic_irq_work_irqs; + unsigned int irq_resched_count; + unsigned int irq_call_count; + unsigned int irq_tlb_count; + unsigned int irq_thermal_count; + unsigned int irq_threshold_count; + unsigned int irq_deferred_error_count; +} irq_cpustat_t; + +typedef struct { + gid_t val; +} kgid_t; + +typedef struct { + projid_t val; +} kprojid_t; + +typedef struct { + uid_t val; +} kuid_t; + +typedef struct { + atomic_long_t a; +} local_t; + +typedef struct { + local_t a; +} local64_t; + +struct qspinlock { + atomic_t val; +}; + +typedef struct qspinlock arch_spinlock_t; + +struct raw_spinlock { + arch_spinlock_t raw_lock; +}; + +struct spinlock { + union { + struct raw_spinlock rlock; + }; +}; + +typedef struct spinlock spinlock_t; + +struct optimistic_spin_queue { + atomic_t tail; +}; + +struct task_struct; + +struct mutex { + atomic_t count; + spinlock_t wait_lock; + struct list_head wait_list; + struct task_struct *owner; + struct optimistic_spin_queue osq; +}; + +struct ldt_struct; + +struct vdso_image; + +typedef struct { + struct ldt_struct *ldt; + short unsigned int ia32_compat; + struct mutex lock; + void *vdso; + const struct vdso_image *vdso_image; + atomic_t perf_rdpmc_allowed; +} mm_context_t; + +struct task_struct___2; + +struct mutex___2 { + atomic_t count; + spinlock_t wait_lock; + struct list_head wait_list; + struct task_struct___2 *owner; + struct optimistic_spin_queue osq; +}; + +typedef struct { + struct ldt_struct *ldt; + short unsigned int ia32_compat; + struct mutex___2 lock; + void *vdso; + const struct vdso_image *vdso_image; + atomic_t perf_rdpmc_allowed; +} mm_context_t___2; + +typedef struct { + long unsigned int seg; +} mm_segment_t; + +typedef struct { + long unsigned int bits[1]; +} nodemask_t; + +typedef struct { + u64 pme; +} pagemap_entry_t; + +typedef struct { + u64 val; +} pfn_t; + +typedef struct { + pgdval_t pgd; +} pgd_t; + +typedef struct { + pmdval_t pmd; +} pmd_t; + +typedef struct { + long unsigned int bits[4]; +} pnp_irq_mask_t; + +typedef struct { + __le16 e_tag; + __le16 e_perm; + __le32 e_id; +} posix_acl_xattr_entry; + +typedef struct { + __le32 a_version; + posix_acl_xattr_entry a_entries[0]; +} posix_acl_xattr_header; + +struct net; + +typedef struct { + struct net *net; +} possible_net_t; + +struct net___2; + +typedef struct { + struct net___2 *net; +} possible_net_t___2; + +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 { + size_t written; + size_t count; + union { + char *buf; + void *data; + } arg; + int error; +} read_descriptor_t; + +struct qrwlock { + atomic_t cnts; + arch_spinlock_t wait_lock; +}; + +typedef struct qrwlock arch_rwlock_t; + +typedef struct { + arch_rwlock_t raw_lock; +} rwlock_t; + +struct seqcount { + unsigned int sequence; +}; + +typedef struct { + struct seqcount seqcount; + spinlock_t lock; +} seqlock_t; + +typedef struct { + long unsigned int sig[1]; +} sigset_t; + +typedef atomic_t snd_use_lock_t; + +struct __wait_queue_head { + spinlock_t lock; + struct list_head task_list; +}; + +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 { + u64 a; + u64 b; +} u128; + +typedef struct { + __u8 b[16]; +} uuid_be; + +typedef struct { + int w; + int h; + video_format_t aspect_ratio; +} video_size_t; + +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; + +union IO_APIC_reg_00 { + u32 raw; + struct { + u32 __reserved_2: 14; + u32 LTS: 1; + u32 delivery_type: 1; + u32 __reserved_1: 8; + u32 ID: 8; + } bits; +}; + +union IO_APIC_reg_01 { + u32 raw; + struct { + u32 version: 8; + u32 __reserved_2: 7; + u32 PRQ: 1; + u32 entries: 8; + u32 __reserved_1: 8; + } bits; +}; + +union IO_APIC_reg_02 { + u32 raw; + struct { + u32 __reserved_2: 24; + u32 arbitration: 4; + u32 __reserved_1: 4; + } bits; +}; + +union IO_APIC_reg_03 { + u32 raw; + struct { + u32 boot_DT: 1; + u32 __reserved_1: 31; + } bits; +}; + +struct IO_APIC_route_entry { + __u32 vector: 8; + __u32 delivery_mode: 3; + __u32 dest_mode: 1; + __u32 delivery_status: 1; + __u32 polarity: 1; + __u32 irr: 1; + __u32 trigger: 1; + __u32 mask: 1; + __u32 __reserved_2: 15; + __u32 __reserved_3: 24; + __u32 dest: 8; +}; + +struct IR_IO_APIC_route_entry { + __u64 vector: 8; + __u64 zero: 3; + __u64 index2: 1; + __u64 delivery_status: 1; + __u64 polarity: 1; + __u64 irr: 1; + __u64 trigger: 1; + __u64 mask: 1; + __u64 reserved: 31; + __u64 format: 1; + __u64 index: 15; +}; + +struct PartitionBlock { + __be32 pb_ID; + __be32 pb_SummedLongs; + __s32 pb_ChkSum; + __u32 pb_HostID; + __be32 pb_Next; + __u32 pb_Flags; + __u32 pb_Reserved1[2]; + __u32 pb_DevFlags; + __u8 pb_DriveName[32]; + __u32 pb_Reserved2[15]; + __be32 pb_Environment[17]; + __u32 pb_EReserved[15]; +}; + +struct gnet_stats_rate_est64 { + __u64 bps; + __u64 pps; +}; + +struct sk_buff; + +struct sk_buff_head { + struct sk_buff *next; + struct sk_buff *prev; + __u32 qlen; + spinlock_t lock; +}; + +struct gnet_stats_basic_packed { + __u64 bytes; + __u32 packets; +} __attribute__((packed)); + +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 Qdisc_ops; + +struct qdisc_size_table; + +struct netdev_queue; + +struct gnet_stats_basic_cpu; + +struct Qdisc { + int (*enqueue)(struct sk_buff *, struct Qdisc *); + struct sk_buff * (*dequeue)(struct Qdisc *); + unsigned int flags; + u32 limit; + const struct Qdisc_ops *ops; + struct qdisc_size_table *stab; + struct list_head list; + u32 handle; + u32 parent; + int (*reshape_fail)(struct sk_buff *, struct Qdisc *); + void *u32_node; + struct Qdisc *__parent; + struct netdev_queue *dev_queue; + struct gnet_stats_rate_est64 rate_est; + struct gnet_stats_basic_cpu *cpu_bstats; + struct gnet_stats_queue *cpu_qstats; + struct Qdisc *next_sched; + struct sk_buff *gso_skb; + long unsigned int state; + struct sk_buff_head q; + struct gnet_stats_basic_packed bstats; + unsigned int __state; + struct gnet_stats_queue qstats; + struct callback_head callback_head; + int padded; + atomic_t refcnt; + long: 64; + long: 64; + spinlock_t busylock; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; +}; + +struct sk_buff___2; + +struct sk_buff_head___2 { + struct sk_buff___2 *next; + struct sk_buff___2 *prev; + __u32 qlen; + spinlock_t lock; +}; + +struct Qdisc_ops___2; + +struct netdev_queue___2; + +struct Qdisc___2 { + int (*enqueue)(struct sk_buff___2 *, struct Qdisc___2 *); + struct sk_buff___2 * (*dequeue)(struct Qdisc___2 *); + unsigned int flags; + u32 limit; + const struct Qdisc_ops___2 *ops; + struct qdisc_size_table *stab; + struct list_head list; + u32 handle; + u32 parent; + int (*reshape_fail)(struct sk_buff___2 *, struct Qdisc___2 *); + void *u32_node; + struct Qdisc___2 *__parent; + struct netdev_queue___2 *dev_queue; + struct gnet_stats_rate_est64 rate_est; + struct gnet_stats_basic_cpu *cpu_bstats; + struct gnet_stats_queue *cpu_qstats; + struct Qdisc___2 *next_sched; + struct sk_buff___2 *gso_skb; + long unsigned int state; + struct sk_buff_head___2 q; + struct gnet_stats_basic_packed bstats; + unsigned int __state; + struct gnet_stats_queue qstats; + struct callback_head callback_head; + int padded; + atomic_t refcnt; + long: 64; + long: 64; + spinlock_t busylock; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; +}; + +struct hlist_node { + struct hlist_node *next; + struct hlist_node **pprev; +}; + +struct Qdisc_class_common { + u32 classid; + 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 nlattr; + +struct qdisc_walker; + +struct tcf_proto; + +struct gnet_dump; + +struct Qdisc_class_ops { + struct netdev_queue * (*select_queue)(struct Qdisc *, struct tcmsg *); + int (*graft)(struct Qdisc *, long unsigned int, struct Qdisc *, struct Qdisc **); + struct Qdisc * (*leaf)(struct Qdisc *, long unsigned int); + void (*qlen_notify)(struct Qdisc *, long unsigned int); + long unsigned int (*get)(struct Qdisc *, u32); + void (*put)(struct Qdisc *, long unsigned int); + int (*change)(struct Qdisc *, u32, u32, struct nlattr **, long unsigned int *); + int (*delete)(struct Qdisc *, long unsigned int); + void (*walk)(struct Qdisc *, struct qdisc_walker *); + struct tcf_proto ** (*tcf_chain)(struct Qdisc *, long unsigned int); + bool (*tcf_cl_offload)(u32); + 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 tcf_proto___2; + +struct gnet_dump___2; + +struct Qdisc_class_ops___2 { + struct netdev_queue___2 * (*select_queue)(struct Qdisc___2 *, struct tcmsg *); + int (*graft)(struct Qdisc___2 *, long unsigned int, struct Qdisc___2 *, struct Qdisc___2 **); + struct Qdisc___2 * (*leaf)(struct Qdisc___2 *, long unsigned int); + void (*qlen_notify)(struct Qdisc___2 *, long unsigned int); + long unsigned int (*get)(struct Qdisc___2 *, u32); + void (*put)(struct Qdisc___2 *, long unsigned int); + int (*change)(struct Qdisc___2 *, u32, u32, struct nlattr **, long unsigned int *); + int (*delete)(struct Qdisc___2 *, long unsigned int); + void (*walk)(struct Qdisc___2 *, struct qdisc_walker *); + struct tcf_proto___2 ** (*tcf_chain)(struct Qdisc___2 *, long unsigned int); + bool (*tcf_cl_offload)(u32); + long unsigned int (*bind_tcf)(struct Qdisc___2 *, long unsigned int, u32); + void (*unbind_tcf)(struct Qdisc___2 *, long unsigned int); + int (*dump)(struct Qdisc___2 *, long unsigned int, struct sk_buff___2 *, struct tcmsg *); + int (*dump_stats)(struct Qdisc___2 *, long unsigned int, struct gnet_dump___2 *); +}; + +struct module; + +struct Qdisc_ops { + struct Qdisc_ops *next; + const struct Qdisc_class_ops *cl_ops; + char id[16]; + int priv_size; + int (*enqueue)(struct sk_buff *, struct Qdisc *); + struct sk_buff * (*dequeue)(struct Qdisc *); + struct sk_buff * (*peek)(struct Qdisc *); + unsigned int (*drop)(struct Qdisc *); + int (*init)(struct Qdisc *, struct nlattr *); + void (*reset)(struct Qdisc *); + void (*destroy)(struct Qdisc *); + int (*change)(struct Qdisc *, struct nlattr *); + void (*attach)(struct Qdisc *); + int (*dump)(struct Qdisc *, struct sk_buff *); + int (*dump_stats)(struct Qdisc *, struct gnet_dump *); + struct module *owner; +}; + +struct module___2; + +struct Qdisc_ops___2 { + struct Qdisc_ops___2 *next; + const struct Qdisc_class_ops___2 *cl_ops; + char id[16]; + int priv_size; + int (*enqueue)(struct sk_buff___2 *, struct Qdisc___2 *); + struct sk_buff___2 * (*dequeue)(struct Qdisc___2 *); + struct sk_buff___2 * (*peek)(struct Qdisc___2 *); + unsigned int (*drop)(struct Qdisc___2 *); + int (*init)(struct Qdisc___2 *, struct nlattr *); + void (*reset)(struct Qdisc___2 *); + void (*destroy)(struct Qdisc___2 *); + int (*change)(struct Qdisc___2 *, struct nlattr *); + void (*attach)(struct Qdisc___2 *); + int (*dump)(struct Qdisc___2 *, struct sk_buff___2 *); + int (*dump_stats)(struct Qdisc___2 *, struct gnet_dump___2 *); + struct module___2 *owner; +}; + +struct RR_CL_s { + char location[8]; +}; + +struct RR_NM_s { + unsigned char flags; + char name[0]; +}; + +struct RR_PL_s { + char location[8]; +}; + +struct RR_PN_s { + char dev_high[8]; + char dev_low[8]; +}; + +struct RR_PX_s { + char mode[8]; + char n_links[8]; + char uid[8]; + char gid[8]; +}; + +struct RR_RR_s { + char flags[1]; +}; + +struct SL_component { + unsigned char flags; + unsigned char len; + char text[0]; +}; + +struct RR_SL_s { + unsigned char flags; + struct SL_component link; +}; + +struct stamp { + char time[7]; +}; + +struct RR_TF_s { + char flags; + struct stamp times[0]; +}; + +struct RR_ZF_s { + char algorithm[2]; + char parms[2]; + char real_size[8]; +}; + +struct RigidDiskBlock { + __u32 rdb_ID; + __be32 rdb_SummedLongs; + __s32 rdb_ChkSum; + __u32 rdb_HostID; + __be32 rdb_BlockBytes; + __u32 rdb_Flags; + __u32 rdb_BadBlockList; + __be32 rdb_PartitionList; + __u32 rdb_FileSysHeaderList; + __u32 rdb_DriveInit; + __u32 rdb_Reserved1[6]; + __u32 rdb_Cylinders; + __u32 rdb_Sectors; + __u32 rdb_Heads; + __u32 rdb_Interleave; + __u32 rdb_Park; + __u32 rdb_Reserved2[3]; + __u32 rdb_WritePreComp; + __u32 rdb_ReducedWrite; + __u32 rdb_StepRate; + __u32 rdb_Reserved3[5]; + __u32 rdb_RDBBlocksLo; + __u32 rdb_RDBBlocksHi; + __u32 rdb_LoCylinder; + __u32 rdb_HiCylinder; + __u32 rdb_CylBlocks; + __u32 rdb_AutoParkSeconds; + __u32 rdb_HighRDSKBlock; + __u32 rdb_Reserved4; + char rdb_DiskVendor[8]; + char rdb_DiskProduct[16]; + char rdb_DiskRevision[4]; + char rdb_ControllerVendor[8]; + char rdb_ControllerProduct[16]; + char rdb_ControllerRevision[4]; + __u32 rdb_Reserved5[10]; +}; + +struct SU_CE_s { + char extent[8]; + char offset[8]; + char size[8]; +}; + +struct SU_ER_s { + unsigned char len_id; + unsigned char len_des; + unsigned char len_src; + unsigned char ext_ver; + char data[0]; +}; + +struct SU_SP_s { + unsigned char magic[2]; + unsigned char skip; +}; + +struct blk_mq_ops; + +struct blk_mq_tags; + +struct blk_mq_tag_set { + struct blk_mq_ops *ops; + 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 mutex___2 tag_list_lock; + struct list_head tag_list; +}; + +struct kref { + atomic_t refcount; +}; + +struct kset; + +struct kobj_type; + +struct kernfs_node; + +struct kobject { + const char *name; + struct list_head entry; + struct kobject *parent; + struct kset *kset; + 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 pm_message { + int event; +}; + +typedef struct pm_message pm_message_t; + +struct completion { + unsigned int done; + wait_queue_head_t wait; +}; + +struct timer_list { + struct hlist_node entry; + long unsigned int expires; + void (*function)(long unsigned int); + long unsigned int data; + u32 flags; + int slack; + int start_pid; + void *start_site; + char start_comm[16]; +}; + +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 wakeup_source; + +struct wake_irq; + +struct pm_subsys_data; + +struct device; + +struct dev_pm_qos; + +struct dev_pm_info { + pm_message_t power_state; + unsigned int can_wakeup: 1; + unsigned int async_suspend: 1; + bool is_prepared: 1; + bool is_suspended: 1; + bool is_noirq_suspended: 1; + bool is_late_suspended: 1; + bool early_init: 1; + bool direct_complete: 1; + spinlock_t lock; + struct list_head entry; + struct completion completion; + struct wakeup_source *wakeup; + bool wakeup_path: 1; + bool syscore: 1; + bool no_pm_callbacks: 1; + struct timer_list suspend_timer; + long unsigned int 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; + unsigned int idle_notification: 1; + unsigned int request_pending: 1; + unsigned int deferred_resume: 1; + unsigned int run_wake: 1; + unsigned int runtime_auto: 1; + bool ignore_children: 1; + unsigned int no_callbacks: 1; + unsigned int irq_safe: 1; + unsigned int use_autosuspend: 1; + unsigned int timer_autosuspends: 1; + unsigned int memalloc_noio: 1; + enum rpm_request request; + enum rpm_status runtime_status; + int runtime_error; + int autosuspend_delay; + long unsigned int last_busy; + long unsigned int active_jiffies; + long unsigned int suspended_jiffies; + long unsigned int accounting_timestamp; + struct pm_subsys_data *subsys_data; + void (*set_latency_tolerance)(struct device *, s32); + struct dev_pm_qos *qos; +}; + +struct dma_coherent_mem; + +struct dma_map_ops; + +struct dev_archdata { + struct dma_map_ops *dma_ops; + void *iommu; +}; + +struct klist_node { + void *n_klist; + struct list_head n_node; + struct kref n_ref; +}; + +struct device_private; + +struct device_type; + +struct bus_type; + +struct device_driver; + +struct dev_pm_domain; + +struct irq_domain; + +struct device_dma_parameters; + +struct device_node; + +struct fwnode_handle; + +struct class; + +struct attribute_group; + +struct iommu_group; + +struct device { + struct device *parent; + struct device_private *p; + struct kobject kobj; + const char *init_name; + const struct device_type *type; + struct mutex mutex; + struct bus_type *bus; + struct device_driver *driver; + void *platform_data; + void *driver_data; + struct dev_pm_info power; + struct dev_pm_domain *pm_domain; + struct irq_domain *msi_domain; + struct list_head msi_list; + int numa_node; + u64 *dma_mask; + u64 coherent_dma_mask; + long unsigned int dma_pfn_offset; + struct device_dma_parameters *dma_parms; + struct list_head dma_pools; + struct dma_coherent_mem *dma_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; + struct klist_node knode_class; + struct class *class; + const struct attribute_group **groups; + void (*release)(struct device *); + struct iommu_group *iommu_group; + bool offline_disabled: 1; + bool offline: 1; +}; + +struct scsi_host_cmd_pool; + +struct scsi_host_template; + +struct scsi_transport_template; + +struct blk_queue_tag; + +struct workqueue_struct; + +struct request_queue; + +struct Scsi_Host { + struct list_head __devices; + struct list_head __targets; + struct scsi_host_cmd_pool *cmd_pool; + spinlock_t free_list_lock; + struct list_head free_list; + struct list_head starved_list; + spinlock_t default_lock; + spinlock_t *host_lock; + struct mutex scan_mutex; + struct list_head eh_cmd_q; + struct task_struct *ehandler; + struct completion *eh_action; + wait_queue_head_t host_wait; + struct scsi_host_template *hostt; + struct scsi_transport_template *transportt; + union { + struct blk_queue_tag *bqt; + struct blk_mq_tag_set tag_set; + }; + atomic_t host_busy; + 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; + long unsigned int dma_boundary; + unsigned int nr_hw_queues; + long unsigned int cmd_serial_number; + unsigned int active_mode: 2; + unsigned int unchecked_isa_dma: 1; + unsigned int use_clustering: 1; + 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 use_blk_mq: 1; + unsigned int use_cmd_list: 1; + unsigned int short_inquiry: 1; + char work_q_name[20]; + struct workqueue_struct *work_q; + struct workqueue_struct *tmf_work_q; + unsigned int no_scsi2_lun_in_cdb: 1; + unsigned int max_host_blocked; + unsigned int prot_capabilities; + unsigned char prot_guard_type; + struct request_queue *uspace_req_q; + 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; + struct list_head sht_legacy_list; + void *shost_data; + struct device *dma_dev; + long unsigned int hostdata[0]; +}; + +struct _HV_REFERENCE_TSC_PAGE { + __u32 tsc_sequence; + __u32 res1; + __u64 tsc_scale; + __s64 tsc_offset; +}; + +typedef struct _HV_REFERENCE_TSC_PAGE HV_REFERENCE_TSC_PAGE; + +struct _U16_S { + u16 v; +}; + +typedef struct _U16_S U16_S; + +struct _U32_S { + u32 v; +}; + +typedef struct _U32_S U32_S; + +struct _U64_S { + u64 v; +}; + +typedef struct _U64_S U64_S; + +struct __arch_relative_insn { + u8 op; + s32 raddr; +} __attribute__((packed)); + +struct __fb_timings { + u32 dclk; + u32 hfreq; + u32 vfreq; + u32 hactive; + u32 vactive; + u32 hblank; + u32 vblank; + u32 htotal; + u32 vtotal; +}; + +struct __kernel_sockaddr_storage { + __kernel_sa_family_t ss_family; + char __data[126]; +}; + +struct __kfifo { + unsigned int in; + unsigned int out; + unsigned int mask; + unsigned int esize; + void *data; +}; + +struct __large_struct { + long unsigned int buf[100]; +}; + +struct __old_kernel_stat { + short unsigned int st_dev; + short unsigned int st_ino; + short unsigned int st_mode; + short unsigned int st_nlink; + short unsigned int st_uid; + short unsigned int st_gid; + short unsigned int st_rdev; + unsigned int st_size; + unsigned int st_atime; + unsigned int st_mtime; + unsigned int st_ctime; +}; + +struct __qrwlock { + union { + atomic_t cnts; + struct { + u8 wmode; + u8 rcnts[3]; + }; + }; + arch_spinlock_t lock; +}; + +struct __qspinlock { + union { + atomic_t val; + struct { + u8 locked; + u8 pending; + }; + struct { + u16 locked_pending; + u16 tail; + }; + }; +}; + +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; +}; + +struct __sysctl_args { + int *name; + int nlen; + void *oldval; + size_t *oldlenp; + void *newval; + size_t newlen; + long unsigned int __unused[4]; +}; + +struct __una_u32 { + u32 x; +}; + +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_tag { + unsigned int gp_offset; + unsigned int fp_offset; + void *overflow_arg_area; + void *reg_save_area; +}; + +typedef __builtin_va_list __gnuc_va_list; + +typedef __gnuc_va_list va_list; + +struct __wait_queue; + +typedef struct __wait_queue wait_queue_t; + +typedef int (*wait_queue_func_t)(wait_queue_t *, unsigned int, int, void *); + +struct __wait_queue { + unsigned int flags; + void *private; + wait_queue_func_t func; + struct list_head task_list; +}; + +struct __x86_intercept { + u32 exit_code; + enum x86_intercept_stage stage; +}; + +struct drm_mm; + +struct drm_mm_node { + struct list_head node_list; + struct list_head hole_stack; + unsigned int hole_follows: 1; + unsigned int scanned_block: 1; + unsigned int scanned_prev_free: 1; + unsigned int scanned_next_free: 1; + unsigned int scanned_preceeds_hole: 1; + unsigned int allocated: 1; + long unsigned int color; + u64 start; + u64 size; + struct drm_mm *mm; +}; + +struct _balloon_info_ { + struct drm_mm_node space[4]; +}; + +struct _cache_table { + unsigned char descriptor; + char cache_type; + short int size; +}; + +union _cpuid4_leaf_eax { + struct { + enum _cache_type type: 5; + unsigned int level: 3; + unsigned int is_self_initializing: 1; + unsigned int is_fully_associative: 1; + unsigned int reserved: 4; + unsigned int num_threads_sharing: 12; + unsigned int num_cores_on_die: 6; + } split; + u32 full; +}; + +union _cpuid4_leaf_ebx { + struct { + unsigned int coherency_line_size: 12; + unsigned int physical_line_partition: 10; + unsigned int ways_of_associativity: 10; + } split; + u32 full; +}; + +union _cpuid4_leaf_ecx { + struct { + unsigned int number_of_sets: 32; + } split; + u32 full; +}; + +struct amd_northbridge; + +struct _cpuid4_info_regs { + union _cpuid4_leaf_eax eax; + union _cpuid4_leaf_ebx ebx; + union _cpuid4_leaf_ecx ecx; + long unsigned int size; + struct amd_northbridge *nb; +}; + +struct _ddebug { + const char *modname; + const char *function; + const char *filename; + const char *format; + unsigned int lineno: 18; + unsigned int flags: 8; +}; + +struct _flow_keys_digest_data { + __be16 n_proto; + u8 ip_proto; + u8 padding; + __be32 ports; + __be32 src; + __be32 dst; +}; + +struct _fpreg { + __u16 significand[4]; + __u16 exponent; +}; + +struct _fpxreg { + __u16 significand[4]; + __u16 exponent; + __u16 padding[3]; +}; + +struct _xmmreg { + __u32 element[4]; +}; + +struct _fpx_sw_bytes { + __u32 magic1; + __u32 extended_size; + __u64 xfeatures; + __u32 xstate_size; + __u32 padding[7]; +}; + +struct _fpstate_32 { + __u32 cw; + __u32 sw; + __u32 tag; + __u32 ipoff; + __u32 cssel; + __u32 dataoff; + __u32 datasel; + struct _fpreg _st[8]; + __u16 status; + __u16 magic; + __u32 _fxsr_env[6]; + __u32 mxcsr; + __u32 reserved; + struct _fpxreg _fxsr_st[8]; + struct _xmmreg _xmm[8]; + union { + __u32 padding1[44]; + __u32 padding[44]; + }; + union { + __u32 padding2[12]; + struct _fpx_sw_bytes sw_reserved; + }; +}; + +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; + efi_char16_t 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 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 intel_gtt_driver; + +struct pci_dev; + +struct _intel_private { + const struct intel_gtt_driver *driver; + struct pci_dev *pcidev; + struct pci_dev *bridge_dev; + u8 *registers; + phys_addr_t gtt_phys_addr; + u32 PGETBL_save; + u32 *gtt; + bool clear_fake_agp; + int num_dcache_entries; + void *i9xx_flush_page; + char *i81x_gtt_table; + struct resource ifp_resource; + int resource_valid; + struct page *scratch_page; + phys_addr_t scratch_page_dma; + int refcount; + unsigned int needs_dmar: 1; + phys_addr_t gma_bus_addr; + unsigned int stolen_size; + unsigned int gtt_total_entries; + unsigned int gtt_mappable_entries; +}; + +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 _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 _old_mixer_info { + char id[16]; + char name[32]; +}; + +typedef struct _old_mixer_info _old_mixer_info; + +struct _sdvo_cmd_name { + u8 cmd; + const char *name; +}; + +struct _thermal_state { + bool new_event; + int event; + u64 next_check; + long unsigned int count; + long unsigned int last_count; +}; + +struct _tlb_table { + unsigned char descriptor; + char tlb_type; + unsigned int entries; + char info[128]; +}; + +struct crypto_ablkcipher; + +struct ablkcipher_request; + +struct skcipher_givcrypt_request; + +struct ablkcipher_alg { + int (*setkey)(struct crypto_ablkcipher *, const u8 *, unsigned int); + int (*encrypt)(struct ablkcipher_request *); + int (*decrypt)(struct ablkcipher_request *); + int (*givencrypt)(struct skcipher_givcrypt_request *); + int (*givdecrypt)(struct skcipher_givcrypt_request *); + const char *geniv; + unsigned int min_keysize; + unsigned int max_keysize; + unsigned int ivsize; +}; + +struct scatterlist; + +struct scatter_walk { + struct scatterlist *sg; + unsigned int offset; +}; + +struct ablkcipher_buffer { + struct list_head entry; + struct scatter_walk dst; + unsigned int len; + void *data; +}; + +struct crypto_async_request; + +typedef void (*crypto_completion_t)(struct crypto_async_request *, int); + +struct crypto_tfm; + +struct crypto_async_request { + struct list_head list; + crypto_completion_t complete; + void *data; + struct crypto_tfm *tfm; + u32 flags; +}; + +struct ablkcipher_request { + struct crypto_async_request base; + unsigned int nbytes; + void *info; + struct scatterlist *src; + struct scatterlist *dst; + void *__ctx[0]; +}; + +struct ablkcipher_tfm { + int (*setkey)(struct crypto_ablkcipher *, const u8 *, unsigned int); + int (*encrypt)(struct ablkcipher_request *); + int (*decrypt)(struct ablkcipher_request *); + int (*givencrypt)(struct skcipher_givcrypt_request *); + int (*givdecrypt)(struct skcipher_givcrypt_request *); + struct crypto_ablkcipher *base; + unsigned int ivsize; + unsigned int reqsize; +}; + +struct ablkcipher_walk { + struct { + struct page *page; + unsigned int offset; + } src; + struct { + struct page *page; + unsigned int offset; + } dst; + struct scatter_walk in; + unsigned int nbytes; + struct scatter_walk out; + unsigned int total; + struct list_head buffers; + u8 *iv_buffer; + u8 *iv; + int flags; + unsigned int blocksize; +}; + +struct snd_ac97; + +struct ac97_codec_id { + unsigned int id; + unsigned int mask; + const char *name; + int (*patch)(struct snd_ac97 *); + int (*mpatch)(struct snd_ac97 *); + unsigned int flags; +}; + +struct ac97_enum { + unsigned char reg; + unsigned char shift_l; + unsigned char shift_r; + short unsigned int mask; + const char * const *texts; +}; + +struct snd_ac97_bus; + +struct ac97_pcm { + struct snd_ac97_bus *bus; + unsigned int stream: 1; + unsigned int exclusive: 1; + unsigned int copy_flag: 1; + unsigned int spdif: 1; + short unsigned int aslots; + short unsigned int cur_dbl; + unsigned int rates; + struct { + short unsigned int slots; + short unsigned int rslots[4]; + unsigned char rate_table[4]; + struct snd_ac97 *codec[4]; + } r[2]; + long unsigned int private_value; +}; + +struct ac97_power_reg { + short unsigned int reg; + short unsigned int power_reg; + short unsigned int mask; +}; + +struct ac97_quirk { + short unsigned int subvendor; + short unsigned int subdevice; + short unsigned int mask; + unsigned int codec_id; + const char *name; + int type; +}; + +struct acct { + char ac_flag; + char ac_version; + __u16 ac_uid16; + __u16 ac_gid16; + __u16 ac_tty; + __u32 ac_btime; + comp_t ac_utime; + comp_t ac_stime; + comp_t ac_etime; + comp_t ac_mem; + comp_t ac_io; + comp_t ac_rw; + comp_t ac_minflt; + comp_t ac_majflt; + comp_t ac_swaps; + __u16 ac_ahz; + __u32 ac_exitcode; + char ac_comm[17]; + __u8 ac_etime_hi; + __u16 ac_etime_lo; + __u32 ac_uid; + __u32 ac_gid; +}; + +typedef struct acct acct_t; + +struct drm_dp_nak_reply { + u8 guid[16]; + u8 reason; + u8 nak_data; +}; + +struct drm_dp_link_addr_reply_port { + bool input_port; + u8 peer_device_type; + u8 port_number; + bool mcs; + bool ddps; + bool legacy_device_plug_status; + u8 dpcd_revision; + u8 peer_guid[16]; + u8 num_sdp_streams; + u8 num_sdp_stream_sinks; +}; + +struct drm_dp_link_address_ack_reply { + u8 guid[16]; + u8 nports; + struct drm_dp_link_addr_reply_port ports[16]; +}; + +struct drm_dp_port_number_rep { + u8 port_number; +}; + +struct drm_dp_enum_path_resources_ack_reply { + u8 port_number; + u16 full_payload_bw_number; + u16 avail_payload_bw_number; +}; + +struct drm_dp_allocate_payload_ack_reply { + u8 port_number; + u8 vcpi; + u16 allocated_pbn; +}; + +struct drm_dp_query_payload_ack_reply { + u8 port_number; + u8 allocated_pbn; +}; + +struct drm_dp_remote_dpcd_read_ack_reply { + u8 port_number; + u8 num_bytes; + u8 bytes[255]; +}; + +struct drm_dp_remote_dpcd_write_ack_reply { + u8 port_number; +}; + +struct drm_dp_remote_dpcd_write_nak_reply { + u8 port_number; + u8 reason; + u8 bytes_written_before_failure; +}; + +struct drm_dp_remote_i2c_read_ack_reply { + u8 port_number; + u8 num_bytes; + u8 bytes[255]; +}; + +struct drm_dp_remote_i2c_read_nak_reply { + u8 port_number; + u8 nak_reason; + u8 i2c_nak_transaction; +}; + +struct drm_dp_remote_i2c_write_ack_reply { + u8 port_number; +}; + +union ack_replies { + struct drm_dp_nak_reply nak; + struct drm_dp_link_address_ack_reply link_addr; + struct drm_dp_port_number_rep port_number; + struct drm_dp_enum_path_resources_ack_reply path_resources; + struct drm_dp_allocate_payload_ack_reply allocate_payload; + struct drm_dp_query_payload_ack_reply query_payload; + struct drm_dp_remote_dpcd_read_ack_reply remote_dpcd_read_ack; + struct drm_dp_remote_dpcd_write_ack_reply remote_dpcd_write_ack; + struct drm_dp_remote_dpcd_write_nak_reply remote_dpcd_write_nack; + struct drm_dp_remote_i2c_read_ack_reply remote_i2c_read_ack; + struct drm_dp_remote_i2c_read_nak_reply remote_i2c_read_nack; + struct drm_dp_remote_i2c_write_ack_reply remote_i2c_write_ack; +}; + +struct drm_dp_connection_status_notify { + u8 guid[16]; + u8 port_number; + bool legacy_device_plug_status; + bool displayport_device_plug_status; + bool message_capability_status; + bool input_port; + u8 peer_device_type; +}; + +struct drm_dp_port_number_req { + u8 port_number; +}; + +struct drm_dp_resource_status_notify { + u8 port_number; + u8 guid[16]; + u16 available_pbn; +}; + +struct drm_dp_query_payload { + u8 port_number; + u8 vcpi; +}; + +struct drm_dp_allocate_payload { + u8 port_number; + u8 number_sdp_streams; + u8 vcpi; + u16 pbn; + u8 sdp_stream_sink[16]; +}; + +struct drm_dp_remote_dpcd_read { + u8 port_number; + u32 dpcd_address; + u8 num_bytes; +}; + +struct drm_dp_remote_dpcd_write { + u8 port_number; + u32 dpcd_address; + u8 num_bytes; + u8 *bytes; +}; + +struct drm_dp_remote_i2c_read { + u8 num_transactions; + u8 port_number; + struct { + u8 i2c_dev_id; + u8 num_bytes; + u8 *bytes; + u8 no_stop_bit; + u8 i2c_transaction_delay; + } transactions[4]; + u8 read_i2c_device_id; + u8 num_bytes_read; +}; + +struct drm_dp_remote_i2c_write { + u8 port_number; + u8 write_i2c_device_id; + u8 num_bytes; + u8 *bytes; +}; + +union ack_req { + struct drm_dp_connection_status_notify conn_stat; + struct drm_dp_port_number_req port_num; + struct drm_dp_resource_status_notify resource_stat; + struct drm_dp_query_payload query_payload; + struct drm_dp_allocate_payload allocate_payload; + struct drm_dp_remote_dpcd_read dpcd_read; + struct drm_dp_remote_dpcd_write dpcd_write; + struct drm_dp_remote_i2c_read i2c_read; + struct drm_dp_remote_i2c_write i2c_write; +}; + +struct ack_sample { + u32 pkts_acked; + s32 rtt_us; +}; + +struct power_supply; + +union power_supply_propval; + +struct power_supply_desc { + const char *name; + enum power_supply_type type; + 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 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 acpi_device; + +struct acpi_ac { + struct power_supply *charger; + struct power_supply_desc charger_desc; + struct acpi_device *device; + long long unsigned int state; + struct notifier_block battery_nb; +}; + +struct acpi_address16_attribute { + u16 granularity; + u16 minimum; + u16 maximum; + u16 translation_offset; + u16 address_length; +}; + +struct acpi_address32_attribute { + u32 granularity; + u32 minimum; + u32 maximum; + u32 translation_offset; + u32 address_length; +}; + +struct acpi_address64_attribute { + u64 granularity; + u64 minimum; + u64 maximum; + u64 translation_offset; + u64 address_length; +}; + +struct acpi_namespace_node; + +struct acpi_address_range { + struct acpi_address_range *next; + struct acpi_namespace_node *region_node; + acpi_physical_address start_address; + acpi_physical_address end_address; +}; + +struct acpi_battery { + struct mutex___2 lock; + struct mutex___2 sysfs_lock; + struct power_supply *bat; + struct power_supply_desc bat_desc; + struct acpi_device *device; + struct notifier_block pm_nb; + long unsigned int update_time; + int revision; + int rate_now; + int capacity_now; + int voltage_now; + int design_capacity; + int full_charge_capacity; + int technology; + int design_voltage; + int design_capacity_warning; + int design_capacity_low; + int cycle_count; + int measurement_accuracy; + int max_sampling_time; + int min_sampling_time; + int max_averaging_interval; + int min_averaging_interval; + int capacity_granularity_1; + int capacity_granularity_2; + int alarm; + char model_number[32]; + char serial_number[32]; + char type[32]; + char oem_info[32]; + int state; + int power_unit; + long unsigned int flags; +}; + +struct acpi_bit_register_info { + u8 parent_register; + u8 bit_position; + u16 access_bit_mask; +}; + +struct acpi_blacklist_item { + char oem_id[7]; + char oem_table_id[9]; + u32 oem_revision; + char *table; + enum acpi_blacklist_predicates oem_revision_predicate; + char *reason; + u32 is_critical_error; +}; + +struct acpi_buffer { + acpi_size length; + void *pointer; +}; + +struct acpi_bus_event { + struct list_head node; + acpi_device_class device_class; + acpi_bus_id bus_id; + u32 type; + u32 data; +}; + +struct acpi_bus_type { + struct list_head list; + const char *name; + bool (*match)(struct device *); + struct acpi_device * (*find_companion)(struct device *); + void (*setup)(struct device *); + void (*cleanup)(struct device *); +}; + +struct input_dev; + +struct acpi_button { + unsigned int type; + struct input_dev *input; + char phys[32]; + long unsigned int pushed; + bool suspended; +}; + +struct acpi_common_descriptor { + void *common_pointer; + u8 descriptor_type; +}; + +struct acpi_common_state { + void *next; + u8 descriptor_type; + u8 flags; + u16 value; + u16 state; +}; + +struct acpi_connection_info { + u8 *connection; + u16 length; + u8 access_length; +}; + +union acpi_parse_object; + +struct acpi_control_state { + void *next; + u8 descriptor_type; + u8 flags; + u16 value; + u16 state; + u16 opcode; + union acpi_parse_object *predicate_op; + u8 *aml_predicate_start; + u8 *package_end; + u32 loop_count; +}; + +struct acpi_create_field_info { + struct acpi_namespace_node *region_node; + struct acpi_namespace_node *field_node; + struct acpi_namespace_node *register_node; + struct acpi_namespace_node *data_register_node; + struct acpi_namespace_node *connection_node; + u8 *resource_buffer; + u32 bank_value; + u32 field_bit_position; + u32 field_bit_length; + u16 resource_length; + u16 pin_number_index; + u8 field_flags; + u8 attribute; + u8 field_type; + u8 access_length; +}; + +struct acpi_csrt_group { + u32 length; + u32 vendor_id; + u32 subvendor_id; + u16 device_id; + u16 subdevice_id; + u16 revision; + u16 reserved; + u32 shared_info_length; +}; + +struct acpi_csrt_shared_info { + u16 major_version; + u16 minor_version; + u32 mmio_base_low; + u32 mmio_base_high; + u32 gsi_interrupt; + u8 interrupt_polarity; + u8 interrupt_mode; + u8 num_channels; + u8 dma_address_width; + u16 base_request_line; + u16 num_handshake_signals; + u32 max_block_size; +}; + +typedef void *acpi_handle; + +struct fwnode_handle { + enum fwnode_type type; + struct fwnode_handle *secondary; +}; + +union acpi_object; + +struct acpi_device_data { + const union acpi_object *pointer; + const union acpi_object *properties; + const union acpi_object *of_compatible; + struct list_head subnodes; +}; + +struct kset___2; + +struct kobj_type___2; + +struct kernfs_node___2; + +struct kobject___2 { + const char *name; + struct list_head entry; + struct kobject___2 *parent; + struct kset___2 *kset; + struct kobj_type___2 *ktype; + struct kernfs_node___2 *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 acpi_data_node { + const char *name; + acpi_handle handle; + struct fwnode_handle fwnode; + struct acpi_device_data data; + struct list_head sibling; + struct kobject___2 kobj; + struct completion kobj_done; +}; + +struct attribute { + const char *name; + umode_t mode; +}; + +struct acpi_data_node_attr { + struct attribute attr; + ssize_t (*show)(struct acpi_data_node *, char *); + ssize_t (*store)(struct acpi_data_node *, const char *, size_t); +}; + +struct acpi_dep_data { + struct list_head node; + acpi_handle master; + acpi_handle slave; +}; + +union acpi_operand_object; + +struct acpi_object_common { + union acpi_operand_object *next_object; + u8 descriptor_type; + u8 type; + u16 reference_count; + u8 flags; +}; + +struct acpi_object_integer { + union acpi_operand_object *next_object; + u8 descriptor_type; + u8 type; + u16 reference_count; + u8 flags; + u8 fill[3]; + u64 value; +}; + +struct acpi_object_string { + union acpi_operand_object *next_object; + u8 descriptor_type; + u8 type; + u16 reference_count; + u8 flags; + char *pointer; + u32 length; +}; + +struct acpi_object_buffer { + union acpi_operand_object *next_object; + u8 descriptor_type; + u8 type; + u16 reference_count; + u8 flags; + u8 *pointer; + u32 length; + u32 aml_length; + u8 *aml_start; + struct acpi_namespace_node *node; +}; + +struct acpi_object_package { + union acpi_operand_object *next_object; + u8 descriptor_type; + u8 type; + u16 reference_count; + u8 flags; + struct acpi_namespace_node *node; + union acpi_operand_object **elements; + u8 *aml_start; + u32 aml_length; + u32 count; +}; + +struct acpi_object_event { + union acpi_operand_object *next_object; + u8 descriptor_type; + u8 type; + u16 reference_count; + u8 flags; + void *os_semaphore; +}; + +struct acpi_walk_state; + +typedef acpi_status (*acpi_internal_method)(struct acpi_walk_state *); + +struct acpi_object_method { + union acpi_operand_object *next_object; + u8 descriptor_type; + u8 type; + u16 reference_count; + u8 flags; + u8 info_flags; + u8 param_count; + u8 sync_level; + union acpi_operand_object *mutex; + union acpi_operand_object *node; + u8 *aml_start; + union { + acpi_internal_method implementation; + union acpi_operand_object *handler; + } dispatch; + u32 aml_length; + u8 thread_count; + acpi_owner_id owner_id; +}; + +struct acpi_thread_state; + +struct acpi_object_mutex { + union acpi_operand_object *next_object; + u8 descriptor_type; + u8 type; + u16 reference_count; + u8 flags; + u8 sync_level; + u16 acquisition_depth; + void *os_mutex; + u64 thread_id; + struct acpi_thread_state *owner_thread; + union acpi_operand_object *prev; + union acpi_operand_object *next; + struct acpi_namespace_node *node; + u8 original_sync_level; +}; + +struct acpi_object_region { + union acpi_operand_object *next_object; + u8 descriptor_type; + u8 type; + u16 reference_count; + u8 flags; + u8 space_id; + struct acpi_namespace_node *node; + union acpi_operand_object *handler; + union acpi_operand_object *next; + acpi_physical_address address; + u32 length; +}; + +struct acpi_object_notify_common { + union acpi_operand_object *next_object; + u8 descriptor_type; + u8 type; + u16 reference_count; + u8 flags; + union acpi_operand_object *notify_list[2]; + union acpi_operand_object *handler; +}; + +struct acpi_gpe_block_info; + +struct acpi_object_device { + union acpi_operand_object *next_object; + u8 descriptor_type; + u8 type; + u16 reference_count; + u8 flags; + union acpi_operand_object *notify_list[2]; + union acpi_operand_object *handler; + struct acpi_gpe_block_info *gpe_block; +}; + +struct acpi_object_power_resource { + union acpi_operand_object *next_object; + u8 descriptor_type; + u8 type; + u16 reference_count; + u8 flags; + union acpi_operand_object *notify_list[2]; + union acpi_operand_object *handler; + u32 system_level; + u32 resource_order; +}; + +struct acpi_object_processor { + union acpi_operand_object *next_object; + u8 descriptor_type; + u8 type; + u16 reference_count; + u8 flags; + u8 proc_id; + u8 length; + union acpi_operand_object *notify_list[2]; + union acpi_operand_object *handler; + acpi_io_address address; +}; + +struct acpi_object_thermal_zone { + union acpi_operand_object *next_object; + u8 descriptor_type; + u8 type; + u16 reference_count; + u8 flags; + union acpi_operand_object *notify_list[2]; + union acpi_operand_object *handler; +}; + +struct acpi_object_field_common { + union acpi_operand_object *next_object; + u8 descriptor_type; + u8 type; + u16 reference_count; + u8 flags; + u8 field_flags; + u8 attribute; + u8 access_byte_width; + struct acpi_namespace_node *node; + u32 bit_length; + u32 base_byte_offset; + u32 value; + u8 start_field_bit_offset; + u8 access_length; + union acpi_operand_object *region_obj; +}; + +struct acpi_object_region_field { + union acpi_operand_object *next_object; + u8 descriptor_type; + u8 type; + u16 reference_count; + u8 flags; + u8 field_flags; + u8 attribute; + u8 access_byte_width; + struct acpi_namespace_node *node; + u32 bit_length; + u32 base_byte_offset; + u32 value; + u8 start_field_bit_offset; + u8 access_length; + u16 resource_length; + union acpi_operand_object *region_obj; + u8 *resource_buffer; + u16 pin_number_index; +}; + +struct acpi_object_buffer_field { + union acpi_operand_object *next_object; + u8 descriptor_type; + u8 type; + u16 reference_count; + u8 flags; + u8 field_flags; + u8 attribute; + u8 access_byte_width; + struct acpi_namespace_node *node; + u32 bit_length; + u32 base_byte_offset; + u32 value; + u8 start_field_bit_offset; + u8 access_length; + union acpi_operand_object *buffer_obj; +}; + +struct acpi_object_bank_field { + union acpi_operand_object *next_object; + u8 descriptor_type; + u8 type; + u16 reference_count; + u8 flags; + u8 field_flags; + u8 attribute; + u8 access_byte_width; + struct acpi_namespace_node *node; + u32 bit_length; + u32 base_byte_offset; + u32 value; + u8 start_field_bit_offset; + u8 access_length; + union acpi_operand_object *region_obj; + union acpi_operand_object *bank_obj; +}; + +struct acpi_object_index_field { + union acpi_operand_object *next_object; + u8 descriptor_type; + u8 type; + u16 reference_count; + u8 flags; + u8 field_flags; + u8 attribute; + u8 access_byte_width; + struct acpi_namespace_node *node; + u32 bit_length; + u32 base_byte_offset; + u32 value; + u8 start_field_bit_offset; + u8 access_length; + union acpi_operand_object *index_obj; + union acpi_operand_object *data_obj; +}; + +typedef void (*acpi_notify_handler)(acpi_handle, u32, void *); + +struct acpi_object_notify_handler { + union acpi_operand_object *next_object; + u8 descriptor_type; + u8 type; + u16 reference_count; + u8 flags; + struct acpi_namespace_node *node; + u32 handler_type; + acpi_notify_handler handler; + void *context; + union acpi_operand_object *next[2]; +}; + +typedef acpi_status (*acpi_adr_space_handler)(u32, acpi_physical_address, u32, u64 *, void *, void *); + +typedef acpi_status (*acpi_adr_space_setup)(acpi_handle, u32, void *, void **); + +struct acpi_object_addr_handler { + union acpi_operand_object *next_object; + u8 descriptor_type; + u8 type; + u16 reference_count; + u8 flags; + u8 space_id; + u8 handler_flags; + acpi_adr_space_handler handler; + struct acpi_namespace_node *node; + void *context; + acpi_adr_space_setup setup; + union acpi_operand_object *region_list; + union acpi_operand_object *next; +}; + +struct acpi_object_reference { + union acpi_operand_object *next_object; + u8 descriptor_type; + u8 type; + u16 reference_count; + u8 flags; + u8 class; + u8 target_type; + u8 reserved; + void *object; + struct acpi_namespace_node *node; + union acpi_operand_object **where; + u8 *index_pointer; + u32 value; +}; + +struct acpi_object_extra { + union acpi_operand_object *next_object; + u8 descriptor_type; + u8 type; + u16 reference_count; + u8 flags; + struct acpi_namespace_node *method_REG; + struct acpi_namespace_node *scope_node; + void *region_context; + u8 *aml_start; + u32 aml_length; +}; + +typedef void (*acpi_object_handler)(acpi_handle, void *); + +struct acpi_object_data { + union acpi_operand_object *next_object; + u8 descriptor_type; + u8 type; + u16 reference_count; + u8 flags; + acpi_object_handler handler; + void *pointer; +}; + +struct acpi_object_cache_list { + union acpi_operand_object *next_object; + u8 descriptor_type; + u8 type; + u16 reference_count; + u8 flags; + union acpi_operand_object *next; +}; + +union acpi_name_union { + u32 integer; + char ascii[4]; +}; + +struct acpi_namespace_node { + union acpi_operand_object *object; + u8 descriptor_type; + u8 type; + u8 flags; + acpi_owner_id owner_id; + union acpi_name_union name; + struct acpi_namespace_node *parent; + struct acpi_namespace_node *child; + struct acpi_namespace_node *peer; +}; + +union acpi_operand_object { + struct acpi_object_common common; + struct acpi_object_integer integer; + struct acpi_object_string string; + struct acpi_object_buffer buffer; + struct acpi_object_package package; + struct acpi_object_event event; + struct acpi_object_method method; + struct acpi_object_mutex mutex; + struct acpi_object_region region; + struct acpi_object_notify_common common_notify; + struct acpi_object_device device; + struct acpi_object_power_resource power_resource; + struct acpi_object_processor processor; + struct acpi_object_thermal_zone thermal_zone; + struct acpi_object_field_common common_field; + struct acpi_object_region_field field; + struct acpi_object_buffer_field buffer_field; + struct acpi_object_bank_field bank_field; + struct acpi_object_index_field index_field; + struct acpi_object_notify_handler notify; + struct acpi_object_addr_handler address_space; + struct acpi_object_reference reference; + struct acpi_object_extra extra; + struct acpi_object_data data; + struct acpi_object_cache_list cache; + struct acpi_namespace_node node; +}; + +union acpi_parse_value { + u64 integer; + u32 size; + char *string; + u8 *buffer; + char *name; + union acpi_parse_object *arg; +}; + +struct acpi_parse_obj_common { + union acpi_parse_object *parent; + u8 descriptor_type; + u8 flags; + u16 aml_opcode; + u8 *aml; + union acpi_parse_object *next; + struct acpi_namespace_node *node; + union acpi_parse_value value; + u8 arg_list_length; +}; + +struct acpi_parse_obj_named { + union acpi_parse_object *parent; + u8 descriptor_type; + u8 flags; + u16 aml_opcode; + u8 *aml; + union acpi_parse_object *next; + struct acpi_namespace_node *node; + union acpi_parse_value value; + u8 arg_list_length; + u8 *path; + u8 *data; + u32 length; + u32 name; +}; + +struct acpi_parse_obj_asl { + union acpi_parse_object *parent; + u8 descriptor_type; + u8 flags; + u16 aml_opcode; + u8 *aml; + union acpi_parse_object *next; + struct acpi_namespace_node *node; + union acpi_parse_value value; + u8 arg_list_length; + union acpi_parse_object *child; + union acpi_parse_object *parent_method; + char *filename; + char *external_name; + char *namepath; + char name_seg[4]; + u32 extra_value; + u32 column; + u32 line_number; + u32 logical_line_number; + u32 logical_byte_offset; + u32 end_line; + u32 end_logical_line; + u32 acpi_btype; + u32 aml_length; + u32 aml_subtree_length; + u32 final_aml_length; + u32 final_aml_offset; + u32 compile_flags; + u16 parse_opcode; + u8 aml_opcode_length; + u8 aml_pkg_len_bytes; + u8 extra; + char parse_op_name[20]; +}; + +union acpi_parse_object { + struct acpi_parse_obj_common common; + struct acpi_parse_obj_named named; + struct acpi_parse_obj_asl asl; +}; + +union acpi_descriptor { + struct acpi_common_descriptor common; + union acpi_operand_object object; + struct acpi_namespace_node node; + union acpi_parse_object op; +}; + +struct acpi_device_status { + u32 present: 1; + u32 enabled: 1; + u32 show_in_ui: 1; + u32 functional: 1; + u32 battery_present: 1; + u32 reserved: 27; +}; + +struct acpi_device_flags { + u32 dynamic_status: 1; + u32 removable: 1; + u32 ejectable: 1; + u32 power_manageable: 1; + u32 match_driver: 1; + u32 initialized: 1; + u32 visited: 1; + u32 hotplug_notify: 1; + u32 is_dock_station: 1; + u32 of_compatible_ok: 1; + u32 coherent_dma: 1; + u32 cca_seen: 1; + u32 reserved: 20; +}; + +struct acpi_pnp_type { + u32 hardware_id: 1; + u32 bus_address: 1; + u32 platform_id: 1; + u32 reserved: 29; +}; + +struct acpi_device_pnp { + acpi_bus_id bus_id; + struct acpi_pnp_type type; + acpi_bus_address bus_address; + char *unique_id; + struct list_head ids; + acpi_device_name device_name; + acpi_device_class device_class; + union acpi_object *str_obj; +}; + +struct acpi_device_power_flags { + u32 explicit_get: 1; + u32 power_resources: 1; + u32 inrush_current: 1; + u32 power_removed: 1; + u32 ignore_parent: 1; + u32 dsw_present: 1; + u32 reserved: 26; +}; + +struct acpi_device_power_state { + struct { + u8 valid: 1; + u8 explicit_set: 1; + u8 reserved: 6; + } flags; + int power; + int latency; + struct list_head resources; +}; + +struct acpi_device_power { + int state; + struct acpi_device_power_flags flags; + struct acpi_device_power_state states[5]; +}; + +struct acpi_device_wakeup_flags { + u8 valid: 1; + u8 run_wake: 1; + u8 notifier_present: 1; + u8 enabled: 1; +}; + +struct device___2; + +struct acpi_device_wakeup_context { + struct work_struct work; + struct device___2 *dev; +}; + +struct acpi_device_wakeup { + acpi_handle gpe_device; + u64 gpe_number; + u64 sleep_state; + struct list_head resources; + struct acpi_device_wakeup_flags flags; + struct acpi_device_wakeup_context context; + struct wakeup_source *ws; + int prepare_count; +}; + +struct acpi_device_perf_flags { + u8 reserved: 8; +}; + +struct acpi_device_perf_state; + +struct acpi_device_perf { + int state; + struct acpi_device_perf_flags flags; + int state_count; + struct acpi_device_perf_state *states; +}; + +struct proc_dir_entry; + +struct acpi_device_dir { + struct proc_dir_entry *entry; +}; + +struct dev_pm_info___2 { + pm_message_t power_state; + unsigned int can_wakeup: 1; + unsigned int async_suspend: 1; + bool is_prepared: 1; + bool is_suspended: 1; + bool is_noirq_suspended: 1; + bool is_late_suspended: 1; + bool early_init: 1; + bool direct_complete: 1; + spinlock_t lock; + struct list_head entry; + struct completion completion; + struct wakeup_source *wakeup; + bool wakeup_path: 1; + bool syscore: 1; + bool no_pm_callbacks: 1; + struct timer_list suspend_timer; + long unsigned int 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; + unsigned int idle_notification: 1; + unsigned int request_pending: 1; + unsigned int deferred_resume: 1; + unsigned int run_wake: 1; + unsigned int runtime_auto: 1; + bool ignore_children: 1; + unsigned int no_callbacks: 1; + unsigned int irq_safe: 1; + unsigned int use_autosuspend: 1; + unsigned int timer_autosuspends: 1; + unsigned int memalloc_noio: 1; + enum rpm_request request; + enum rpm_status runtime_status; + int runtime_error; + int autosuspend_delay; + long unsigned int last_busy; + long unsigned int active_jiffies; + long unsigned int suspended_jiffies; + long unsigned int accounting_timestamp; + struct pm_subsys_data *subsys_data; + void (*set_latency_tolerance)(struct device___2 *, s32); + struct dev_pm_qos *qos; +}; + +struct dma_map_ops___2; + +struct dev_archdata___2 { + struct dma_map_ops___2 *dma_ops; + void *iommu; +}; + +struct device_type___2; + +struct bus_type___2; + +struct device_driver___2; + +struct dev_pm_domain___2; + +struct device_node___2; + +struct class___2; + +struct attribute_group___2; + +struct device___2 { + struct device___2 *parent; + struct device_private *p; + struct kobject___2 kobj; + const char *init_name; + const struct device_type___2 *type; + struct mutex___2 mutex; + struct bus_type___2 *bus; + struct device_driver___2 *driver; + void *platform_data; + void *driver_data; + struct dev_pm_info___2 power; + struct dev_pm_domain___2 *pm_domain; + struct irq_domain *msi_domain; + struct list_head msi_list; + int numa_node; + u64 *dma_mask; + u64 coherent_dma_mask; + long unsigned int dma_pfn_offset; + struct device_dma_parameters *dma_parms; + struct list_head dma_pools; + struct dma_coherent_mem *dma_mem; + struct dev_archdata___2 archdata; + struct device_node___2 *of_node; + struct fwnode_handle *fwnode; + dev_t devt; + u32 id; + spinlock_t devres_lock; + struct list_head devres_head; + struct klist_node knode_class; + struct class___2 *class; + const struct attribute_group___2 **groups; + void (*release)(struct device___2 *); + struct iommu_group *iommu_group; + bool offline_disabled: 1; + bool offline: 1; +}; + +struct acpi_scan_handler; + +struct acpi_hotplug_context; + +struct acpi_driver; + +struct acpi_gpio_mapping; + +struct acpi_device { + int device_type; + acpi_handle handle; + struct fwnode_handle fwnode; + struct acpi_device *parent; + struct list_head children; + struct list_head node; + struct list_head wakeup_list; + struct list_head del_list; + struct acpi_device_status status; + struct acpi_device_flags flags; + struct acpi_device_pnp pnp; + struct acpi_device_power power; + struct acpi_device_wakeup wakeup; + struct acpi_device_perf performance; + struct acpi_device_dir dir; + struct acpi_device_data data; + struct acpi_scan_handler *handler; + struct acpi_hotplug_context *hp; + struct acpi_driver *driver; + const struct acpi_gpio_mapping *driver_gpios; + void *driver_data; + struct device___2 dev; + unsigned int physical_node_count; + unsigned int dep_unmet; + struct list_head physical_node_list; + struct mutex___2 physical_node_lock; + void (*remove)(struct acpi_device *); +}; + +struct acpi_device_bus_id { + char bus_id[15]; + unsigned int instance_no; + struct list_head node; +}; + +struct acpi_device_id { + __u8 id[9]; + kernel_ulong_t driver_data; + __u32 cls; + __u32 cls_msk; +}; + +struct acpi_pnp_device_id { + u32 length; + char *string; +}; + +struct acpi_pnp_device_id_list { + u32 count; + u32 list_size; + struct acpi_pnp_device_id ids[1]; +}; + +struct acpi_device_info { + u32 info_size; + u32 name; + acpi_object_type type; + u8 param_count; + u16 valid; + u8 flags; + u8 highest_dstates[4]; + u8 lowest_dstates[5]; + u32 current_status; + u64 address; + struct acpi_pnp_device_id hardware_id; + struct acpi_pnp_device_id unique_id; + struct acpi_pnp_device_id class_code; + struct acpi_pnp_device_id_list compatible_id_list; +}; + +typedef int (*acpi_op_add)(struct acpi_device *); + +typedef int (*acpi_op_remove)(struct acpi_device *); + +typedef void (*acpi_op_notify)(struct acpi_device *, u32); + +struct acpi_device_ops { + acpi_op_add add; + acpi_op_remove remove; + acpi_op_notify notify; +}; + +struct acpi_device_perf_state { + struct { + u8 valid: 1; + u8 reserved: 7; + } flags; + u8 power; + u8 performance; + int latency; +}; + +struct acpi_device_physical_node { + unsigned int node_id; + struct list_head node; + struct device *dev; + bool put_online: 1; +}; + +struct acpi_table_desc; + +struct acpi_evaluate_info; + +struct acpi_device_walk_info { + struct acpi_table_desc *table_desc; + struct acpi_evaluate_info *evaluate_info; + u32 device_count; + u32 num_STA; + u32 num_INI; +}; + +struct dma_chan; + +struct acpi_dma_spec; + +struct acpi_dma { + struct list_head dma_controllers; + struct device___2 *dev; + struct dma_chan * (*acpi_dma_xlate)(struct acpi_dma_spec *, struct acpi_dma *); + void *data; + short unsigned int base_request_line; + short unsigned int end_request_line; +}; + +typedef bool (*dma_filter_fn)(struct dma_chan *, void *); + +struct acpi_dma_filter_info { + dma_cap_mask_t dma_cap; + dma_filter_fn filter_fn; +}; + +struct acpi_dma_spec { + int chan_id; + int slave_id; + struct device___2 *dev; +}; + +struct acpi_dma_parser_data { + struct acpi_dma_spec dma_spec; + size_t index; + size_t n; +}; + +struct acpi_dmar_header { + u16 type; + u16 length; +}; + +struct acpi_dmar_andd { + struct acpi_dmar_header header; + u8 reserved[3]; + u8 device_number; + char device_name[1]; +} __attribute__((packed)); + +struct acpi_dmar_atsr { + struct acpi_dmar_header header; + u8 flags; + u8 reserved; + u16 segment; +}; + +struct acpi_dmar_device_scope { + u8 entry_type; + u8 length; + u16 reserved; + u8 enumeration_id; + u8 bus; +}; + +struct acpi_dmar_hardware_unit { + struct acpi_dmar_header header; + u8 flags; + u8 reserved; + u16 segment; + u64 address; +}; + +struct acpi_dmar_pci_path { + u8 device; + u8 function; +}; + +struct acpi_dmar_reserved_memory { + struct acpi_dmar_header header; + u16 reserved; + u16 segment; + u64 base_address; + u64 end_address; +}; + +struct acpi_dmar_rhsa { + struct acpi_dmar_header header; + u32 reserved; + u64 base_address; + u32 proximity_domain; +} __attribute__((packed)); + +struct of_device_id; + +struct dev_pm_ops; + +struct driver_private; + +struct device_driver___2 { + const char *name; + struct bus_type___2 *bus; + struct module___2 *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___2 *); + int (*remove)(struct device___2 *); + void (*shutdown)(struct device___2 *); + int (*suspend)(struct device___2 *, pm_message_t); + int (*resume)(struct device___2 *); + const struct attribute_group___2 **groups; + const struct dev_pm_ops *pm; + struct driver_private *p; +}; + +struct acpi_driver { + char name[80]; + char class[80]; + const struct acpi_device_id *ids; + unsigned int flags; + struct acpi_device_ops ops; + struct device_driver___2 drv; + struct module___2 *owner; +}; + +struct transaction; + +struct acpi_ec { + acpi_handle handle; + long unsigned int gpe; + long unsigned int command_addr; + long unsigned int data_addr; + bool global_lock; + long unsigned int flags; + long unsigned int reference_count; + struct mutex___2 mutex; + wait_queue_head_t wait; + struct list_head list; + struct transaction *curr; + spinlock_t lock; + struct work_struct work; + long unsigned int timestamp; + long unsigned int nr_pending_queries; +}; + +struct transaction { + const u8 *wdata; + u8 *rdata; + short unsigned int irq_count; + u8 command; + u8 wi; + u8 ri; + u8 wlen; + u8 rlen; + u8 flags; +}; + +struct acpi_ec_query_handler; + +struct acpi_ec_query { + struct transaction transaction; + struct work_struct work; + struct acpi_ec_query_handler *handler; +}; + +typedef int (*acpi_ec_query_func)(void *); + +struct acpi_ec_query_handler { + struct list_head node; + acpi_ec_query_func func; + acpi_handle handle; + void *data; + u8 query_bit; + struct kref kref; +}; + +union acpi_predefined_info; + +struct acpi_evaluate_info { + struct acpi_namespace_node *prefix_node; + const char *relative_pathname; + union acpi_operand_object **parameters; + struct acpi_namespace_node *node; + union acpi_operand_object *obj_desc; + char *full_pathname; + const union acpi_predefined_info *predefined; + union acpi_operand_object *return_object; + union acpi_operand_object *parent_package; + u32 return_flags; + u32 return_btype; + u16 param_count; + u8 pass_number; + u8 return_object_type; + u8 node_flags; + u8 flags; +}; + +struct acpi_exception_info { + char *name; +}; + +struct acpi_fadt_info { + const char *name; + u16 address64; + u16 address32; + u16 length; + u8 default_length; + u8 flags; +}; + +struct acpi_generic_address; + +struct acpi_fadt_pm_info { + struct acpi_generic_address *target; + u16 source; + u8 register_num; +}; + +struct acpi_fan_fif { + u64 revision; + u64 fine_grain_ctrl; + u64 step_size; + u64 low_speed_notification; +}; + +struct acpi_fan_fps; + +struct thermal_cooling_device; + +struct acpi_fan { + bool acpi4; + struct acpi_fan_fif fif; + struct acpi_fan_fps *fps; + int fps_count; + struct thermal_cooling_device *cdev; +}; + +struct acpi_fan_fps { + u64 control; + u64 trip_point; + u64 speed; + u64 noise_level; + u64 power; +}; + +typedef u32 (*acpi_event_handler)(void *); + +struct acpi_fixed_event_handler { + acpi_event_handler handler; + void *context; +}; + +struct acpi_fixed_event_info { + u8 status_register_id; + u8 enable_register_id; + u16 status_bit_mask; + u16 enable_bit_mask; +}; + +struct acpi_generic_address { + u8 space_id; + u8 bit_width; + u8 bit_offset; + u8 access_width; + u64 address; +} __attribute__((packed)); + +struct acpi_update_state { + void *next; + u8 descriptor_type; + u8 flags; + u16 value; + u16 state; + union acpi_operand_object *object; +}; + +struct acpi_scope_state { + void *next; + u8 descriptor_type; + u8 flags; + u16 value; + u16 state; + struct acpi_namespace_node *node; +}; + +struct acpi_pscope_state { + void *next; + u8 descriptor_type; + u8 flags; + u16 value; + u16 state; + u32 arg_count; + union acpi_parse_object *op; + u8 *arg_end; + u8 *pkg_end; + u32 arg_list; +}; + +struct acpi_pkg_state { + void *next; + u8 descriptor_type; + u8 flags; + u16 value; + u16 state; + u16 index; + union acpi_operand_object *source_object; + union acpi_operand_object *dest_object; + struct acpi_walk_state *walk_state; + void *this_target_obj; + u32 num_packages; +}; + +struct acpi_thread_state { + void *next; + u8 descriptor_type; + u8 flags; + u16 value; + u16 state; + u8 current_sync_level; + struct acpi_walk_state *walk_state_list; + union acpi_operand_object *acquired_mutex_list; + u64 thread_id; +}; + +struct acpi_result_values { + void *next; + u8 descriptor_type; + u8 flags; + u16 value; + u16 state; + union acpi_operand_object *obj_desc[8]; +}; + +struct acpi_global_notify_handler; + +struct acpi_notify_info { + void *next; + u8 descriptor_type; + u8 flags; + u16 value; + u16 state; + u8 handler_list_id; + struct acpi_namespace_node *node; + union acpi_operand_object *handler_list_head; + struct acpi_global_notify_handler *global; +}; + +union acpi_generic_state { + struct acpi_common_state common; + struct acpi_control_state control; + struct acpi_update_state update; + struct acpi_scope_state scope; + struct acpi_pscope_state parse_scope; + struct acpi_pkg_state pkg; + struct acpi_thread_state thread; + struct acpi_result_values results; + struct acpi_notify_info notify; +}; + +struct acpi_genl_event { + acpi_device_class device_class; + char bus_id[15]; + u32 type; + u32 data; +}; + +typedef acpi_status (*acpi_walk_callback)(acpi_handle, u32, void *, void **); + +struct acpi_get_devices_info { + acpi_walk_callback user_function; + void *context; + const char *hid; +}; + +struct acpi_global_notify_handler { + acpi_notify_handler handler; + void *context; +}; + +struct acpi_gpe_xrupt_info; + +struct acpi_gpe_register_info; + +struct acpi_gpe_event_info; + +struct acpi_gpe_block_info { + struct acpi_namespace_node *node; + struct acpi_gpe_block_info *previous; + struct acpi_gpe_block_info *next; + struct acpi_gpe_xrupt_info *xrupt_block; + struct acpi_gpe_register_info *register_info; + struct acpi_gpe_event_info *event_info; + u64 address; + u32 register_count; + u16 gpe_count; + u16 block_base_number; + u8 space_id; + u8 initialized; +}; + +struct acpi_gpe_device_info { + u32 index; + u32 next_block_base_index; + acpi_status status; + struct acpi_namespace_node *gpe_device; +}; + +struct acpi_gpe_handler_info; + +struct acpi_gpe_notify_info; + +union acpi_gpe_dispatch_info { + struct acpi_namespace_node *method_node; + struct acpi_gpe_handler_info *handler; + struct acpi_gpe_notify_info *notify_list; +}; + +struct acpi_gpe_event_info { + union acpi_gpe_dispatch_info dispatch; + struct acpi_gpe_register_info *register_info; + u8 flags; + u8 gpe_number; + u8 runtime_count; +}; + +typedef u32 (*acpi_gpe_handler)(acpi_handle, u32, void *); + +struct acpi_gpe_handler_info { + acpi_gpe_handler address; + void *context; + struct acpi_namespace_node *method_node; + u8 original_flags; + u8 originally_enabled; +}; + +struct acpi_gpe_notify_info { + struct acpi_namespace_node *device_node; + struct acpi_gpe_notify_info *next; +}; + +struct acpi_gpe_register_info { + struct acpi_generic_address status_address; + struct acpi_generic_address enable_address; + u16 base_gpe_number; + u8 enable_for_wake; + u8 enable_for_run; + u8 enable_mask; +}; + +struct acpi_gpe_walk_info { + struct acpi_namespace_node *gpe_device; + struct acpi_gpe_block_info *gpe_block; + u16 count; + acpi_owner_id owner_id; + u8 execute_by_owner_id; +}; + +struct acpi_gpe_xrupt_info { + struct acpi_gpe_xrupt_info *previous; + struct acpi_gpe_xrupt_info *next; + struct acpi_gpe_block_info *gpe_block_list_head; + u32 interrupt_number; +}; + +struct acpi_gpio_params; + +struct acpi_gpio_mapping { + const char *name; + const struct acpi_gpio_params *data; + unsigned int size; +}; + +struct acpi_gpio_params { + unsigned int crs_entry_index; + unsigned int line_index; + bool active_low; +}; + +struct acpi_handle_list { + u32 count; + acpi_handle handles[10]; +}; + +struct acpi_handle_node { + struct list_head node; + acpi_handle handle; +}; + +struct acpi_hardware_id { + struct list_head list; + const char *id; +}; + +struct acpi_hotplug_context { + struct acpi_device *self; + int (*notify)(struct acpi_device *, u32); + void (*uevent)(struct acpi_device *, u32); + void (*fixup)(struct acpi_device *); +}; + +struct acpi_hotplug_profile { + struct kobject___2 kobj; + int (*scan_dependent)(struct acpi_device *); + void (*notify_online)(struct acpi_device *); + bool enabled: 1; + bool demand_offline: 1; +}; + +struct acpi_hp_work { + struct work_struct work; + struct acpi_device *adev; + u32 src; +}; + +struct i2c_adapter; + +struct acpi_i2c_handler_data { + struct acpi_connection_info info; + struct i2c_adapter *adapter; +}; + +struct i2c_board_info; + +struct acpi_i2c_lookup { + struct i2c_board_info *info; + acpi_handle adapter_handle; + acpi_handle device_handle; +}; + +struct acpi_init_walk_info { + u32 table_index; + u32 object_count; + u32 method_count; + u32 serial_method_count; + u32 non_serial_method_count; + u32 serialized_method_count; + u32 device_count; + u32 op_region_count; + u32 field_count; + u32 buffer_count; + u32 package_count; + u32 op_region_init; + u32 field_init; + u32 buffer_init; + u32 package_init; + acpi_owner_id owner_id; +}; + +struct acpi_interface_info { + char *name; + struct acpi_interface_info *next; + u8 flags; + u8 value; +}; + +struct acpi_io_attribute { + u8 range_type; + u8 translation; + u8 translation_type; + u8 reserved1; +}; + +struct acpi_ioremap { + struct list_head list; + void *virt; + acpi_physical_address phys; + acpi_size size; + long unsigned int refcount; +}; + +struct acpi_lpat { + int temp; + int raw; +}; + +struct acpi_lpat_conversion_table { + struct acpi_lpat *lpat; + int lpat_count; +}; + +struct acpi_subtable_header { + u8 type; + u8 length; +}; + +struct acpi_madt_generic_distributor { + struct acpi_subtable_header header; + u16 reserved; + u32 gic_id; + u64 base_address; + u32 global_irq_base; + u8 version; + u8 reserved2[3]; +}; + +struct acpi_madt_generic_interrupt { + struct acpi_subtable_header header; + u16 reserved; + u32 cpu_interface_number; + u32 uid; + u32 flags; + u32 parking_version; + u32 performance_interrupt; + u64 parked_address; + u64 base_address; + u64 gicv_base_address; + u64 gich_base_address; + u32 vgic_interrupt; + u64 gicr_base_address; + u64 arm_mpidr; + u8 efficiency_class; + u8 reserved2[3]; +} __attribute__((packed)); + +struct acpi_madt_interrupt_override { + struct acpi_subtable_header header; + u8 bus; + u8 source_irq; + u32 global_irq; + u16 inti_flags; +} __attribute__((packed)); + +struct acpi_madt_interrupt_source { + struct acpi_subtable_header header; + u16 inti_flags; + u8 type; + u8 id; + u8 eid; + u8 io_sapic_vector; + u32 global_irq; + u32 flags; +}; + +struct acpi_madt_io_apic { + struct acpi_subtable_header header; + u8 id; + u8 reserved; + u32 address; + u32 global_irq_base; +}; + +struct acpi_madt_io_sapic { + struct acpi_subtable_header header; + u8 id; + u8 reserved; + u32 global_irq_base; + u64 address; +}; + +struct acpi_madt_local_apic { + struct acpi_subtable_header header; + u8 processor_id; + u8 id; + u32 lapic_flags; +}; + +struct acpi_madt_local_apic_nmi { + struct acpi_subtable_header header; + u8 processor_id; + u16 inti_flags; + u8 lint; +} __attribute__((packed)); + +struct acpi_madt_local_apic_override { + struct acpi_subtable_header header; + u16 reserved; + u64 address; +} __attribute__((packed)); + +struct acpi_madt_local_sapic { + struct acpi_subtable_header header; + u8 processor_id; + u8 id; + u8 eid; + u8 reserved[3]; + u32 lapic_flags; + u32 uid; + char uid_string[1]; +} __attribute__((packed)); + +struct acpi_madt_local_x2apic { + struct acpi_subtable_header header; + u16 reserved; + u32 local_apic_id; + u32 lapic_flags; + u32 uid; +}; + +struct acpi_madt_local_x2apic_nmi { + struct acpi_subtable_header header; + u16 inti_flags; + u32 uid; + u8 lint; + u8 reserved[3]; +}; + +struct acpi_madt_nmi_source { + struct acpi_subtable_header header; + u16 inti_flags; + u32 global_irq; +}; + +struct acpi_mcfg_allocation { + u64 address; + u16 pci_segment; + u8 start_bus_number; + u8 end_bus_number; + u32 reserved; +}; + +struct acpi_mem_space_context { + u32 length; + acpi_physical_address address; + acpi_physical_address mapped_physical_address; + u8 *mapped_logical_address; + acpi_size mapped_length; +}; + +struct acpi_memory_attribute { + u8 write_protect; + u8 caching; + u8 range_type; + u8 translation; +}; + +struct acpi_mutex_info { + void *mutex; + u32 use_count; + u64 thread_id; +}; + +struct acpi_name_info { + char name[4]; + u16 argument_list; + u8 expected_btypes; +} __attribute__((packed)); + +struct acpi_namestring_info { + const char *external_name; + const char *next_external_char; + char *internal_name; + u32 length; + u32 num_segments; + u32 num_carats; + u8 fully_qualified; +}; + +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_object_list { + u32 count; + union acpi_object *pointer; +}; + +struct acpi_offsets { + size_t offset; + u8 mode; +}; + +struct acpi_opcode_info { + u32 parse_args; + u32 runtime_args; + u16 flags; + u8 object_type; + u8 class; + u8 type; +}; + +typedef void (*acpi_osd_exec_callback)(void *); + +struct acpi_os_dpc { + acpi_osd_exec_callback function; + void *context; + struct work_struct work; +}; + +struct acpi_osc_context { + char *uuid_str; + int rev; + struct acpi_buffer cap; + struct acpi_buffer ret; +}; + +struct acpi_osi_config { + u8 default_disabling; + unsigned int linux_enable: 1; + unsigned int linux_dmi: 1; + unsigned int linux_cmdline: 1; + unsigned int darwin_enable: 1; + unsigned int darwin_dmi: 1; + unsigned int darwin_cmdline: 1; +}; + +struct acpi_osi_entry { + char string[64]; + bool enable; +}; + +struct acpi_package_info { + u8 type; + u8 object_type1; + u8 count1; + u8 object_type2; + u8 count2; + u16 reserved; +} __attribute__((packed)); + +struct acpi_package_info2 { + u8 type; + u8 count; + u8 object_type[4]; + u8 reserved; +}; + +struct acpi_package_info3 { + u8 type; + u8 count; + u8 object_type[2]; + u8 tail_object_type; + u16 reserved; +} __attribute__((packed)); + +struct acpi_package_info4 { + u8 type; + u8 object_type1; + u8 count1; + u8 sub_object_types; + u8 pkg_count; + u16 reserved; +} __attribute__((packed)); + +struct acpi_parse_state { + u8 *aml_start; + u8 *aml; + u8 *aml_end; + u8 *pkg_start; + u8 *pkg_end; + union acpi_parse_object *start_op; + struct acpi_namespace_node *start_node; + union acpi_generic_state *scope; + union acpi_parse_object *start_scope; + u32 aml_size; +}; + +struct acpi_pci_device { + acpi_handle device; + struct acpi_pci_device *next; +}; + +struct acpi_pci_id { + u16 segment; + u16 bus; + u16 device; + u16 function; +}; + +struct acpi_pci_ioapic { + acpi_handle root_handle; + acpi_handle handle; + u32 gsi_base; + struct resource res; + struct pci_dev *pdev; + struct list_head list; +}; + +struct acpi_pci_link_irq { + u32 active; + u8 triggering; + u8 polarity; + u8 resource_type; + u8 possible_count; + u32 possible[16]; + u8 initialized: 1; + u8 reserved: 7; +}; + +struct acpi_pci_link { + struct list_head list; + struct acpi_device *device; + struct acpi_pci_link_irq irq; + int refcnt; +}; + +struct pci_bus; + +struct acpi_pci_root { + struct acpi_device *device; + struct pci_bus *bus; + u16 segment; + struct resource secondary; + u32 osc_support_set; + u32 osc_control_set; + phys_addr_t mcfg_addr; +}; + +struct acpi_pci_root_ops; + +struct acpi_pci_root_info { + struct acpi_pci_root *root; + struct acpi_device *bridge; + struct acpi_pci_root_ops *ops; + struct list_head resources; + char name[16]; +}; + +struct pci_ops; + +struct acpi_pci_root_ops { + struct pci_ops *pci_ops; + int (*init_info)(struct acpi_pci_root_info *); + void (*release_info)(struct acpi_pci_root_info *); + int (*prepare_resources)(struct acpi_pci_root_info *); +}; + +struct acpi_pci_routing_table { + u32 length; + u32 pin; + u64 address; + u32 source_index; + char source[4]; +}; + +struct acpi_pct_register { + u8 descriptor; + u16 length; + u8 space_id; + u8 bit_width; + u8 bit_offset; + u8 reserved; + u64 address; +} __attribute__((packed)); + +struct acpi_pkg_info { + u8 *free_space; + acpi_size length; + u32 object_space; + u32 num_packages; +}; + +struct acpi_pld_info { + u8 revision; + u8 ignore_color; + u8 red; + u8 green; + u8 blue; + u16 width; + u16 height; + u8 user_visible; + u8 dock; + u8 lid; + u8 panel; + u8 vertical_position; + u8 horizontal_position; + u8 shape; + u8 group_orientation; + u8 group_token; + u8 group_position; + u8 bay; + u8 ejectable; + u8 ospm_eject_required; + u8 cabinet_number; + u8 card_cage_number; + u8 reference; + u8 rotation; + u8 order; + u8 reserved; + u16 vertical_offset; + u16 horizontal_offset; +}; + +struct acpi_port_info { + char *name; + u16 start; + u16 end; + u8 osi_dependency; +}; + +struct acpi_power_register { + u8 descriptor; + u16 length; + u8 space_id; + u8 bit_width; + u8 bit_offset; + u8 access_size; + u64 address; +} __attribute__((packed)); + +struct acpi_power_resource { + struct acpi_device device; + struct list_head list_node; + char *name; + u32 system_level; + u32 order; + unsigned int ref_count; + bool wakeup_enabled; + struct mutex___2 resource_lock; +}; + +struct acpi_power_resource_entry { + struct list_head node; + struct acpi_power_resource *resource; +}; + +union acpi_predefined_info { + struct acpi_name_info info; + struct acpi_package_info ret_info; + struct acpi_package_info2 ret_info2; + struct acpi_package_info3 ret_info3; + struct acpi_package_info4 ret_info4; +}; + +struct acpi_predefined_names { + const char *name; + u8 type; + char *val; +}; + +struct acpi_probe_entry; + +typedef bool (*acpi_probe_entry_validate_subtbl)(struct acpi_subtable_header *, struct acpi_probe_entry *); + +struct acpi_table_header; + +typedef int (*acpi_tbl_table_handler)(struct acpi_table_header *); + +typedef int (*acpi_tbl_entry_handler)(struct acpi_subtable_header *, const long unsigned int); + +struct acpi_probe_entry { + __u8 id[5]; + __u8 type; + acpi_probe_entry_validate_subtbl subtable_valid; + union { + acpi_tbl_table_handler probe_table; + acpi_tbl_entry_handler probe_subtbl; + }; + kernel_ulong_t driver_data; +}; + +struct acpi_processor_flags { + u8 power: 1; + u8 performance: 1; + u8 throttling: 1; + u8 limit: 1; + u8 bm_control: 1; + u8 bm_check: 1; + u8 has_cst: 1; + u8 power_setup_done: 1; + u8 bm_rld_set: 1; + u8 need_hotplug_init: 1; +}; + +struct acpi_processor_cx { + u8 valid; + u8 type; + u32 address; + u8 entry_method; + u8 index; + u32 latency; + u8 bm_sts_skip; + char desc[32]; +}; + +struct acpi_processor_power { + int count; + struct acpi_processor_cx states[8]; + int timer_broadcast_on_state; +}; + +struct acpi_tsd_package { + u64 num_entries; + u64 revision; + u64 domain; + u64 coord_type; + u64 num_processors; +}; + +struct cpumask { + long unsigned int bits[1]; +}; + +typedef struct cpumask cpumask_var_t[1]; + +struct acpi_processor_tx { + u16 power; + u16 performance; +}; + +struct acpi_processor_tx_tss; + +struct acpi_processor; + +struct acpi_processor_throttling { + unsigned int state; + unsigned int platform_limit; + struct acpi_pct_register control_register; + struct acpi_pct_register status_register; + unsigned int state_count; + struct acpi_processor_tx_tss *states_tss; + struct acpi_tsd_package domain_info; + cpumask_var_t shared_cpu_map; + int (*acpi_processor_get_throttling)(struct acpi_processor *); + int (*acpi_processor_set_throttling)(struct acpi_processor *, int, bool); + u32 address; + u8 duty_offset; + u8 duty_width; + u8 tsd_valid_flag; + unsigned int shared_type; + struct acpi_processor_tx states[16]; +}; + +struct acpi_processor_lx { + int px; + int tx; +}; + +struct acpi_processor_limit { + struct acpi_processor_lx state; + struct acpi_processor_lx thermal; + struct acpi_processor_lx user; +}; + +struct acpi_processor_performance; + +struct acpi_processor { + acpi_handle handle; + u32 acpi_id; + phys_cpuid_t phys_id; + u32 id; + u32 pblk; + int performance_platform_limit; + int throttling_platform_limit; + struct acpi_processor_flags flags; + struct acpi_processor_power power; + struct acpi_processor_performance *performance; + struct acpi_processor_throttling throttling; + struct acpi_processor_limit limit; + struct thermal_cooling_device *cdev; + struct device *dev; +}; + +struct acpi_processor_errata { + u8 smp; + struct { + u8 throttle: 1; + u8 fdma: 1; + u8 reserved: 6; + u32 bmisx; + } piix4; +}; + +struct acpi_psd_package { + u64 num_entries; + u64 revision; + u64 domain; + u64 coord_type; + u64 num_processors; +}; + +struct acpi_processor_px; + +struct acpi_processor_performance { + unsigned int state; + unsigned int platform_limit; + struct acpi_pct_register control_register; + struct acpi_pct_register status_register; + unsigned int state_count; + struct acpi_processor_px *states; + struct acpi_psd_package domain_info; + cpumask_var_t shared_cpu_map; + unsigned int shared_type; +}; + +struct acpi_processor_px { + u64 core_frequency; + u64 power; + u64 transition_latency; + u64 bus_master_latency; + u64 control; + u64 status; +}; + +struct acpi_processor_throttling_arg { + struct acpi_processor *pr; + int target_state; + bool force; +}; + +struct acpi_processor_tx_tss { + u64 freqpercentage; + u64 power; + u64 transition_latency; + u64 control; + u64 status; +}; + +struct acpi_prt_entry { + struct acpi_pci_id id; + u8 pin; + acpi_handle link; + u32 index; +}; + +struct acpi_reference_args { + struct acpi_device *adev; + size_t nargs; + u64 args[8]; +}; + +struct acpi_reg_walk_info { + acpi_adr_space_type space_id; + u32 function; + u32 reg_run_count; +}; + +typedef acpi_status (*acpi_repair_function)(struct acpi_evaluate_info *, union acpi_operand_object **); + +struct acpi_repair_info { + char name[4]; + acpi_repair_function repair_function; +}; + +struct acpi_resource_irq { + u8 descriptor_length; + u8 triggering; + u8 polarity; + u8 sharable; + u8 wake_capable; + u8 interrupt_count; + u8 interrupts[1]; +}; + +struct acpi_resource_dma { + u8 type; + u8 bus_master; + u8 transfer; + u8 channel_count; + u8 channels[1]; +}; + +struct acpi_resource_start_dependent { + u8 descriptor_length; + u8 compatibility_priority; + u8 performance_robustness; +}; + +struct acpi_resource_io { + u8 io_decode; + u8 alignment; + u8 address_length; + u16 minimum; + u16 maximum; +} __attribute__((packed)); + +struct acpi_resource_fixed_io { + u16 address; + u8 address_length; +} __attribute__((packed)); + +struct acpi_resource_fixed_dma { + u16 request_lines; + u16 channels; + u8 width; +} __attribute__((packed)); + +struct acpi_resource_vendor { + u16 byte_length; + u8 byte_data[1]; +} __attribute__((packed)); + +struct acpi_resource_vendor_typed { + u16 byte_length; + u8 uuid_subtype; + u8 uuid[16]; + u8 byte_data[1]; +}; + +struct acpi_resource_end_tag { + u8 checksum; +}; + +struct acpi_resource_memory24 { + u8 write_protect; + u16 minimum; + u16 maximum; + u16 alignment; + u16 address_length; +} __attribute__((packed)); + +struct acpi_resource_memory32 { + u8 write_protect; + u32 minimum; + u32 maximum; + u32 alignment; + u32 address_length; +} __attribute__((packed)); + +struct acpi_resource_fixed_memory32 { + u8 write_protect; + u32 address; + u32 address_length; +} __attribute__((packed)); + +union acpi_resource_attribute { + struct acpi_memory_attribute mem; + struct acpi_io_attribute io; + u8 type_specific; +}; + +struct acpi_resource_source { + u8 index; + u16 string_length; + char *string_ptr; +} __attribute__((packed)); + +struct acpi_resource_address16 { + u8 resource_type; + u8 producer_consumer; + u8 decode; + u8 min_address_fixed; + u8 max_address_fixed; + union acpi_resource_attribute info; + struct acpi_address16_attribute address; + struct acpi_resource_source resource_source; +} __attribute__((packed)); + +struct acpi_resource_address32 { + u8 resource_type; + u8 producer_consumer; + u8 decode; + u8 min_address_fixed; + u8 max_address_fixed; + union acpi_resource_attribute info; + struct acpi_address32_attribute address; + struct acpi_resource_source resource_source; +} __attribute__((packed)); + +struct acpi_resource_address64 { + u8 resource_type; + u8 producer_consumer; + u8 decode; + u8 min_address_fixed; + u8 max_address_fixed; + union acpi_resource_attribute info; + struct acpi_address64_attribute address; + struct acpi_resource_source resource_source; +} __attribute__((packed)); + +struct acpi_resource_extended_address64 { + u8 resource_type; + u8 producer_consumer; + u8 decode; + u8 min_address_fixed; + u8 max_address_fixed; + union acpi_resource_attribute info; + u8 revision_ID; + struct acpi_address64_attribute address; + u64 type_specific; +} __attribute__((packed)); + +struct acpi_resource_extended_irq { + u8 producer_consumer; + u8 triggering; + u8 polarity; + u8 sharable; + u8 wake_capable; + u8 interrupt_count; + struct acpi_resource_source resource_source; + u32 interrupts[1]; +} __attribute__((packed)); + +struct acpi_resource_generic_register { + u8 space_id; + u8 bit_width; + u8 bit_offset; + u8 access_size; + u64 address; +} __attribute__((packed)); + +struct acpi_resource_gpio { + u8 revision_id; + u8 connection_type; + u8 producer_consumer; + u8 pin_config; + u8 sharable; + u8 wake_capable; + u8 io_restriction; + u8 triggering; + u8 polarity; + u16 drive_strength; + u16 debounce_timeout; + u16 pin_table_length; + u16 vendor_length; + struct acpi_resource_source resource_source; + u16 *pin_table; + u8 *vendor_data; +} __attribute__((packed)); + +struct acpi_resource_i2c_serialbus { + u8 revision_id; + u8 type; + u8 producer_consumer; + u8 slave_mode; + u8 connection_sharing; + u8 type_revision_id; + u16 type_data_length; + u16 vendor_length; + struct acpi_resource_source resource_source; + u8 *vendor_data; + u8 access_mode; + u16 slave_address; + u32 connection_speed; +} __attribute__((packed)); + +struct acpi_resource_spi_serialbus { + u8 revision_id; + u8 type; + u8 producer_consumer; + u8 slave_mode; + u8 connection_sharing; + u8 type_revision_id; + u16 type_data_length; + u16 vendor_length; + struct acpi_resource_source resource_source; + u8 *vendor_data; + u8 wire_mode; + u8 device_polarity; + u8 data_bit_length; + u8 clock_phase; + u8 clock_polarity; + u16 device_selection; + u32 connection_speed; +} __attribute__((packed)); + +struct acpi_resource_uart_serialbus { + u8 revision_id; + u8 type; + u8 producer_consumer; + u8 slave_mode; + u8 connection_sharing; + u8 type_revision_id; + u16 type_data_length; + u16 vendor_length; + struct acpi_resource_source resource_source; + u8 *vendor_data; + u8 endian; + u8 data_bits; + u8 stop_bits; + u8 flow_control; + u8 parity; + u8 lines_enabled; + u16 rx_fifo_size; + u16 tx_fifo_size; + u32 default_baud_rate; +} __attribute__((packed)); + +struct acpi_resource_common_serialbus { + u8 revision_id; + u8 type; + u8 producer_consumer; + u8 slave_mode; + u8 connection_sharing; + u8 type_revision_id; + u16 type_data_length; + u16 vendor_length; + struct acpi_resource_source resource_source; + u8 *vendor_data; +} __attribute__((packed)); + +struct acpi_resource_address { + u8 resource_type; + u8 producer_consumer; + u8 decode; + u8 min_address_fixed; + u8 max_address_fixed; + union acpi_resource_attribute info; +}; + +union acpi_resource_data { + struct acpi_resource_irq irq; + struct acpi_resource_dma dma; + struct acpi_resource_start_dependent start_dpf; + struct acpi_resource_io io; + struct acpi_resource_fixed_io fixed_io; + struct acpi_resource_fixed_dma fixed_dma; + struct acpi_resource_vendor vendor; + struct acpi_resource_vendor_typed vendor_typed; + struct acpi_resource_end_tag end_tag; + struct acpi_resource_memory24 memory24; + struct acpi_resource_memory32 memory32; + struct acpi_resource_fixed_memory32 fixed_memory32; + struct acpi_resource_address16 address16; + struct acpi_resource_address32 address32; + struct acpi_resource_address64 address64; + struct acpi_resource_extended_address64 ext_address64; + struct acpi_resource_extended_irq extended_irq; + struct acpi_resource_generic_register generic_reg; + struct acpi_resource_gpio gpio; + struct acpi_resource_i2c_serialbus i2c_serial_bus; + struct acpi_resource_spi_serialbus spi_serial_bus; + struct acpi_resource_uart_serialbus uart_serial_bus; + struct acpi_resource_common_serialbus common_serial_bus; + struct acpi_resource_address address; +}; + +struct acpi_resource { + u32 type; + u32 length; + union acpi_resource_data data; +}; + +struct acpi_rsconvert_info { + u8 opcode; + u8 resource_offset; + u8 aml_offset; + u8 value; +}; + +struct acpi_rw_lock { + void *writer_mutex; + void *reader_mutex; + u32 num_readers; +}; + +struct acpi_scan_handler { + const struct acpi_device_id *ids; + struct list_head list_node; + bool (*match)(const char *, const struct acpi_device_id **); + int (*attach)(struct acpi_device *, const struct acpi_device_id *); + void (*detach)(struct acpi_device *); + void (*bind)(struct device___2 *); + void (*unbind)(struct device___2 *); + struct acpi_hotplug_profile hotplug; +}; + +typedef u32 (*acpi_sci_handler)(void *); + +struct acpi_sci_handler_info { + struct acpi_sci_handler_info *next; + acpi_sci_handler address; + void *context; +}; + +struct acpi_signal_fatal_info { + u32 type; + u32 code; + u32 argument; +}; + +typedef acpi_status (*acpi_object_converter)(struct acpi_namespace_node *, union acpi_operand_object *, union acpi_operand_object **); + +struct acpi_simple_repair_info { + char name[4]; + u32 unexpected_btypes; + u32 package_index; + acpi_object_converter object_converter; +}; + +typedef acpi_status (*acpi_sleep_function)(u8); + +struct acpi_sleep_functions { + acpi_sleep_function legacy_function; + acpi_sleep_function extended_function; +}; + +struct acpi_srat_cpu_affinity { + struct acpi_subtable_header header; + u8 proximity_domain_lo; + u8 apic_id; + u32 flags; + u8 local_sapic_eid; + u8 proximity_domain_hi[3]; + u32 clock_domain; +}; + +struct acpi_srat_mem_affinity { + struct acpi_subtable_header header; + u32 proximity_domain; + u16 reserved; + u64 base_address; + u64 length; + u32 reserved1; + u32 flags; + u64 reserved2; +} __attribute__((packed)); + +struct acpi_srat_x2apic_cpu_affinity { + struct acpi_subtable_header header; + u16 reserved; + u32 proximity_domain; + u32 apic_id; + u32 flags; + u32 clock_domain; + u32 reserved2; +}; + +struct acpi_subtable_proc { + int id; + acpi_tbl_entry_handler handler; + int count; +}; + +struct file; + +struct vm_area_struct; + +struct bin_attribute { + struct attribute attr; + size_t size; + void *private; + ssize_t (*read)(struct file *, struct kobject___2 *, struct bin_attribute *, char *, loff_t, size_t); + ssize_t (*write)(struct file *, struct kobject___2 *, struct bin_attribute *, char *, loff_t, size_t); + int (*mmap)(struct file *, struct kobject___2 *, struct bin_attribute *, struct vm_area_struct *); +}; + +struct acpi_table_attr { + struct bin_attribute attr; + char name[8]; + int instance; + struct list_head node; +}; + +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 acpi_table_boot { + struct acpi_table_header header; + u8 cmos_index; + u8 reserved[3]; +}; + +struct acpi_table_csrt { + struct acpi_table_header header; +}; + +struct acpi_table_desc { + acpi_physical_address address; + struct acpi_table_header *pointer; + u32 length; + union acpi_name_union signature; + acpi_owner_id owner_id; + u8 flags; +}; + +struct acpi_table_dmar { + struct acpi_table_header header; + u8 width; + u8 flags; + u8 reserved[10]; +}; + +struct acpi_table_ecdt { + struct acpi_table_header header; + struct acpi_generic_address control; + struct acpi_generic_address data; + u32 uid; + u8 gpe; + u8 id[1]; +} __attribute__((packed)); + +struct acpi_table_facs { + char signature[4]; + u32 length; + u32 hardware_signature; + u32 firmware_waking_vector; + u32 global_lock; + u32 flags; + u64 xfirmware_waking_vector; + u8 version; + u8 reserved[3]; + u32 ospm_flags; + u8 reserved1[24]; +}; + +struct acpi_table_fadt { + struct acpi_table_header header; + u32 facs; + u32 dsdt; + u8 model; + u8 preferred_profile; + u16 sci_interrupt; + u32 smi_command; + u8 acpi_enable; + u8 acpi_disable; + u8 s4_bios_request; + u8 pstate_control; + u32 pm1a_event_block; + u32 pm1b_event_block; + u32 pm1a_control_block; + u32 pm1b_control_block; + u32 pm2_control_block; + u32 pm_timer_block; + u32 gpe0_block; + u32 gpe1_block; + u8 pm1_event_length; + u8 pm1_control_length; + u8 pm2_control_length; + u8 pm_timer_length; + u8 gpe0_block_length; + u8 gpe1_block_length; + u8 gpe1_base; + u8 cst_control; + u16 c2_latency; + u16 c3_latency; + u16 flush_size; + u16 flush_stride; + u8 duty_offset; + u8 duty_width; + u8 day_alarm; + u8 month_alarm; + u8 century; + u16 boot_flags; + u8 reserved; + u32 flags; + struct acpi_generic_address reset_register; + u8 reset_value; + u16 arm_boot_flags; + u8 minor_revision; + u64 Xfacs; + u64 Xdsdt; + struct acpi_generic_address xpm1a_event_block; + struct acpi_generic_address xpm1b_event_block; + struct acpi_generic_address xpm1a_control_block; + struct acpi_generic_address xpm1b_control_block; + struct acpi_generic_address xpm2_control_block; + struct acpi_generic_address xpm_timer_block; + struct acpi_generic_address xgpe0_block; + struct acpi_generic_address xgpe1_block; + struct acpi_generic_address sleep_control; + struct acpi_generic_address sleep_status; + u64 hypervisor_id; +} __attribute__((packed)); + +struct acpi_table_hpet { + struct acpi_table_header header; + u32 id; + struct acpi_generic_address address; + u8 sequence; + u16 minimum_tick; + u8 flags; +} __attribute__((packed)); + +struct acpi_table_list { + struct acpi_table_desc *tables; + u32 current_table_count; + u32 max_table_count; + u8 flags; +}; + +struct acpi_table_madt { + struct acpi_table_header header; + u32 address; + u32 flags; +}; + +struct acpi_table_mcfg { + struct acpi_table_header header; + u8 reserved[8]; +}; + +struct acpi_table_rsdp { + char signature[8]; + u8 checksum; + char oem_id[6]; + u8 revision; + u32 rsdt_physical_address; + u32 length; + u64 xsdt_physical_address; + u8 extended_checksum; + u8 reserved[3]; +} __attribute__((packed)); + +struct acpi_table_slit { + struct acpi_table_header header; + u64 locality_count; + u8 entry[1]; +} __attribute__((packed)); + +struct acpi_table_srat { + struct acpi_table_header header; + u32 table_revision; + u64 reserved; +}; + +struct acpi_thermal_flags { + u8 cooling_mode: 1; + u8 devices: 1; + u8 reserved: 6; +}; + +struct acpi_thermal_state { + u8 critical: 1; + u8 hot: 1; + u8 passive: 1; + u8 active: 1; + u8 reserved: 4; + int active_index; +}; + +struct acpi_thermal_state_flags { + u8 valid: 1; + u8 enabled: 1; + u8 reserved: 6; +}; + +struct acpi_thermal_critical { + struct acpi_thermal_state_flags flags; + long unsigned int temperature; +}; + +struct acpi_thermal_hot { + struct acpi_thermal_state_flags flags; + long unsigned int temperature; +}; + +struct acpi_thermal_passive { + struct acpi_thermal_state_flags flags; + long unsigned int temperature; + long unsigned int tc1; + long unsigned int tc2; + long unsigned int tsp; + struct acpi_handle_list devices; +}; + +struct acpi_thermal_active { + struct acpi_thermal_state_flags flags; + long unsigned int temperature; + struct acpi_handle_list devices; +}; + +struct acpi_thermal_trips { + struct acpi_thermal_critical critical; + struct acpi_thermal_hot hot; + struct acpi_thermal_passive passive; + struct acpi_thermal_active active[10]; +}; + +struct thermal_zone_device; + +struct acpi_thermal { + struct acpi_device *device; + acpi_bus_id name; + long unsigned int temperature; + long unsigned int last_temperature; + long unsigned int polling_frequency; + volatile u8 zombie; + struct acpi_thermal_flags flags; + struct acpi_thermal_state state; + struct acpi_thermal_trips trips; + struct acpi_handle_list devices; + struct thermal_zone_device *thermal_zone; + int tz_enabled; + int kelvin_offset; + struct work_struct thermal_check_work; +}; + +struct acpi_vendor_uuid { + u8 subtype; + u8 data[16]; +}; + +struct acpi_vendor_walk_info { + struct acpi_vendor_uuid *uuid; + struct acpi_buffer *buffer; + acpi_status status; +}; + +struct acpi_video_brightness_flags { + u8 _BCL_no_ac_battery_levels: 1; + u8 _BCL_reversed: 1; + u8 _BQC_use_index: 1; +}; + +struct acpi_video_bus_cap { + u8 _DOS: 1; + u8 _DOD: 1; + u8 _ROM: 1; + u8 _GPD: 1; + u8 _SPD: 1; + u8 _VPO: 1; + u8 reserved: 2; +}; + +struct acpi_video_bus_flags { + u8 multihead: 1; + u8 rom: 1; + u8 post: 1; + u8 reserved: 5; +}; + +struct acpi_video_enumerated_device; + +struct acpi_video_bus { + struct acpi_device *device; + bool backlight_registered; + u8 dos_setting; + struct acpi_video_enumerated_device *attached_array; + u8 attached_count; + u8 child_count; + struct acpi_video_bus_cap cap; + struct acpi_video_bus_flags flags; + struct list_head video_device_list; + struct mutex___2 device_list_lock; + struct list_head entry; + struct input_dev *input; + char phys[32]; + struct notifier_block pm_nb; +}; + +struct acpi_video_device_flags { + u8 crt: 1; + u8 lcd: 1; + u8 tvout: 1; + u8 dvi: 1; + u8 bios: 1; + u8 unknown: 1; + u8 notify: 1; + u8 reserved: 1; +}; + +struct acpi_video_device_cap { + u8 _ADR: 1; + u8 _BCL: 1; + u8 _BCM: 1; + u8 _BQC: 1; + u8 _BCQ: 1; + u8 _DDC: 1; +}; + +struct delayed_work { + struct work_struct work; + struct timer_list timer; + struct workqueue_struct *wq; + int cpu; +}; + +struct acpi_video_device_brightness; + +struct backlight_device; + +struct acpi_video_device { + long unsigned int device_id; + struct acpi_video_device_flags flags; + struct acpi_video_device_cap cap; + struct list_head entry; + struct delayed_work switch_brightness_work; + int switch_brightness_event; + struct acpi_video_bus *video; + struct acpi_device *dev; + struct acpi_video_device_brightness *brightness; + struct backlight_device *backlight; + struct thermal_cooling_device *cooling_dev; +}; + +struct acpi_video_device_attrib { + u32 display_index: 4; + u32 display_port_attachment: 4; + u32 display_type: 4; + u32 vendor_specific: 4; + u32 bios_can_detect: 1; + u32 depend_on_vga: 1; + u32 pipe_id: 3; + u32 reserved: 10; + u32 device_id_scheme: 1; +}; + +struct acpi_video_device_brightness { + int curr; + int count; + int *levels; + struct acpi_video_brightness_flags flags; +}; + +struct acpi_video_enumerated_device { + union { + u32 int_val; + struct acpi_video_device_attrib attrib; + } value; + struct acpi_video_device *bind_info; +}; + +typedef acpi_status (*acpi_parse_downwards)(struct acpi_walk_state *, union acpi_parse_object **); + +typedef acpi_status (*acpi_parse_upwards)(struct acpi_walk_state *); + +struct acpi_walk_state { + struct acpi_walk_state *next; + u8 descriptor_type; + u8 walk_type; + u16 opcode; + u8 next_op_info; + u8 num_operands; + u8 operand_index; + acpi_owner_id owner_id; + u8 last_predicate; + u8 current_result; + u8 return_used; + u8 scope_depth; + u8 pass_number; + u8 namespace_override; + u8 result_size; + u8 result_count; + u8 *aml; + u32 arg_types; + u32 method_breakpoint; + u32 user_breakpoint; + u32 parse_flags; + struct acpi_parse_state parser_state; + u32 prev_arg_types; + u32 arg_count; + struct acpi_namespace_node arguments[7]; + struct acpi_namespace_node local_variables[8]; + union acpi_operand_object *operands[9]; + union acpi_operand_object **params; + u8 *aml_last_while; + union acpi_operand_object **caller_return_desc; + union acpi_generic_state *control_state; + struct acpi_namespace_node *deferred_node; + union acpi_operand_object *implicit_return_obj; + struct acpi_namespace_node *method_call_node; + union acpi_parse_object *method_call_op; + union acpi_operand_object *method_desc; + struct acpi_namespace_node *method_node; + union acpi_parse_object *op; + const struct acpi_opcode_info *op_info; + union acpi_parse_object *origin; + union acpi_operand_object *result_obj; + union acpi_generic_state *results; + union acpi_operand_object *return_desc; + union acpi_generic_state *scope_info; + union acpi_parse_object *prev_op; + union acpi_parse_object *next_op; + struct acpi_thread_state *thread; + acpi_parse_downwards descending_callback; + acpi_parse_upwards ascending_callback; +}; + +struct acpihid_map_entry { + struct list_head list; + u8 uid[256]; + u8 hid[9]; + u16 devid; + u16 root_devid; + bool cmd_line; + struct iommu_group *group; +}; + +struct pnp_dev; + +struct acpipnp_parse_option_s { + struct pnp_dev *dev; + unsigned int option_flags; +}; + +struct action_devres { + void *data; + void (*action)(void *); +}; + +struct snd_pcm_substream; + +struct action_ops { + int (*pre_action)(struct snd_pcm_substream *, int); + int (*do_action)(struct snd_pcm_substream *, int); + void (*undo_action)(struct snd_pcm_substream *, int); + void (*post_action)(struct snd_pcm_substream *, int); +}; + +struct radix_tree_node; + +struct radix_tree_root { + gfp_t gfp_mask; + struct radix_tree_node *rnode; +}; + +struct rb_node; + +struct rb_root { + struct rb_node *rb_node; +}; + +typedef struct raw_spinlock raw_spinlock_t; + +struct rw_semaphore { + long int count; + struct list_head wait_list; + raw_spinlock_t wait_lock; + struct optimistic_spin_queue osq; + struct task_struct *owner; +}; + +struct inode; + +struct address_space_operations; + +struct address_space { + struct inode *host; + struct radix_tree_root page_tree; + spinlock_t tree_lock; + atomic_t i_mmap_writable; + struct rb_root i_mmap; + struct rw_semaphore i_mmap_rwsem; + long unsigned int nrpages; + long unsigned int nrexceptional; + long unsigned int writeback_index; + const struct address_space_operations *a_ops; + long unsigned int flags; + spinlock_t private_lock; + struct list_head private_list; + void *private_data; +}; + +struct rw_semaphore___2 { + long int count; + struct list_head wait_list; + raw_spinlock_t wait_lock; + struct optimistic_spin_queue osq; + struct task_struct___2 *owner; +}; + +struct inode___2; + +struct address_space_operations___2; + +struct address_space___2 { + struct inode___2 *host; + struct radix_tree_root page_tree; + spinlock_t tree_lock; + atomic_t i_mmap_writable; + struct rb_root i_mmap; + struct rw_semaphore___2 i_mmap_rwsem; + long unsigned int nrpages; + long unsigned int nrexceptional; + long unsigned int writeback_index; + const struct address_space_operations___2 *a_ops; + long unsigned int flags; + spinlock_t private_lock; + struct list_head private_list; + void *private_data; +}; + +struct page___2; + +struct writeback_control; + +struct file___2; + +struct kiocb; + +struct iov_iter; + +struct swap_info_struct; + +struct address_space_operations { + int (*writepage)(struct page___2 *, struct writeback_control *); + int (*readpage)(struct file___2 *, struct page___2 *); + int (*writepages)(struct address_space *, struct writeback_control *); + int (*set_page_dirty)(struct page___2 *); + int (*readpages)(struct file___2 *, struct address_space *, struct list_head *, unsigned int); + int (*write_begin)(struct file___2 *, struct address_space *, loff_t, unsigned int, unsigned int, struct page___2 **, void **); + int (*write_end)(struct file___2 *, struct address_space *, loff_t, unsigned int, unsigned int, struct page___2 *, void *); + sector_t (*bmap)(struct address_space *, sector_t); + void (*invalidatepage)(struct page___2 *, unsigned int, unsigned int); + int (*releasepage)(struct page___2 *, gfp_t); + void (*freepage)(struct page___2 *); + ssize_t (*direct_IO)(struct kiocb *, struct iov_iter *); + int (*migratepage)(struct address_space *, struct page___2 *, struct page___2 *, enum migrate_mode); + int (*launder_page)(struct page___2 *); + int (*is_partially_uptodate)(struct page___2 *, long unsigned int, long unsigned int); + void (*is_dirty_writeback)(struct page___2 *, bool *, bool *); + int (*error_remove_page)(struct address_space *, struct page___2 *); + int (*swap_activate)(struct swap_info_struct *, struct file___2 *, sector_t *); + void (*swap_deactivate)(struct file___2 *); +}; + +struct kiocb___2; + +struct iov_iter___2; + +struct address_space_operations___2 { + int (*writepage)(struct page *, struct writeback_control *); + int (*readpage)(struct file *, struct page *); + int (*writepages)(struct address_space___2 *, struct writeback_control *); + int (*set_page_dirty)(struct page *); + int (*readpages)(struct file *, struct address_space___2 *, struct list_head *, unsigned int); + int (*write_begin)(struct file *, struct address_space___2 *, loff_t, unsigned int, unsigned int, struct page **, void **); + int (*write_end)(struct file *, struct address_space___2 *, loff_t, unsigned int, unsigned int, struct page *, void *); + sector_t (*bmap)(struct address_space___2 *, sector_t); + void (*invalidatepage)(struct page *, unsigned int, unsigned int); + int (*releasepage)(struct page *, gfp_t); + void (*freepage)(struct page *); + ssize_t (*direct_IO)(struct kiocb___2 *, struct iov_iter___2 *); + int (*migratepage)(struct address_space___2 *, struct page *, struct page *, enum migrate_mode); + int (*launder_page)(struct page *); + int (*is_partially_uptodate)(struct page *, long unsigned int, long unsigned int); + void (*is_dirty_writeback)(struct page *, bool *, bool *); + int (*error_remove_page)(struct address_space___2 *, struct page *); + int (*swap_activate)(struct swap_info_struct *, struct file *, sector_t *); + void (*swap_deactivate)(struct file *); +}; + +struct blkcipher_desc; + +struct blkcipher_alg { + int (*setkey)(struct crypto_tfm *, const u8 *, unsigned int); + int (*encrypt)(struct blkcipher_desc *, struct scatterlist *, struct scatterlist *, unsigned int); + int (*decrypt)(struct blkcipher_desc *, struct scatterlist *, struct scatterlist *, unsigned int); + const char *geniv; + unsigned int min_keysize; + unsigned int max_keysize; + unsigned int ivsize; +}; + +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; + atomic_t cra_refcnt; + char cra_name[64]; + char cra_driver_name[64]; + const struct crypto_type *cra_type; + union { + struct ablkcipher_alg ablkcipher; + struct blkcipher_alg blkcipher; + 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___2 *cra_module; +}; + +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 *); + const char *geniv; + unsigned int ivsize; + unsigned int maxauthsize; + struct crypto_alg base; +}; + +struct crypto_blkcipher; + +struct aead_geniv_ctx { + spinlock_t lock; + struct crypto_aead *child; + struct crypto_blkcipher *null; + u8 salt[0]; +}; + +struct crypto_template; + +struct crypto_instance { + struct crypto_alg alg; + struct crypto_template *tmpl; + struct hlist_node list; + 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 aer_broadcast_data { + enum pci_channel_state state; + enum pci_ers_result result; +}; + +struct aer_header_log_regs { + unsigned int dw0; + unsigned int dw1; + unsigned int dw2; + unsigned int dw3; +}; + +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 aer_header_log_regs tlp; +}; + +struct aer_err_source { + unsigned int status; + unsigned int id; +}; + +struct pcie_device; + +struct aer_rpc { + struct pcie_device *rpd; + struct work_struct dpc_handler; + struct aer_err_source e_sources[100]; + short unsigned int prod_idx; + short unsigned int cons_idx; + int isr; + spinlock_t e_lock; + struct mutex___2 rpc_mutex; +}; + +struct agp_3_5_dev { + struct list_head list; + u8 capndx; + u32 maxbw; + struct pci_dev *dev; +}; + +struct agp_allocate { + int key; + size_t pg_count; + u32 type; + u32 physical; +}; + +struct agp_allocate32 { + compat_int_t key; + compat_size_t pg_count; + u32 type; + u32 physical; +}; + +struct agp_bind { + int key; + off_t pg_start; +}; + +struct agp_bind32 { + compat_int_t key; + compat_off_t pg_start; +}; + +struct agp_version; + +struct agp_bridge_driver; + +struct vm_operations_struct; + +struct agp_bridge_data { + const struct agp_version *version; + const struct agp_bridge_driver *driver; + const struct vm_operations_struct *vm_ops; + void *previous_size; + void *current_size; + void *dev_private_data; + struct pci_dev *dev; + u32 *gatt_table; + u32 *gatt_table_real; + long unsigned int scratch_page; + struct page *scratch_page_page; + dma_addr_t scratch_page_dma; + long unsigned int gart_bus_addr; + long unsigned int gatt_bus_addr; + u32 mode; + enum chipset_type type; + long unsigned int *key_list; + atomic_t current_memory_agp; + atomic_t agp_in_use; + int max_memory_agp; + int aperture_size_idx; + int capndx; + int flags; + char major_version; + char minor_version; + struct list_head list; + u32 apbase_config; + struct list_head mapped_list; + spinlock_t mapped_lock; +}; + +struct gatt_mask; + +struct agp_memory; + +struct agp_bridge_driver { + struct module___2 *owner; + const void *aperture_sizes; + int num_aperture_sizes; + enum aper_size_type size_type; + bool cant_use_aperture; + bool needs_scratch_page; + const struct gatt_mask *masks; + int (*fetch_size)(void); + int (*configure)(void); + void (*agp_enable)(struct agp_bridge_data *, u32); + void (*cleanup)(void); + void (*tlb_flush)(struct agp_memory *); + long unsigned int (*mask_memory)(struct agp_bridge_data *, dma_addr_t, int); + void (*cache_flush)(void); + int (*create_gatt_table)(struct agp_bridge_data *); + int (*free_gatt_table)(struct agp_bridge_data *); + int (*insert_memory)(struct agp_memory *, off_t, int); + int (*remove_memory)(struct agp_memory *, off_t, int); + struct agp_memory * (*alloc_by_type)(size_t, int); + void (*free_by_type)(struct agp_memory *); + struct page * (*agp_alloc_page)(struct agp_bridge_data *); + int (*agp_alloc_pages)(struct agp_bridge_data *, struct agp_memory *, size_t); + void (*agp_destroy_page)(struct page *, int); + void (*agp_destroy_pages)(struct agp_memory *); + int (*agp_type_to_mask_type)(struct agp_bridge_data *, int); +}; + +struct agp_segment_priv; + +struct agp_client { + struct agp_client *next; + struct agp_client *prev; + pid_t pid; + int num_segments; + struct agp_segment_priv **segments; +}; + +struct agp_controller { + struct agp_controller *next; + struct agp_controller *prev; + pid_t pid; + int num_clients; + struct agp_memory *pool; + struct agp_client *clients; +}; + +struct agp_file_private { + struct agp_file_private *next; + struct agp_file_private *prev; + pid_t my_pid; + long unsigned int access_flags; +}; + +struct agp_front_data { + struct mutex___2 agp_mutex; + struct agp_controller *current_controller; + struct agp_controller *controllers; + struct agp_file_private *file_priv_list; + bool used_by_controller; + bool backend_acquired; +}; + +struct agp_version { + u16 major; + u16 minor; +}; + +struct agp_info { + struct agp_version version; + u32 bridge_id; + u32 agp_mode; + long unsigned int aper_base; + size_t aper_size; + size_t pg_total; + size_t pg_system; + size_t pg_used; +}; + +struct agp_info32 { + struct agp_version version; + u32 bridge_id; + u32 agp_mode; + compat_long_t aper_base; + compat_size_t aper_size; + compat_size_t pg_total; + compat_size_t pg_system; + compat_size_t pg_used; +}; + +struct agp_kern_info { + struct agp_version version; + struct pci_dev *device; + enum chipset_type chipset; + long unsigned int mode; + long unsigned int aper_base; + size_t aper_size; + int max_memory; + int current_memory; + bool cant_use_aperture; + long unsigned int page_mask; + const struct vm_operations_struct *vm_ops; +}; + +struct agp_memory { + struct agp_memory *next; + struct agp_memory *prev; + struct agp_bridge_data *bridge; + struct page **pages; + size_t page_count; + int key; + int num_scratch_pages; + off_t pg_start; + u32 type; + u32 physical; + bool is_bound; + bool is_flushed; + struct list_head mapped_list; + struct scatterlist *sg_list; + int num_sg; +}; + +struct agp_segment; + +struct agp_region { + pid_t pid; + size_t seg_count; + struct agp_segment *seg_list; +}; + +struct agp_segment32; + +struct agp_region32 { + compat_pid_t pid; + compat_size_t seg_count; + struct agp_segment32 *seg_list; +}; + +struct agp_segment { + off_t pg_start; + size_t pg_count; + int prot; +}; + +struct agp_segment32 { + compat_off_t pg_start; + compat_size_t pg_count; + compat_int_t prot; +}; + +struct pgprot { + pgprotval_t pgprot; +}; + +typedef struct pgprot pgprot_t; + +struct agp_segment_priv { + off_t pg_start; + size_t pg_count; + pgprot_t prot; +}; + +struct agp_setup { + u32 agp_mode; +}; + +struct agp_unbind { + int key; + u32 priority; +}; + +struct agp_unbind32 { + compat_int_t key; + u32 priority; +}; + +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); + struct hash_alg_common halg; +}; + +struct ahash_instance { + 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 ahash_request_priv { + crypto_completion_t complete; + void *data; + u8 *result; + void *ubuf[0]; +}; + +struct ahci_cmd_hdr { + __le32 opts; + __le32 status; + __le32 tbl_addr; + __le32 tbl_addr_hi; + __le32 reserved[4]; +}; + +struct ahci_em_priv { + enum sw_activity blink_policy; + struct timer_list timer; + long unsigned int saved_activity; + long unsigned int activity; + long unsigned int led_state; +}; + +struct clk; + +struct regulator; + +struct phy; + +struct msix_entry; + +struct ata_port; + +struct ahci_host_priv { + unsigned int flags; + u32 force_port_map; + u32 mask_port_map; + void *mmio; + u32 cap; + u32 cap2; + u32 version; + u32 port_map; + u32 saved_cap; + u32 saved_cap2; + u32 saved_port_map; + u32 em_loc; + u32 em_buf_sz; + u32 em_msg_type; + bool got_runtime_pm; + struct clk *clks[5]; + struct regulator **target_pwrs; + struct phy **phys; + struct msix_entry *msix; + unsigned int nports; + void *plat_data; + unsigned int irq; + void (*start_engine)(struct ata_port *); + irqreturn_t (*irq_handler)(int, void *); +}; + +struct ata_link; + +struct ahci_port_priv { + struct ata_link *active_link; + struct ahci_cmd_hdr *cmd_slot; + dma_addr_t cmd_slot_dma; + void *cmd_tbl; + dma_addr_t cmd_tbl_dma; + void *rx_fis; + dma_addr_t rx_fis_dma; + unsigned int ncq_saw_d2h: 1; + unsigned int ncq_saw_dmas: 1; + unsigned int ncq_saw_sdb: 1; + spinlock_t lock; + u32 intr_mask; + bool fbs_supported; + bool fbs_enabled; + int fbs_last_dev; + struct ahci_em_priv em_priv[8]; + char *irq_desc; +}; + +struct ahci_sg { + __le32 addr; + __le32 addr_hi; + __le32 reserved; + __le32 flags_size; +}; + +struct kiocb { + struct file___2 *ki_filp; + loff_t ki_pos; + void (*ki_complete)(struct kiocb *, long int, long int); + void *private; + int ki_flags; +}; + +typedef int kiocb_cancel_fn(struct kiocb *); + +struct kioctx; + +struct iocb; + +struct aio_kiocb { + struct kiocb common; + struct kioctx *ki_ctx; + kiocb_cancel_fn *ki_cancel; + struct iocb *ki_user_iocb; + __u64 ki_user_data; + struct list_head ki_list; + struct eventfd_ctx *ki_eventfd; +}; + +struct io_event { + __u64 data; + __u64 obj; + __s64 res; + __s64 res2; +}; + +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 akcipher_request; + +struct crypto_akcipher; + +struct akcipher_alg { + int (*sign)(struct akcipher_request *); + int (*verify)(struct akcipher_request *); + 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); + int (*max_size)(struct crypto_akcipher *); + int (*init)(struct crypto_akcipher *); + void (*exit)(struct crypto_akcipher *); + unsigned int reqsize; + struct crypto_alg base; +}; + +struct akcipher_instance { + void (*free)(struct akcipher_instance *); + union { + struct { + char head[80]; + 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 rb_node { + long unsigned int __rb_parent_color; + struct rb_node *rb_right; + struct rb_node *rb_left; +}; + +union ktime { + s64 tv64; +}; + +typedef union ktime ktime_t; + +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; + int start_pid; + void *start_site; + char start_comm[16]; +}; + +struct alarm { + struct timerqueue_node node; + struct hrtimer timer; + enum alarmtimer_restart (*function)(struct alarm *, ktime_t); + enum alarmtimer_type type; + int state; + void *data; +}; + +struct timerqueue_head { + struct rb_root head; + struct timerqueue_node *next; +}; + +struct alarm_base { + spinlock_t lock; + struct timerqueue_head timerqueue; + ktime_t (*gettime)(void); + clockid_t base_clockid; +}; + +struct alc_codec_rename_pci_table { + unsigned int codec_vendor_id; + short unsigned int pci_subvendor; + short unsigned int pci_subdevice; + const char *name; +}; + +struct alc_codec_rename_table { + unsigned int vendor_id; + short unsigned int coef_mask; + short unsigned int coef_bits; + const char *name; +}; + +struct alc_customize_define { + unsigned int sku_cfg; + unsigned char port_connectivity; + unsigned char check_sum; + unsigned char customization; + unsigned char external_amp; + unsigned int enable_pcbeep: 1; + unsigned int platform_type: 1; + unsigned int swap: 1; + unsigned int override: 1; + unsigned int fixup: 1; +}; + +struct hda_multi_out { + int num_dacs; + const hda_nid_t *dac_nids; + hda_nid_t hp_nid; + hda_nid_t hp_out_nid[5]; + hda_nid_t extra_out_nid[5]; + hda_nid_t dig_out_nid; + const hda_nid_t *slave_dig_outs; + int max_channels; + int dig_out_used; + int no_share_stream; + int share_spdif; + unsigned int analog_rates; + unsigned int analog_maxbps; + u64 analog_formats; + unsigned int spdif_rates; + unsigned int spdif_maxbps; + u64 spdif_formats; +}; + +struct hda_input_mux_item { + char label[32]; + unsigned int index; +}; + +struct hda_input_mux { + unsigned int num_items; + struct hda_input_mux_item items[16]; +}; + +struct auto_pin_cfg_item { + hda_nid_t pin; + int type; + unsigned int is_headset_mic: 1; + unsigned int is_headphone_mic: 1; + unsigned int has_boost_on_pin: 1; +}; + +struct auto_pin_cfg { + int line_outs; + hda_nid_t line_out_pins[5]; + int speaker_outs; + hda_nid_t speaker_pins[5]; + int hp_outs; + int line_out_type; + hda_nid_t hp_pins[5]; + int num_inputs; + struct auto_pin_cfg_item inputs[8]; + int dig_outs; + hda_nid_t dig_out_pins[2]; + hda_nid_t dig_in_pin; + hda_nid_t mono_out_pin; + int dig_out_type[2]; + int dig_in_type; +}; + +struct snd_array { + unsigned int used; + unsigned int alloced; + unsigned int elem_size; + unsigned int alloc_align; + void *list; +}; + +struct automic_entry { + hda_nid_t pin; + int idx; + unsigned int attr; +}; + +struct snd_kcontrol; + +struct hda_codec; + +struct hda_vmaster_mute_hook { + struct snd_kcontrol *sw_kctl; + void (*hook)(void *, int); + unsigned int mute_mode; + struct hda_codec *codec; +}; + +struct hda_amp_list; + +struct hda_loopback_check { + const struct hda_amp_list *amplist; + int power_on; +}; + +struct hda_multi_io { + hda_nid_t pin; + hda_nid_t dac; + unsigned int ctl_in; +}; + +struct hda_pcm_stream; + +struct hda_pcm; + +struct badness_table; + +struct snd_ctl_elem_value; + +struct hda_jack_callback; + +struct hda_gen_spec { + char stream_name_analog[32]; + const struct hda_pcm_stream *stream_analog_playback; + const struct hda_pcm_stream *stream_analog_capture; + char stream_name_alt_analog[32]; + const struct hda_pcm_stream *stream_analog_alt_playback; + const struct hda_pcm_stream *stream_analog_alt_capture; + char stream_name_digital[32]; + const struct hda_pcm_stream *stream_digital_playback; + const struct hda_pcm_stream *stream_digital_capture; + unsigned int active_streams; + struct mutex pcm_mutex; + struct hda_multi_out multiout; + hda_nid_t alt_dac_nid; + hda_nid_t slave_dig_outs[3]; + int dig_out_type; + unsigned int num_adc_nids; + hda_nid_t adc_nids[8]; + hda_nid_t dig_in_nid; + hda_nid_t mixer_nid; + hda_nid_t mixer_merge_nid; + const char *input_labels[16]; + int input_label_idxs[16]; + hda_nid_t cur_adc; + unsigned int cur_adc_stream_tag; + unsigned int cur_adc_format; + struct hda_input_mux input_mux; + unsigned int cur_mux[3]; + int min_channel_count; + int ext_channel_count; + int const_channel_count; + struct hda_pcm *pcm_rec[3]; + struct auto_pin_cfg autocfg; + struct snd_array kctls; + hda_nid_t private_dac_nids[5]; + hda_nid_t imux_pins[16]; + unsigned int dyn_adc_idx[16]; + hda_nid_t shared_mic_vref_pin; + hda_nid_t hp_mic_pin; + int hp_mic_mux_idx; + int num_all_dacs; + hda_nid_t all_dacs[16]; + int num_all_adcs; + hda_nid_t all_adcs[8]; + struct snd_array paths; + int out_paths[5]; + int hp_paths[5]; + int speaker_paths[5]; + int aamix_out_paths[3]; + int digout_paths[5]; + int input_paths[128]; + int loopback_paths[16]; + int loopback_merge_path; + int digin_path; + int am_num_entries; + struct automic_entry am_entry[3]; + unsigned int hp_jack_present: 1; + unsigned int line_jack_present: 1; + unsigned int speaker_muted: 1; + unsigned int line_out_muted: 1; + unsigned int auto_mic: 1; + unsigned int automute_speaker: 1; + unsigned int automute_lo: 1; + unsigned int detect_hp: 1; + unsigned int detect_lo: 1; + unsigned int automute_speaker_possible: 1; + unsigned int automute_lo_possible: 1; + unsigned int master_mute: 1; + unsigned int keep_vref_in_automute: 1; + unsigned int line_in_auto_switch: 1; + unsigned int auto_mute_via_amp: 1; + unsigned int suppress_auto_mute: 1; + unsigned int suppress_auto_mic: 1; + unsigned int need_dac_fix: 1; + unsigned int hp_mic: 1; + unsigned int suppress_hp_mic_detect: 1; + unsigned int no_primary_hp: 1; + unsigned int no_multi_io: 1; + unsigned int multi_cap_vol: 1; + unsigned int inv_dmic_split: 1; + unsigned int own_eapd_ctl: 1; + unsigned int keep_eapd_on: 1; + unsigned int vmaster_mute_enum: 1; + unsigned int indep_hp: 1; + unsigned int prefer_hp_amp: 1; + unsigned int add_stereo_mix_input: 2; + unsigned int add_jack_modes: 1; + unsigned int power_down_unused: 1; + unsigned int dac_min_mute: 1; + unsigned int no_analog: 1; + unsigned int dyn_adc_switch: 1; + unsigned int indep_hp_enabled: 1; + unsigned int have_aamix_ctl: 1; + unsigned int hp_mic_jack_modes: 1; + u64 mute_bits; + u64 out_vol_mask; + const struct badness_table *main_out_badness; + const struct badness_table *extra_out_badness; + const hda_nid_t *preferred_dacs; + bool aamix_mode; + hda_nid_t beep_nid; + hda_nid_t vmaster_nid; + unsigned int vmaster_tlv[4]; + struct hda_vmaster_mute_hook vmaster_mute; + struct hda_loopback_check loopback; + struct snd_array loopback_list; + int multi_ios; + struct hda_multi_io multi_io[4]; + void (*init_hook)(struct hda_codec *); + void (*automute_hook)(struct hda_codec *); + void (*cap_sync_hook)(struct hda_codec *, struct snd_kcontrol *, struct snd_ctl_elem_value *); + void (*pcm_playback_hook)(struct hda_pcm_stream *, struct hda_codec *, struct snd_pcm_substream *, int); + void (*pcm_capture_hook)(struct hda_pcm_stream *, struct hda_codec *, struct snd_pcm_substream *, int); + void (*hp_automute_hook)(struct hda_codec *, struct hda_jack_callback *); + void (*line_automute_hook)(struct hda_codec *, struct hda_jack_callback *); + void (*mic_autoswitch_hook)(struct hda_codec *, struct hda_jack_callback *); +}; + +struct snd_kcontrol_new; + +struct alc_spec { + struct hda_gen_spec gen; + const struct snd_kcontrol_new *mixers[5]; + unsigned int num_mixers; + unsigned int beep_amp; + struct alc_customize_define cdefine; + unsigned int parse_flags; + int mute_led_polarity; + hda_nid_t mute_led_nid; + hda_nid_t cap_mute_led_nid; + unsigned int gpio_led; + unsigned int gpio_mute_led_mask; + unsigned int gpio_mic_led_mask; + hda_nid_t headset_mic_pin; + hda_nid_t headphone_mic_pin; + int current_headset_mode; + int current_headset_type; + void (*init_hook)(struct hda_codec *); + void (*power_hook)(struct hda_codec *); + void (*shutup)(struct hda_codec *); + void (*reboot_notify)(struct hda_codec *); + int init_amp; + int codec_variant; + unsigned int has_alc5505_dsp: 1; + unsigned int no_depop_delay: 1; + hda_nid_t pll_nid; + unsigned int pll_coef_idx; + unsigned int pll_coef_bit; + unsigned int coef0; + struct input_dev *kb_dev; + u8 alc_mute_keycode_map[1]; +}; + +struct zonelist; + +struct zoneref; + +struct alloc_context { + struct zonelist *zonelist; + nodemask_t *nodemask; + struct zoneref *preferred_zoneref; + int migratetype; + enum zone_type high_zoneidx; + bool spread_dirty_pages; +}; + +struct alps_bitmap_point { + int start_bit; + int num_bits; +}; + +struct input_mt_pos { + s16 x; + s16 y; +}; + +struct alps_fields { + unsigned int x_map; + unsigned int y_map; + unsigned int fingers; + int pressure; + struct input_mt_pos st; + struct input_mt_pos mt[4]; + unsigned int first_mp: 1; + unsigned int is_mp: 1; + unsigned int left: 1; + unsigned int right: 1; + unsigned int middle: 1; + unsigned int ts_left: 1; + unsigned int ts_right: 1; + unsigned int ts_middle: 1; +}; + +struct psmouse; + +struct alps_nibble_commands; + +struct alps_data { + struct psmouse *psmouse; + struct input_dev *dev2; + struct input_dev *dev3; + char phys2[32]; + char phys3[32]; + struct delayed_work dev3_register_work; + const struct alps_nibble_commands *nibble_commands; + int addr_command; + u16 proto_version; + u8 byte0; + u8 mask0; + u8 fw_ver[3]; + int flags; + int x_max; + int y_max; + int x_bits; + int y_bits; + unsigned int x_res; + unsigned int y_res; + int (*hw_init)(struct psmouse *); + void (*process_packet)(struct psmouse *); + int (*decode_fields)(struct alps_fields *, unsigned char *, struct psmouse *); + void (*set_abs_params)(struct alps_data *, struct input_dev *); + int prev_fin; + int multi_packet; + int second_touch; + unsigned char multi_data[6]; + struct alps_fields f; + u8 quirks; + struct timer_list timer; +}; + +struct alps_protocol_info { + u16 version; + u8 byte0; + u8 mask0; + unsigned int flags; +}; + +struct alps_model_info { + u8 signature[3]; + u8 command_mode_resp; + struct alps_protocol_info protocol_info; +}; + +struct alps_nibble_commands { + int command; + unsigned char data; +}; + +struct alt_instr { + s32 instr_offset; + s32 repl_offset; + u16 cpuid; + u8 instrlen; + u8 replacementlen; + u8 padlen; +} __attribute__((packed)); + +struct amd_decoder_ops { + bool (*mc0_mce)(u16, u8); + bool (*mc1_mce)(u16, u8); + bool (*mc2_mce)(u16, u8); +}; + +struct amd_hostbridge { + u32 bus; + u32 slot; + u32 device; +}; + +struct amd_hwid { + const char *name; + unsigned int hwid; +}; + +struct amd_iommu { + struct list_head list; + int index; + spinlock_t lock; + struct pci_dev *dev; + struct pci_dev *root_pdev; + u64 mmio_phys; + u64 mmio_phys_end; + u8 *mmio_base; + u32 cap; + u8 acpi_flags; + u64 features; + bool is_iommu_v2; + u16 devid; + u16 cap_ptr; + u16 pci_seg; + u64 exclusion_start; + u64 exclusion_length; + u8 *cmd_buf; + u8 *evt_buf; + u8 *ppr_log; + bool int_enabled; + bool need_sync; + struct device___2 *iommu_dev; + u32 stored_addr_lo; + u32 stored_addr_hi; + u32 stored_l1[108]; + u32 stored_l2[131]; + u8 max_banks; + u8 max_counters; +}; + +struct amd_iommu_device_info { + int max_pasids; + u32 flags; +}; + +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 amd_iommu_event_desc { + struct kobj_attribute attr; + const char *event; +}; + +struct amd_iommu_fault { + u64 address; + u32 pasid; + u16 device_id; + u16 tag; + u16 flags; +}; + +struct amd_l3_cache { + unsigned int indices; + u8 subcaches[4]; +}; + +struct event_constraint { + union { + long unsigned int idxmsk[1]; + u64 idxmsk64; + }; + u64 code; + u64 cmask; + int weight; + int overlap; + int flags; +}; + +struct perf_event; + +struct amd_nb { + int nb_id; + int refcnt; + struct perf_event *owners[64]; + struct event_constraint event_constraints[64]; +}; + +struct amd_nb_bus_dev_range { + u8 bus; + u8 dev_base; + u8 dev_limit; +}; + +struct threshold_bank; + +struct amd_northbridge { + struct pci_dev *misc; + struct pci_dev *link; + struct amd_l3_cache l3_cache; + struct threshold_bank *bank4; +}; + +struct amd_northbridge_info { + u16 num; + u64 flags; + struct amd_northbridge *nb; +}; + +typedef struct cpumask cpumask_t; + +struct pmu; + +struct amd_uncore { + int id; + int refcnt; + int cpu; + int num_counters; + int rdpmc_base; + u32 msr_base; + cpumask_t *active_mask; + struct pmu *pmu; + struct perf_event *events[4]; + struct amd_uncore *free_when_cpu_online; +}; + +struct aml_resource_small_header { + u8 descriptor_type; +}; + +struct aml_resource_large_header { + u8 descriptor_type; + u16 resource_length; +} __attribute__((packed)); + +struct aml_resource_irq { + u8 descriptor_type; + u16 irq_mask; + u8 flags; +} __attribute__((packed)); + +struct aml_resource_dma { + u8 descriptor_type; + u8 dma_channel_mask; + u8 flags; +}; + +struct aml_resource_start_dependent { + u8 descriptor_type; + u8 flags; +}; + +struct aml_resource_end_dependent { + u8 descriptor_type; +}; + +struct aml_resource_io { + u8 descriptor_type; + u8 flags; + u16 minimum; + u16 maximum; + u8 alignment; + u8 address_length; +}; + +struct aml_resource_fixed_io { + u8 descriptor_type; + u16 address; + u8 address_length; +} __attribute__((packed)); + +struct aml_resource_fixed_dma { + u8 descriptor_type; + u16 request_lines; + u16 channels; + u8 width; +} __attribute__((packed)); + +struct aml_resource_vendor_small { + u8 descriptor_type; +}; + +struct aml_resource_end_tag { + u8 descriptor_type; + u8 checksum; +}; + +struct aml_resource_memory24 { + u8 descriptor_type; + u16 resource_length; + u8 flags; + u16 minimum; + u16 maximum; + u16 alignment; + u16 address_length; +} __attribute__((packed)); + +struct aml_resource_generic_register { + u8 descriptor_type; + u16 resource_length; + u8 address_space_id; + u8 bit_width; + u8 bit_offset; + u8 access_size; + u64 address; +} __attribute__((packed)); + +struct aml_resource_vendor_large { + u8 descriptor_type; + u16 resource_length; +} __attribute__((packed)); + +struct aml_resource_memory32 { + u8 descriptor_type; + u16 resource_length; + u8 flags; + u32 minimum; + u32 maximum; + u32 alignment; + u32 address_length; +} __attribute__((packed)); + +struct aml_resource_fixed_memory32 { + u8 descriptor_type; + u16 resource_length; + u8 flags; + u32 address; + u32 address_length; +} __attribute__((packed)); + +struct aml_resource_address16 { + u8 descriptor_type; + u16 resource_length; + u8 resource_type; + u8 flags; + u8 specific_flags; + u16 granularity; + u16 minimum; + u16 maximum; + u16 translation_offset; + u16 address_length; +} __attribute__((packed)); + +struct aml_resource_address32 { + u8 descriptor_type; + u16 resource_length; + u8 resource_type; + u8 flags; + u8 specific_flags; + u32 granularity; + u32 minimum; + u32 maximum; + u32 translation_offset; + u32 address_length; +} __attribute__((packed)); + +struct aml_resource_address64 { + u8 descriptor_type; + u16 resource_length; + u8 resource_type; + u8 flags; + u8 specific_flags; + u64 granularity; + u64 minimum; + u64 maximum; + u64 translation_offset; + u64 address_length; +} __attribute__((packed)); + +struct aml_resource_extended_address64 { + u8 descriptor_type; + u16 resource_length; + u8 resource_type; + u8 flags; + u8 specific_flags; + u8 revision_ID; + u8 reserved; + u64 granularity; + u64 minimum; + u64 maximum; + u64 translation_offset; + u64 address_length; + u64 type_specific; +} __attribute__((packed)); + +struct aml_resource_extended_irq { + u8 descriptor_type; + u16 resource_length; + u8 flags; + u8 interrupt_count; + u32 interrupts[1]; +} __attribute__((packed)); + +struct aml_resource_gpio { + u8 descriptor_type; + u16 resource_length; + u8 revision_id; + u8 connection_type; + u16 flags; + u16 int_flags; + u8 pin_config; + u16 drive_strength; + u16 debounce_timeout; + u16 pin_table_offset; + u8 res_source_index; + u16 res_source_offset; + u16 vendor_offset; + u16 vendor_length; +} __attribute__((packed)); + +struct aml_resource_i2c_serialbus { + u8 descriptor_type; + u16 resource_length; + u8 revision_id; + u8 res_source_index; + u8 type; + u8 flags; + u16 type_specific_flags; + u8 type_revision_id; + u16 type_data_length; + u32 connection_speed; + u16 slave_address; +} __attribute__((packed)); + +struct aml_resource_spi_serialbus { + u8 descriptor_type; + u16 resource_length; + u8 revision_id; + u8 res_source_index; + u8 type; + u8 flags; + u16 type_specific_flags; + u8 type_revision_id; + u16 type_data_length; + u32 connection_speed; + u8 data_bit_length; + u8 clock_phase; + u8 clock_polarity; + u16 device_selection; +} __attribute__((packed)); + +struct aml_resource_uart_serialbus { + u8 descriptor_type; + u16 resource_length; + u8 revision_id; + u8 res_source_index; + u8 type; + u8 flags; + u16 type_specific_flags; + u8 type_revision_id; + u16 type_data_length; + u32 default_baud_rate; + u16 rx_fifo_size; + u16 tx_fifo_size; + u8 parity; + u8 lines_enabled; +} __attribute__((packed)); + +struct aml_resource_common_serialbus { + u8 descriptor_type; + u16 resource_length; + u8 revision_id; + u8 res_source_index; + u8 type; + u8 flags; + u16 type_specific_flags; + u8 type_revision_id; + u16 type_data_length; +} __attribute__((packed)); + +struct aml_resource_address { + u8 descriptor_type; + u16 resource_length; + u8 resource_type; + u8 flags; + u8 specific_flags; +} __attribute__((packed)); + +union aml_resource { + u8 descriptor_type; + struct aml_resource_small_header small_header; + struct aml_resource_large_header large_header; + struct aml_resource_irq irq; + struct aml_resource_dma dma; + struct aml_resource_start_dependent start_dpf; + struct aml_resource_end_dependent end_dpf; + struct aml_resource_io io; + struct aml_resource_fixed_io fixed_io; + struct aml_resource_fixed_dma fixed_dma; + struct aml_resource_vendor_small vendor_small; + struct aml_resource_end_tag end_tag; + struct aml_resource_memory24 memory24; + struct aml_resource_generic_register generic_reg; + struct aml_resource_vendor_large vendor_large; + struct aml_resource_memory32 memory32; + struct aml_resource_fixed_memory32 fixed_memory32; + struct aml_resource_address16 address16; + struct aml_resource_address32 address32; + struct aml_resource_address64 address64; + struct aml_resource_extended_address64 ext_address64; + struct aml_resource_extended_irq extended_irq; + struct aml_resource_gpio gpio; + struct aml_resource_i2c_serialbus i2c_serial_bus; + struct aml_resource_spi_serialbus spi_serial_bus; + struct aml_resource_uart_serialbus uart_serial_bus; + struct aml_resource_common_serialbus common_serial_bus; + struct aml_resource_address address; + u32 dword_item; + u16 word_item; + u8 byte_item; +}; + +struct class_attribute; + +struct kobj_uevent_env; + +struct kobj_ns_type_operations; + +struct dev_pm_ops___2; + +struct subsys_private; + +struct class { + const char *name; + struct module *owner; + struct class_attribute *class_attrs; + const struct attribute_group **dev_groups; + struct kobject *dev_kobj; + int (*dev_uevent)(struct device *, struct kobj_uevent_env *); + char * (*devnode)(struct device *, umode_t *); + void (*class_release)(struct class *); + void (*dev_release)(struct device *); + int (*suspend)(struct device *, pm_message_t); + int (*resume)(struct device *); + const struct kobj_ns_type_operations *ns_type; + const void * (*namespace)(struct device *); + const struct dev_pm_ops___2 *pm; + struct subsys_private *p; +}; + +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 { + 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; + unsigned int degree; + struct anon_vma *parent; + struct rb_root rb_root; +}; + +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 apd_private_data; + +struct apd_device_desc { + unsigned int flags; + unsigned int fixed_clk_rate; + int (*setup)(struct apd_private_data *); +}; + +struct apd_private_data { + struct clk *clk; + struct acpi_device *adev; + const struct apd_device_desc *dev_desc; +}; + +struct aper_size_info_16 { + int size; + int num_entries; + int page_order; + u16 size_value; +}; + +struct aper_size_info_32 { + int size; + int num_entries; + int page_order; + u32 size_value; +}; + +struct aper_size_info_8 { + int size; + int num_entries; + int page_order; + u8 size_value; +}; + +struct aper_size_info_fixed { + int size; + int num_entries; + int page_order; +}; + +struct aper_size_info_lvl2 { + int size; + int num_entries; + u32 size_value; +}; + +struct aperture { + resource_size_t base; + resource_size_t size; +}; + +struct aperture_range { + spinlock_t bitmap_lock; + long unsigned int *bitmap; + long unsigned int offset; + long unsigned int next_bit; + u64 *pte_pages[64]; +}; + +struct apertures_struct { + unsigned int count; + struct aperture ranges[0]; +}; + +struct physid_mask; + +typedef struct physid_mask physid_mask_t; + +struct apic { + char *name; + int (*probe)(void); + int (*acpi_madt_oem_check)(char *, char *); + int (*apic_id_valid)(int); + int (*apic_id_registered)(void); + u32 irq_delivery_mode; + u32 irq_dest_mode; + const struct cpumask * (*target_cpus)(void); + int disable_esr; + int dest_logical; + long unsigned int (*check_apicid_used)(physid_mask_t *, int); + void (*vector_allocation_domain)(int, struct cpumask *, const struct cpumask *); + void (*init_apic_ldr)(void); + void (*ioapic_phys_id_map)(physid_mask_t *, physid_mask_t *); + void (*setup_apic_routing)(void); + int (*cpu_present_to_apicid)(int); + void (*apicid_to_cpu_present)(int, physid_mask_t *); + int (*check_phys_apicid_present)(int); + int (*phys_pkg_id)(int, int); + unsigned int (*get_apic_id)(long unsigned int); + long unsigned int (*set_apic_id)(unsigned int); + long unsigned int apic_id_mask; + int (*cpu_mask_to_apicid_and)(const struct cpumask *, const struct cpumask *, unsigned int *); + void (*send_IPI)(int, int); + void (*send_IPI_mask)(const struct cpumask *, int); + void (*send_IPI_mask_allbutself)(const struct cpumask *, int); + void (*send_IPI_allbutself)(int); + void (*send_IPI_all)(int); + void (*send_IPI_self)(int); + int (*wakeup_secondary_cpu)(int, long unsigned int); + void (*inquire_remote_apic)(int); + u32 (*read)(u32); + void (*write)(u32, u32); + void (*eoi_write)(u32, u32); + u64 (*icr_read)(void); + void (*icr_write)(u32, u32); + void (*wait_icr_idle)(void); + u32 (*safe_wait_icr_idle)(void); +}; + +struct irq_cfg { + unsigned int dest_apicid; + u8 vector; + u8 old_vector; +}; + +struct apic_chip_data { + struct irq_cfg cfg; + cpumask_var_t domain; + cpumask_var_t old_domain; + u8 move_in_progress: 1; +}; + +struct apm_bios_info { + __u16 version; + __u16 cseg; + __u32 offset; + __u16 cseg_16; + __u16 dseg; + __u16 flags; + __u16 cseg_len; + __u16 cseg_16_len; + __u16 dseg_len; +}; + +struct apply_microcode_ctx { + int err; +}; + +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 arc4_ctx { + u32 S[256]; + u32 x; + u32 y; +}; + +struct arch_clocksource_data { + int vclock_mode; +}; + +struct arch_elf_state {}; + +struct arch_hw_breakpoint { + long unsigned int address; + long unsigned int mask; + u8 len; + u8 type; +}; + +struct arch_specific_insn { + kprobe_opcode_t *insn; + int boostable; + bool if_modifier; +}; + +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; + char sa_data[14]; +}; + +struct arpreq { + struct sockaddr arp_pa; + struct sockaddr arp_ha; + int arp_flags; + struct sockaddr arp_netmask; + char arp_dev[16]; +}; + +struct array_data { + void *array; + u32 elements; +}; + +struct aspm_latency { + u32 l0s; + u32 l1; +}; + +struct aspm_register_info { + u32 support: 2; + u32 enabled: 2; + u32 latency_encoding_l0s; + u32 latency_encoding_l1; +}; + +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 crypto_queue { + struct list_head list; + struct list_head *backlog; + unsigned int qlen; + unsigned int max_qlen; +}; + +struct async_chainiv_ctx { + long unsigned int state; + spinlock_t lock; + int err; + struct crypto_queue queue; + struct work_struct postponed; + char iv[0]; +}; + +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 async_scan_data { + struct list_head list; + struct Scsi_Host *shost; + struct completion prev_finished; +}; + +struct ata_acpi_drive { + u32 pio; + u32 dma; +}; + +struct ata_acpi_gtf { + u8 tf[7]; +}; + +struct ata_acpi_gtm { + struct ata_acpi_drive drive[2]; + u32 flags; +}; + +struct ata_device; + +struct ata_acpi_hotplug_context { + struct acpi_hotplug_context hp; + union { + struct ata_port *ap; + struct ata_device *dev; + } data; +}; + +struct ata_blacklist_entry { + const char *model_num; + const char *model_rev; + long unsigned int horkage; +}; + +struct ata_bmdma_prd { + __le32 addr; + __le32 flags_len; +}; + +struct ata_ering_entry { + unsigned int eflags; + unsigned int err_mask; + u64 timestamp; +}; + +struct ata_ering { + int cursor; + struct ata_ering_entry ring[32]; +}; + +struct scsi_device; + +struct ata_device { + struct ata_link *link; + unsigned int devno; + unsigned int horkage; + long unsigned int flags; + struct scsi_device *sdev; + void *private_data; + union acpi_object *gtf_cache; + unsigned int gtf_filter; + struct device tdev; + u64 n_sectors; + u64 n_native_sectors; + unsigned int class; + long unsigned int unpark_deadline; + u8 pio_mode; + u8 dma_mode; + u8 xfer_mode; + unsigned int xfer_shift; + unsigned int multi_count; + unsigned int max_sectors; + unsigned int cdb_len; + long unsigned int pio_mask; + long unsigned int mwdma_mask; + long unsigned int udma_mask; + u16 cylinders; + u16 heads; + u16 sectors; + long: 64; + long: 64; + long: 64; + long: 64; + union { + u16 id[256]; + u32 gscr[128]; + }; + u8 devslp_timing[8]; + u8 ncq_send_recv_cmds[20]; + u8 ncq_non_data_cmds[64]; + u32 zac_zoned_cap; + u32 zac_zones_optimal_open; + u32 zac_zones_optimal_nonseq; + u32 zac_zones_max_open; + int spdn_cnt; + struct ata_ering ering; + long: 64; +}; + +struct ata_eh_cmd_timeout_ent { + const u8 *commands; + const long unsigned int *timeouts; +}; + +struct ata_eh_info { + struct ata_device *dev; + u32 serror; + unsigned int err_mask; + unsigned int action; + unsigned int dev_action[2]; + unsigned int flags; + unsigned int probe_mask; + char desc[80]; + int desc_len; +}; + +struct ata_eh_context { + struct ata_eh_info i; + int tries[2]; + int cmd_timeout_idx[12]; + unsigned int classes[2]; + unsigned int did_probe_mask; + unsigned int unloaded_mask; + unsigned int saved_ncq_enabled; + u8 saved_xfer_mode[2]; + long unsigned int last_reset; +}; + +struct ata_force_param { + const char *name; + unsigned int cbl; + int spd_limit; + long unsigned int xfer_mask; + unsigned int horkage_on; + unsigned int horkage_off; + unsigned int lflags; +}; + +struct ata_force_ent { + int port; + int device; + struct ata_force_param param; +}; + +struct ata_port_operations; + +struct ata_host { + spinlock_t lock; + struct device *dev; + void * const *iomap; + unsigned int n_ports; + unsigned int n_tags; + void *private_data; + struct ata_port_operations *ops; + long unsigned int flags; + struct mutex eh_mutex; + struct task_struct *eh_owner; + struct ata_port *simplex_claimed; + struct ata_port *ports[0]; +}; + +struct transport_container { + struct attribute_container ac; + const struct attribute_group *statistics; +}; + +struct scsi_cmnd; + +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 *); + enum blk_eh_timer_return (*eh_timed_out)(struct scsi_cmnd *); + int (*it_nexus_response)(struct Scsi_Host *, u64, int); + int (*tsk_mgmt_response)(struct Scsi_Host *, u64, u64, int); +}; + +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 ata_internal { + struct scsi_transport_template t; + struct device_attribute private_port_attrs[3]; + struct device_attribute private_link_attrs[3]; + struct device_attribute private_dev_attrs[9]; + struct transport_container link_attr_cont; + struct transport_container dev_attr_cont; + struct device_attribute *link_attrs[4]; + struct device_attribute *port_attrs[4]; + struct device_attribute *dev_attrs[10]; +}; + +struct ata_ioports { + void *cmd_addr; + void *data_addr; + void *error_addr; + void *feature_addr; + void *nsect_addr; + void *lbal_addr; + void *lbam_addr; + void *lbah_addr; + void *device_addr; + void *status_addr; + void *command_addr; + void *altstatus_addr; + void *ctl_addr; + void *bmdma_addr; + void *scr_addr; +}; + +struct ata_link { + struct ata_port *ap; + int pmp; + struct device tdev; + unsigned int active_tag; + u32 sactive; + unsigned int flags; + u32 saved_scontrol; + unsigned int hw_sata_spd_limit; + unsigned int sata_spd_limit; + unsigned int sata_spd; + enum ata_lpm_policy lpm_policy; + struct ata_eh_info eh_info; + struct ata_eh_context eh_context; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + struct ata_device device[2]; + long unsigned int last_lpm_change; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; +}; + +struct ata_taskfile { + long unsigned int flags; + u8 protocol; + u8 ctl; + u8 hob_feature; + u8 hob_nsect; + u8 hob_lbal; + u8 hob_lbam; + u8 hob_lbah; + u8 feature; + u8 nsect; + u8 lbal; + u8 lbam; + u8 lbah; + u8 device; + u8 command; + u32 auxiliary; +}; + +struct scatterlist { + long unsigned int page_link; + unsigned int offset; + unsigned int length; + dma_addr_t dma_address; + unsigned int dma_length; +}; + +struct ata_queued_cmd; + +typedef void (*ata_qc_cb_t)(struct ata_queued_cmd *); + +struct ata_queued_cmd { + struct ata_port *ap; + struct ata_device *dev; + struct scsi_cmnd *scsicmd; + void (*scsidone)(struct scsi_cmnd *); + struct ata_taskfile tf; + u8 cdb[16]; + long unsigned int flags; + unsigned int tag; + unsigned int n_elem; + unsigned int orig_n_elem; + int dma_dir; + unsigned int sect_size; + unsigned int nbytes; + unsigned int extrabytes; + unsigned int curbytes; + struct scatterlist sgent; + struct scatterlist *sg; + struct scatterlist *cursg; + unsigned int cursg_ofs; + unsigned int err_mask; + struct ata_taskfile result_tf; + ata_qc_cb_t complete_fn; + void *private_data; + void *lldd_task; +}; + +struct ata_port_stats { + long unsigned int unhandled_irq; + long unsigned int idle_irq; + long unsigned int rw_reqbuf; +}; + +struct ata_port { + struct Scsi_Host *scsi_host; + struct ata_port_operations *ops; + spinlock_t *lock; + long unsigned int flags; + unsigned int pflags; + unsigned int print_id; + unsigned int local_port_no; + unsigned int port_no; + struct ata_ioports ioaddr; + u8 ctl; + u8 last_ctl; + struct ata_link *sff_pio_task_link; + struct delayed_work sff_pio_task; + struct ata_bmdma_prd *bmdma_prd; + dma_addr_t bmdma_prd_dma; + unsigned int pio_mask; + unsigned int mwdma_mask; + unsigned int udma_mask; + unsigned int cbl; + struct ata_queued_cmd qcmd[32]; + long unsigned int sas_tag_allocated; + unsigned int qc_active; + int nr_active_links; + unsigned int sas_last_tag; + long: 64; + long: 64; + struct ata_link link; + struct ata_link *slave_link; + int nr_pmp_links; + struct ata_link *pmp_link; + struct ata_link *excl_link; + struct ata_port_stats stats; + struct ata_host *host; + struct device *dev; + struct device tdev; + struct mutex scsi_scan_mutex; + struct delayed_work hotplug_task; + struct work_struct scsi_rescan_task; + unsigned int hsm_task_state; + u32 msg_enable; + struct list_head eh_done_q; + wait_queue_head_t eh_wait_q; + int eh_tries; + struct completion park_req_pending; + pm_message_t pm_mesg; + enum ata_lpm_policy target_lpm_policy; + struct timer_list fastdrain_timer; + long unsigned int fastdrain_cnt; + int em_message_type; + void *private_data; + struct ata_acpi_gtm __acpi_init_gtm; + long: 0; + u8 sector_buf[512]; +}; + +struct ata_port_info { + long unsigned int flags; + long unsigned int link_flags; + long unsigned int pio_mask; + long unsigned int mwdma_mask; + long unsigned int udma_mask; + struct ata_port_operations *port_ops; + void *private_data; +}; + +typedef int (*ata_prereset_fn_t)(struct ata_link *, long unsigned int); + +typedef int (*ata_reset_fn_t)(struct ata_link *, unsigned int *, long unsigned int); + +typedef void (*ata_postreset_fn_t)(struct ata_link *, unsigned int *); + +struct ata_port_operations { + int (*qc_defer)(struct ata_queued_cmd *); + int (*check_atapi_dma)(struct ata_queued_cmd *); + void (*qc_prep)(struct ata_queued_cmd *); + unsigned int (*qc_issue)(struct ata_queued_cmd *); + bool (*qc_fill_rtf)(struct ata_queued_cmd *); + int (*cable_detect)(struct ata_port *); + long unsigned int (*mode_filter)(struct ata_device *, long unsigned int); + void (*set_piomode)(struct ata_port *, struct ata_device *); + void (*set_dmamode)(struct ata_port *, struct ata_device *); + int (*set_mode)(struct ata_link *, struct ata_device **); + unsigned int (*read_id)(struct ata_device *, struct ata_taskfile *, u16 *); + void (*dev_config)(struct ata_device *); + void (*freeze)(struct ata_port *); + void (*thaw)(struct ata_port *); + ata_prereset_fn_t prereset; + ata_reset_fn_t softreset; + ata_reset_fn_t hardreset; + ata_postreset_fn_t postreset; + ata_prereset_fn_t pmp_prereset; + ata_reset_fn_t pmp_softreset; + ata_reset_fn_t pmp_hardreset; + ata_postreset_fn_t pmp_postreset; + void (*error_handler)(struct ata_port *); + void (*lost_interrupt)(struct ata_port *); + void (*post_internal_cmd)(struct ata_queued_cmd *); + void (*sched_eh)(struct ata_port *); + void (*end_eh)(struct ata_port *); + int (*scr_read)(struct ata_link *, unsigned int, u32 *); + int (*scr_write)(struct ata_link *, unsigned int, u32); + void (*pmp_attach)(struct ata_port *); + void (*pmp_detach)(struct ata_port *); + int (*set_lpm)(struct ata_link *, enum ata_lpm_policy, unsigned int); + int (*port_suspend)(struct ata_port *, pm_message_t); + int (*port_resume)(struct ata_port *); + int (*port_start)(struct ata_port *); + void (*port_stop)(struct ata_port *); + void (*host_stop)(struct ata_host *); + void (*sff_dev_select)(struct ata_port *, unsigned int); + void (*sff_set_devctl)(struct ata_port *, u8); + u8 (*sff_check_status)(struct ata_port *); + u8 (*sff_check_altstatus)(struct ata_port *); + void (*sff_tf_load)(struct ata_port *, const struct ata_taskfile *); + void (*sff_tf_read)(struct ata_port *, struct ata_taskfile *); + void (*sff_exec_command)(struct ata_port *, const struct ata_taskfile *); + unsigned int (*sff_data_xfer)(struct ata_device *, unsigned char *, unsigned int, int); + void (*sff_irq_on)(struct ata_port *); + bool (*sff_irq_check)(struct ata_port *); + void (*sff_irq_clear)(struct ata_port *); + void (*sff_drain_fifo)(struct ata_queued_cmd *); + void (*bmdma_setup)(struct ata_queued_cmd *); + void (*bmdma_start)(struct ata_queued_cmd *); + void (*bmdma_stop)(struct ata_queued_cmd *); + u8 (*bmdma_status)(struct ata_port *); + ssize_t (*em_show)(struct ata_port *, char *); + ssize_t (*em_store)(struct ata_port *, const char *, size_t); + ssize_t (*sw_activity_show)(struct ata_device *, char *); + ssize_t (*sw_activity_store)(struct ata_device *, enum sw_activity); + ssize_t (*transmit_led_message)(struct ata_port *, u32, ssize_t); + void (*phy_reset)(struct ata_port *); + void (*eng_timeout)(struct ata_port *); + const struct ata_port_operations *inherits; +}; + +struct ata_scsi_args { + struct ata_device *dev; + u16 *id; + struct scsi_cmnd *cmd; + void (*done)(struct scsi_cmnd *); +}; + +struct ata_show_ering_arg { + char *buf; + int written; +}; + +struct ata_timing { + short unsigned int mode; + short unsigned int setup; + short unsigned int act8b; + short unsigned int rec8b; + short unsigned int cyc8b; + short unsigned int active; + short unsigned int recover; + short unsigned int dmack_hold; + short unsigned int cycle; + short unsigned int udma; +}; + +struct ata_xfer_ent { + int shift; + int bits; + u8 base; +}; + +struct serio; + +struct ps2dev { + struct serio *serio; + struct mutex cmd_mutex; + wait_queue_head_t wait; + long unsigned int flags; + unsigned char cmdbuf[8]; + unsigned char cmdcnt; + unsigned char nak; +}; + +struct atkbd { + struct ps2dev ps2dev; + struct input_dev *dev; + char name[64]; + char phys[32]; + short unsigned int id; + short unsigned int keycode[512]; + long unsigned int force_release_mask[8]; + unsigned char set; + bool translated; + bool extra; + bool write; + bool softrepeat; + bool softraw; + bool scroll; + bool enabled; + unsigned char emul; + bool resend; + bool release; + long unsigned int xl_bit; + unsigned int last; + long unsigned int time; + long unsigned int err_count; + struct delayed_work event_work; + long unsigned int event_jiffies; + long unsigned int event_mask; + struct mutex mutex; +}; + +struct atomic_notifier_head { + spinlock_t lock; + struct notifier_block *head; +}; + +struct bin_attribute___2; + +struct attribute_group { + const char *name; + umode_t (*is_visible)(struct kobject *, struct attribute *, int); + umode_t (*is_bin_visible)(struct kobject *, struct bin_attribute___2 *, int); + struct attribute **attrs; + struct bin_attribute___2 **bin_attrs; +}; + +struct attribute_group___2 { + const char *name; + umode_t (*is_visible)(struct kobject___2 *, struct attribute *, int); + umode_t (*is_bin_visible)(struct kobject___2 *, struct bin_attribute *, int); + struct attribute **attrs; + struct bin_attribute **bin_attrs; +}; + +struct audio_buf_info { + int fragments; + int fragstotal; + int fragsize; + int bytes; +}; + +struct kernel_cap_struct { + __u32 cap[2]; +}; + +typedef struct kernel_cap_struct kernel_cap_t; + +struct audit_cap_data { + kernel_cap_t permitted; + kernel_cap_t inheritable; + union { + unsigned int fE; + kernel_cap_t effective; + }; +}; + +struct timespec { + __kernel_time_t tv_sec; + long int tv_nsec; +}; + +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; + u32 osid; + struct audit_cap_data fcap; + unsigned int fcap_ver; + unsigned char type; + bool should_free; +}; + +struct vfsmount; + +struct dentry___2; + +struct path { + struct vfsmount *mnt; + struct dentry___2 *dentry; +}; + +struct audit_aux_data; + +struct audit_tree_refs; + +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 audit_proctitle { + int len; + char *value; +}; + +struct audit_context { + int dummy; + int in_syscall; + enum audit_state state; + enum audit_state current_state; + unsigned int serial; + int major; + struct timespec ctime; + 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 pid; + 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; + u32 target_sid; + 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; + u32 osid; + 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 timespec 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 { + int argc; + } execve; + }; + int fds[2]; + struct audit_proctitle proctitle; +}; + +struct crypto_spawn { + struct list_head list; + struct crypto_alg *alg; + struct crypto_instance *inst; + const struct crypto_type *frontend; + u32 mask; +}; + +struct crypto_ahash_spawn { + struct crypto_spawn base; +}; + +struct crypto_skcipher_spawn { + struct crypto_spawn base; +}; + +struct authenc_esn_instance_ctx { + struct crypto_ahash_spawn auth; + struct crypto_skcipher_spawn enc; +}; + +struct authenc_esn_request_ctx { + struct scatterlist src[2]; + struct scatterlist dst[2]; + char tail[0]; +}; + +struct authenc_instance_ctx { + struct crypto_ahash_spawn auth; + struct crypto_skcipher_spawn enc; + unsigned int reqoff; +}; + +struct authenc_request_ctx { + struct scatterlist src[2]; + struct scatterlist dst[2]; + char tail[0]; +}; + +struct auto_out_pin { + hda_nid_t pin; + short int seq; +}; + +struct task_group; + +struct autogroup { + struct kref kref; + struct task_group *tg; + struct rw_semaphore lock; + long unsigned int id; + int nice; +}; + +struct hdac_rb { + __le32 *buf; + dma_addr_t addr; + short unsigned int rp; + short unsigned int wp; + int cmds[8]; + u32 res[8]; +}; + +struct snd_dma_device { + int type; + struct device *dev; +}; + +struct snd_dma_buffer { + struct snd_dma_device dev; + unsigned char *area; + dma_addr_t addr; + size_t bytes; + void *private_data; +}; + +struct hdac_bus_ops; + +struct hdac_io_ops; + +struct hdac_device; + +struct i915_audio_component; + +struct hdac_bus { + struct device *dev; + const struct hdac_bus_ops *ops; + const struct hdac_io_ops *io_ops; + long unsigned int addr; + void *remap_addr; + int irq; + struct list_head codec_list; + unsigned int num_codecs; + struct hdac_device *caddr_tbl[16]; + u32 unsol_queue[128]; + unsigned int unsol_rp; + unsigned int unsol_wp; + struct work_struct unsol_work; + long unsigned int codec_mask; + long unsigned int codec_powered; + struct hdac_rb corb; + struct hdac_rb rirb; + unsigned int last_cmd[8]; + struct snd_dma_buffer rb; + struct snd_dma_buffer posbuf; + struct list_head stream_list; + bool chip_init: 1; + bool sync_write: 1; + bool use_posbuf: 1; + bool snoop: 1; + bool align_bdle_4k: 1; + bool reverse_assign: 1; + bool corbrp_self_clear: 1; + int bdl_pos_adj; + spinlock_t reg_lock; + struct mutex cmd_mutex; + struct i915_audio_component *audio_component; + int i915_power_refcount; +}; + +struct snd_card; + +struct hda_bus { + struct hdac_bus core; + struct snd_card *card; + struct pci_dev *pci; + const char *modelname; + struct mutex prepare_mutex; + long unsigned int pcm_dev_bits[1]; + unsigned int needs_damn_long_delay: 1; + unsigned int allow_bus_reset: 1; + unsigned int shutdown: 1; + unsigned int response_reset: 1; + unsigned int in_reset: 1; + unsigned int no_response_fallback: 1; + int primary_dig_out_type; + unsigned int mixer_assigned; +}; + +struct azx; + +struct azx_dev; + +typedef unsigned int (*azx_get_pos_callback_t)(struct azx *, struct azx_dev *); + +typedef int (*azx_get_delay_callback_t)(struct azx *, struct azx_dev *, unsigned int); + +struct hda_controller_ops; + +struct azx { + struct hda_bus bus; + struct snd_card *card; + struct pci_dev *pci; + int dev_index; + int driver_type; + unsigned int driver_caps; + int playback_streams; + int playback_index_offset; + int capture_streams; + int capture_index_offset; + int num_streams; + const int *jackpoll_ms; + const struct hda_controller_ops *ops; + azx_get_pos_callback_t get_position[2]; + azx_get_delay_callback_t get_delay[2]; + struct mutex open_mutex; + struct list_head pcm_list; + int codec_probe_mask; + unsigned int beep_mode; + int bdl_pos_adj; + int poll_count; + unsigned int running: 1; + unsigned int single_cmd: 1; + unsigned int polling_mode: 1; + unsigned int msi: 1; + unsigned int probing: 1; + unsigned int snoop: 1; + unsigned int align_buffer_size: 1; + unsigned int region_requested: 1; + unsigned int disabled: 1; +}; + +struct cyclecounter; + +struct timecounter { + const struct cyclecounter *cc; + cycle_t cycle_last; + u64 nsec; + u64 mask; + u64 frac; +}; + +struct cyclecounter { + cycle_t (*read)(const struct cyclecounter *); + cycle_t mask; + u32 mult; + u32 shift; +}; + +struct hdac_stream { + struct hdac_bus *bus; + struct snd_dma_buffer bdl; + __le32 *posbuf; + int direction; + unsigned int bufsize; + unsigned int period_bytes; + unsigned int frags; + unsigned int fifo_size; + void *sd_addr; + u32 sd_int_sta_mask; + struct snd_pcm_substream *substream; + unsigned int format_val; + unsigned char stream_tag; + unsigned char index; + int assigned_key; + bool opened: 1; + bool running: 1; + bool prepared: 1; + bool no_period_wakeup: 1; + bool locked: 1; + long unsigned int start_wallclk; + long unsigned int period_wallclk; + struct timecounter tc; + struct cyclecounter cc; + int delay_negative_threshold; + struct list_head list; +}; + +struct azx_dev { + struct hdac_stream core; + unsigned int irq_pending: 1; + unsigned int insufficient: 1; + unsigned int wc_marked: 1; +}; + +struct snd_pcm; + +struct azx_pcm { + struct azx *chip; + struct snd_pcm *pcm; + struct hda_codec *codec; + struct hda_pcm *info; + struct list_head list; +}; + +typedef int congested_fn(void *, int); + +struct percpu_counter { + raw_spinlock_t lock; + s64 count; + struct list_head list; + s32 *counters; +}; + +struct fprop_local_percpu { + struct percpu_counter events; + unsigned int period; + raw_spinlock_t lock; +}; + +struct backing_dev_info; + +struct bdi_writeback_congested; + +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; + struct percpu_counter stat[4]; + struct bdi_writeback_congested *congested; + 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; + spinlock_t work_lock; + struct list_head work_list; + struct delayed_work dwork; + struct list_head bdi_node; +}; + +struct backing_dev_info { + struct list_head bdi_list; + long unsigned int ra_pages; + unsigned int capabilities; + congested_fn *congested_fn; + void *congested_data; + char *name; + unsigned int min_ratio; + unsigned int max_ratio; + unsigned int max_prop_frac; + atomic_long_t tot_write_bandwidth; + struct bdi_writeback wb; + struct list_head wb_list; + struct bdi_writeback_congested *wb_congested; + wait_queue_head_t wb_waitq; + struct device *dev; + struct timer_list laptop_mode_wb_timer; + struct dentry___2 *debug_dir; + struct dentry___2 *debug_stats; +}; + +struct backlight_properties { + int brightness; + int max_brightness; + int power; + int fb_blank; + enum backlight_type type; + unsigned int state; +}; + +struct backlight_ops; + +struct backlight_device { + struct backlight_properties props; + struct mutex___2 update_lock; + struct mutex___2 ops_lock; + const struct backlight_ops *ops; + struct notifier_block fb_notif; + struct list_head entry; + struct device___2 dev; + bool fb_bl_on[32]; + int use_count; +}; + +struct fb_info; + +struct backlight_ops { + unsigned int options; + int (*update_status)(struct backlight_device *); + int (*get_brightness)(struct backlight_device *); + int (*check_fb)(struct backlight_device *, struct fb_info *); +}; + +struct pt_regs { + long unsigned int r15; + long unsigned int r14; + long unsigned int r13; + long unsigned int r12; + long unsigned int bp; + long unsigned int bx; + long unsigned int r11; + long unsigned int r10; + long unsigned int r9; + long unsigned int r8; + long unsigned int ax; + long unsigned int cx; + long unsigned int dx; + long unsigned int si; + long unsigned int di; + long unsigned int orig_ax; + long unsigned int ip; + long unsigned int cs; + long unsigned int flags; + long unsigned int sp; + long unsigned int ss; +}; + +struct bad_iret_stack { + void *error_entry_ret; + struct pt_regs regs; +}; + +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 badness_table { + int no_primary_dac; + int no_dac; + int shared_primary; + int shared_surr; + int shared_clfe; + int shared_surr_main; +}; + +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 gendisk; + +struct bd_holder_disk { + struct list_head list; + struct gendisk *disk; + int refcnt; +}; + +struct bdb_driver_features { + u8 boot_dev_algorithm: 1; + u8 block_display_switch: 1; + u8 allow_display_switch: 1; + u8 hotplug_dvo: 1; + u8 dual_view_zoom: 1; + u8 int15h_hook: 1; + u8 sprite_in_clone: 1; + u8 primary_lfp_id: 1; + u16 boot_mode_x; + u16 boot_mode_y; + u8 boot_mode_bpp; + u8 boot_mode_refresh; + u16 enable_lfp_primary: 1; + u16 selective_mode_pruning: 1; + u16 dual_frequency: 1; + u16 render_clock_freq: 1; + u16 nt_clone_support: 1; + u16 power_scheme_ui: 1; + u16 sprite_display_assign: 1; + u16 cui_aspect_scaling: 1; + u16 preserve_aspect_ratio: 1; + u16 sdvo_device_power_down: 1; + u16 crt_hotplug: 1; + u16 lvds_config: 2; + u16 tv_hotplug: 1; + u16 hdmi_config: 2; + u8 static_display: 1; + u8 reserved2: 7; + u16 legacy_crt_max_x; + u16 legacy_crt_max_y; + u8 legacy_crt_max_refresh; + u8 hdmi_termination; + u8 custom_vbt_version; + u16 rmpm_enabled: 1; + u16 s2ddt_enabled: 1; + u16 dpst_enabled: 1; + u16 bltclt_enabled: 1; + u16 adb_enabled: 1; + u16 drrs_enabled: 1; + u16 grs_enabled: 1; + u16 gpmt_enabled: 1; + u16 tbt_enabled: 1; + u16 psr_enabled: 1; + u16 ips_enabled: 1; + u16 reserved3: 4; + u16 pc_feature_valid: 1; +} __attribute__((packed)); + +struct edp_power_seq { + u16 t1_t3; + u16 t8; + u16 t9; + u16 t10; + u16 t11_t12; +}; + +struct edp_link_params { + u8 rate: 4; + u8 lanes: 4; + u8 preemphasis: 4; + u8 vswing: 4; +}; + +struct bdb_edp { + struct edp_power_seq power_seqs[16]; + u32 color_depth; + struct edp_link_params link_params[16]; + u32 sdrrs_msa_timing_delay; + u16 edp_s3d_feature; + u16 edp_t3_optimization; + u64 edp_vswing_preemph; +} __attribute__((packed)); + +struct bdb_general_definitions { + u8 crt_ddc_gmbus_pin; + u8 dpms_acpi: 1; + u8 skip_boot_crt_detect: 1; + u8 dpms_aim: 1; + u8 rsvd1: 5; + u8 boot_display[2]; + u8 child_dev_size; + uint8_t devices[0]; +}; + +struct bdb_general_features { + u8 panel_fitting: 2; + u8 flexaim: 1; + u8 msg_enable: 1; + u8 clear_screen: 3; + u8 color_flip: 1; + u8 download_ext_vbt: 1; + u8 enable_ssc: 1; + u8 ssc_freq: 1; + u8 enable_lfp_on_override: 1; + u8 disable_ssc_ddt: 1; + u8 rsvd7: 1; + u8 display_clock_mode: 1; + u8 rsvd8: 1; + u8 disable_smooth_vision: 1; + u8 single_dvi: 1; + u8 rsvd9: 1; + u8 fdi_rx_polarity_inverted: 1; + u8 rsvd10: 4; + u8 legacy_monitor_detect; + u8 int_crt_support: 1; + u8 int_tv_support: 1; + u8 int_efp_support: 1; + u8 dp_ssc_enb: 1; + u8 dp_ssc_freq: 1; + u8 rsvd11: 3; +}; + +struct bdb_header { + u8 signature[16]; + u16 version; + u16 header_size; + u16 bdb_size; +}; + +struct bdb_lfp_backlight_data_entry { + u8 type: 2; + u8 active_low_pwm: 1; + u8 obsolete1: 5; + u16 pwm_freq_hz; + u8 min_brightness; + u8 obsolete2; + u8 obsolete3; +} __attribute__((packed)); + +struct bdb_lfp_backlight_data { + u8 entry_size; + struct bdb_lfp_backlight_data_entry data[16]; + u8 level[16]; +}; + +struct lvds_fp_timing { + u16 x_res; + u16 y_res; + u32 lvds_reg; + u32 lvds_reg_val; + u32 pp_on_reg; + u32 pp_on_reg_val; + u32 pp_off_reg; + u32 pp_off_reg_val; + u32 pp_cycle_reg; + u32 pp_cycle_reg_val; + u32 pfit_reg; + u32 pfit_reg_val; + u16 terminator; +} __attribute__((packed)); + +struct lvds_dvo_timing { + u16 clock; + u8 hactive_lo; + u8 hblank_lo; + u8 hblank_hi: 4; + u8 hactive_hi: 4; + u8 vactive_lo; + u8 vblank_lo; + u8 vblank_hi: 4; + u8 vactive_hi: 4; + u8 hsync_off_lo; + u8 hsync_pulse_width; + u8 vsync_pulse_width: 4; + u8 vsync_off: 4; + u8 rsvd0: 6; + u8 hsync_off_hi: 2; + u8 h_image; + u8 v_image; + u8 max_hv; + u8 h_border; + u8 v_border; + u8 rsvd1: 3; + u8 digital: 2; + u8 vsync_positive: 1; + u8 hsync_positive: 1; + u8 rsvd2: 1; +}; + +struct lvds_pnp_id { + u16 mfg_name; + u16 product_code; + u32 serial; + u8 mfg_week; + u8 mfg_year; +} __attribute__((packed)); + +struct bdb_lvds_lfp_data_entry { + struct lvds_fp_timing fp_timing; + struct lvds_dvo_timing dvo_timing; + struct lvds_pnp_id pnp_id; +}; + +struct bdb_lvds_lfp_data { + struct bdb_lvds_lfp_data_entry data[16]; +}; + +struct bdb_lvds_lfp_data_ptr { + u16 fp_timing_offset; + u8 fp_table_size; + u16 dvo_timing_offset; + u8 dvo_table_size; + u16 panel_pnp_id_offset; + u8 pnp_table_size; +} __attribute__((packed)); + +struct bdb_lvds_lfp_data_ptrs { + u8 lvds_entries; + struct bdb_lvds_lfp_data_ptr ptr[16]; +}; + +struct bdb_lvds_options { + u8 panel_type; + u8 rsvd1; + u8 pfit_mode: 2; + u8 pfit_text_mode_enhanced: 1; + u8 pfit_gfx_mode_enhanced: 1; + u8 pfit_ratio_auto: 1; + u8 pixel_dither: 1; + u8 lvds_edid: 1; + u8 rsvd2: 1; + u8 rsvd4; + u32 lvds_panel_channel_bits; + u16 ssc_bits; + u16 ssc_freq; + u16 ssc_ddt; + u16 panel_color_depth; + u32 dps_panel_type_bits; + u32 blt_control_type_bits; +}; + +struct mipi_config { + u16 panel_id; + u32 enable_dithering: 1; + u32 rsvd1: 1; + u32 is_bridge: 1; + u32 panel_arch_type: 2; + u32 is_cmd_mode: 1; + u32 video_transfer_mode: 2; + u32 cabc_supported: 1; + u32 pwm_blc: 1; + u32 videomode_color_format: 4; + u32 rotation: 2; + u32 bta_enabled: 1; + u32 rsvd2: 15; + u16 dual_link: 2; + u16 lane_cnt: 2; + u16 pixel_overlap: 3; + u16 rsvd3: 9; + u16 rsvd4; + u8 rsvd5; + u32 target_burst_mode_freq; + u32 dsi_ddr_clk; + u32 bridge_ref_clk; + u8 byte_clk_sel: 2; + u8 rsvd6: 6; + u16 dphy_param_valid: 1; + u16 eot_pkt_disabled: 1; + u16 enable_clk_stop: 1; + u16 rsvd7: 13; + u32 hs_tx_timeout; + u32 lp_rx_timeout; + u32 turn_around_timeout; + u32 device_reset_timer; + u32 master_init_timer; + u32 dbi_bw_timer; + u32 lp_byte_clk_val; + u32 prepare_cnt: 6; + u32 rsvd8: 2; + u32 clk_zero_cnt: 8; + u32 trail_cnt: 5; + u32 rsvd9: 3; + u32 exit_zero_cnt: 6; + u32 rsvd10: 2; + u32 clk_lane_switch_cnt; + u32 hl_switch_cnt; + u32 rsvd11[6]; + u8 tclk_miss; + u8 tclk_post; + u8 rsvd12; + u8 tclk_pre; + u8 tclk_prepare; + u8 tclk_settle; + u8 tclk_term_enable; + u8 tclk_trail; + u16 tclk_prepare_clkzero; + u8 rsvd13; + u8 td_term_enable; + u8 teot; + u8 ths_exit; + u8 ths_prepare; + u16 ths_prepare_hszero; + u8 rsvd14; + u8 ths_settle; + u8 ths_skip; + u8 ths_trail; + u8 tinit; + u8 tlpx; + u8 rsvd15[3]; + u8 panel_enable; + u8 bl_enable; + u8 pwm_enable; + u8 reset_r_n; + u8 pwr_down_r; + u8 stdby_r_n; +} __attribute__((packed)); + +struct mipi_pps_data { + u16 panel_on_delay; + u16 bl_enable_delay; + u16 bl_disable_delay; + u16 panel_off_delay; + u16 panel_power_cycle_delay; +}; + +struct bdb_mipi_config { + struct mipi_config config[6]; + struct mipi_pps_data pps[6]; +}; + +struct bdb_mipi_sequence { + u8 version; + u8 data[0]; +}; + +struct psr_table { + u8 full_link: 1; + u8 require_aux_to_wakeup: 1; + u8 feature_bits_rsvd: 6; + u8 idle_frames: 4; + u8 lines_to_wait: 3; + u8 wait_times_rsvd: 1; + u16 tp1_wakeup_time; + u16 tp2_tp3_wakeup_time; +}; + +struct bdb_psr { + struct psr_table psr_table[16]; +}; + +struct bdb_sdvo_lvds_options { + u8 panel_backlight; + u8 h40_set_panel_type; + u8 panel_type; + u8 ssc_clk_freq; + u16 als_low_trip; + u16 als_high_trip; + u8 sclalarcoeff_tab_row_num; + u8 sclalarcoeff_tab_row_size; + u8 coefficient[8]; + u8 panel_misc_bits_1; + u8 panel_misc_bits_2; + u8 panel_misc_bits_3; + u8 panel_misc_bits_4; +}; + +struct super_block; + +struct hd_struct; + +struct block_device { + dev_t bd_dev; + int bd_openers; + struct inode *bd_inode; + struct super_block *bd_super; + struct mutex bd_mutex; + struct list_head bd_inodes; + void *bd_claiming; + void *bd_holder; + int bd_holders; + bool bd_write_holder; + struct list_head bd_holder_disks; + struct block_device *bd_contains; + unsigned int bd_block_size; + struct hd_struct *bd_part; + unsigned int bd_part_count; + int bd_invalidated; + struct gendisk *bd_disk; + struct request_queue *bd_queue; + struct list_head bd_list; + long unsigned int bd_private; + int bd_fsfreeze_count; + struct mutex bd_fsfreeze_mutex; +}; + +struct hlist_head { + struct hlist_node *first; +}; + +struct posix_acl; + +struct inode_operations; + +struct super_block___2; + +struct file_operations; + +struct file_lock_context; + +struct pipe_inode_info; + +struct block_device___2; + +struct cdev; + +struct inode___2 { + 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___2 *i_sb; + struct address_space___2 *i_mapping; + long unsigned int i_ino; + union { + const unsigned int i_nlink; + unsigned int __i_nlink; + }; + dev_t i_rdev; + loff_t i_size; + struct timespec i_atime; + struct timespec i_mtime; + struct timespec i_ctime; + spinlock_t i_lock; + short unsigned int i_bytes; + unsigned int i_blkbits; + blkcnt_t i_blocks; + long unsigned int i_state; + struct rw_semaphore___2 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 list_head i_lru; + struct list_head i_sb_list; + union { + struct hlist_head i_dentry; + struct callback_head i_rcu; + }; + u64 i_version; + atomic_t i_count; + atomic_t i_dio_count; + atomic_t i_writecount; + const struct file_operations *i_fop; + struct file_lock_context *i_flctx; + struct address_space___2 i_data; + struct list_head i_devices; + union { + struct pipe_inode_info *i_pipe; + struct block_device___2 *i_bdev; + struct cdev *i_cdev; + char *i_link; + unsigned int i_dir_seq; + }; + __u32 i_generation; + __u32 i_fsnotify_mask; + struct hlist_head i_fsnotify_marks; + void *i_private; +}; + +struct bdev_inode { + struct block_device bdev; + struct inode___2 vfs_inode; +}; + +struct bdi_writeback_congested { + long unsigned int state; + atomic_t refcnt; +}; + +struct bh_accounting { + int nr; + int ratelimit; +}; + +struct buffer_head; + +struct bh_lru { + struct buffer_head *bhs[16]; +}; + +struct bictcp { + u32 cnt; + u32 last_max_cwnd; + u32 loss_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 vm_area_struct___2; + +struct bin_attribute___2 { + struct attribute attr; + size_t size; + void *private; + ssize_t (*read)(struct file___2 *, struct kobject *, struct bin_attribute___2 *, char *, loff_t, size_t); + ssize_t (*write)(struct file___2 *, struct kobject *, struct bin_attribute___2 *, char *, loff_t, size_t); + int (*mmap)(struct file___2 *, struct kobject *, struct bin_attribute___2 *, struct vm_area_struct___2 *); +}; + +struct bvec_iter { + sector_t bi_sector; + unsigned int bi_size; + unsigned int bi_idx; + unsigned int bi_bvec_done; +}; + +struct bio; + +typedef void bio_end_io_t(struct bio *); + +struct bio_vec { + struct page___2 *bv_page; + unsigned int bv_len; + unsigned int bv_offset; +}; + +struct bio_set; + +struct bio { + struct bio *bi_next; + struct block_device *bi_bdev; + unsigned int bi_flags; + int bi_error; + long unsigned int bi_rw; + struct bvec_iter bi_iter; + unsigned int bi_phys_segments; + unsigned int bi_seg_front_size; + unsigned int bi_seg_back_size; + atomic_t __bi_remaining; + bio_end_io_t *bi_end_io; + void *bi_private; + union {}; + 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_list { + struct bio *head; + struct bio *tail; +}; + +struct iovec; + +struct kvec; + +struct bio_vec___2; + +struct iov_iter___2 { + int type; + size_t iov_offset; + size_t count; + union { + const struct iovec *iov; + const struct kvec *kvec; + const struct bio_vec___2 *bvec; + }; + long unsigned int nr_segs; +}; + +struct iovec { + void *iov_base; + __kernel_size_t iov_len; +}; + +struct bio_map_data { + int is_our_pages; + struct iov_iter___2 iter; + struct iovec iov[0]; +}; + +struct kmem_cache; + +struct mempool_s; + +typedef struct mempool_s mempool_t; + +struct bio_set { + struct kmem_cache *bio_slab; + unsigned int front_pad; + mempool_t *bio_pool; + mempool_t *bvec_pool; + spinlock_t rescue_lock; + struct bio_list rescue_list; + struct work_struct rescue_work; + struct workqueue_struct *rescue_workqueue; +}; + +struct bio_slab { + struct kmem_cache *slab; + unsigned int slab_ref; + unsigned int slab_size; + char name[8]; +}; + +struct bio_vec___2 { + struct page *bv_page; + unsigned int bv_len; + unsigned int bv_offset; +}; + +struct biovec_slab { + int nr_vecs; + char *name; + struct kmem_cache *slab; +}; + +typedef void (*fetch_func_t)(struct pt_regs *, void *, void *); + +struct fetch_param { + fetch_func_t fn; + void *data; +}; + +struct bitfield_fetch_param { + struct fetch_param orig; + unsigned char hi_shift; + unsigned char low_shift; +}; + +struct bitmap_page; + +struct bitmap_counts { + spinlock_t lock; + struct bitmap_page *bp; + long unsigned int pages; + long unsigned int missing_pages; + long unsigned int chunkshift; + long unsigned int chunks; +}; + +struct bitmap_storage { + struct file___2 *file; + struct page___2 *sb_page; + struct page___2 **filemap; + long unsigned int *filemap_attr; + long unsigned int file_pages; + long unsigned int bytes; +}; + +struct mddev; + +struct bitmap { + struct bitmap_counts counts; + struct mddev *mddev; + __u64 events_cleared; + int need_sync; + struct bitmap_storage storage; + long unsigned int flags; + int allclean; + atomic_t behind_writes; + long unsigned int behind_writes_used; + long unsigned int daemon_lastrun; + long unsigned int last_end_sync; + atomic_t pending_writes; + wait_queue_head_t write_wait; + wait_queue_head_t overflow_wait; + wait_queue_head_t behind_wait; + struct kernfs_node *sysfs_can_clear; + int cluster_slot; +}; + +struct bitmap_page { + char *map; + unsigned int hijacked: 1; + unsigned int pending: 1; + unsigned int count: 30; +}; + +struct bitmap_super_s { + __le32 magic; + __le32 version; + __u8 uuid[16]; + __le64 events; + __le64 events_cleared; + __le64 sync_size; + __le32 state; + __le32 chunksize; + __le32 daemon_sleep; + __le32 write_behind; + __le32 sectors_reserved; + __le32 nodes; + __u8 cluster_name[64]; + __u8 pad[120]; +}; + +typedef struct bitmap_super_s bitmap_super_t; + +struct blacklist_entry { + struct list_head next; + char *buf; +}; + +struct blk_align_bitmap { + long unsigned int word; + long unsigned int depth; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; +}; + +struct blk_cmd_filter { + long unsigned int read_ok[4]; + long unsigned int write_ok[4]; +}; + +struct blk_dax_ctl { + sector_t sector; + void *addr; + long int size; + pfn_t pfn; +}; + +struct request; + +struct blk_flush_queue { + unsigned int flush_queue_delayed: 1; + unsigned int flush_pending_idx: 1; + unsigned int flush_running_idx: 1; + long unsigned int flush_pending_since; + struct list_head flush_queue[2]; + struct list_head flush_data_in_flight; + struct request *flush_rq; + struct request *orig_rq; + spinlock_t mq_flush_lock; +}; + +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_major_name { + struct blk_major_name *next; + int major; + char name[16]; +}; + +struct blk_mq_hw_ctx; + +struct blk_mq_ctx; + +struct blk_map_ctx { + struct blk_mq_hw_ctx *hctx; + struct blk_mq_ctx *ctx; +}; + +struct blk_mq_alloc_data { + struct request_queue *q; + unsigned int flags; + struct blk_mq_ctx *ctx; + struct blk_mq_hw_ctx *hctx; +}; + +struct bt_wait_state; + +struct blk_mq_bitmap_tags { + unsigned int depth; + unsigned int wake_cnt; + unsigned int bits_per_word; + unsigned int map_nr; + struct blk_align_bitmap *map; + atomic_t wake_index; + struct bt_wait_state *bs; +}; + +struct blk_mq_cpu_notifier { + struct list_head list; + void *data; + int (*notify)(void *, long unsigned int, unsigned int); +}; + +struct blk_mq_ctx { + struct { + spinlock_t lock; + struct list_head rq_list; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + }; + unsigned int cpu; + unsigned int index_hw; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + unsigned int last_tag; + long unsigned int rq_dispatched[2]; + long unsigned int rq_merged; + long: 64; + long: 64; + long: 64; + long: 64; + long unsigned int rq_completed[2]; + struct request_queue *queue; + struct kobject___2 kobj; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; +}; + +struct blk_mq_ctx_sysfs_entry { + struct attribute attr; + ssize_t (*show)(struct blk_mq_ctx *, char *); + ssize_t (*store)(struct blk_mq_ctx *, const char *, size_t); +}; + +struct blk_mq_ctxmap { + unsigned int size; + unsigned int bits_per_word; + struct blk_align_bitmap *map; +}; + +struct blk_mq_hw_ctx { + struct { + spinlock_t lock; + struct list_head dispatch; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + }; + long unsigned int state; + struct delayed_work run_work; + struct delayed_work delay_work; + cpumask_var_t cpumask; + int next_cpu; + int next_cpu_batch; + long unsigned int flags; + struct request_queue *queue; + struct blk_flush_queue *fq; + void *driver_data; + struct blk_mq_ctxmap ctx_map; + unsigned int nr_ctx; + struct blk_mq_ctx **ctxs; + atomic_t wait_index; + struct blk_mq_tags *tags; + long unsigned int queued; + long unsigned int run; + long unsigned int dispatched[10]; + unsigned int numa_node; + unsigned int queue_num; + atomic_t nr_active; + struct blk_mq_cpu_notifier cpu_notifier; + struct kobject___2 kobj; + long unsigned int poll_invoked; + long unsigned int poll_success; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; +}; + +struct blk_mq_hw_ctx_sysfs_entry { + struct attribute attr; + ssize_t (*show)(struct blk_mq_hw_ctx *, char *); + ssize_t (*store)(struct blk_mq_hw_ctx *, const char *, size_t); +}; + +struct blk_mq_queue_data; + +typedef int queue_rq_fn(struct blk_mq_hw_ctx *, const struct blk_mq_queue_data *); + +typedef struct blk_mq_hw_ctx *map_queue_fn(struct request_queue *, const int); + +typedef enum blk_eh_timer_return timeout_fn(struct request *, bool); + +typedef int poll_fn(struct blk_mq_hw_ctx *, unsigned int); + +typedef void softirq_done_fn(struct request *); + +typedef int init_hctx_fn(struct blk_mq_hw_ctx *, void *, unsigned int); + +typedef void exit_hctx_fn(struct blk_mq_hw_ctx *, unsigned int); + +typedef int init_request_fn(void *, struct request *, unsigned int, unsigned int, unsigned int); + +typedef void exit_request_fn(void *, struct request *, unsigned int, unsigned int); + +struct blk_mq_ops { + queue_rq_fn *queue_rq; + map_queue_fn *map_queue; + timeout_fn *timeout; + poll_fn *poll; + softirq_done_fn *complete; + init_hctx_fn *init_hctx; + exit_hctx_fn *exit_hctx; + init_request_fn *init_request; + exit_request_fn *exit_request; +}; + +struct blk_mq_queue_data { + struct request *rq; + struct list_head *list; + bool last; +}; + +struct blk_mq_tags { + unsigned int nr_tags; + unsigned int nr_reserved_tags; + atomic_t active_queues; + struct blk_mq_bitmap_tags bitmap_tags; + struct blk_mq_bitmap_tags breserved_tags; + struct request **rqs; + struct list_head page_list; + int alloc_policy; + cpumask_var_t cpumask; +}; + +struct blk_mq_timeout_data { + long unsigned int next; + unsigned int next_set; +}; + +struct blk_plug { + struct list_head list; + struct list_head mq_list; + 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_tag { + struct request **tag_index; + long unsigned int *tag_map; + int busy; + int max_depth; + int real_max_depth; + atomic_t refcnt; + int alloc_policy; + int next_tag; +}; + +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___2 *dir; + struct dentry___2 *dropped_file; + struct dentry___2 *msg_file; + 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 blkcg {}; + +struct blkcg_gq {}; + +struct blkcipher_desc { + struct crypto_blkcipher *tfm; + void *info; + u32 flags; +}; + +struct blkcipher_tfm { + void *iv; + int (*setkey)(struct crypto_tfm *, const u8 *, unsigned int); + int (*encrypt)(struct blkcipher_desc *, struct scatterlist *, struct scatterlist *, unsigned int); + int (*decrypt)(struct blkcipher_desc *, struct scatterlist *, struct scatterlist *, unsigned int); +}; + +struct blkcipher_walk { + union { + struct { + struct page *page; + long unsigned int offset; + } phys; + struct { + u8 *page; + u8 *addr; + } virt; + } src; + union { + struct { + struct page *page; + long unsigned int offset; + } phys; + struct { + u8 *page; + u8 *addr; + } virt; + } dst; + struct scatter_walk in; + unsigned int nbytes; + struct scatter_walk out; + unsigned int total; + void *page; + u8 *buffer; + u8 *iv; + unsigned int ivsize; + int flags; + unsigned int walk_blocksize; + unsigned int cipher_blocksize; + unsigned int alignmask; +}; + +struct blkg_policy_data {}; + +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]; +}; + +struct block_device___2 { + dev_t bd_dev; + int bd_openers; + struct inode___2 *bd_inode; + struct super_block___2 *bd_super; + struct mutex___2 bd_mutex; + struct list_head bd_inodes; + void *bd_claiming; + void *bd_holder; + int bd_holders; + bool bd_write_holder; + struct list_head bd_holder_disks; + struct block_device___2 *bd_contains; + unsigned int bd_block_size; + struct hd_struct *bd_part; + unsigned int bd_part_count; + int bd_invalidated; + struct gendisk *bd_disk; + struct request_queue *bd_queue; + struct list_head bd_list; + long unsigned int bd_private; + int bd_fsfreeze_count; + struct mutex___2 bd_fsfreeze_mutex; +}; + +struct hd_geometry; + +struct pr_ops; + +struct block_device_operations { + int (*open)(struct block_device *, fmode_t); + void (*release)(struct gendisk *, fmode_t); + int (*rw_page)(struct block_device *, sector_t, struct page___2 *, int); + int (*ioctl)(struct block_device *, fmode_t, unsigned int, long unsigned int); + int (*compat_ioctl)(struct block_device *, fmode_t, unsigned int, long unsigned int); + long int (*direct_access)(struct block_device *, sector_t, void **, pfn_t *, long int); + unsigned int (*check_events)(struct gendisk *, unsigned int); + int (*media_changed)(struct gendisk *); + void (*unlock_native_capacity)(struct gendisk *); + int (*revalidate_disk)(struct gendisk *); + int (*getgeo)(struct block_device *, struct hd_geometry *); + void (*swap_slot_free_notify)(struct block_device *, long unsigned int); + struct module *owner; + const struct pr_ops *pr_ops; +}; + +struct blocking_notifier_head { + struct rw_semaphore rwsem; + struct notifier_block *head; +}; + +struct mem_zone_bm_rtree; + +struct rtree_node; + +struct bm_position { + struct mem_zone_bm_rtree *zone; + struct rtree_node *node; + long unsigned int node_pfn; + int node_bit; +}; + +struct ttm_bus_placement { + void *addr; + phys_addr_t base; + long unsigned int size; + long unsigned int offset; + bool is_iomem; + bool io_reserved_vm; + uint64_t io_reserved_count; +}; + +struct ttm_mem_reg { + void *mm_node; + long unsigned int start; + long unsigned int size; + long unsigned int num_pages; + uint32_t page_alignment; + uint32_t mem_type; + uint32_t placement; + struct ttm_bus_placement bus; +}; + +struct drm_vma_offset_node { + rwlock_t vm_lock; + struct drm_mm_node vm_node; + struct rb_node vm_rb; + struct rb_root vm_files; +}; + +struct ww_acquire_ctx; + +struct ww_mutex { + struct mutex base; + struct ww_acquire_ctx *ctx; +}; + +typedef struct seqcount seqcount_t; + +struct fence; + +struct reservation_object_list; + +struct reservation_object { + struct ww_mutex lock; + seqcount_t seq; + struct fence *fence_excl; + struct reservation_object_list *fence; + struct reservation_object_list *staged; +}; + +struct ttm_bo_global; + +struct ttm_bo_device; + +struct ttm_tt; + +struct sg_table; + +struct ttm_buffer_object { + struct ttm_bo_global *glob; + struct ttm_bo_device *bdev; + enum ttm_bo_type type; + void (*destroy)(struct ttm_buffer_object *); + long unsigned int num_pages; + size_t acc_size; + struct kref kref; + struct kref list_kref; + struct ttm_mem_reg mem; + struct file___2 *persistent_swap_storage; + struct ttm_tt *ttm; + bool evicted; + atomic_t cpu_writers; + struct list_head lru; + struct list_head ddestroy; + struct list_head swap; + struct list_head io_reserve_lru; + long unsigned int priv_flags; + struct drm_vma_offset_node vma_node; + uint64_t offset; + uint32_t cur_placement; + struct sg_table *sg; + struct reservation_object *resv; + struct reservation_object ttm_resv; + struct mutex___2 wu_mutex; +}; + +struct ttm_place; + +struct ttm_placement { + unsigned int num_placement; + const struct ttm_place *placement; + unsigned int num_busy_placement; + const struct ttm_place *busy_placement; +}; + +struct ttm_bo_kmap_obj { + void *virtual; + struct page *page; + enum { + ttm_bo_map_iomap = 129, + ttm_bo_map_vmap = 2, + ttm_bo_map_kmap = 3, + ttm_bo_map_premapped = 132, + } bo_kmap_type; + struct ttm_buffer_object *bo; +}; + +struct drm_device; + +struct dma_buf; + +struct dma_buf_attachment; + +struct drm_gem_object { + struct kref refcount; + unsigned int handle_count; + struct drm_device *dev; + struct file___2 *filp; + struct drm_vma_offset_node vma_node; + size_t size; + int name; + uint32_t read_domains; + uint32_t write_domain; + uint32_t pending_read_domains; + uint32_t pending_write_domain; + struct dma_buf *dma_buf; + struct dma_buf_attachment *import_attach; +}; + +struct ttm_place { + unsigned int fpfn; + unsigned int lpfn; + uint32_t flags; +}; + +struct bochs_bo { + struct ttm_buffer_object bo; + struct ttm_placement placement; + struct ttm_bo_kmap_obj kmap; + struct drm_gem_object gem; + struct ttm_place placements[3]; + int pin_count; +}; + +struct drm_modeset_lock { + struct ww_mutex mutex; + struct list_head head; +}; + +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_display_mode { + struct list_head head; + struct drm_mode_object base; + char name[32]; + enum drm_mode_status status; + unsigned int type; + int clock; + int hdisplay; + int hsync_start; + int hsync_end; + int htotal; + int hskew; + int vdisplay; + int vsync_start; + int vsync_end; + int vtotal; + int vscan; + unsigned int flags; + int width_mm; + int height_mm; + int crtc_clock; + int crtc_hdisplay; + int crtc_hblank_start; + int crtc_hblank_end; + int crtc_hsync_start; + int crtc_hsync_end; + int crtc_htotal; + int crtc_hskew; + int crtc_vdisplay; + int crtc_vblank_start; + int crtc_vblank_end; + int crtc_vsync_start; + int crtc_vsync_end; + int crtc_vtotal; + int *private; + int private_flags; + int vrefresh; + int hsync; + enum hdmi_picture_aspect picture_aspect_ratio; +}; + +struct drm_property; + +struct drm_object_properties { + int count; + int atomic_count; + struct drm_property *properties[24]; + uint64_t values[24]; +}; + +struct drm_plane; + +struct drm_crtc_funcs; + +struct drm_crtc_helper_funcs; + +struct drm_crtc_state; + +struct drm_modeset_acquire_ctx; + +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; + 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_crtc_state *state; + struct drm_modeset_acquire_ctx *acquire_ctx; +}; + +struct drm_bridge; + +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; + uint32_t possible_crtcs; + uint32_t possible_clones; + struct drm_crtc *crtc; + struct drm_bridge *bridge; + const struct drm_encoder_funcs *funcs; + const struct drm_encoder_helper_funcs *helper_private; +}; + +struct drm_display_info { + char name[32]; + unsigned int width_mm; + unsigned int height_mm; + unsigned int min_vfreq; + unsigned int max_vfreq; + unsigned int min_hfreq; + unsigned int max_hfreq; + unsigned int pixel_clock; + unsigned int bpc; + enum subpixel_order subpixel_order; + u32 color_formats; + const u32 *bus_formats; + unsigned int num_bus_formats; + u32 bus_flags; + u8 edid_hdmi_dc_modes; + u8 cea_rev; +}; + +struct drm_cmdline_mode { + bool specified; + bool refresh_specified; + bool bpp_specified; + int xres; + int yres; + int bpp; + int refresh; + bool rb; + bool interlace; + bool cvt; + bool margins; + enum drm_connector_force force; +}; + +struct drm_connector_funcs; + +struct drm_property_blob; + +struct drm_connector_helper_funcs; + +struct drm_connector_state; + +struct drm_tile_group; + +struct drm_connector { + struct drm_device *dev; + struct device *kdev; + struct device_attribute *attr; + struct list_head head; + struct drm_mode_object base; + char *name; + int connector_id; + int connector_type; + int connector_type_id; + bool interlace_allowed; + bool doublescan_allowed; + bool stereo_allowed; + 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_blob *path_blob_ptr; + struct drm_property_blob *tile_blob_ptr; + uint8_t polled; + int dpms; + const struct drm_connector_helper_funcs *helper_private; + struct drm_cmdline_mode cmdline_mode; + enum drm_connector_force force; + bool override_edid; + uint32_t encoder_ids[3]; + struct drm_encoder *encoder; + uint8_t eld[128]; + bool dvi_dual; + int max_tmds_clock; + bool latency_present[2]; + int video_latency[2]; + int audio_latency[2]; + int null_edid_counter; + unsigned int bad_edid_counter; + bool edid_corrupt; + struct dentry *debugfs_entry; + struct drm_connector_state *state; + 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 drm_global_reference { + enum drm_global_types global_type; + size_t size; + void *object; + int (*init)(struct drm_global_reference *); + void (*release)(struct drm_global_reference *); +}; + +struct ttm_mem_global; + +struct ttm_bo_global_ref { + struct drm_global_reference ref; + struct ttm_mem_global *mem_glob; +}; + +struct ttm_mem_type_manager_func; + +struct ttm_mem_type_manager { + struct ttm_bo_device *bdev; + bool has_type; + bool use_type; + uint32_t flags; + uint64_t gpu_offset; + uint64_t size; + uint32_t available_caching; + uint32_t default_caching; + const struct ttm_mem_type_manager_func *func; + void *priv; + struct mutex___2 io_reserve_mutex; + bool use_io_reserve_lru; + bool io_reserve_fastpath; + struct list_head io_reserve_lru; + struct list_head lru; +}; + +struct drm_mm { + struct list_head hole_stack; + struct drm_mm_node head_node; + unsigned int scan_check_range: 1; + unsigned int scan_alignment; + long unsigned int scan_color; + u64 scan_size; + u64 scan_hit_start; + u64 scan_hit_end; + unsigned int scanned_blocks; + u64 scan_start; + u64 scan_end; + struct drm_mm_node *prev_scanned_node; + void (*color_adjust)(struct drm_mm_node *, long unsigned int, u64 *, u64 *); +}; + +struct drm_vma_offset_manager { + rwlock_t vm_lock; + struct rb_root vm_addr_space_rb; + struct drm_mm vm_addr_space_mm; +}; + +struct ttm_bo_driver; + +struct ttm_bo_device { + struct list_head device_list; + struct ttm_bo_global *glob; + struct ttm_bo_driver *driver; + struct ttm_mem_type_manager man[8]; + struct drm_vma_offset_manager vma_manager; + struct list_head ddestroy; + struct address_space___2 *dev_mapping; + struct delayed_work wq; + bool need_dma32; +}; + +struct drm_framebuffer_funcs; + +struct drm_framebuffer { + struct drm_device *dev; + struct list_head head; + struct drm_mode_object base; + const struct drm_framebuffer_funcs *funcs; + unsigned int pitches[4]; + unsigned int offsets[4]; + uint64_t modifier[4]; + unsigned int width; + unsigned int height; + unsigned int depth; + int bits_per_pixel; + int flags; + uint32_t pixel_format; + struct list_head filp_head; +}; + +struct bochs_framebuffer { + struct drm_framebuffer base; + struct drm_gem_object *obj; +}; + +struct drm_clip_rect { + short unsigned int x1; + short unsigned int y1; + short unsigned int x2; + short unsigned int y2; +}; + +struct drm_fb_helper_crtc; + +struct drm_fb_helper_connector; + +struct drm_fb_helper_funcs; + +struct drm_fb_helper { + struct drm_framebuffer *fb; + struct drm_device *dev; + int crtc_count; + struct drm_fb_helper_crtc *crtc_info; + int connector_count; + int connector_info_alloc_count; + struct drm_fb_helper_connector **connector_info; + const struct drm_fb_helper_funcs *funcs; + struct fb_info *fbdev; + u32 pseudo_palette[17]; + struct drm_clip_rect dirty_clip; + spinlock_t dirty_lock; + struct work_struct dirty_work; + struct list_head kernel_fb_list; + bool delayed_hotplug; + bool atomic; +}; + +struct bochs_device { + void *mmio; + int ioports; + void *fb_map; + long unsigned int fb_base; + long unsigned int fb_size; + u16 xres; + u16 yres; + u16 yres_virtual; + u32 stride; + u32 bpp; + struct drm_device *dev; + struct drm_crtc crtc; + struct drm_encoder encoder; + struct drm_connector connector; + bool mode_config_initialized; + struct { + struct drm_global_reference mem_global_ref; + struct ttm_bo_global_ref bo_global_ref; + struct ttm_bo_device bdev; + bool initialized; + } ttm; + struct { + struct bochs_framebuffer gfb; + struct drm_fb_helper helper; + int size; + bool initialized; + } fb; +}; + +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 ist_info { + __u32 signature; + __u32 command; + __u32 event; + __u32 perf_level; +}; + +struct sys_desc_table { + __u16 length; + __u8 table[14]; +}; + +struct olpc_ofw_header { + __u32 ofw_magic; + __u32 ofw_version; + __u32 cif_handler; + __u32 irq_desc_table; +}; + +struct edid_info { + unsigned char dummy[128]; +}; + +struct efi_info { + __u32 efi_loader_signature; + __u32 efi_systab; + __u32 efi_memdesc_size; + __u32 efi_memdesc_version; + __u32 efi_memmap; + __u32 efi_memmap_size; + __u32 efi_systab_hi; + __u32 efi_memmap_hi; +}; + +struct setup_header { + __u8 setup_sects; + __u16 root_flags; + __u32 syssize; + __u16 ram_size; + __u16 vid_mode; + __u16 root_dev; + __u16 boot_flag; + __u16 jump; + __u32 header; + __u16 version; + __u32 realmode_swtch; + __u16 start_sys; + __u16 kernel_version; + __u8 type_of_loader; + __u8 loadflags; + __u16 setup_move_size; + __u32 code32_start; + __u32 ramdisk_image; + __u32 ramdisk_size; + __u32 bootsect_kludge; + __u16 heap_end_ptr; + __u8 ext_loader_ver; + __u8 ext_loader_type; + __u32 cmd_line_ptr; + __u32 initrd_addr_max; + __u32 kernel_alignment; + __u8 relocatable_kernel; + __u8 min_alignment; + __u16 xloadflags; + __u32 cmdline_size; + __u32 hardware_subarch; + __u64 hardware_subarch_data; + __u32 payload_offset; + __u32 payload_length; + __u64 setup_data; + __u64 pref_address; + __u32 init_size; + __u32 handover_offset; +} __attribute__((packed)); + +struct e820entry { + __u64 addr; + __u64 size; + __u32 type; +} __attribute__((packed)); + +struct edd_device_params { + __u16 length; + __u16 info_flags; + __u32 num_default_cylinders; + __u32 num_default_heads; + __u32 sectors_per_track; + __u64 number_of_sectors; + __u16 bytes_per_sector; + __u32 dpte_ptr; + __u16 key; + __u8 device_path_info_length; + __u8 reserved2; + __u16 reserved3; + __u8 host_bus_type[4]; + __u8 interface_type[8]; + union { + struct { + __u16 base_address; + __u16 reserved1; + __u32 reserved2; + } isa; + struct { + __u8 bus; + __u8 slot; + __u8 function; + __u8 channel; + __u32 reserved; + } pci; + struct { + __u64 reserved; + } ibnd; + struct { + __u64 reserved; + } xprs; + struct { + __u64 reserved; + } htpt; + struct { + __u64 reserved; + } unknown; + } interface_path; + union { + struct { + __u8 device; + __u8 reserved1; + __u16 reserved2; + __u32 reserved3; + __u64 reserved4; + } ata; + struct { + __u8 device; + __u8 lun; + __u8 reserved1; + __u8 reserved2; + __u32 reserved3; + __u64 reserved4; + } atapi; + struct { + __u16 id; + __u64 lun; + __u16 reserved1; + __u32 reserved2; + } __attribute__((packed)) scsi; + struct { + __u64 serial_number; + __u64 reserved; + } usb; + struct { + __u64 eui; + __u64 reserved; + } i1394; + struct { + __u64 wwid; + __u64 lun; + } fibre; + struct { + __u64 identity_tag; + __u64 reserved; + } i2o; + struct { + __u32 array_number; + __u32 reserved1; + __u64 reserved2; + } raid; + struct { + __u8 device; + __u8 reserved1; + __u16 reserved2; + __u32 reserved3; + __u64 reserved4; + } sata; + struct { + __u64 reserved1; + __u64 reserved2; + } unknown; + } device_path; + __u8 reserved4; + __u8 checksum; +} __attribute__((packed)); + +struct edd_info { + __u8 device; + __u8 version; + __u16 interface_support; + __u16 legacy_max_cylinder; + __u8 legacy_max_head; + __u8 legacy_sectors_per_track; + struct edd_device_params params; +}; + +struct boot_params { + struct screen_info screen_info; + struct apm_bios_info apm_bios_info; + __u8 _pad2[4]; + __u64 tboot_addr; + struct ist_info ist_info; + __u8 _pad3[16]; + __u8 hd0_info[16]; + __u8 hd1_info[16]; + struct sys_desc_table sys_desc_table; + struct olpc_ofw_header olpc_ofw_header; + __u32 ext_ramdisk_image; + __u32 ext_ramdisk_size; + __u32 ext_cmd_line_ptr; + __u8 _pad4[116]; + struct edid_info edid_info; + struct efi_info efi_info; + __u32 alt_mem_k; + __u32 scratch; + __u8 e820_entries; + __u8 eddbuf_entries; + __u8 edd_mbr_sig_buf_entries; + __u8 kbd_status; + __u8 _pad5[3]; + __u8 sentinel; + __u8 _pad6[1]; + struct setup_header hdr; + __u8 _pad7[40]; + __u32 edd_mbr_sig_buffer[16]; + struct e820entry e820_map[128]; + __u8 _pad8[48]; + struct edd_info eddbuf[6]; + __u8 _pad9[276]; +}; + +struct iphdr { + __u8 ihl: 4; + __u8 version: 4; + __u8 tos; + __be16 tot_len; + __be16 id; + __be16 frag_off; + __u8 ttl; + __u8 protocol; + __sum16 check; + __be32 saddr; + __be32 daddr; +}; + +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_busy_slots { + unsigned int pinned; + unsigned int flexible; +}; + +struct bp_cpuinfo { + unsigned int cpu_pinned; + unsigned int *tsk_pinned; + unsigned int flexible; +}; + +struct user_struct; + +struct bpf_map_ops; + +struct bpf_map { + atomic_t refcnt; + enum bpf_map_type map_type; + u32 key_size; + u32 value_size; + u32 max_entries; + u32 map_flags; + u32 pages; + struct user_struct *user; + const struct bpf_map_ops *ops; + struct work_struct work; + atomic_t usercnt; +}; + +struct bpf_array { + struct bpf_map map; + u32 elem_size; + enum bpf_prog_type owner_prog_type; + bool owner_jited; + union { + char value[0]; + void *ptrs[0]; + void *pptrs[0]; + }; +}; + +union bpf_attr { + struct { + __u32 map_type; + __u32 key_size; + __u32 value_size; + __u32 max_entries; + __u32 map_flags; + }; + struct { + __u32 map_fd; + __u64 key; + union { + __u64 value; + __u64 next_key; + }; + __u64 flags; + }; + struct { + __u32 prog_type; + __u32 insn_cnt; + __u64 insns; + __u64 license; + __u32 log_level; + __u32 log_size; + __u64 log_buf; + __u32 kern_version; + }; + struct { + __u64 pathname; + __u32 bpf_fd; + }; +}; + +struct bpf_binary_header { + unsigned int pages; + u8 image[0]; +}; + +struct bpf_call_arg_meta { + struct bpf_map *map_ptr; + bool raw_mode; + int regno; + int access_size; +}; + +struct bpf_func_proto { + u64 (*func)(u64, u64, u64, u64, u64); + bool gpl_only; + enum bpf_return_type ret_type; + 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; +}; + +struct pcpu_freelist_head; + +struct pcpu_freelist { + struct pcpu_freelist_head *freelist; +}; + +struct bucket; + +struct bpf_htab { + struct bpf_map map; + struct bucket *buckets; + void *elems; + struct pcpu_freelist freelist; + atomic_t count; + u32 n_buckets; + u32 elem_size; +}; + +struct bpf_insn { + __u8 code; + __u8 dst_reg: 4; + __u8 src_reg: 4; + __s16 off; + __s32 imm; +}; + +struct user_struct___2; + +struct bpf_map_ops___2; + +struct bpf_map___2 { + atomic_t refcnt; + enum bpf_map_type map_type; + u32 key_size; + u32 value_size; + u32 max_entries; + u32 map_flags; + u32 pages; + struct user_struct___2 *user; + const struct bpf_map_ops___2 *ops; + struct work_struct work; + atomic_t usercnt; +}; + +struct bpf_map_ops { + struct bpf_map * (*map_alloc)(union bpf_attr *); + void (*map_free)(struct bpf_map *); + int (*map_get_next_key)(struct bpf_map *, void *, void *); + void * (*map_lookup_elem)(struct bpf_map *, void *); + int (*map_update_elem)(struct bpf_map *, void *, void *, u64); + int (*map_delete_elem)(struct bpf_map *, void *); + void * (*map_fd_get_ptr)(struct bpf_map *, int); + void (*map_fd_put_ptr)(void *); +}; + +struct bpf_map_ops___2 { + struct bpf_map___2 * (*map_alloc)(union bpf_attr *); + void (*map_free)(struct bpf_map___2 *); + int (*map_get_next_key)(struct bpf_map___2 *, void *, void *); + void * (*map_lookup_elem)(struct bpf_map___2 *, void *); + int (*map_update_elem)(struct bpf_map___2 *, void *, void *, u64); + int (*map_delete_elem)(struct bpf_map___2 *, void *); + void * (*map_fd_get_ptr)(struct bpf_map___2 *, int); + void (*map_fd_put_ptr)(void *); +}; + +struct bpf_map_type_list { + struct list_head list_node; + const struct bpf_map_ops *ops; + enum bpf_map_type type; +}; + +struct sock_filter { + __u16 code; + __u8 jt; + __u8 jf; + __u32 k; +}; + +struct bpf_prog_aux; + +struct sock_fprog_kern; + +struct bpf_prog { + u16 pages; + u16 jited: 1; + u16 gpl_compatible: 1; + u16 cb_access: 1; + u16 dst_needed: 1; + u32 len; + enum bpf_prog_type type; + struct bpf_prog_aux *aux; + struct sock_fprog_kern *orig_prog; + unsigned int (*bpf_func)(const struct sk_buff *, const struct bpf_insn *); + union { + struct sock_filter insns[0]; + struct bpf_insn insnsi[0]; + }; +}; + +struct bpf_prog_aux___2; + +struct bpf_prog___2 { + u16 pages; + u16 jited: 1; + u16 gpl_compatible: 1; + u16 cb_access: 1; + u16 dst_needed: 1; + u32 len; + enum bpf_prog_type type; + struct bpf_prog_aux___2 *aux; + struct sock_fprog_kern *orig_prog; + unsigned int (*bpf_func)(const struct sk_buff___2 *, const struct bpf_insn *); + union { + struct sock_filter insns[0]; + struct bpf_insn insnsi[0]; + }; +}; + +struct bpf_verifier_ops; + +struct bpf_prog_aux { + atomic_t refcnt; + u32 used_map_cnt; + u32 max_ctx_offset; + const struct bpf_verifier_ops *ops; + struct bpf_map **used_maps; + struct bpf_prog *prog; + struct user_struct *user; + union { + struct work_struct work; + struct callback_head rcu; + }; +}; + +struct bpf_verifier_ops___2; + +struct bpf_prog_aux___2 { + atomic_t refcnt; + u32 used_map_cnt; + u32 max_ctx_offset; + const struct bpf_verifier_ops___2 *ops; + struct bpf_map___2 **used_maps; + struct bpf_prog___2 *prog; + struct user_struct___2 *user; + union { + struct work_struct work; + struct callback_head rcu; + }; +}; + +struct bpf_prog_type_list { + struct list_head list_node; + const struct bpf_verifier_ops *ops; + enum bpf_prog_type type; +}; + +struct bpf_scratchpad { + union { + __be32 diff[128]; + u8 buff[512]; + }; +}; + +struct qdisc_skb_cb { + 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_end; +}; + +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_tunnel_key { + __u32 tunnel_id; + union { + __u32 remote_ipv4; + __u32 remote_ipv6[4]; + }; + __u8 tunnel_tos; + __u8 tunnel_ttl; + __u16 tunnel_ext; + __u32 tunnel_label; +}; + +struct bpf_verifier_ops { + const struct bpf_func_proto * (*get_func_proto)(enum bpf_func_id); + bool (*is_valid_access)(int, int, enum bpf_access_type); + u32 (*convert_ctx_access)(enum bpf_access_type, int, int, int, struct bpf_insn *, struct bpf_prog *); +}; + +struct bpf_verifier_ops___2 { + const struct bpf_func_proto * (*get_func_proto)(enum bpf_func_id); + bool (*is_valid_access)(int, int, enum bpf_access_type); + u32 (*convert_ctx_access)(enum bpf_access_type, int, int, int, struct bpf_insn *, struct bpf_prog___2 *); +}; + +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 branch { + unsigned char opcode; + u32 delta; +} __attribute__((packed)); + +struct sock; + +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 pid_namespace; + +struct bsd_acct_struct { + struct fs_pin pin; + atomic_long_t count; + struct callback_head rcu; + struct mutex lock; + int active; + long unsigned int needcheck; + struct file___2 *file; + struct pid_namespace *ns; + struct work_struct work; + struct completion done; +}; + +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_class_device { + struct device *class_dev; + struct device *parent; + int minor; + struct request_queue *queue; + struct kref ref; + void (*release)(struct device *); +}; + +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 bsg_device; + +struct bsg_command { + struct bsg_device *bd; + struct list_head list; + struct request *rq; + struct bio *bio; + struct bio *bidi_bio; + int err; + struct sg_io_v4 hdr; + char sense[96]; +}; + +struct bsg_device { + struct request_queue *queue; + spinlock_t lock; + struct list_head busy_list; + struct list_head done_list; + struct hlist_node dev_list; + atomic_t ref_count; + int queued_cmds; + int done_cmds; + wait_queue_head_t wq_done; + wait_queue_head_t wq_free; + char name[20]; + int max_queue; + long unsigned int flags; +}; + +struct bt_wait_state { + atomic_t wait_cnt; + wait_queue_head_t wait; + long: 64; + long: 64; + long: 64; + long: 64; +}; + +struct bts_phys { + struct page___2 *page; + long unsigned int size; + long unsigned int offset; + long unsigned int displacement; +}; + +struct bts_buffer { + size_t real_size; + unsigned int nr_pages; + unsigned int nr_bufs; + unsigned int cur_buf; + bool snapshot; + local_t data_size; + local_t lost; + local_t head; + long unsigned int end; + void **data_pages; + struct bts_phys buf[0]; +}; + +struct ring_buffer; + +struct perf_output_handle { + struct perf_event *event; + struct ring_buffer *rb; + long unsigned int wakeup; + long unsigned int size; + union { + void *addr; + long unsigned int head; + }; + int page; +}; + +struct debug_store { + u64 bts_buffer_base; + u64 bts_index; + u64 bts_absolute_maximum; + u64 bts_interrupt_threshold; + u64 pebs_buffer_base; + u64 pebs_index; + u64 pebs_absolute_maximum; + u64 pebs_interrupt_threshold; + u64 pebs_event_reset[8]; +}; + +struct bts_ctx { + struct perf_output_handle handle; + struct debug_store ds_back; + int started; +}; + +struct bts_record { + u64 from; + u64 to; + u64 flags; +}; + +struct bucket { + struct hlist_head head; + raw_spinlock_t lock; +}; + +struct rhash_head; + +struct bucket_table { + unsigned int size; + unsigned int rehash; + u32 hash_rnd; + unsigned int locks_mask; + spinlock_t *locks; + struct list_head walkers; + struct callback_head rcu; + struct bucket_table *future_tbl; + struct rhash_head *buckets[0]; +}; + +struct buffer_data_page { + u64 time_stamp; + local_t commit; + unsigned char data[0]; +}; + +typedef void bh_end_io_t(struct buffer_head *, int); + +struct buffer_head { + long unsigned int b_state; + struct buffer_head *b_this_page; + struct page___2 *b_page; + 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; +}; + +typedef struct buffer_head *pto_T_____13; + +struct buffer_page { + struct list_head list; + local_t write; + unsigned int read; + local_t entries; + long unsigned int real_end; + struct buffer_data_page *page; +}; + +struct buffer_ref { + struct ring_buffer *buffer; + void *page; + int ref; +}; + +struct buffmem_desc { + unsigned int *buffer; + int size; +}; + +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 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)(struct bus_type *, char *); + ssize_t (*store)(struct bus_type *, const char *, size_t); +}; + +struct lock_class_key {}; + +struct iommu_ops; + +struct bus_type { + const char *name; + const char *dev_name; + struct device *dev_root; + struct device_attribute *dev_attrs; + const struct attribute_group **bus_groups; + const struct attribute_group **dev_groups; + const struct attribute_group **drv_groups; + int (*match)(struct device *, struct device_driver *); + int (*uevent)(struct device *, struct kobj_uevent_env *); + int (*probe)(struct device *); + int (*remove)(struct device *); + void (*shutdown)(struct device *); + int (*online)(struct device *); + int (*offline)(struct device *); + int (*suspend)(struct device *, pm_message_t); + int (*resume)(struct device *); + const struct dev_pm_ops___2 *pm; + const struct iommu_ops *iommu_ops; + struct subsys_private *p; + struct lock_class_key lock_key; +}; + +struct device_attribute___2; + +struct bus_type___2 { + const char *name; + const char *dev_name; + struct device___2 *dev_root; + struct device_attribute___2 *dev_attrs; + const struct attribute_group___2 **bus_groups; + const struct attribute_group___2 **dev_groups; + const struct attribute_group___2 **drv_groups; + int (*match)(struct device___2 *, struct device_driver___2 *); + int (*uevent)(struct device___2 *, struct kobj_uevent_env *); + int (*probe)(struct device___2 *); + int (*remove)(struct device___2 *); + void (*shutdown)(struct device___2 *); + int (*online)(struct device___2 *); + int (*offline)(struct device___2 *); + int (*suspend)(struct device___2 *, pm_message_t); + int (*resume)(struct device___2 *); + const struct dev_pm_ops *pm; + const struct iommu_ops *iommu_ops; + struct subsys_private *p; + struct lock_class_key lock_key; +}; + +struct bxt_clk_div { + int clock; + uint32_t p1; + uint32_t p2; + uint32_t m2_int; + uint32_t m2_frac; + bool m2_frac_en; + uint32_t n; +}; + +struct bxt_ddi_buf_trans { + u32 margin; + u32 scale; + u32 enable; + u32 deemphasis; + bool default_index; +}; + +struct byd_data { + struct timer_list timer; + s32 abs_x; + s32 abs_y; + volatile long unsigned int last_touch_time; + bool btn_left; + bool btn_right; + bool touch; +}; + +union c { + __u64 u64; + __u32 u32[2]; +}; + +struct cacheinfo { + 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; + struct device_node *of_node; + bool disable_sysfs; + void *priv; +}; + +struct iommu_table; + +struct cal_chipset_ops { + void (*handle_quirks)(struct iommu_table *, struct pci_dev *); + void (*tce_cache_blast)(struct iommu_table *); + void (*dump_error_regs)(struct iommu_table *); +}; + +struct calgary_bus_info { + void *tce_space; + unsigned char translation_disabled; + signed char phbid; + void *bbar; +}; + +struct call_single_data; + +struct call_function_data { + struct call_single_data *csd; + cpumask_var_t cpumask; +}; + +struct llist_node { + struct llist_node *next; +}; + +typedef void (*smp_call_func_t)(void *); + +struct call_single_data { + struct llist_node llist; + smp_call_func_t func; + void *info; + unsigned int flags; +}; + +struct perf_callchain_entry; + +struct callchain_cpus_entries { + struct callback_head callback_head; + struct perf_callchain_entry *cpu_entries[0]; +}; + +struct cb_id { + __u32 idx; + __u32 val; +}; + +struct ccm_instance_ctx { + struct crypto_skcipher_spawn ctr; + struct crypto_spawn cipher; +}; + +struct file_operations___2; + +struct cdev { + struct kobject kobj; + struct module *owner; + const struct file_operations___2 *ops; + struct list_head list; + dev_t dev; + unsigned int count; +}; + +struct cdrom_msf0 { + __u8 minute; + __u8 second; + __u8 frame; +}; + +union cdrom_addr { + struct cdrom_msf0 msf; + int lba; +}; + +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; + void *reserved[1]; +}; + +struct cdrom_multisession { + union cdrom_addr addr; + __u8 xa_flag; + __u8 addr_format; +}; + +struct cdrom_read_audio { + union cdrom_addr addr; + __u8 addr_format; + int nframes; + __u8 *buf; +}; + +struct cdrom_tocentry { + __u8 cdte_track; + __u8 cdte_adr: 4; + __u8 cdte_ctrl: 4; + __u8 cdte_format; + union cdrom_addr cdte_addr; + __u8 cdte_datamode; +}; + +struct clock_event_device; + +struct ce_unbind { + struct clock_event_device *ce; + int res; +}; + +struct cea_sad { + u8 format; + u8 channels; + u8 freq; + u8 byte2; +}; + +struct cfq_ttime { + long unsigned int last_end_request; + long unsigned int ttime_total; + long unsigned int ttime_samples; + long unsigned int ttime_mean; +}; + +struct cfq_rb_root { + struct rb_root rb; + struct rb_node *left; + unsigned int count; + u64 min_vdisktime; + struct cfq_ttime ttime; +}; + +struct cfq_data; + +struct cfq_group; + +struct cfq_queue { + int ref; + unsigned int flags; + struct cfq_data *cfqd; + struct rb_node rb_node; + long unsigned int rb_key; + struct rb_node p_node; + struct rb_root *p_root; + struct rb_root sort_list; + struct request *next_rq; + int queued[2]; + int allocated[2]; + struct list_head fifo; + long unsigned int dispatch_start; + unsigned int allocated_slice; + unsigned int slice_dispatch; + long unsigned int slice_start; + long unsigned int slice_end; + long int slice_resid; + int prio_pending; + int dispatched; + short unsigned int ioprio; + short unsigned int org_ioprio; + short unsigned int ioprio_class; + pid_t pid; + u32 seek_history; + sector_t last_request_pos; + struct cfq_rb_root *service_tree; + struct cfq_queue *new_cfqq; + struct cfq_group *cfqg; + long unsigned int nr_sectors; +}; + +struct cfq_io_cq; + +struct cfq_data { + struct request_queue *queue; + struct cfq_rb_root grp_service_tree; + struct cfq_group *root_group; + enum wl_class_t serving_wl_class; + enum wl_type_t serving_wl_type; + long unsigned int workload_expires; + struct cfq_group *serving_group; + struct rb_root prio_trees[8]; + unsigned int busy_queues; + unsigned int busy_sync_queues; + int rq_in_driver; + int rq_in_flight[2]; + int rq_queued; + int hw_tag; + int hw_tag_est_depth; + unsigned int hw_tag_samples; + struct timer_list idle_slice_timer; + struct work_struct unplug_work; + struct cfq_queue *active_queue; + struct cfq_io_cq *active_cic; + sector_t last_position; + unsigned int cfq_quantum; + unsigned int cfq_fifo_expire[2]; + unsigned int cfq_back_penalty; + unsigned int cfq_back_max; + unsigned int cfq_slice[2]; + unsigned int cfq_slice_async_rq; + unsigned int cfq_slice_idle; + unsigned int cfq_group_idle; + unsigned int cfq_latency; + unsigned int cfq_target_latency; + struct cfq_queue oom_cfqq; + long unsigned int last_delayed_sync; +}; + +struct cfqg_stats {}; + +struct cfq_group { + struct blkg_policy_data pd; + struct rb_node rb_node; + u64 vdisktime; + int nr_active; + unsigned int children_weight; + unsigned int vfraction; + unsigned int weight; + unsigned int new_weight; + unsigned int dev_weight; + unsigned int leaf_weight; + unsigned int new_leaf_weight; + unsigned int dev_leaf_weight; + int nr_cfqq; + unsigned int busy_queues_avg[3]; + struct cfq_rb_root service_trees[6]; + struct cfq_rb_root service_tree_idle; + long unsigned int saved_wl_slice; + enum wl_type_t saved_wl_type; + enum wl_class_t saved_wl_class; + int dispatched; + struct cfq_ttime ttime; + struct cfqg_stats stats; + struct cfq_queue *async_cfqq[16]; + struct cfq_queue *async_idle_cfqq; +}; + +struct io_context; + +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 cfq_io_cq { + struct io_cq icq; + struct cfq_queue *cfqq[2]; + struct cfq_ttime ttime; + int ioprio; +}; + +struct cfs_bandwidth {}; + +struct load_weight { + long unsigned int weight; + u32 inv_weight; +}; + +struct sched_avg { + u64 last_update_time; + u64 load_sum; + u32 util_sum; + u32 period_contrib; + long unsigned int load_avg; + long unsigned int util_avg; +}; + +struct sched_entity; + +struct rq; + +struct cfs_rq { + struct load_weight load; + unsigned int nr_running; + unsigned int h_nr_running; + u64 exec_clock; + u64 min_vruntime; + struct rb_root tasks_timeline; + struct rb_node *rb_leftmost; + struct sched_entity *curr; + struct sched_entity *next; + struct sched_entity *last; + struct sched_entity *skip; + unsigned int nr_spread_over; + struct sched_avg avg; + u64 runnable_load_sum; + long unsigned int runnable_load_avg; + long unsigned int tg_load_avg_contrib; + atomic_long_t removed_load_avg; + atomic_long_t removed_util_avg; + 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; +}; + +struct cgroup_subsys; + +struct kernfs_ops; + +struct cgroup_subsys_state; + +struct seq_file; + +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; + 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); +}; + +struct cgroup_subsys___2; + +struct kernfs_ops___2; + +struct cgroup_subsys_state___2; + +struct seq_file___2; + +struct kernfs_open_file___2; + +struct cftype___2 { + char name[64]; + long unsigned int private; + size_t max_write_len; + unsigned int flags; + unsigned int file_offset; + struct cgroup_subsys___2 *ss; + struct list_head node; + struct kernfs_ops___2 *kf_ops; + u64 (*read_u64)(struct cgroup_subsys_state___2 *, struct cftype___2 *); + s64 (*read_s64)(struct cgroup_subsys_state___2 *, struct cftype___2 *); + int (*seq_show)(struct seq_file___2 *, void *); + void * (*seq_start)(struct seq_file___2 *, loff_t *); + void * (*seq_next)(struct seq_file___2 *, void *, loff_t *); + void (*seq_stop)(struct seq_file___2 *, void *); + int (*write_u64)(struct cgroup_subsys_state___2 *, struct cftype___2 *, u64); + int (*write_s64)(struct cgroup_subsys_state___2 *, struct cftype___2 *, s64); + ssize_t (*write)(struct kernfs_open_file___2 *, char *, size_t, loff_t); +}; + +struct percpu_ref; + +typedef void percpu_ref_func_t(struct percpu_ref *); + +struct percpu_ref { + atomic_long_t count; + long unsigned int percpu_count_ptr; + percpu_ref_func_t *release; + percpu_ref_func_t *confirm_switch; + bool force_atomic: 1; + struct callback_head rcu; +}; + +struct cgroup; + +struct cgroup_subsys_state { + struct cgroup *cgroup; + struct cgroup_subsys *ss; + struct percpu_ref refcnt; + struct cgroup_subsys_state *parent; + struct list_head sibling; + struct list_head children; + int id; + unsigned int flags; + u64 serial_nr; + atomic_t online_cnt; + struct callback_head callback_head; + struct work_struct destroy_work; +}; + +struct cgroup_file { + struct kernfs_node *kn; +}; + +struct cgroup_root; + +struct cgroup { + struct cgroup_subsys_state self; + long unsigned int flags; + int id; + int level; + int populated_cnt; + struct kernfs_node *kn; + struct cgroup_file procs_file; + struct cgroup_file events_file; + u16 subtree_control; + u16 subtree_ss_mask; + u16 old_subtree_control; + u16 old_subtree_ss_mask; + struct cgroup_subsys_state *subsys[4]; + struct cgroup_root *root; + struct list_head cset_links; + struct list_head e_csets[4]; + struct list_head pidlists; + struct mutex pidlist_mutex; + wait_queue_head_t offline_waitq; + struct work_struct release_agent_work; + int ancestor_ids[0]; +}; + +struct cgroup___2; + +struct cgroup_subsys_state___2 { + struct cgroup___2 *cgroup; + struct cgroup_subsys___2 *ss; + struct percpu_ref refcnt; + struct cgroup_subsys_state___2 *parent; + struct list_head sibling; + struct list_head children; + int id; + unsigned int flags; + u64 serial_nr; + atomic_t online_cnt; + struct callback_head callback_head; + struct work_struct destroy_work; +}; + +struct cgroup_file___2 { + struct kernfs_node___2 *kn; +}; + +struct cgroup_root___2; + +struct cgroup___2 { + struct cgroup_subsys_state___2 self; + long unsigned int flags; + int id; + int level; + int populated_cnt; + struct kernfs_node___2 *kn; + struct cgroup_file___2 procs_file; + struct cgroup_file___2 events_file; + u16 subtree_control; + u16 subtree_ss_mask; + u16 old_subtree_control; + u16 old_subtree_ss_mask; + struct cgroup_subsys_state___2 *subsys[4]; + struct cgroup_root___2 *root; + struct list_head cset_links; + struct list_head e_csets[4]; + struct list_head pidlists; + struct mutex___2 pidlist_mutex; + wait_queue_head_t offline_waitq; + struct work_struct release_agent_work; + int ancestor_ids[0]; +}; + +struct proc_ns_operations; + +struct ns_common { + atomic_long_t stashed; + const struct proc_ns_operations *ops; + unsigned int inum; +}; + +struct user_namespace; + +struct css_set; + +struct cgroup_namespace { + atomic_t count; + struct ns_common ns; + struct user_namespace *user_ns; + struct css_set *root_cset; +}; + +struct css_set___2; + +struct cgroup_namespace___2 { + atomic_t count; + struct ns_common ns; + struct user_namespace *user_ns; + struct css_set___2 *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 idr_layer; + +struct idr { + struct idr_layer *hint; + struct idr_layer *top; + int layers; + int cur; + spinlock_t lock; + int id_free_cnt; + struct idr_layer *id_free; +}; + +struct kernfs_root; + +struct cgroup_root { + struct kernfs_root *kf_root; + unsigned int subsys_mask; + int hierarchy_id; + struct cgroup cgrp; + int cgrp_ancestor_id_storage; + atomic_t nr_cgrps; + struct list_head root_list; + unsigned int flags; + struct idr cgroup_idr; + char release_agent_path[4096]; + char name[64]; +}; + +struct kernfs_root___2; + +struct cgroup_root___2 { + struct kernfs_root___2 *kf_root; + unsigned int subsys_mask; + int hierarchy_id; + struct cgroup___2 cgrp; + int cgrp_ancestor_id_storage; + atomic_t nr_cgrps; + struct list_head root_list; + unsigned int flags; + struct idr cgroup_idr; + char release_agent_path[4096]; + char name[64]; +}; + +struct cgroup_sb_opts { + u16 subsys_mask; + unsigned int flags; + char *release_agent; + bool cpuset_clone_children; + char *name; + bool none; +}; + +struct cgroup_taskset; + +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 *); + 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 *); + void (*cancel_fork)(struct task_struct *); + void (*fork)(struct task_struct *); + void (*exit)(struct task_struct *); + void (*free)(struct task_struct *); + void (*bind)(struct cgroup_subsys_state *); + bool early_init: 1; + bool implicit_on_dfl: 1; + bool broken_hierarchy: 1; + bool warned_broken_hierarchy: 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 cgroup_subsys___2 { + struct cgroup_subsys_state___2 * (*css_alloc)(struct cgroup_subsys_state___2 *); + int (*css_online)(struct cgroup_subsys_state___2 *); + void (*css_offline)(struct cgroup_subsys_state___2 *); + void (*css_released)(struct cgroup_subsys_state___2 *); + void (*css_free)(struct cgroup_subsys_state___2 *); + void (*css_reset)(struct cgroup_subsys_state___2 *); + 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___2 *); + void (*cancel_fork)(struct task_struct___2 *); + void (*fork)(struct task_struct___2 *); + void (*exit)(struct task_struct___2 *); + void (*free)(struct task_struct___2 *); + void (*bind)(struct cgroup_subsys_state___2 *); + bool early_init: 1; + bool implicit_on_dfl: 1; + bool broken_hierarchy: 1; + bool warned_broken_hierarchy: 1; + int id; + const char *name; + const char *legacy_name; + struct cgroup_root___2 *root; + struct idr css_idr; + struct list_head cfts; + struct cftype___2 *dfl_cftypes; + struct cftype___2 *legacy_cftypes; + unsigned int depends_on; +}; + +struct cgroup_taskset { + struct list_head src_csets; + struct list_head dst_csets; + int ssid; + struct list_head *csets; + struct css_set *cur_cset; + struct task_struct *cur_task; +}; + +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 ch7017_priv { + uint8_t dummy; +}; + +struct ch7xxx_did_struct { + uint8_t did; + char *name; +}; + +struct ch7xxx_id_struct { + uint8_t vid; + char *name; +}; + +struct ch7xxx_priv { + bool quiet; +}; + +struct linked_page; + +struct chain_allocator { + struct linked_page *chain; + unsigned int used_space; + gfp_t gfp_mask; + int safe_needed; +}; + +struct chainiv_ctx { + spinlock_t lock; + char iv[0]; +}; + +struct change_member { + struct e820entry *pbios; + long long unsigned int addr; +}; + +struct channel_map_table { + unsigned char map; + int spk_mask; +}; + +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_pred_data { + int count; + int max; +}; + +struct old_child_dev_config { + u16 handle; + u16 device_type; + u8 device_id[10]; + u16 addin_offset; + u8 dvo_port; + u8 i2c_pin; + u8 slave_addr; + u8 ddc_pin; + u16 edid_ptr; + u8 dvo_cfg; + u8 dvo2_port; + u8 i2c2_pin; + u8 slave2_addr; + u8 ddc2_pin; + u8 capabilities; + u8 dvo_wiring; + u8 dvo2_wiring; + u16 extended_type; + u8 dvo_function; +} __attribute__((packed)); + +struct common_child_dev_config { + u16 handle; + u16 device_type; + u8 not_common1[12]; + u8 dvo_port; + u8 not_common2[2]; + u8 ddc_pin; + u16 edid_ptr; + u8 dvo_cfg; + u8 efp_routed: 1; + u8 lane_reversal: 1; + u8 lspcon: 1; + u8 iboost: 1; + u8 hpd_invert: 1; + u8 flag_reserved: 3; + u8 hdmi_support: 1; + u8 dp_support: 1; + u8 tmds_support: 1; + u8 support_reserved: 5; + u8 not_common3[12]; + u8 iboost_level; +}; + +union child_device_config { + u8 raw[33]; + struct old_child_dev_config old; + struct common_child_dev_config common; +}; + +struct chipset { + u32 vendor; + u32 device; + u32 class; + u32 class_mask; + u32 flags; + void (*f)(int, int, int); +}; + +struct chksum_ctx { + u32 key; +}; + +struct chksum_desc_ctx { + u32 crc; +}; + +struct cipher_tfm { + int (*cit_setkey)(struct crypto_tfm *, const u8 *, unsigned int); + void (*cit_encrypt_one)(struct crypto_tfm *, u8 *, const u8 *); + void (*cit_decrypt_one)(struct crypto_tfm *, u8 *, const u8 *); +}; + +struct circ_buf { + char *buf; + int head; + int tail; +}; + +struct cis_cache_entry { + struct list_head node; + unsigned int addr; + unsigned int len; + unsigned int attr; + unsigned char cache[0]; +}; + +struct cistpl_device_t { + u_char ndev; + struct { + u_char type; + u_char wp; + u_int speed; + u_int size; + } dev[4]; +}; + +typedef struct cistpl_device_t cistpl_device_t; + +struct cistpl_checksum_t { + u_short addr; + u_short len; + u_char sum; +}; + +typedef struct cistpl_checksum_t cistpl_checksum_t; + +struct cistpl_longlink_t { + u_int addr; +}; + +typedef struct cistpl_longlink_t cistpl_longlink_t; + +struct cistpl_longlink_mfc_t { + u_char nfn; + struct { + u_char space; + u_int addr; + } fn[8]; +}; + +typedef struct cistpl_longlink_mfc_t cistpl_longlink_mfc_t; + +struct cistpl_vers_1_t { + u_char major; + u_char minor; + u_char ns; + u_char ofs[4]; + char str[254]; +}; + +typedef struct cistpl_vers_1_t cistpl_vers_1_t; + +struct cistpl_altstr_t { + u_char ns; + u_char ofs[4]; + char str[254]; +}; + +typedef struct cistpl_altstr_t cistpl_altstr_t; + +struct cistpl_jedec_t { + u_char nid; + struct { + u_char mfr; + u_char info; + } id[4]; +}; + +typedef struct cistpl_jedec_t cistpl_jedec_t; + +struct cistpl_manfid_t { + u_short manf; + u_short card; +}; + +typedef struct cistpl_manfid_t cistpl_manfid_t; + +struct cistpl_funcid_t { + u_char func; + u_char sysinit; +}; + +typedef struct cistpl_funcid_t cistpl_funcid_t; + +struct cistpl_funce_t { + u_char type; + u_char data[0]; +}; + +typedef struct cistpl_funce_t cistpl_funce_t; + +struct cistpl_bar_t { + u_char attr; + u_int size; +}; + +typedef struct cistpl_bar_t cistpl_bar_t; + +struct cistpl_config_t { + u_char last_idx; + u_int base; + u_int rmask[4]; + u_char subtuples; +}; + +typedef struct cistpl_config_t cistpl_config_t; + +struct cistpl_power_t { + u_char present; + u_char flags; + u_int param[7]; +}; + +typedef struct cistpl_power_t cistpl_power_t; + +struct cistpl_timing_t { + u_int wait; + u_int waitscale; + u_int ready; + u_int rdyscale; + u_int reserved; + u_int rsvscale; +}; + +typedef struct cistpl_timing_t cistpl_timing_t; + +struct cistpl_io_t { + u_char flags; + u_char nwin; + struct { + u_int base; + u_int len; + } win[16]; +}; + +typedef struct cistpl_io_t cistpl_io_t; + +struct cistpl_irq_t { + u_int IRQInfo1; + u_int IRQInfo2; +}; + +typedef struct cistpl_irq_t cistpl_irq_t; + +struct cistpl_mem_t { + u_char flags; + u_char nwin; + struct { + u_int len; + u_int card_addr; + u_int host_addr; + } win[8]; +}; + +typedef struct cistpl_mem_t cistpl_mem_t; + +struct cistpl_cftable_entry_t { + u_char index; + u_short flags; + u_char interface; + cistpl_power_t vcc; + cistpl_power_t vpp1; + cistpl_power_t vpp2; + cistpl_timing_t timing; + cistpl_io_t io; + cistpl_irq_t irq; + cistpl_mem_t mem; + u_char subtuples; +}; + +typedef struct cistpl_cftable_entry_t cistpl_cftable_entry_t; + +struct cistpl_cftable_entry_cb_t { + u_char index; + u_int flags; + cistpl_power_t vcc; + cistpl_power_t vpp1; + cistpl_power_t vpp2; + u_char io; + cistpl_irq_t irq; + u_char mem; + u_char subtuples; +}; + +typedef struct cistpl_cftable_entry_cb_t cistpl_cftable_entry_cb_t; + +struct cistpl_device_geo_t { + u_char ngeo; + struct { + u_char buswidth; + u_int erase_block; + u_int read_block; + u_int write_block; + u_int partition; + u_int interleave; + } geo[4]; +}; + +typedef struct cistpl_device_geo_t cistpl_device_geo_t; + +struct cistpl_vers_2_t { + u_char vers; + u_char comply; + u_short dindex; + u_char vspec8; + u_char vspec9; + u_char nhdr; + u_char vendor; + u_char info; + char str[244]; +}; + +typedef struct cistpl_vers_2_t cistpl_vers_2_t; + +struct cistpl_org_t { + u_char data_org; + char desc[30]; +}; + +typedef struct cistpl_org_t cistpl_org_t; + +struct cistpl_format_t { + u_char type; + u_char edc; + u_int offset; + u_int length; +}; + +typedef struct cistpl_format_t cistpl_format_t; + +union cisparse_t { + cistpl_device_t device; + cistpl_checksum_t checksum; + cistpl_longlink_t longlink; + cistpl_longlink_mfc_t longlink_mfc; + cistpl_vers_1_t version_1; + cistpl_altstr_t altstr; + cistpl_jedec_t jedec; + cistpl_manfid_t manfid; + cistpl_funcid_t funcid; + cistpl_funce_t funce; + cistpl_bar_t bar; + cistpl_config_t config; + cistpl_cftable_entry_t cftable_entry; + cistpl_cftable_entry_cb_t cftable_entry_cb; + cistpl_device_geo_t device_geo; + cistpl_vers_2_t vers_2; + cistpl_org_t org; + cistpl_format_t format; +}; + +typedef union cisparse_t cisparse_t; + +struct class_attribute___2; + +struct class___2 { + const char *name; + struct module___2 *owner; + struct class_attribute___2 *class_attrs; + const struct attribute_group___2 **dev_groups; + struct kobject___2 *dev_kobj; + int (*dev_uevent)(struct device___2 *, struct kobj_uevent_env *); + char * (*devnode)(struct device___2 *, umode_t *); + void (*class_release)(struct class___2 *); + void (*dev_release)(struct device___2 *); + int (*suspend)(struct device___2 *, pm_message_t); + int (*resume)(struct device___2 *); + const struct kobj_ns_type_operations *ns_type; + const void * (*namespace)(struct device___2 *); + const struct dev_pm_ops *pm; + struct subsys_private *p; +}; + +struct class_attribute { + struct attribute attr; + ssize_t (*show)(struct class *, struct class_attribute *, char *); + ssize_t (*store)(struct class *, struct class_attribute *, const char *, size_t); +}; + +struct class_attribute___2 { + struct attribute attr; + ssize_t (*show)(struct class___2 *, struct class_attribute___2 *, char *); + ssize_t (*store)(struct class___2 *, struct class_attribute___2 *, const char *, size_t); +}; + +struct class_attribute_string { + struct class_attribute___2 attr; + char *str; +}; + +struct class_compat { + struct kobject *kobj; +}; + +struct klist_iter { + struct klist *i_klist; + struct klist_node *i_cur; +}; + +struct class_dev_iter { + struct klist_iter ki; + const struct device_type *type; +}; + +struct class_dir { + struct kobject kobj; + struct class *class; +}; + +struct class_interface { + struct list_head node; + struct class *class; + int (*add_dev)(struct device *, struct class_interface *); + void (*remove_dev)(struct device *, struct class_interface *); +}; + +struct clear_refs_private { + enum clear_refs_types type; +}; + +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 clocksource { + cycle_t (*read)(struct clocksource *); + cycle_t mask; + u32 mult; + u32 shift; + u64 max_idle_ns; + u32 maxadj; + struct arch_clocksource_data archdata; + u64 max_cycles; + const char *name; + struct list_head list; + int rating; + int (*enable)(struct clocksource *); + void (*disable)(struct clocksource *); + long unsigned int flags; + void (*suspend)(struct clocksource *); + void (*resume)(struct clocksource *); + struct list_head wd_list; + cycle_t cs_last; + cycle_t wd_last; + struct module *owner; +}; + +struct mapped_device; + +struct dm_table; + +struct dm_io; + +struct clone_info { + struct mapped_device *md; + struct dm_table *map; + struct bio *bio; + struct dm_io *io; + sector_t sector; + unsigned int sector_count; +}; + +struct drm_i915_cmd_descriptor; + +struct cmd_node { + const struct drm_i915_cmd_descriptor *desc; + struct hlist_node node; +}; + +struct rtc_device; + +struct cmos_rtc { + struct rtc_device *rtc; + struct device *dev; + int irq; + struct resource *iomem; + time64_t alarm_expires; + void (*wake_on)(struct device *); + void (*wake_off)(struct device *); + u8 enabled_wake; + u8 suspend_ctrl; + u8 day_alrm; + u8 mon_alrm; + u8 century; +}; + +struct cmos_rtc_board_info { + void (*wake_on)(struct device *); + void (*wake_off)(struct device *); + u32 flags; + int address_space; + u8 rtc_day_alarm; + u8 rtc_mon_alarm; + u8 rtc_century; +}; + +struct cmp_data { + struct task_struct *thr; + atomic_t ready; + atomic_t stop; + int ret; + wait_queue_head_t go; + wait_queue_head_t done; + size_t unc_len; + size_t cmp_len; + unsigned char unc[131072]; + unsigned char cmp[143360]; + unsigned char wrk[16384]; +}; + +struct cmsghdr { + __kernel_size_t cmsg_len; + int cmsg_level; + int cmsg_type; +}; + +struct cn_callback_id { + unsigned char name[32]; + struct cb_id id; +}; + +struct cn_queue_dev; + +struct cn_msg; + +struct netlink_skb_parms; + +struct cn_callback_entry { + struct list_head callback_entry; + atomic_t refcnt; + struct cn_queue_dev *pdev; + struct cn_callback_id id; + void (*callback)(struct cn_msg *, struct netlink_skb_parms *); + u32 seq; + u32 group; +}; + +struct cn_dev { + struct cb_id id; + u32 seq; + u32 groups; + struct sock *nls; + void (*input)(struct sk_buff *); + struct cn_queue_dev *cbdev; +}; + +struct cn_msg { + struct cb_id id; + __u32 seq; + __u32 ack; + __u16 len; + __u16 flags; + __u8 data[0]; +}; + +struct cn_queue_dev { + atomic_t refcnt; + unsigned char name[32]; + struct list_head queue_list; + spinlock_t queue_lock; + struct sock *nls; +}; + +struct coef_fw { + unsigned char nid; + unsigned char idx; + short unsigned int mask; + short unsigned int val; +}; + +struct color_conversion { + u16 ry; + u16 gy; + u16 by; + u16 ay; + u16 ru; + u16 gu; + u16 bu; + u16 au; + u16 rv; + u16 gv; + u16 bv; + u16 av; +}; + +struct color_luts { + u16 degamma_lut_size; + u16 gamma_lut_size; +}; + +struct comm_proc_event { + __kernel_pid_t process_pid; + __kernel_pid_t process_tgid; + char comm[16]; +}; + +struct comp_opts { + int dict_size; +}; + +struct zone; + +struct compact_control { + struct list_head freepages; + struct list_head migratepages; + long unsigned int nr_freepages; + long unsigned int nr_migratepages; + long unsigned int free_pfn; + long unsigned int migrate_pfn; + long unsigned int last_migrated_pfn; + enum migrate_mode mode; + bool ignore_skip_hint; + bool direct_compaction; + bool whole_zone; + int order; + const gfp_t gfp_mask; + const unsigned int alloc_flags; + const int classzone_idx; + struct zone *zone; + int contended; +}; + +struct compat_blk_user_trace_setup { + char name[32]; + u16 act_mask; + int: 0; + u32 buf_size; + u32 buf_nr; + compat_u64 start_lba; + compat_u64 end_lba; + u32 pid; +} __attribute__((packed)); + +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; + compat_int_t quiet; + compat_int_t timeout; + compat_caddr_t reserved[1]; +}; + +struct compat_cdrom_read_audio { + union cdrom_addr addr; + u8 addr_format; + compat_int_t nframes; + compat_caddr_t buf; +}; + +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_consolefontdesc { + short unsigned int charcount; + short unsigned int charheight; + compat_caddr_t chardata; +}; + +struct compat_efi_variable { + efi_char16_t VariableName[512]; + efi_guid_t VendorGuid; + __u32 DataSize; + __u8 Data[1024]; + __u32 Status; + __u32 Attributes; +}; + +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 compat_timeval { + compat_time_t tv_sec; + s32 tv_usec; +}; + +struct user_regs_struct32 { + __u32 ebx; + __u32 ecx; + __u32 edx; + __u32 esi; + __u32 edi; + __u32 ebp; + __u32 eax; + short unsigned int ds; + short unsigned int __ds; + short unsigned int es; + short unsigned int __es; + short unsigned int fs; + short unsigned int __fs; + short unsigned int gs; + short unsigned int __gs; + __u32 orig_eax; + __u32 eip; + short unsigned int cs; + short unsigned int __cs; + __u32 eflags; + __u32 esp; + short unsigned int ss; + short unsigned int __ss; +}; + +typedef struct user_regs_struct32 compat_elf_gregset_t; + +struct compat_elf_prstatus { + 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 compat_timeval pr_utime; + struct compat_timeval pr_stime; + struct compat_timeval pr_cutime; + struct compat_timeval pr_cstime; + compat_elf_gregset_t pr_reg; + compat_int_t pr_fpvalid; +}; + +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 compat_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; + compat_u64 ring_cookie; + u32 location; +} __attribute__((packed)); + +struct compat_ethtool_rxnfc { + u32 cmd; + u32 flow_type; + compat_u64 data; + struct compat_ethtool_rx_flow_spec fs; + u32 rule_cnt; + u32 rule_locs[0]; +} __attribute__((packed)); + +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; +} __attribute__((packed)); + +struct floppy_max_errors { + unsigned int abort; + unsigned int read_track; + unsigned int reset; + unsigned int recal; + unsigned int reporting; +}; + +struct compat_floppy_drive_params { + char cmos; + compat_ulong_t max_dtr; + compat_ulong_t hlt; + compat_ulong_t hut; + compat_ulong_t srt; + compat_ulong_t spinup; + compat_ulong_t spindown; + unsigned char spindown_offset; + unsigned char select_delay; + unsigned char rps; + unsigned char tracks; + compat_ulong_t timeout; + unsigned char interleave_sect; + struct floppy_max_errors max_errors; + char flags; + char read_track; + short int autodetect[8]; + compat_int_t checkfreq; + compat_int_t native_format; +}; + +struct compat_floppy_drive_struct { + signed char flags; + compat_ulong_t spinup_date; + compat_ulong_t select_date; + compat_ulong_t first_read_date; + short int probed_format; + short int track; + short int maxblock; + short int maxtrack; + compat_int_t generation; + compat_int_t keep_data; + compat_int_t fd_ref; + compat_int_t fd_device; + compat_int_t last_checked; + compat_caddr_t dmabuf; + compat_int_t bufblocks; +}; + +struct compat_floppy_fdc_state { + compat_int_t spec1; + compat_int_t spec2; + compat_int_t dtr; + unsigned char version; + unsigned char dor; + compat_ulong_t address; + unsigned int rawcmd: 2; + unsigned int reset: 1; + unsigned int need_configure: 1; + unsigned int perp_mode: 2; + unsigned int has_fifo: 1; + unsigned int driver_version; + unsigned char track[4]; +}; + +struct compat_floppy_struct { + compat_uint_t size; + compat_uint_t sect; + compat_uint_t head; + compat_uint_t track; + compat_uint_t stretch; + unsigned char gap; + unsigned char rate; + unsigned char spec1; + unsigned char fmt_gap; + const compat_caddr_t name; +}; + +struct compat_floppy_write_errors { + unsigned int write_errors; + compat_ulong_t first_error_sector; + compat_int_t first_error_generation; + compat_ulong_t last_error_sector; + compat_int_t last_error_generation; + compat_uint_t badness; +}; + +struct compat_fs_qfilestat { + compat_u64 dqb_bhardlimit; + compat_u64 qfs_nblks; + compat_uint_t qfs_nextents; +} __attribute__((packed)); + +struct compat_fs_quota_stat { + __s8 qs_version; + __u16 qs_flags; + __s8 qs_pad; + long: 0; + struct compat_fs_qfilestat qs_uquota; + struct compat_fs_qfilestat qs_gquota; + compat_uint_t qs_incoredqs; + compat_int_t qs_btimelimit; + compat_int_t qs_itimelimit; + compat_int_t qs_rtbtimelimit; + __u16 qs_bwarnlimit; + __u16 qs_iwarnlimit; +}; + +struct dir_context; + +typedef int (*filldir_t)(struct dir_context *, const char *, int, loff_t, u64, unsigned int); + +struct dir_context { + const filldir_t actor; + loff_t pos; +}; + +struct compat_linux_dirent; + +struct compat_getdents_callback { + struct dir_context ctx; + struct compat_linux_dirent *current_dir; + struct compat_linux_dirent *previous; + int count; + int error; +}; + +struct linux_dirent64; + +struct compat_getdents_callback64 { + struct dir_context ctx; + struct linux_dirent64 *current_dir; + struct linux_dirent64 *previous; + int count; + int error; +}; + +struct compat_group_filter { + __u32 gf_interface; + struct __kernel_sockaddr_storage gf_group; + __u32 gf_fmode; + __u32 gf_numsrc; + struct __kernel_sockaddr_storage gf_slist[1]; +}; + +struct compat_group_req { + __u32 gr_interface; + struct __kernel_sockaddr_storage gr_group; +}; + +struct compat_group_source_req { + __u32 gsr_interface; + struct __kernel_sockaddr_storage gsr_group; + struct __kernel_sockaddr_storage gsr_source; +}; + +struct compat_hd_geometry { + unsigned char heads; + unsigned char sectors; + short unsigned int cylinders; + u32 start; +}; + +struct compat_hpet_info { + compat_ulong_t hi_ireqfreq; + compat_ulong_t hi_flags; + short unsigned int hi_hpet; + short unsigned int hi_timer; +}; + +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; +} __attribute__((packed)); + +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_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; + short unsigned int mode; + short unsigned int __pad1; + short unsigned int seq; + short unsigned int __pad2; + compat_ulong_t unused1; + compat_ulong_t unused2; +}; + +struct compat_ipc_kludge { + compat_uptr_t msgp; + compat_long_t msgtyp; +}; + +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_timespec { + compat_time_t tv_sec; + s32 tv_nsec; +}; + +struct compat_itimerspec { + struct compat_timespec it_interval; + struct compat_timespec it_value; +}; + +struct compat_itimerval { + struct compat_timeval it_interval; + struct compat_timeval it_value; +}; + +struct compat_kexec_segment { + compat_uptr_t buf; + compat_size_t bufsz; + compat_ulong_t mem; + compat_size_t memsz; +}; + +struct compat_kvm_dirty_log { + __u32 slot; + __u32 padding1; + union { + compat_uptr_t dirty_bitmap; + __u64 padding2; + }; +}; + +struct compat_linux_dirent { + compat_ulong_t d_ino; + compat_ulong_t d_off; + short unsigned int d_reclen; + char d_name[1]; +}; + +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[1]; +}; + +struct compat_msqid64_ds { + struct compat_ipc64_perm msg_perm; + compat_time_t msg_stime; + compat_ulong_t __unused1; + compat_time_t msg_rtime; + compat_ulong_t __unused2; + compat_time_t msg_ctime; + compat_ulong_t __unused3; + 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; + compat_time_t msg_stime; + compat_time_t msg_rtime; + compat_time_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_ncp_mount_data { + compat_int_t version; + compat_uint_t ncp_fd; + __compat_uid_t mounted_uid; + compat_pid_t wdog_pid; + unsigned char mounted_vol[17]; + compat_uint_t time_out; + compat_uint_t retry_count; + compat_uint_t flags; + __compat_uid_t uid; + __compat_gid_t gid; + compat_mode_t file_mode; + compat_mode_t dir_mode; +}; + +struct compat_ncp_mount_data_v4 { + compat_int_t version; + compat_ulong_t flags; + compat_ulong_t mounted_uid; + compat_long_t wdog_pid; + compat_uint_t ncp_fd; + compat_uint_t time_out; + compat_uint_t retry_count; + compat_ulong_t uid; + compat_ulong_t gid; + compat_ulong_t file_mode; + compat_ulong_t dir_mode; +}; + +struct compat_nfs_string { + compat_uint_t len; + compat_uptr_t data; +}; + +struct compat_nfs4_mount_data_v1 { + compat_int_t version; + compat_int_t flags; + compat_int_t rsize; + compat_int_t wsize; + compat_int_t timeo; + compat_int_t retrans; + compat_int_t acregmin; + compat_int_t acregmax; + compat_int_t acdirmin; + compat_int_t acdirmax; + struct compat_nfs_string client_addr; + struct compat_nfs_string mnt_path; + struct compat_nfs_string hostname; + compat_uint_t host_addrlen; + compat_uptr_t host_addr; + compat_int_t proto; + compat_int_t auth_flavourlen; + compat_uptr_t auth_flavours; +}; + +struct compat_old_linux_dirent { + compat_ulong_t d_ino; + compat_ulong_t d_offset; + short unsigned int d_namlen; + char d_name[1]; +}; + +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_resume_swap_area { + compat_loff_t offset; + u32 dev; +} __attribute__((packed)); + +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; +}; + +struct compat_rusage { + struct compat_timeval ru_utime; + struct compat_timeval 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_time_t sem_otime; + compat_ulong_t __unused1; + compat_time_t sem_ctime; + compat_ulong_t __unused2; + compat_ulong_t sem_nsems; + compat_ulong_t __unused3; + compat_ulong_t __unused4; +}; + +struct compat_semid_ds { + struct compat_ipc_perm sem_perm; + compat_time_t sem_otime; + compat_time_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_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_time_t shm_atime; + compat_ulong_t __unused1; + compat_time_t shm_dtime; + compat_ulong_t __unused2; + compat_time_t shm_ctime; + compat_ulong_t __unused3; + 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; + compat_time_t shm_atime; + compat_time_t shm_dtime; + compat_time_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_sigaltstack { + compat_uptr_t ss_sp; + int ss_flags; + compat_size_t ss_size; +}; + +typedef struct compat_sigaltstack compat_stack_t; + +union compat_sigval { + compat_int_t sival_int; + compat_uptr_t sival_ptr; +}; + +typedef union compat_sigval compat_sigval_t; + +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; +}; + +struct compat_siginfo { + int si_signo; + int si_errno; + int si_code; + union { + int _pad[29]; + struct { + unsigned int _pid; + unsigned int _uid; + } _kill; + struct { + compat_timer_t _tid; + int _overrun; + compat_sigval_t _sigval; + int _sys_private; + int _overrun_incr; + } _timer; + struct { + unsigned int _pid; + unsigned int _uid; + compat_sigval_t _sigval; + } _rt; + struct { + unsigned int _pid; + unsigned int _uid; + int _status; + compat_clock_t _utime; + compat_clock_t _stime; + } _sigchld; + struct { + unsigned int _pid; + unsigned int _uid; + int _status; + compat_s64 _utime; + compat_s64 _stime; + } __attribute__((packed)) _sigchld_x32; + struct { + unsigned int _addr; + } _sigfault; + struct { + int _band; + int _fd; + } _sigpoll; + struct { + unsigned int _call_addr; + int _syscall; + unsigned int _arch; + } _sigsys; + } _sifields; +}; + +typedef struct compat_siginfo compat_siginfo_t; + +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 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; + u16 __pad1; + compat_ino_t st_ino; + compat_mode_t st_mode; + compat_nlink_t st_nlink; + __compat_uid_t st_uid; + __compat_gid_t st_gid; + compat_dev_t st_rdev; + u16 __pad2; + u32 st_size; + u32 st_blksize; + u32 st_blocks; + u32 st_atime; + u32 st_atime_nsec; + u32 st_mtime; + u32 st_mtime_nsec; + u32 st_ctime; + u32 st_ctime_nsec; + u32 __unused4; + u32 __unused5; +}; + +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_sysctl_args { + compat_uptr_t name; + int nlen; + compat_uptr_t oldval; + compat_uptr_t oldlenp; + compat_uptr_t newval; + compat_size_t newlen; + compat_ulong_t __unused[4]; +}; + +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_timex { + compat_uint_t modes; + compat_long_t offset; + compat_long_t freq; + compat_long_t maxerror; + compat_long_t esterror; + compat_int_t status; + compat_long_t constant; + compat_long_t precision; + compat_long_t tolerance; + struct compat_timeval time; + compat_long_t tick; + compat_long_t ppsfreq; + compat_long_t jitter; + compat_int_t shift; + compat_long_t stabil; + compat_long_t jitcnt; + compat_long_t calcnt; + compat_long_t errcnt; + compat_long_t stbcnt; + compat_int_t tai; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; +}; + +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 compat_utimbuf { + compat_time_t actime; + compat_time_t modtime; +}; + +struct compat_video_event { + int32_t type; + compat_time_t timestamp; + union { + video_size_t size; + unsigned int frame_rate; + } u; +}; + +struct compat_video_spu_palette { + int length; + compat_uptr_t palette; +}; + +struct compat_video_still_picture { + compat_uptr_t iFrame; + int32_t size; +}; + +struct master; + +struct component_ops; + +struct component { + struct list_head node; + struct master *master; + bool bound; + const struct component_ops *ops; + 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 *); + 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 compress_tfm { + int (*cot_compress)(struct crypto_tfm *, const u8 *, unsigned int, u8 *, unsigned int *); + int (*cot_decompress)(struct crypto_tfm *, const u8 *, unsigned int, u8 *, unsigned int *); +}; + +struct consw; + +struct con_driver { + const struct consw *con; + const char *desc; + struct device *dev; + int node; + int first; + int last; + int flag; +}; + +struct config_t { + struct kref ref; + unsigned int state; + struct resource io[2]; + struct resource mem[4]; +}; + +typedef struct config_t config_t; + +struct tty_driver; + +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 (*match)(struct console *, char *, int, char *); + short int flags; + short int index; + int cflag; + void *data; + struct console *next; +}; + +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 console___2 { + struct list_head list; + struct hvc_struct *hvc; + struct winsize ws; + u32 vtermno; +}; + +struct console_cmdline { + char name[16]; + int index; + char *options; +}; + +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 consolefontdesc { + short unsigned int charcount; + short unsigned int charheight; + char *chardata; +}; + +struct vc_data; + +struct consw { + struct module *owner; + const char * (*con_startup)(void); + void (*con_init)(struct vc_data *, int); + void (*con_deinit)(struct vc_data *); + void (*con_clear)(struct vc_data *, int, int, int, int); + void (*con_putc)(struct vc_data *, int, int, int); + void (*con_putcs)(struct vc_data *, const short unsigned int *, int, int, int); + void (*con_cursor)(struct vc_data *, int); + int (*con_scroll)(struct vc_data *, int, int, int, int); + void (*con_bmove)(struct vc_data *, int, int, int, int, int, int); + int (*con_switch)(struct vc_data *); + int (*con_blank)(struct vc_data *, int, int); + int (*con_font_set)(struct vc_data *, struct console_font *, unsigned int); + int (*con_font_get)(struct vc_data *, struct console_font *); + int (*con_font_default)(struct vc_data *, struct console_font *, char *); + int (*con_font_copy)(struct vc_data *, int); + int (*con_resize)(struct vc_data *, unsigned int, unsigned int, unsigned int); + int (*con_set_palette)(struct vc_data *, const unsigned char *); + int (*con_scrolldelta)(struct vc_data *, int); + int (*con_set_origin)(struct vc_data *); + void (*con_save_screen)(struct vc_data *); + u8 (*con_build_attr)(struct vc_data *, u8, u8, u8, u8, u8, u8); + void (*con_invert_region)(struct vc_data *, u16 *, int); + u16 * (*con_screen_pos)(struct vc_data *, int); + long unsigned int (*con_getxy)(struct vc_data *, long unsigned int, int *, int *); + int (*con_debug_enter)(struct vc_data *); + int (*con_debug_leave)(struct vc_data *); +}; + +struct cont { + char buf[992]; + size_t len; + size_t cons; + struct task_struct *owner; + u64 ts_nsec; + u8 level; + u8 facility; + enum log_flags flags; + bool flushed: 1; +}; + +struct container_dev { + struct device___2 dev; + int (*offline)(struct container_dev *); +}; + +struct context_entry { + u64 lo; + u64 hi; +}; + +struct contig_page_info { + long unsigned int free_pages; + long unsigned int free_blocks_total; + long unsigned int free_blocks_suitable; +}; + +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_thread___2 { + struct task_struct___2 *task; + struct core_thread___2 *next; +}; + +struct core_state___2 { + atomic_t nr_threads; + struct core_thread___2 dumper; + struct completion startup; +}; + +struct siginfo; + +typedef struct siginfo siginfo_t; + +struct coredump_params { + const siginfo_t *siginfo; + struct pt_regs *regs; + struct file___2 *file; + long unsigned int limit; + long unsigned int mm_flags; + loff_t written; + loff_t pos; +}; + +struct coredump_proc_event { + __kernel_pid_t process_pid; + __kernel_pid_t process_tgid; +}; + +struct count_info { + int bytes; + int blocks; + int ptr; +}; + +struct cpa_data { + long unsigned int *vaddr; + pgd_t *pgd; + pgprot_t mask_set; + pgprot_t mask_clr; + long unsigned int numpages; + int flags; + long unsigned int pfn; + unsigned int force_split: 1; + int curpage; + struct page___2 **pages; +}; + +struct cparams { + u16 i; + u16 t; + u16 m; + u16 c; +}; + +struct cpio_data { + void *data; + size_t size; + char name[18]; +}; + +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 num_levels; + unsigned int num_leaves; +}; + +struct cpuinfo_x86; + +struct cpu_dev { + const char *c_vendor; + const char *c_ident[2]; + void (*c_early_init)(struct cpuinfo_x86 *); + void (*c_bsp_init)(struct cpuinfo_x86 *); + void (*c_init)(struct cpuinfo_x86 *); + void (*c_identify)(struct cpuinfo_x86 *); + void (*c_detect_tlb)(struct cpuinfo_x86 *); + void (*c_bsp_resume)(struct cpuinfo_x86 *); + int c_x86_vendor; +}; + +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 reserved: 44; +}; + +struct perf_branch_stack { + __u64 nr; + struct perf_branch_entry entries[0]; +}; + +struct perf_guest_switch_msr { + unsigned int msr; + u64 host; + u64 guest; +}; + +struct er_account; + +struct intel_shared_regs; + +struct intel_excl_cntrs; + +struct cpu_hw_events { + struct perf_event *events[64]; + long unsigned int active_mask[1]; + long unsigned int running[1]; + int enabled; + int n_events; + int n_added; + int n_txn; + int assign[64]; + u64 tags[64]; + struct perf_event *event_list[64]; + struct event_constraint *event_constraint[64]; + int n_excl; + unsigned int txn_flags; + int is_fake; + struct debug_store *ds; + u64 pebs_enabled; + int lbr_users; + void *lbr_context; + struct perf_branch_stack lbr_stack; + struct perf_branch_entry lbr_entries[32]; + struct er_account *lbr_sel; + u64 br_sel; + u64 intel_ctrl_guest_mask; + u64 intel_ctrl_host_mask; + struct perf_guest_switch_msr guest_switch_msrs[64]; + u64 intel_cp_status; + struct intel_shared_regs *shared_regs; + struct event_constraint *constraint_list; + struct intel_excl_cntrs *excl_cntrs; + int excl_thread_id; + struct amd_nb *amd_nb; + u64 perf_ctr_virt_mask; + void *kfree_on_online[2]; +}; + +struct cpu_signature; + +struct cpu_info_ctx { + struct cpu_signature *cpu_sig; + int err; +}; + +struct cpu_itimer { + cputime_t expires; + cputime_t incr; + u32 error; + u32 incr_error; +}; + +struct cpu_perf_ibs { + struct perf_event *event; + long unsigned int state[1]; +}; + +struct cpu_rmap { + struct kref refcount; + u16 size; + u16 used; + void **obj; + struct { + u16 index; + u16 dist; + } near[0]; +}; + +struct cpu_signature { + unsigned int sig; + unsigned int pf; + unsigned int rev; +}; + +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; + void *arg; + struct cpu_stop_done *done; +}; + +struct cpu_stopper { + struct task_struct *thread; + spinlock_t lock; + bool enabled; + struct list_head works; + struct cpu_stop_work stop_work; +}; + +struct cpu_timer_list { + struct list_head entry; + long long unsigned int expires; + long long unsigned int incr; + struct task_struct *task; + int firing; +}; + +struct cpu_vfs_cap_data { + __u32 magic_etc; + kernel_cap_t permitted; + kernel_cap_t inheritable; +}; + +struct cpuacct_usage; + +struct kernel_cpustat; + +struct cpuacct { + struct cgroup_subsys_state css; + struct cpuacct_usage *cpuusage; + struct kernel_cpustat *cpustat; +}; + +struct cpuacct_usage { + u64 usages[2]; +}; + +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 cpufreq_cpuinfo { + unsigned int max_freq; + unsigned int min_freq; + unsigned int transition_latency; +}; + +struct cpufreq_freqs { + unsigned int cpu; + unsigned int old; + unsigned int new; + u8 flags; +}; + +struct cpufreq_frequency_table { + unsigned int flags; + unsigned int driver_data; + unsigned int frequency; +}; + +struct cpufreq_policy; + +struct cpufreq_governor { + char name[16]; + int initialized; + int (*governor)(struct cpufreq_policy *, unsigned int); + ssize_t (*show_setspeed)(struct cpufreq_policy *, char *); + int (*store_setspeed)(struct cpufreq_policy *, unsigned int); + unsigned int max_transition_latency; + struct list_head governor_list; + struct module *owner; +}; + +struct cpufreq_user_policy { + unsigned int min; + unsigned int max; +}; + +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 restore_freq; + 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 cpufreq_user_policy user_policy; + struct cpufreq_frequency_table *freq_table; + 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 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 cpuhp_cpu_state { + enum cpuhp_state state; + enum cpuhp_state target; + struct task_struct *thread; + bool should_run; + bool rollback; + enum cpuhp_state cb_state; + int (*cb)(unsigned int); + int result; + struct completion done; +}; + +struct cpuhp_step { + const char *name; + int (*startup)(unsigned int); + int (*teardown)(unsigned int); + bool skip_onerr; + bool cant_stop; +}; + +union cpuid10_eax { + struct { + unsigned int version_id: 8; + unsigned int num_counters: 8; + unsigned int bit_width: 8; + unsigned int mask_length: 8; + } split; + unsigned int full; +}; + +union cpuid10_ebx { + struct { + unsigned int no_unhalted_core_cycles: 1; + unsigned int no_instructions_retired: 1; + unsigned int no_unhalted_reference_cycles: 1; + unsigned int no_llc_reference: 1; + unsigned int no_llc_misses: 1; + unsigned int no_branch_instruction_retired: 1; + unsigned int no_branch_misses_retired: 1; + } split; + unsigned int full; +}; + +union cpuid10_edx { + struct { + unsigned int num_counters_fixed: 5; + unsigned int bit_width_fixed: 8; + unsigned int reserved: 19; + } split; + unsigned int full; +}; + +struct cpuid_bit { + u16 feature; + u8 reg; + u8 bit; + u32 level; + u32 sub_leaf; +}; + +struct cpuid_dependent_feature { + u32 feature; + u32 level; +}; + +struct cpuid_regs___2 { + u32 eax; + u32 ebx; + u32 ecx; + u32 edx; +}; + +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; + long long unsigned int time; +}; + +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 cpu; + int last_residency; + 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]; + unsigned int flags; + unsigned int exit_latency; + int power_usage; + unsigned int target_residency; + bool disabled; + int (*enter)(struct cpuidle_device *, struct cpuidle_driver *, int); + int (*enter_dead)(struct cpuidle_device *, int); + void (*enter_freeze)(struct cpuidle_device *, struct cpuidle_driver *, int); +}; + +struct cpuidle_driver { + const char *name; + struct module *owner; + int refcnt; + unsigned int bctimer: 1; + struct cpuidle_state states[10]; + int state_count; + int safe_state_index; + struct cpumask *cpumask; +}; + +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 *); + void (*reflect)(struct cpuidle_device *, int); + struct module *owner; +}; + +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 cpuinfo_x86 { + __u8 x86; + __u8 x86_vendor; + __u8 x86_model; + __u8 x86_mask; + int x86_tlbsize; + __u8 x86_virt_bits; + __u8 x86_phys_bits; + __u8 x86_coreid_bits; + __u32 extended_cpuid_level; + int cpuid_level; + __u32 x86_capability[19]; + char x86_vendor_id[16]; + char x86_model_id[64]; + int x86_cache_size; + int x86_cache_alignment; + int x86_cache_max_rmid; + int x86_cache_occ_scale; + int x86_power; + long unsigned int loops_per_jiffy; + u16 x86_max_cores; + u16 apicid; + u16 initial_apicid; + u16 x86_clflush_size; + u16 booted_cores; + u16 phys_proc_id; + u16 logical_proc_id; + u16 cpu_core_id; + u16 cpu_index; + u32 microcode; +}; + +struct cpupri_vec { + atomic_t count; + cpumask_var_t mask; +}; + +struct cpupri { + struct cpupri_vec pri_to_cpu[102]; + int *cpu_to_pri; +}; + +struct fmeter { + int cnt; + int val; + time64_t time; + spinlock_t lock; +}; + +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; + nodemask_t old_mems_allowed; + struct fmeter fmeter; + int attach_in_progress; + int pn; + int relax_domain_level; +}; + +struct mm_struct; + +struct cpuset_migrate_mm_work { + struct work_struct work; + struct mm_struct *mm; + nodemask_t from; + nodemask_t to; +}; + +struct cqm_rmid_entry { + u32 rmid; + enum rmid_recycle_state state; + struct list_head list; + long unsigned int queue_time; +}; + +struct crc_data { + struct task_struct *thr; + atomic_t ready; + atomic_t stop; + unsigned int run_threads; + wait_queue_head_t go; + wait_queue_head_t done; + u32 *crc32; + size_t *unc_len[3]; + unsigned char *unc[3]; +}; + +struct key; + +struct group_info; + +struct cred { + atomic_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; + struct user_struct *user; + struct user_namespace *user_ns; + struct group_info *group_info; + struct callback_head rcu; +}; + +struct key___2; + +struct cred___2 { + atomic_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___2 *session_keyring; + struct key___2 *process_keyring; + struct key___2 *thread_keyring; + struct key___2 *request_key_auth; + struct user_struct___2 *user; + struct user_namespace *user_ns; + struct group_info *group_info; + struct callback_head rcu; +}; + +struct crypto_tfm { + u32 crt_flags; + union { + struct ablkcipher_tfm ablkcipher; + struct blkcipher_tfm blkcipher; + struct cipher_tfm cipher; + struct compress_tfm compress; + } crt_u; + void (*exit)(struct crypto_tfm *); + struct crypto_alg *__crt_alg; + void *__crt_ctx[0]; +}; + +struct crypto_ablkcipher { + struct crypto_tfm base; +}; + +struct crypto_aead { + unsigned int authsize; + unsigned int reqsize; + struct crypto_tfm base; +}; + +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 { + 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); + unsigned int reqsize; + bool has_setkey; + struct crypto_tfm base; +}; + +struct crypto_akcipher { + struct crypto_tfm base; +}; + +struct crypto_akcipher_spawn { + struct crypto_spawn base; +}; + +struct crypto_attr_alg { + char name[64]; +}; + +struct crypto_attr_type { + u32 type; + u32 mask; +}; + +struct crypto_attr_u32 { + u32 num; +}; + +struct crypto_authenc_ctx { + struct crypto_ahash *auth; + struct crypto_ablkcipher *enc; + struct crypto_blkcipher *null; +}; + +struct crypto_authenc_esn_ctx { + unsigned int reqoff; + struct crypto_ahash *auth; + struct crypto_ablkcipher *enc; + struct crypto_blkcipher *null; +}; + +struct crypto_authenc_key_param { + __be32 enckeylen; +}; + +struct crypto_authenc_keys { + const u8 *authkey; + const u8 *enckey; + unsigned int authkeylen; + unsigned int enckeylen; +}; + +struct crypto_blkcipher { + struct crypto_tfm base; +}; + +struct crypto_cipher; + +struct crypto_cbc_ctx { + struct crypto_cipher *child; +}; + +struct crypto_ccm_ctx { + struct crypto_cipher *cipher; + struct crypto_ablkcipher *ctr; +}; + +struct crypto_ccm_req_priv_ctx { + u8 odata[16]; + u8 idata[16]; + u8 auth_tag[16]; + u32 ilen; + u32 flags; + struct scatterlist src[3]; + struct scatterlist dst[3]; + struct ablkcipher_request abreq; +}; + +struct crypto_cipher { + struct crypto_tfm base; +}; + +struct crypto_ctr_ctx { + struct crypto_cipher *child; +}; + +struct crypto_gcm_ctx { + struct crypto_ablkcipher *ctr; + struct crypto_ahash *ghash; +}; + +struct crypto_gcm_ghash_ctx { + unsigned int cryptlen; + struct scatterlist *src; + int (*complete)(struct aead_request *, u32); +}; + +struct crypto_gcm_req_priv_ctx { + u8 iv[16]; + u8 auth_tag[16]; + u8 iauth_tag[16]; + struct scatterlist src[3]; + struct scatterlist dst[3]; + struct scatterlist sg; + struct crypto_gcm_ghash_ctx ghash_ctx; + union { + struct ahash_request ahreq; + struct ablkcipher_request abreq; + } u; +}; + +struct crypto_gcm_setkey_result { + int err; + struct completion completion; +}; + +struct crypto_hash_walk { + char *data; + unsigned int offset; + unsigned int alignmask; + struct page *pg; + unsigned int entrylen; + unsigned int total; + struct scatterlist *sg; + unsigned int flags; +}; + +struct crypto_larval { + struct crypto_alg alg; + struct crypto_alg *adult; + struct completion completion; + u32 mask; +}; + +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_hash { + char type[64]; + unsigned int blocksize; + unsigned int digestsize; +}; + +struct crypto_report_rng { + char type[64]; + unsigned int seedsize; +}; + +struct crypto_rfc3686_ctx { + struct crypto_ablkcipher *child; + u8 nonce[4]; +}; + +struct crypto_rfc3686_req_ctx { + u8 iv[16]; + struct ablkcipher_request subreq; +}; + +struct crypto_rfc4106_ctx { + struct crypto_aead *child; + u8 nonce[4]; +}; + +struct crypto_rfc4106_req_ctx { + struct scatterlist src[3]; + struct scatterlist dst[3]; + struct aead_request subreq; +}; + +struct crypto_rfc4309_ctx { + struct crypto_aead *child; + u8 nonce[3]; +}; + +struct crypto_rfc4309_req_ctx { + struct scatterlist src[3]; + struct scatterlist dst[3]; + struct aead_request subreq; +}; + +struct crypto_rfc4543_ctx { + struct crypto_aead *child; + struct crypto_blkcipher *null; + u8 nonce[4]; +}; + +struct crypto_rfc4543_instance_ctx { + struct crypto_aead_spawn aead; +}; + +struct crypto_rfc4543_req_ctx { + struct aead_request subreq; +}; + +struct crypto_rng { + struct crypto_tfm base; +}; + +struct crypto_shash { + unsigned int descsize; + struct crypto_tfm base; +}; + +struct crypto_shash_spawn { + struct crypto_spawn base; +}; + +struct skcipher_request; + +struct crypto_skcipher { + int (*setkey)(struct crypto_skcipher *, const u8 *, unsigned int); + int (*encrypt)(struct skcipher_request *); + int (*decrypt)(struct skcipher_request *); + unsigned int ivsize; + unsigned int reqsize; + unsigned int keysize; + struct crypto_tfm base; +}; + +struct rtattr; + +struct crypto_template { + struct list_head list; + struct hlist_head instances; + struct module___2 *module; + struct crypto_instance * (*alloc)(struct rtattr **); + void (*free)(struct crypto_instance *); + int (*create)(struct crypto_template *, struct rtattr **); + char name[64]; +}; + +struct crypto_test_param { + char driver[64]; + char alg[64]; + u32 type; +}; + +struct crypto_type { + unsigned int (*ctxsize)(struct crypto_alg *, u32, u32); + unsigned int (*extsize)(struct crypto_alg *); + int (*init)(struct crypto_tfm *, u32, u32); + int (*init_tfm)(struct crypto_tfm *); + void (*show)(struct seq_file *, struct crypto_alg *); + int (*report)(struct sk_buff___2 *, struct crypto_alg *); + struct crypto_alg * (*lookup)(const char *, u32, u32); + 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; + union { + struct rtattr attr; + struct { + struct rtattr attr; + struct crypto_attr_alg data; + } alg; + struct { + struct rtattr attr; + struct crypto_attr_u32 data; + } nu32; + } attrs[32]; + char template[64]; + struct crypto_larval *larval; + u32 otype; + u32 omask; +}; + +struct css_set { + atomic_t refcount; + struct hlist_node hlist; + struct list_head tasks; + struct list_head mg_tasks; + struct list_head cgrp_links; + struct cgroup *dfl_cgrp; + struct cgroup_subsys_state *subsys[4]; + struct list_head mg_preload_node; + struct list_head mg_node; + struct cgroup *mg_src_cgrp; + struct cgroup *mg_dst_cgrp; + struct css_set *mg_dst_cset; + struct list_head e_cset_node[4]; + struct list_head task_iters; + bool dead; + struct callback_head callback_head; +}; + +struct css_set___2 { + atomic_t refcount; + struct hlist_node hlist; + struct list_head tasks; + struct list_head mg_tasks; + struct list_head cgrp_links; + struct cgroup___2 *dfl_cgrp; + struct cgroup_subsys_state___2 *subsys[4]; + struct list_head mg_preload_node; + struct list_head mg_node; + struct cgroup___2 *mg_src_cgrp; + struct cgroup___2 *mg_dst_cgrp; + struct css_set___2 *mg_dst_cset; + struct list_head e_cset_node[4]; + struct list_head task_iters; + bool dead; + struct callback_head callback_head; +}; + +struct css_task_iter { + struct cgroup_subsys *ss; + struct list_head *cset_pos; + struct list_head *cset_head; + struct list_head *task_pos; + struct list_head *tasks_head; + struct list_head *mg_tasks_head; + struct css_set *cur_cset; + struct task_struct *cur_task; + struct list_head iters_node; +}; + +struct cstate { + int state; + uint32_t rep0; + uint32_t rep1; + uint32_t rep2; + uint32_t rep3; +}; + +struct cstate_entry { + struct { + unsigned int eax; + unsigned int ecx; + } states[8]; +}; + +struct cstate_model { + long unsigned int core_events; + long unsigned int pkg_events; + long unsigned int quirks; +}; + +struct ctl_table; + +struct ctl_table_root; + +struct ctl_table_set; + +struct ctl_dir; + +struct ctl_node; + +struct ctl_table_header { + union { + struct { + struct ctl_table *ctl_table; + int used; + int count; + int nreg; + }; + struct callback_head rcu; + }; + struct completion *unregistering; + 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 ctl_dir { + struct ctl_table_header header; + struct rb_root root; +}; + +struct ctl_table_root___2; + +struct ctl_table_set___2; + +struct ctl_dir___2; + +struct ctl_node___2; + +struct ctl_table_header___2 { + union { + struct { + struct ctl_table *ctl_table; + int used; + int count; + int nreg; + }; + struct callback_head rcu; + }; + struct completion *unregistering; + struct ctl_table *ctl_table_arg; + struct ctl_table_root___2 *root; + struct ctl_table_set___2 *set; + struct ctl_dir___2 *parent; + struct ctl_node___2 *node; +}; + +struct ctl_dir___2 { + struct ctl_table_header___2 header; + struct rb_root root; +}; + +struct ctl_node { + struct rb_node node; + struct ctl_table_header *header; +}; + +struct ctl_node___2 { + struct rb_node node; + struct ctl_table_header___2 *header; +}; + +struct ctl_path { + const char *procname; +}; + +typedef int proc_handler(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; + struct ctl_table *child; + 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 nsproxy; + +struct ctl_table_root { + struct ctl_table_set default_set; + struct ctl_table_set * (*lookup)(struct ctl_table_root *, struct nsproxy *); + int (*permissions)(struct ctl_table_header *, struct ctl_table *); +}; + +struct ctl_table_set___2 { + int (*is_seen)(struct ctl_table_set___2 *); + struct ctl_dir___2 dir; +}; + +struct nsproxy___2; + +struct ctl_table_root___2 { + struct ctl_table_set___2 default_set; + struct ctl_table_set___2 * (*lookup)(struct ctl_table_root___2 *, struct nsproxy___2 *); + int (*permissions)(struct ctl_table_header___2 *, struct ctl_table *); +}; + +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 cuse_init_in { + uint32_t major; + uint32_t minor; + uint32_t unused; + uint32_t flags; +}; + +struct cvt_timing { + u8 code[3]; +}; + +struct cwt_wait { + wait_queue_t wait; + struct work_struct *work; +}; + +struct cxsr_latency { + int is_desktop; + int is_ddr3; + long unsigned int fsb_freq; + long unsigned int mem_freq; + long unsigned int display_sr; + long unsigned int display_hpll_disable; + long unsigned int cursor_sr; + long unsigned int cursor_hpll_disable; +}; + +struct cyc2ns_data { + u32 cyc2ns_mul; + u32 cyc2ns_shift; + u64 cyc2ns_offset; + u32 __count; +}; + +struct cyc2ns { + struct cyc2ns_data data[2]; + struct cyc2ns_data *head; + struct cyc2ns_data *tail; +}; + +typedef struct cyc2ns_data *pto_T_____14; + +struct cytp_contact { + int x; + int y; + int z; +}; + +struct cytp_data { + int fw_version; + int pkt_size; + int mode; + int tp_min_pressure; + int tp_max_pressure; + int tp_width; + int tp_high; + int tp_max_abs_x; + int tp_max_abs_y; + int tp_res_x; + int tp_res_y; + int tp_metrics_supported; +}; + +struct cytp_report_data { + int contact_cnt; + struct cytp_contact contacts[2]; + unsigned int left: 1; + unsigned int right: 1; + unsigned int middle: 1; + unsigned int tap: 1; +}; + +struct d_partition { + __le32 p_size; + __le32 p_offset; + __le32 p_fsize; + u8 p_fstype; + u8 p_frag; + __le16 p_cpg; +}; + +struct d_partition___2 { + __le32 p_res; + u8 p_fstype; + u8 p_res2[3]; + __le32 p_offset; + __le32 p_size; +}; + +struct data_chunk { + size_t size; + size_t icg; + size_t dst_icg; + size_t src_icg; +}; + +struct path___2 { + struct vfsmount *mnt; + struct dentry *dentry; +}; + +struct dcookie_struct { + struct path___2 path; + struct list_head hash_list; +}; + +struct dcookie_user { + struct list_head next; +}; + +struct ddi_buf_trans { + u32 trans1; + u32 trans2; + u8 i_boost; +}; + +struct ddi_vbt_port_info { + uint8_t hdmi_level_shift; + uint8_t supports_dvi: 1; + uint8_t supports_hdmi: 1; + uint8_t supports_dp: 1; + uint8_t alternate_aux_channel; + uint8_t alternate_ddc_pin; + uint8_t dp_boost_level; + uint8_t hdmi_boost_level; +}; + +struct deadline_data { + struct rb_root sort_list[2]; + struct list_head fifo_list[2]; + struct request *next_rq[2]; + unsigned int batching; + unsigned int starved; + int fifo_expire[2]; + int fifo_batch; + int writes_starved; + int front_merges; +}; + +struct debugfs_blob_wrapper { + void *data; + long unsigned int size; +}; + +struct debugfs_devm_entry { + int (*read)(struct seq_file___2 *, void *); + struct device___2 *dev; +}; + +struct debugfs_mount_opts { + kuid_t uid; + kgid_t gid; + umode_t mode; +}; + +struct debugfs_fs_info { + struct debugfs_mount_opts mount_opts; +}; + +struct debugfs_reg32 { + char *name; + long unsigned int offset; +}; + +struct debugfs_regset32 { + const struct debugfs_reg32 *regs; + int nregs; + void *base; +}; + +struct dec_data { + struct task_struct *thr; + atomic_t ready; + atomic_t stop; + int ret; + wait_queue_head_t go; + wait_queue_head_t done; + size_t unc_len; + size_t cmp_len; + unsigned char unc[131072]; + unsigned char cmp[143360]; +}; + +struct fence_cb; + +typedef void (*fence_func_t)(struct fence *, struct fence_cb *); + +struct fence_cb { + struct list_head node; + fence_func_t func; +}; + +struct default_wait_cb { + struct fence_cb base; + struct task_struct *task; +}; + +struct deferred_flush_table; + +struct deferred_flush_data { + spinlock_t lock; + int timer_on; + struct timer_list timer; + long int size; + struct deferred_flush_table *tables; +}; + +struct dmar_domain; + +struct deferred_flush_entry { + long unsigned int iova_pfn; + long unsigned int nrpages; + struct dmar_domain *domain; + struct page *freelist; +}; + +struct deferred_flush_table { + int next; + struct deferred_flush_entry entries[250]; +}; + +struct delayed_call { + void (*fn)(void *); + void *arg; +}; + +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; +}; + +struct lockref { + union { + __u64 lock_count; + struct { + spinlock_t lock; + int count; + }; + }; +}; + +struct dentry_operations; + +struct dentry___2 { + unsigned int d_flags; + seqcount_t d_seq; + struct hlist_bl_node d_hash; + struct dentry___2 *d_parent; + struct qstr d_name; + struct inode *d_inode; + unsigned char d_iname[32]; + struct lockref d_lockref; + const struct dentry_operations *d_op; + struct super_block *d_sb; + long unsigned int d_time; + void *d_fsdata; + union { + struct list_head d_lru; + wait_queue_head_t *d_wait; + }; + struct list_head d_child; + struct list_head d_subdirs; + union { + struct hlist_node d_alias; + struct hlist_bl_node d_in_lookup_hash; + struct callback_head d_rcu; + } d_u; +}; + +struct dentry_operations___2; + +struct dentry { + unsigned int d_flags; + seqcount_t d_seq; + struct hlist_bl_node d_hash; + struct dentry *d_parent; + struct qstr d_name; + struct inode___2 *d_inode; + unsigned char d_iname[32]; + struct lockref d_lockref; + const struct dentry_operations___2 *d_op; + struct super_block___2 *d_sb; + long unsigned int d_time; + void *d_fsdata; + union { + struct list_head d_lru; + wait_queue_head_t *d_wait; + }; + struct list_head d_child; + struct list_head d_subdirs; + union { + struct hlist_node d_alias; + struct hlist_bl_node d_in_lookup_hash; + struct callback_head d_rcu; + } d_u; +}; + +struct dentry_operations { + int (*d_revalidate)(struct dentry___2 *, unsigned int); + int (*d_weak_revalidate)(struct dentry___2 *, unsigned int); + int (*d_hash)(const struct dentry___2 *, struct qstr *); + int (*d_compare)(const struct dentry___2 *, const struct dentry___2 *, unsigned int, const char *, const struct qstr *); + int (*d_delete)(const struct dentry___2 *); + void (*d_release)(struct dentry___2 *); + void (*d_prune)(struct dentry___2 *); + void (*d_iput)(struct dentry___2 *, struct inode *); + char * (*d_dname)(struct dentry___2 *, char *, int); + struct vfsmount * (*d_automount)(struct path *); + int (*d_manage)(struct dentry___2 *, bool); + struct inode * (*d_select_inode)(struct dentry___2 *, unsigned int); + struct dentry___2 * (*d_real)(struct dentry___2 *, struct inode *); + long: 64; + long: 64; + long: 64; +}; + +struct dentry_operations___2 { + int (*d_revalidate)(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 *, const struct dentry *, unsigned int, const char *, const struct qstr *); + int (*d_delete)(const struct dentry *); + void (*d_release)(struct dentry *); + void (*d_prune)(struct dentry *); + void (*d_iput)(struct dentry *, struct inode___2 *); + char * (*d_dname)(struct dentry *, char *, int); + struct vfsmount * (*d_automount)(struct path___2 *); + int (*d_manage)(struct dentry *, bool); + struct inode___2 * (*d_select_inode)(struct dentry *, unsigned int); + struct dentry * (*d_real)(struct dentry *, struct inode___2 *); + long: 64; + long: 64; + long: 64; +}; + +struct dentry_stat_t { + long int nr_dentry; + long int nr_unused; + long int age_limit; + long int want_pages; + long int dummy[2]; +}; + +struct deref_fetch_param { + struct fetch_param orig; + long int offset; + fetch_func_t fetch; + fetch_func_t fetch_size; +}; + +struct des3_ede_ctx { + u32 expkey[96]; +}; + +struct des_ctx { + u32 expkey[32]; +}; + +struct desc_ptr { + short unsigned int size; + long unsigned int address; +} __attribute__((packed)); + +struct desc_struct { + union { + struct { + unsigned int a; + unsigned int b; + }; + struct { + u16 limit0; + u16 base0; + unsigned int base1: 8; + unsigned int type: 4; + unsigned int s: 1; + unsigned int dpl: 2; + unsigned int p: 1; + unsigned int limit: 4; + unsigned int avl: 1; + unsigned int l: 1; + unsigned int d: 1; + unsigned int g: 1; + unsigned int base2: 8; + }; + }; +}; + +struct dest_map { + long unsigned int map[4]; + u8 vectors[255]; +}; + +struct select_data { + struct dentry___2 *start; + struct list_head dispose; + int found; +}; + +struct detach_data { + struct select_data select; + struct dentry___2 *mountpoint; +}; + +struct detached_freelist { + struct page *page; + 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 edid; + +struct detailed_mode_closure { + struct drm_connector *connector; + struct edid *edid; + bool preferred; + u32 quirks; + 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 detected_devices_node { + struct list_head list; + dev_t dev; +}; + +struct dev_ext_attribute { + struct device_attribute attr; + void *var; +}; + +struct dev_kfree_skb_cb { + enum skb_free_reason reason; +}; + +struct vmem_altmap; + +struct dev_pagemap { + struct vmem_altmap *altmap; + const struct resource *res; + struct percpu_ref *ref; + struct device *dev; +}; + +struct dev_pm_ops___2 { + 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___2 ops; + void (*detach)(struct device *, bool); + int (*activate)(struct device *); + void (*sync)(struct device *); + void (*dismiss)(struct device *); +}; + +struct dev_pm_ops { + int (*prepare)(struct device___2 *); + void (*complete)(struct device___2 *); + int (*suspend)(struct device___2 *); + int (*resume)(struct device___2 *); + int (*freeze)(struct device___2 *); + int (*thaw)(struct device___2 *); + int (*poweroff)(struct device___2 *); + int (*restore)(struct device___2 *); + int (*suspend_late)(struct device___2 *); + int (*resume_early)(struct device___2 *); + int (*freeze_late)(struct device___2 *); + int (*thaw_early)(struct device___2 *); + int (*poweroff_late)(struct device___2 *); + int (*restore_early)(struct device___2 *); + int (*suspend_noirq)(struct device___2 *); + int (*resume_noirq)(struct device___2 *); + int (*freeze_noirq)(struct device___2 *); + int (*thaw_noirq)(struct device___2 *); + int (*poweroff_noirq)(struct device___2 *); + int (*restore_noirq)(struct device___2 *); + int (*runtime_suspend)(struct device___2 *); + int (*runtime_resume)(struct device___2 *); + int (*runtime_idle)(struct device___2 *); +}; + +struct dev_pm_domain___2 { + struct dev_pm_ops ops; + void (*detach)(struct device___2 *, bool); + int (*activate)(struct device___2 *); + void (*sync)(struct device___2 *); + void (*dismiss)(struct device___2 *); +}; + +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 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 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 plist_node { + int prio; + struct list_head prio_list; + struct list_head node_list; +}; + +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; + } data; + struct device *dev; +}; + +struct dev_table_entry { + u64 data[4]; +}; + +struct devfreq_dev_status { + long unsigned int total_time; + long unsigned int busy_time; + long unsigned int current_frequency; + void *private_data; +}; + +struct device_attach_data { + struct device *dev; + bool check_async; + bool want_async; + bool have_async; +}; + +struct device_attribute___2 { + struct attribute attr; + ssize_t (*show)(struct device___2 *, struct device_attribute___2 *, char *); + ssize_t (*store)(struct device___2 *, struct device_attribute___2 *, const char *, size_t); +}; + +struct device_dma_parameters { + unsigned int max_segment_size; + long unsigned int segment_boundary_mask; +}; + +struct intel_iommu; + +struct device_domain_info { + struct list_head link; + struct list_head global; + u8 bus; + u8 devfn; + u8 pasid_supported: 3; + u8 pasid_enabled: 1; + u8 pri_supported: 1; + u8 pri_enabled: 1; + u8 ats_supported: 1; + u8 ats_enabled: 1; + u8 ats_qdep; + struct device *dev; + struct intel_iommu *iommu; + struct dmar_domain *domain; +}; + +struct device_driver { + const char *name; + 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 *); + 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 dev_pm_ops___2 *pm; + struct driver_private *p; +}; + +struct property; + +struct device_node { + const char *name; + const char *type; + 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 property___2; + +struct device_node___2 { + const char *name; + const char *type; + phandle phandle; + const char *full_name; + struct fwnode_handle fwnode; + struct property___2 *properties; + struct property___2 *deadprops; + struct device_node___2 *parent; + struct device_node___2 *child; + struct device_node___2 *sibling; + struct kobject___2 kobj; + long unsigned int _flags; + void *data; +}; + +struct dma_pool; + +struct device_pools { + struct list_head pools; + struct device___2 *dev; + struct dma_pool *pool; +}; + +struct device_private { + struct klist klist_children; + struct klist_node knode_parent; + struct klist_node knode_driver; + struct klist_node knode_bus; + struct list_head deferred_probe; + struct device *device; +}; + +struct device_type { + const char *name; + const struct attribute_group **groups; + int (*uevent)(struct device *, struct kobj_uevent_env *); + char * (*devnode)(struct device *, umode_t *, kuid_t *, kgid_t *); + void (*release)(struct device *); + const struct dev_pm_ops___2 *pm; +}; + +struct device_type___2 { + const char *name; + const struct attribute_group___2 **groups; + int (*uevent)(struct device___2 *, struct kobj_uevent_env *); + char * (*devnode)(struct device___2 *, umode_t *, kuid_t *, kgid_t *); + void (*release)(struct device___2 *); + const struct dev_pm_ops *pm; +}; + +struct devid_map { + struct list_head list; + u8 id; + u16 devid; + bool cmd_line; +}; + +struct devinet_sysctl_table { + struct ctl_table_header *sysctl_header; + struct ctl_table devinet_vars[32]; +}; + +struct devkmsg_user { + u64 seq; + u32 idx; + enum log_flags prev; + struct mutex lock; + char buf[8192]; +}; + +struct net_device; + +struct devprobe2 { + struct net_device * (*probe)(int); + int status; +}; + +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 long unsigned int data[0]; +}; + +struct devres_group { + struct devres_node node[2]; + void *id; + int color; +}; + +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; +}; + +typedef int dio_iodone_t(struct kiocb___2 *, loff_t, ssize_t, void *); + +struct dio { + int flags; + int rw; + blk_qc_t bio_cookie; + struct block_device *bio_bdev; + struct inode___2 *inode; + loff_t i_size; + dio_iodone_t *end_io; + 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___2 *waiter; + struct kiocb___2 *iocb; + ssize_t result; + union { + struct page *pages[64]; + struct work_struct complete_work; + }; + long: 64; +}; + +typedef int get_block_t(struct inode___2 *, sector_t, struct buffer_head *, int); + +typedef void dio_submit_t(int, struct bio *, struct inode___2 *, loff_t); + +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; + dio_submit_t *submit_io; + 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___2 *iter; + unsigned int head; + unsigned int tail; + size_t from; + size_t to; +}; + +struct dir_entry { + struct list_head list; + char *name; + time_t mtime; +}; + +struct dirty_throttle_control { + 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 wb_dirty; + long unsigned int wb_thresh; + long unsigned int wb_bg_thresh; + long unsigned int pos_ratio; +}; + +struct disk_comp_opts { + __le32 dictionary_size; + __le32 flags; +}; + +struct disk_events { + struct list_head node; + struct gendisk *disk; + spinlock_t lock; + struct mutex___2 block_mutex; + int block; + unsigned int pending; + unsigned int clearing; + long int poll_msecs; + struct delayed_work dwork; +}; + +struct disk_part_iter { + struct gendisk *disk; + struct hd_struct *part; + int idx; + unsigned int flags; +}; + +struct disk_part_tbl { + struct callback_head callback_head; + int len; + struct hd_struct *last_lookup; + struct hd_struct *part[0]; +}; + +struct disk_stats { + long unsigned int sectors[2]; + long unsigned int ios[2]; + long unsigned int merges[2]; + long unsigned int ticks[2]; + long unsigned int io_ticks; + long unsigned int time_in_queue; +}; + +struct disklabel { + __le32 d_magic; + __le16 d_type; + __le16 d_subtype; + u8 d_typename[16]; + u8 d_packname[16]; + __le32 d_secsize; + __le32 d_nsectors; + __le32 d_ntracks; + __le32 d_ncylinders; + __le32 d_secpercyl; + __le32 d_secprtunit; + __le16 d_sparespertrack; + __le16 d_sparespercyl; + __le32 d_acylinders; + __le16 d_rpm; + __le16 d_interleave; + __le16 d_trackskew; + __le16 d_cylskew; + __le32 d_headswitch; + __le32 d_trkseek; + __le32 d_flags; + __le32 d_drivedata[5]; + __le32 d_spare[5]; + __le32 d_magic2; + __le16 d_checksum; + __le16 d_npartitions; + __le32 d_bbsize; + __le32 d_sbsize; + struct d_partition d_partitions[18]; +}; + +struct disklabel___2 { + u8 d_reserved[270]; + struct d_partition___2 d_partitions[2]; + u8 d_blank[208]; + __le16 d_magic; +} __attribute__((packed)); + +struct fb_bitfield { + __u32 offset; + __u32 length; + __u32 msb_right; +}; + +struct fb_videomode; + +struct display { + const u_char *fontdata; + int userfont; + u_short scrollmode; + 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 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_hdr { + 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 dl_bandwidth { + raw_spinlock_t dl_runtime_lock; + u64 dl_runtime; + u64 dl_period; +}; + +struct dl_bw { + raw_spinlock_t lock; + u64 bw; + u64 total_bw; +}; + +struct dl_rq { + struct rb_root rb_root; + struct rb_node *rb_leftmost; + long unsigned int dl_nr_running; + struct { + u64 curr; + u64 next; + } earliest_dl; + long unsigned int dl_nr_migratory; + int overloaded; + struct rb_root pushable_dl_tasks_root; + struct rb_node *pushable_dl_tasks_leftmost; +}; + +struct dm_arg { + unsigned int min; + unsigned int max; + char *error; +}; + +struct dm_arg_set { + unsigned int argc; + char **argv; +}; + +struct dm_bio_details { + struct block_device *bi_bdev; + long unsigned int bi_flags; + struct bvec_iter bi_iter; +}; + +struct dm_dev { + struct block_device *bdev; + fmode_t mode; + char name[16]; +}; + +struct dm_dev_internal { + struct list_head list; + atomic_t count; + struct dm_dev *dm_dev; +}; + +struct dm_dirty_log_type; + +struct dm_target; + +struct dm_dirty_log { + struct dm_dirty_log_type *type; + int (*flush_callback_fn)(struct dm_target *); + void *context; +}; + +struct dm_dirty_log_type { + const char *name; + struct module *module; + struct list_head list; + int (*ctr)(struct dm_dirty_log *, struct dm_target *, unsigned int, char **); + void (*dtr)(struct dm_dirty_log *); + int (*presuspend)(struct dm_dirty_log *); + int (*postsuspend)(struct dm_dirty_log *); + int (*resume)(struct dm_dirty_log *); + uint32_t (*get_region_size)(struct dm_dirty_log *); + int (*is_clean)(struct dm_dirty_log *, region_t); + int (*in_sync)(struct dm_dirty_log *, region_t, int); + int (*flush)(struct dm_dirty_log *); + void (*mark_region)(struct dm_dirty_log *, region_t); + void (*clear_region)(struct dm_dirty_log *, region_t); + int (*get_resync_work)(struct dm_dirty_log *, region_t *); + void (*set_region_sync)(struct dm_dirty_log *, region_t, int); + region_t (*get_sync_count)(struct dm_dirty_log *); + int (*status)(struct dm_dirty_log *, status_type_t, char *, unsigned int); + int (*is_remote_recovering)(struct dm_dirty_log *, region_t); +}; + +struct dm_stats_aux { + bool merged; + long long unsigned int duration_ns; +}; + +struct dm_io { + struct mapped_device *md; + int error; + atomic_t io_count; + struct bio *bio; + long unsigned int start_time; + spinlock_t endio_lock; + struct dm_stats_aux stats_aux; +}; + +struct dm_io_client { + mempool_t *pool; + struct bio_set *bios; +}; + +struct page_list; + +struct dm_io_memory { + enum dm_io_mem_type type; + unsigned int offset; + union { + struct page_list *pl; + struct bio *bio; + void *vma; + void *addr; + } ptr; +}; + +typedef void (*io_notify_fn)(long unsigned int, void *); + +struct dm_io_notify { + io_notify_fn fn; + void *context; +}; + +struct dm_io_region { + struct block_device *bdev; + sector_t sector; + sector_t count; +}; + +struct dm_io_request { + int bi_rw; + struct dm_io_memory mem; + struct dm_io_notify notify; + struct dm_io_client *client; +}; + +struct dm_ioctl { + __u32 version[3]; + __u32 data_size; + __u32 data_start; + __u32 target_count; + __s32 open_count; + __u32 flags; + __u32 event_nr; + __u32 padding; + __u64 dev; + char name[128]; + char uuid[129]; + char data[7]; +}; + +struct dm_kcopyd_throttle; + +struct dm_kcopyd_client { + struct page_list *pages; + unsigned int nr_reserved_pages; + unsigned int nr_free_pages; + struct dm_io_client *io_client; + wait_queue_head_t destroyq; + atomic_t nr_jobs; + mempool_t *job_pool; + struct workqueue_struct *kcopyd_wq; + struct work_struct kcopyd_work; + struct dm_kcopyd_throttle *throttle; + spinlock_t job_lock; + struct list_head complete_jobs; + struct list_head io_jobs; + struct list_head pages_jobs; +}; + +struct dm_kcopyd_throttle { + unsigned int throttle; + unsigned int num_io_jobs; + unsigned int io_period; + unsigned int total_period; + unsigned int last_jiffies; +}; + +struct dm_kobject_holder { + struct kobject kobj; + struct completion completion; +}; + +struct dm_md_mempools { + mempool_t *io_pool; + mempool_t *rq_pool; + struct bio_set *bs; +}; + +struct dm_name_list { + __u64 dev; + __u32 next; + char name[0]; +}; + +struct mirror; + +struct dm_raid1_bio_record { + struct mirror *m; + struct dm_bio_details details; + region_t write_region; +}; + +struct dm_region_hash; + +struct dm_region { + struct dm_region_hash *rh; + region_t key; + int state; + struct list_head hash_list; + struct list_head list; + atomic_t pending; + struct bio_list delayed_bios; +}; + +struct semaphore { + raw_spinlock_t lock; + unsigned int count; + struct list_head wait_list; +}; + +struct dm_region_hash { + uint32_t region_size; + unsigned int region_shift; + struct dm_dirty_log *log; + rwlock_t hash_lock; + mempool_t *region_pool; + unsigned int mask; + unsigned int nr_buckets; + unsigned int prime; + unsigned int shift; + struct list_head *buckets; + unsigned int max_recovery; + spinlock_t region_lock; + atomic_t recovery_in_flight; + struct semaphore recovery_count; + struct list_head clean_regions; + struct list_head quiesced_regions; + struct list_head recovered_regions; + struct list_head failed_recovered_regions; + int flush_failure; + void *context; + sector_t target_begin; + void (*dispatch_bios)(void *, struct bio_list *); + void (*wakeup_workers)(void *); + void (*wakeup_all_recovery_waiters)(void *); +}; + +struct dm_rq_target_io; + +struct dm_rq_clone_bio_info { + struct bio *orig; + struct dm_rq_target_io *tio; + struct bio clone; +}; + +struct kthread_work; + +typedef void (*kthread_work_func_t)(struct kthread_work *); + +struct kthread_worker; + +struct kthread_work { + struct list_head node; + kthread_work_func_t func; + struct kthread_worker *worker; +}; + +union map_info { + void *ptr; +}; + +struct dm_target___2; + +struct dm_rq_target_io { + struct mapped_device *md; + struct dm_target___2 *ti; + struct request *orig; + struct request *clone; + struct kthread_work work; + int error; + union map_info info; + struct dm_stats_aux stats_aux; + long unsigned int duration_jiffies; + unsigned int n_sectors; +}; + +struct dm_stat_percpu { + long long unsigned int sectors[2]; + long long unsigned int ios[2]; + long long unsigned int merges[2]; + long long unsigned int ticks[2]; + long long unsigned int io_ticks[2]; + long long unsigned int io_ticks_total; + long long unsigned int time_in_queue; + long long unsigned int *histogram; +}; + +struct dm_stat_shared { + atomic_t in_flight[2]; + long long unsigned int stamp; + struct dm_stat_percpu tmp; +}; + +struct dm_stat { + struct list_head list_entry; + int id; + unsigned int stat_flags; + size_t n_entries; + sector_t start; + sector_t end; + sector_t step; + unsigned int n_histogram_entries; + long long unsigned int *histogram_boundaries; + const char *program_id; + const char *aux_data; + struct callback_head callback_head; + size_t shared_alloc_size; + size_t percpu_alloc_size; + size_t histogram_alloc_size; + struct dm_stat_percpu *stat_percpu[64]; + struct dm_stat_shared stat_shared[0]; +}; + +struct dm_stats_last_position; + +struct dm_stats { + struct mutex mutex; + struct list_head list; + struct dm_stats_last_position *last; + sector_t last_sector; + unsigned int last_rw; +}; + +struct dm_stats_last_position { + sector_t last_sector; + unsigned int last_rw; +}; + +struct dm_sysfs_attr { + struct attribute attr; + ssize_t (*show)(struct mapped_device *, char *); + ssize_t (*store)(struct mapped_device *, const char *, size_t); +}; + +struct target_type; + +struct dm_table { + struct mapped_device *md; + unsigned int type; + unsigned int depth; + unsigned int counts[16]; + sector_t *index[16]; + unsigned int num_targets; + unsigned int num_allocated; + sector_t *highs; + struct dm_target___2 *targets; + struct target_type *immutable_target_type; + unsigned int integrity_supported: 1; + unsigned int singleton: 1; + fmode_t mode; + struct list_head devices; + void (*event_fn)(void *); + void *event_context; + struct dm_md_mempools *mempools; + struct list_head target_callbacks; +}; + +struct dm_table___2 { + int undefined__; +}; + +typedef unsigned int (*dm_num_write_bios_fn)(struct dm_target___2 *, struct bio *); + +struct dm_target___2 { + struct dm_table *table; + struct target_type *type; + sector_t begin; + sector_t len; + uint32_t max_io_len; + unsigned int num_flush_bios; + unsigned int num_discard_bios; + unsigned int num_write_same_bios; + unsigned int per_io_data_size; + dm_num_write_bios_fn num_write_bios; + void *private; + char *error; + bool flush_supported: 1; + bool discards_supported: 1; + bool split_discard_bios: 1; + bool discard_zeroes_data_unsupported: 1; +}; + +typedef unsigned int (*dm_num_write_bios_fn___2)(struct dm_target *, struct bio *); + +struct target_type___2; + +struct dm_target { + struct dm_table___2 *table; + struct target_type___2 *type; + sector_t begin; + sector_t len; + uint32_t max_io_len; + unsigned int num_flush_bios; + unsigned int num_discard_bios; + unsigned int num_write_same_bios; + unsigned int per_io_data_size; + dm_num_write_bios_fn___2 num_write_bios; + void *private; + char *error; + bool flush_supported: 1; + bool discards_supported: 1; + bool split_discard_bios: 1; + bool discard_zeroes_data_unsupported: 1; +}; + +struct dm_target_callbacks { + struct list_head list; + int (*congested_fn)(struct dm_target_callbacks *, int); +}; + +struct dm_target_deps { + __u32 count; + __u32 padding; + __u64 dev[0]; +}; + +struct dm_target_io { + struct dm_io *io; + struct dm_target___2 *ti; + unsigned int target_bio_nr; + unsigned int *len_ptr; + struct bio clone; +}; + +struct dm_target_msg { + __u64 sector; + char message[0]; +}; + +struct dm_target_spec { + __u64 sector_start; + __u64 length; + __s32 status; + __u32 next; + char target_type[16]; +}; + +struct dm_target_versions { + __u32 next; + __u32 version[3]; + char name[0]; +}; + +typedef void (*dma_async_tx_callback)(void *); + +struct dmaengine_unmap_data; + +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; + void *callback_param; + struct dmaengine_unmap_data *unmap; +}; + +struct dma_attrs { + long unsigned int flags[1]; +}; + +struct dma_buf_poll_cb_t { + struct fence_cb cb; + wait_queue_head_t *poll; + long unsigned int active; +}; + +struct dma_buf_ops; + +struct dma_buf { + size_t size; + struct file___2 *file; + struct list_head attachments; + const struct dma_buf_ops *ops; + struct mutex___2 lock; + unsigned int vmapping_counter; + void *vmap_ptr; + const char *exp_name; + struct module___2 *owner; + struct list_head list_node; + void *priv; + struct reservation_object *resv; + wait_queue_head_t poll; + struct dma_buf_poll_cb_t cb_excl; + struct dma_buf_poll_cb_t cb_shared; +}; + +struct dma_buf_attachment { + struct dma_buf *dmabuf; + struct device *dev; + struct list_head node; + void *priv; +}; + +struct dma_buf_export_info { + const char *exp_name; + struct module___2 *owner; + const struct dma_buf_ops *ops; + size_t size; + int flags; + struct reservation_object *resv; + void *priv; +}; + +struct dma_buf_list { + struct list_head head; + struct mutex lock; +}; + +struct dma_buf_ops { + int (*attach)(struct dma_buf *, struct device *, struct dma_buf_attachment *); + void (*detach)(struct dma_buf *, 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); + void * (*kmap_atomic)(struct dma_buf *, long unsigned int); + void (*kunmap_atomic)(struct dma_buf *, long unsigned int, void *); + void * (*kmap)(struct dma_buf *, long unsigned int); + void (*kunmap)(struct dma_buf *, long unsigned int, void *); + int (*mmap)(struct dma_buf *, struct vm_area_struct *); + void * (*vmap)(struct dma_buf *); + void (*vunmap)(struct dma_buf *, void *); +}; + +struct dma_buf_sync { + __u64 flags; +}; + +struct dma_chan___2 { + int lock; + const char *device_id; +}; + +struct dma_device; + +struct dma_chan_dev; + +struct dma_chan_percpu; + +struct dma_router; + +struct dma_chan { + struct dma_device *device; + dma_cookie_t cookie; + dma_cookie_t completed_cookie; + int chan_id; + struct dma_chan_dev *dev; + 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 dma_chan_dev { + struct dma_chan *chan; + struct device___2 device; + int dev_id; + atomic_t *idr_ref; +}; + +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_slave_map; + +struct dma_filter { + dma_filter_fn fn; + int mapcnt; + const struct dma_slave_map *map; +}; + +struct dma_interleaved_template; + +struct dma_slave_config; + +struct dma_tx_state; + +struct dma_device { + 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; + 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___2 *dev; + u32 src_addr_widths; + u32 dst_addr_widths; + u32 directions; + u32 max_burst; + bool descriptor_reuse; + enum dma_residue_granularity residue_granularity; + int (*device_alloc_chan_resources)(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_dma_sg)(struct dma_chan *, struct scatterlist *, unsigned int, struct scatterlist *, unsigned int, 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); + 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 *); +}; + +struct dma_devres { + size_t size; + void *vaddr; + dma_addr_t dma_handle; +}; + +struct dma_domain { + struct list_head node; + struct dma_map_ops *dma_ops; + int domain_nr; +}; + +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, struct dma_attrs *); + void (*free)(struct device *, size_t, void *, dma_addr_t, struct dma_attrs *); + int (*mmap)(struct device *, struct vm_area_struct___2 *, void *, dma_addr_t, size_t, struct dma_attrs *); + int (*get_sgtable)(struct device *, struct sg_table *, void *, dma_addr_t, size_t, struct dma_attrs *); + dma_addr_t (*map_page)(struct device *, struct page___2 *, long unsigned int, size_t, enum dma_data_direction, struct dma_attrs *); + void (*unmap_page)(struct device *, dma_addr_t, size_t, enum dma_data_direction, struct dma_attrs *); + int (*map_sg)(struct device *, struct scatterlist *, int, enum dma_data_direction, struct dma_attrs *); + void (*unmap_sg)(struct device *, struct scatterlist *, int, enum dma_data_direction, struct dma_attrs *); + 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); + int (*mapping_error)(struct device *, dma_addr_t); + int (*dma_supported)(struct device *, u64); + int (*set_dma_mask)(struct device *, u64); + int is_phys; +}; + +struct dma_map_ops___2 { + void * (*alloc)(struct device___2 *, size_t, dma_addr_t *, gfp_t, struct dma_attrs *); + void (*free)(struct device___2 *, size_t, void *, dma_addr_t, struct dma_attrs *); + int (*mmap)(struct device___2 *, struct vm_area_struct *, void *, dma_addr_t, size_t, struct dma_attrs *); + int (*get_sgtable)(struct device___2 *, struct sg_table *, void *, dma_addr_t, size_t, struct dma_attrs *); + dma_addr_t (*map_page)(struct device___2 *, struct page *, long unsigned int, size_t, enum dma_data_direction, struct dma_attrs *); + void (*unmap_page)(struct device___2 *, dma_addr_t, size_t, enum dma_data_direction, struct dma_attrs *); + int (*map_sg)(struct device___2 *, struct scatterlist *, int, enum dma_data_direction, struct dma_attrs *); + void (*unmap_sg)(struct device___2 *, struct scatterlist *, int, enum dma_data_direction, struct dma_attrs *); + void (*sync_single_for_cpu)(struct device___2 *, dma_addr_t, size_t, enum dma_data_direction); + void (*sync_single_for_device)(struct device___2 *, dma_addr_t, size_t, enum dma_data_direction); + void (*sync_sg_for_cpu)(struct device___2 *, struct scatterlist *, int, enum dma_data_direction); + void (*sync_sg_for_device)(struct device___2 *, struct scatterlist *, int, enum dma_data_direction); + int (*mapping_error)(struct device___2 *, dma_addr_t); + int (*dma_supported)(struct device___2 *, u64); + int (*set_dma_mask)(struct device___2 *, u64); + int is_phys; +}; + +struct iommu_domain; + +typedef int (*iommu_fault_handler_t)(struct iommu_domain *, struct device *, long unsigned int, int, void *); + +struct iommu_domain_geometry { + dma_addr_t aperture_start; + dma_addr_t aperture_end; + bool force_aperture; +}; + +struct iommu_domain { + unsigned int type; + const struct iommu_ops *ops; + long unsigned int pgsize_bitmap; + iommu_fault_handler_t handler; + void *handler_token; + struct iommu_domain_geometry geometry; + void *iova_cookie; +}; + +struct protection_domain { + struct list_head list; + struct list_head dev_list; + struct iommu_domain domain; + spinlock_t lock; + struct mutex___2 api_lock; + u16 id; + int mode; + u64 *pt_root; + int glx; + u64 *gcr3_tbl; + long unsigned int flags; + bool updated; + unsigned int dev_cnt; + unsigned int dev_iommu[32]; + void *priv; +}; + +struct dma_ops_domain { + struct protection_domain domain; + long unsigned int aperture_size; + u32 *next_index; + struct aperture_range *aperture[32]; +}; + +struct dma_page { + struct list_head page_list; + void *vaddr; + dma_addr_t dma; + unsigned int in_use; + unsigned int offset; +}; + +struct dma_page___2 { + struct list_head page_list; + void *vaddr; + struct page *p; + dma_addr_t dma; +}; + +struct dma_pool___2 { + struct list_head page_list; + spinlock_t lock; + size_t size; + struct device___2 *dev; + size_t allocation; + size_t boundary; + char name[32]; + struct list_head pools; +}; + +struct dma_pool { + struct list_head pools; + enum pool_type type; + spinlock_t lock; + struct list_head inuse_list; + struct list_head free_list; + struct device___2 *dev; + unsigned int size; + unsigned int npages_free; + unsigned int npages_in_use; + long unsigned int nfrees; + long unsigned int nrefills; + gfp_t gfp_flags; + char name[13]; + char dev_name[64]; +}; + +struct dma_pte { + u64 val; +}; + +struct dma_router { + struct device___2 *dev; + void (*route_free)(struct device___2 *, void *); +}; + +struct dma_slave_caps { + u32 src_addr_widths; + u32 dst_addr_widths; + u32 directions; + u32 max_burst; + bool cmd_pause; + bool cmd_terminate; + enum dma_residue_granularity residue_granularity; + bool descriptor_reuse; +}; + +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; + bool device_fc; + unsigned int slave_id; +}; + +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; +}; + +struct dmaengine_unmap_data { + u8 map_cnt; + u8 to_cnt; + u8 from_cnt; + u8 bidi_cnt; + struct device___2 *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 dmar_dev_scope; + +struct dmar_atsr_unit { + struct list_head list; + struct acpi_dmar_header *hdr; + struct dmar_dev_scope *devices; + int devices_cnt; + u8 include_all: 1; +}; + +struct dmar_dev_scope { + struct device___2 *dev; + u8 bus; + u8 devfn; +}; + +struct iova_magazine; + +struct iova_cpu_rcache; + +struct iova_rcache { + spinlock_t lock; + long unsigned int depot_size; + struct iova_magazine *depot[32]; + struct iova_cpu_rcache *cpu_rcaches; +}; + +struct iova_domain { + spinlock_t iova_rbtree_lock; + struct rb_root rbroot; + struct rb_node *cached32_node; + long unsigned int granule; + long unsigned int start_pfn; + long unsigned int dma_32bit_pfn; + struct iova_rcache rcaches[6]; +}; + +struct dmar_domain { + int nid; + unsigned int iommu_refcnt[128]; + u16 iommu_did[128]; + bool has_iotlb_device; + struct list_head devices; + struct iova_domain iovad; + struct dma_pte *pgd; + int gaw; + int agaw; + int flags; + int iommu_coherency; + int iommu_snooping; + int iommu_count; + int iommu_superpage; + u64 max_addr; + struct iommu_domain domain; +}; + +struct dmar_drhd_unit { + struct list_head list; + struct acpi_dmar_header *hdr; + u64 reg_base_addr; + struct dmar_dev_scope *devices; + int devices_cnt; + u16 segment; + u8 ignored: 1; + u8 include_all: 1; + struct intel_iommu *iommu; +}; + +struct dmar_pci_path { + u8 bus; + u8 device; + u8 function; +}; + +struct dmar_pci_notify_info { + struct pci_dev *dev; + long unsigned int event; + int bus; + u16 seg; + u16 level; + struct dmar_pci_path path[0]; +}; + +typedef int (*dmar_res_handler_t)(struct acpi_dmar_header *, void *); + +struct dmar_res_callback { + dmar_res_handler_t cb[5]; + void *arg[5]; + bool ignore_unhandled; + bool print_entry; +}; + +struct dmar_rmrr_unit { + struct list_head list; + struct acpi_dmar_header *hdr; + u64 base_address; + u64 end_address; + struct dmar_dev_scope *devices; + int devices_cnt; +}; + +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; + u16 handle; +}; + +struct dmi_onboard_device_info { + const char *name; + u8 type; + short unsigned int i2c_addr; + const char *i2c_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 dmt_videomode { + u32 dmt_id; + u32 std_2byte_code; + u32 cvt_3byte_code; + const struct fb_videomode *mode; +}; + +struct fsnotify_group; + +struct fsnotify_mark { + __u32 mask; + atomic_t refcnt; + struct fsnotify_group *group; + struct list_head g_list; + spinlock_t lock; + struct hlist_node obj_list; + union { + struct inode___2 *inode; + struct vfsmount *mnt; + }; + __u32 ignored_mask; + unsigned int flags; + void (*free_mark)(struct fsnotify_mark *); +}; + +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 do_proc_dointvec_minmax_conv_param { + int *min; + int *max; +}; + +struct dock_dependent_device { + struct list_head list; + struct acpi_device *adev; +}; + +struct platform_device; + +struct dock_station { + acpi_handle handle; + long unsigned int last_dock_time; + u32 flags; + struct list_head dependent_devices; + struct list_head sibling; + struct platform_device *dock_device; +}; + +struct domain_context_mapping_data { + struct dmar_domain *domain; + struct intel_iommu *iommu; +}; + +struct dotl_iattr_map { + int iattr_valid; + int p9_iattr_valid; +}; + +struct dotl_openflag_map { + int open_flag; + int dotl_flag; +}; + +struct double_list { + struct list_head *top; + struct list_head *bottom; +}; + +struct dpll { + int n; + int m1; + int m2; + int p1; + int p2; + int dot; + int vco; + int m; + int p; +}; + +struct dp_link_dpll { + int clock; + struct dpll dpll; +}; + +struct dpages { + void (*get_page)(struct dpages *, struct page___2 **, long unsigned int *, unsigned int *); + void (*next_page)(struct dpages *); + unsigned int context_u; + void *context_ptr; + void *vma_invalidate_address; + long unsigned int vma_invalidate_size; +}; + +struct dpcd_block { + unsigned int offset; + unsigned int end; + size_t size; + bool edp; +}; + +typedef struct dpll intel_clock_t; + +struct intel_shared_dpll_funcs; + +struct dpll_info { + const char *name; + const int id; + const struct intel_shared_dpll_funcs *funcs; + uint32_t flags; +}; + +struct dql { + unsigned int num_queued; + unsigned int adj_limit; + unsigned int last_obj_cnt; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + 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; + long: 64; + long: 64; +}; + +struct dqstats { + 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; + time_t dqb_btime; + time_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; + atomic_t dq_count; + wait_queue_head_t dq_wait_unused; + 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___2 { + struct hlist_node dq_hash; + struct list_head dq_inuse; + struct list_head dq_free; + struct list_head dq_dirty; + struct mutex___2 dq_lock; + atomic_t dq_count; + wait_queue_head_t dq_wait_unused; + struct super_block___2 *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_next_id)(struct super_block *, struct kqid *); +}; + +struct dquot_operations___2 { + int (*write_dquot)(struct dquot___2 *); + struct dquot___2 * (*alloc_dquot)(struct super_block___2 *, int); + void (*destroy_dquot)(struct dquot___2 *); + int (*acquire_dquot)(struct dquot___2 *); + int (*release_dquot)(struct dquot___2 *); + int (*mark_dirty)(struct dquot___2 *); + int (*write_info)(struct super_block___2 *, int); + qsize_t * (*get_reserved_space)(struct inode___2 *); + int (*get_projid)(struct inode___2 *, kprojid_t *); + int (*get_next_id)(struct super_block___2 *, 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[64]; + char backend_cra_name[64]; +}; + +struct drbg_string { + const unsigned char *buf; + size_t len; + struct list_head list; +}; + +struct random_ready_callback { + struct list_head list; + void (*func)(struct random_ready_callback *); + struct module___2 *owner; +}; + +struct drbg_state_ops; + +struct drbg_state { + struct mutex___2 drbg_mutex; + unsigned char *V; + unsigned char *C; + size_t reseed_ctr; + size_t reseed_threshold; + unsigned char *scratchpad; + void *priv_data; + bool seeded; + bool pr; + struct work_struct seed_work; + struct crypto_rng *jent; + const struct drbg_state_ops *d_ops; + const struct drbg_core *core; + struct drbg_string test_data; + struct random_ready_callback random_ready; +}; + +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 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_agp_binding { + long unsigned int handle; + long unsigned int offset; +}; + +struct drm_agp_binding32 { + u32 handle; + u32 offset; +}; + +typedef struct drm_agp_binding32 drm_agp_binding32_t; + +struct drm_agp_buffer { + long unsigned int size; + long unsigned int handle; + long unsigned int type; + long unsigned int physical; +}; + +struct drm_agp_buffer32 { + u32 size; + u32 handle; + u32 type; + u32 physical; +}; + +typedef struct drm_agp_buffer32 drm_agp_buffer32_t; + +struct drm_agp_head { + struct agp_kern_info agp_info; + struct list_head memory; + long unsigned int mode; + struct agp_bridge_data *bridge; + int enabled; + int acquired; + long unsigned int base; + int agp_mtrr; + int cant_use_aperture; + long unsigned int page_mask; +}; + +struct drm_agp_info { + int agp_version_major; + int agp_version_minor; + long unsigned int mode; + long unsigned int aperture_base; + long unsigned int aperture_size; + long unsigned int memory_allowed; + long unsigned int memory_used; + short unsigned int id_vendor; + short unsigned int id_device; +}; + +struct drm_agp_info32 { + int agp_version_major; + int agp_version_minor; + u32 mode; + u32 aperture_base; + u32 aperture_size; + u32 memory_allowed; + u32 memory_used; + short unsigned int id_vendor; + short unsigned int id_device; +}; + +typedef struct drm_agp_info32 drm_agp_info32_t; + +struct drm_agp_mem { + long unsigned int handle; + struct agp_memory *memory; + long unsigned int bound; + int pages; + struct list_head head; +}; + +struct drm_agp_mode { + long unsigned int mode; +}; + +struct drm_agp_mode32 { + u32 mode; +}; + +typedef struct drm_agp_mode32 drm_agp_mode32_t; + +struct drm_local_map { + resource_size_t offset; + long unsigned int size; + enum drm_map_type type; + enum drm_map_flags flags; + void *handle; + int mtrr; +}; + +struct drm_dma_handle; + +struct drm_ati_pcigart_info { + int gart_table_location; + int gart_reg_if; + void *addr; + dma_addr_t bus_addr; + dma_addr_t table_mask; + struct drm_dma_handle *table_handle; + struct drm_local_map mapping; + int table_size; +}; + +struct drm_plane_state; + +struct drm_atomic_state { + struct drm_device *dev; + bool allow_modeset: 1; + bool legacy_cursor_update: 1; + bool legacy_set_config: 1; + struct drm_plane **planes; + struct drm_plane_state **plane_states; + struct drm_crtc **crtcs; + struct drm_crtc_state **crtc_states; + int num_connector; + struct drm_connector **connectors; + struct drm_connector_state **connector_states; + struct drm_modeset_acquire_ctx *acquire_ctx; +}; + +struct drm_auth { + drm_magic_t magic; +}; + +struct drm_bridge_funcs; + +struct drm_bridge { + struct drm_device *dev; + struct drm_encoder *encoder; + struct drm_bridge *next; + struct list_head list; + const struct drm_bridge_funcs *funcs; + void *driver_private; +}; + +struct drm_bridge_funcs { + int (*attach)(struct drm_bridge *); + 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 *, struct drm_display_mode *, struct drm_display_mode *); + void (*pre_enable)(struct drm_bridge *); + void (*enable)(struct drm_bridge *); +}; + +struct drm_file; + +struct drm_buf { + int idx; + int total; + int order; + int used; + long unsigned int offset; + void *address; + long unsigned int bus_address; + struct drm_buf *next; + volatile int waiting; + volatile int pending; + struct drm_file *file_priv; + int context; + int while_locked; + enum { + DRM_LIST_NONE = 0, + DRM_LIST_FREE = 1, + DRM_LIST_WAIT = 2, + DRM_LIST_PEND = 3, + DRM_LIST_PRIO = 4, + DRM_LIST_RECLAIM = 5, + } list; + int dev_priv_size; + void *dev_private; +}; + +struct drm_buf_desc { + int count; + int size; + int low_mark; + int high_mark; + enum { + _DRM_PAGE_ALIGN = 1, + _DRM_AGP_BUFFER = 2, + _DRM_SG_BUFFER = 4, + _DRM_FB_BUFFER = 8, + _DRM_PCI_BUFFER_RO = 16, + } flags; + long unsigned int agp_start; +}; + +struct drm_buf_desc32 { + int count; + int size; + int low_mark; + int high_mark; + int flags; + u32 agp_start; +}; + +typedef struct drm_buf_desc32 drm_buf_desc32_t; + +struct drm_buf_entry { + int buf_size; + int buf_count; + struct drm_buf *buflist; + int seg_count; + int page_order; + struct drm_dma_handle **seglist; + int low_mark; + int high_mark; +}; + +struct drm_buf_free { + int count; + int *list; +}; + +struct drm_buf_free32 { + int count; + u32 list; +}; + +typedef struct drm_buf_free32 drm_buf_free32_t; + +struct drm_buf_info { + int count; + struct drm_buf_desc *list; +}; + +struct drm_buf_info32 { + int count; + u32 list; +}; + +typedef struct drm_buf_info32 drm_buf_info32_t; + +struct drm_buf_pub; + +struct drm_buf_map { + int count; + void *virtual; + struct drm_buf_pub *list; +}; + +struct drm_buf_map32 { + int count; + u32 virtual; + u32 list; +}; + +typedef struct drm_buf_map32 drm_buf_map32_t; + +struct drm_buf_pub { + int idx; + int total; + int used; + void *address; +}; + +struct drm_buf_pub32 { + int idx; + int total; + int used; + u32 address; +}; + +typedef struct drm_buf_pub32 drm_buf_pub32_t; + +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_color_ctm { + __s64 matrix[9]; +}; + +struct drm_color_lut { + __u16 red; + __u16 green; + __u16 blue; + __u16 reserved; +}; + +struct ida_bitmap; + +struct ida { + struct idr idr; + struct ida_bitmap *free_bitmap; +}; + +struct drm_conn_prop_enum_list { + int type; + const char *name; + struct ida ida; +}; + +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); + 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 *); +}; + +struct drm_connector_helper_funcs { + int (*get_modes)(struct drm_connector *); + enum drm_mode_status (*mode_valid)(struct drm_connector *, struct drm_display_mode *); + struct drm_encoder * (*best_encoder)(struct drm_connector *); + struct drm_encoder * (*atomic_best_encoder)(struct drm_connector *, struct drm_connector_state *); +}; + +struct drm_connector_state { + struct drm_connector *connector; + struct drm_crtc *crtc; + struct drm_encoder *best_encoder; + struct drm_atomic_state *state; +}; + +struct drm_control { + enum { + DRM_ADD_COMMAND = 0, + DRM_RM_COMMAND = 1, + DRM_INST_HANDLER = 2, + DRM_UNINST_HANDLER = 3, + } func; + int irq; +}; + +struct drm_mode_set; + +struct drm_pending_vblank_event; + +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); + void (*gamma_set)(struct drm_crtc *, u16 *, u16 *, u16 *, uint32_t, uint32_t); + void (*destroy)(struct drm_crtc *); + int (*set_config)(struct drm_mode_set *); + int (*page_flip)(struct drm_crtc *, struct drm_framebuffer *, struct drm_pending_vblank_event *, uint32_t); + 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 *); +}; + +struct drm_crtc_helper_funcs { + void (*dpms)(struct drm_crtc *, int); + void (*prepare)(struct drm_crtc *); + void (*commit)(struct drm_crtc *); + 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 (*load_lut)(struct drm_crtc *); + void (*disable)(struct drm_crtc *); + void (*enable)(struct drm_crtc *); + int (*atomic_check)(struct drm_crtc *, struct drm_crtc_state *); + void (*atomic_begin)(struct drm_crtc *, struct drm_crtc_state *); + void (*atomic_flush)(struct drm_crtc *, struct drm_crtc_state *); +}; + +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 color_mgmt_changed: 1; + u32 plane_mask; + u32 connector_mask; + u32 encoder_mask; + u32 last_vblank_count; + 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; + struct drm_pending_vblank_event *event; + struct drm_atomic_state *state; +}; + +struct drm_ctx { + drm_context_t handle; + enum drm_ctx_flags flags; +}; + +struct drm_ctx_list { + struct list_head head; + drm_context_t handle; + struct drm_file *tag; +}; + +struct drm_ctx_priv_map { + unsigned int ctx_id; + void *handle; +}; + +struct drm_ctx_priv_map32 { + unsigned int ctx_id; + u32 handle; +}; + +typedef struct drm_ctx_priv_map32 drm_ctx_priv_map32_t; + +struct drm_ctx_res { + int count; + struct drm_ctx *contexts; +}; + +struct drm_ctx_res32 { + int count; + u32 contexts; +}; + +typedef struct drm_ctx_res32 drm_ctx_res32_t; + +struct drm_open_hash { + struct hlist_head *table; + u8 order; +}; + +struct drm_mode_config_funcs; + +struct drm_mode_config { + struct mutex___2 mutex; + struct drm_modeset_lock connection_mutex; + struct drm_modeset_acquire_ctx *acquire_ctx; + struct mutex___2 idr_mutex; + struct idr crtc_idr; + struct idr tile_idr; + struct mutex___2 fb_lock; + int num_fb; + struct list_head fb_list; + int num_connector; + struct ida connector_ida; + struct list_head connector_list; + int num_encoder; + struct list_head encoder_list; + int num_overlay_plane; + int num_total_plane; + struct list_head plane_list; + int num_crtc; + struct list_head crtc_list; + struct list_head property_list; + int min_width; + int min_height; + int max_width; + int max_height; + const struct drm_mode_config_funcs *funcs; + resource_size_t fb_base; + bool poll_enabled; + bool poll_running; + bool delayed_event; + struct delayed_work output_poll_work; + struct mutex___2 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 *plane_type_property; + struct drm_property *rotation_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_crtc_id; + struct drm_property *prop_active; + struct drm_property *prop_mode_id; + struct drm_property *dvi_i_subconnector_property; + struct drm_property *dvi_i_select_subconnector_property; + struct drm_property *tv_subconnector_property; + struct drm_property *tv_select_subconnector_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 *dirty_info_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; + uint32_t preferred_depth; + uint32_t prefer_shadow; + bool async_page_flip; + bool allow_fb_modifiers; + uint32_t cursor_width; + uint32_t cursor_height; +}; + +struct drm_driver; + +struct drm_minor; + +struct drm_device_dma; + +struct drm_vblank_crtc; + +struct virtio_device; + +struct drm_sg_mem; + +struct drm_hw_lock; + +struct drm_device { + struct list_head legacy_dev_list; + int if_version; + struct kref ref; + struct device *dev; + struct drm_driver *driver; + void *dev_private; + struct drm_minor *control; + struct drm_minor *primary; + struct drm_minor *render; + atomic_t unplugged; + struct inode___2 *anon_inode; + char *unique; + struct mutex___2 struct_mutex; + struct mutex___2 master_mutex; + int open_count; + spinlock_t buf_lock; + int buf_use; + atomic_t buf_alloc; + struct mutex___2 filelist_mutex; + struct list_head filelist; + struct list_head maplist; + struct drm_open_hash map_hash; + struct list_head ctxlist; + struct mutex___2 ctxlist_mutex; + struct idr ctx_idr; + struct list_head vmalist; + struct drm_device_dma *dma; + volatile long int context_flag; + int last_context; + bool irq_enabled; + int irq; + 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; + struct drm_agp_head *agp; + struct pci_dev *pdev; + struct platform_device *platformdev; + struct virtio_device *virtdev; + struct drm_sg_mem *sg; + unsigned int num_crtcs; + struct { + int context; + struct drm_hw_lock *lock; + } sigdata; + struct drm_local_map *agp_buffer_map; + unsigned int agp_buffer_token; + struct drm_mode_config mode_config; + struct mutex___2 object_name_lock; + struct idr object_name_idr; + struct drm_vma_offset_manager *vma_offset_manager; + int switch_power_state; +}; + +struct drm_device_dma { + struct drm_buf_entry bufs[23]; + int buf_count; + struct drm_buf **buflist; + int seg_count; + int page_count; + long unsigned int *pagelist; + long unsigned int byte_count; + enum { + _DRM_DMA_USE_AGP = 1, + _DRM_DMA_USE_SG = 2, + _DRM_DMA_USE_FB = 4, + _DRM_DMA_USE_PCI_RO = 8, + } flags; +}; + +struct drm_dma { + int context; + int send_count; + int *send_indices; + int *send_sizes; + enum drm_dma_flags flags; + int request_count; + int request_size; + int *request_indices; + int *request_sizes; + int granted_count; +}; + +struct drm_dma32 { + int context; + int send_count; + u32 send_indices; + u32 send_sizes; + enum drm_dma_flags flags; + int request_count; + int request_size; + u32 request_indices; + u32 request_sizes; + int granted_count; +}; + +typedef struct drm_dma32 drm_dma32_t; + +struct drm_dma_handle { + dma_addr_t busaddr; + void *vaddr; + size_t size; +}; + +typedef struct drm_dma_handle drm_dma_handle_t; + +struct rt_mutex { + raw_spinlock_t wait_lock; + struct rb_root waiters; + struct rb_node *waiters_leftmost; + struct task_struct *owner; +}; + +struct i2c_algorithm; + +struct i2c_bus_recovery_info; + +struct i2c_adapter_quirks; + +struct i2c_adapter { + struct module___2 *owner; + unsigned int class; + const struct i2c_algorithm *algo; + void *algo_data; + struct rt_mutex bus_lock; + struct rt_mutex mux_lock; + int timeout; + int retries; + struct device___2 dev; + int nr; + char name[48]; + struct completion dev_released; + struct mutex___2 userspace_clients_lock; + struct list_head userspace_clients; + struct i2c_bus_recovery_info *bus_recovery_info; + const struct i2c_adapter_quirks *quirks; + 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 drm_dp_aux_msg; + +struct drm_dp_aux { + const char *name; + struct i2c_adapter ddc; + struct device___2 *dev; + struct mutex___2 hw_mutex; + ssize_t (*transfer)(struct drm_dp_aux *, struct drm_dp_aux_msg *); + unsigned int i2c_nack_count; + unsigned int i2c_defer_count; +}; + +struct drm_dp_aux_msg { + unsigned int address; + u8 request; + u8 reply; + void *buffer; + size_t size; +}; + +struct drm_dp_link { + unsigned char revision; + unsigned int rate; + unsigned int num_lanes; + long unsigned int capabilities; +}; + +struct drm_dp_mst_port; + +struct drm_dp_mst_topology_mgr; + +struct drm_dp_sideband_msg_tx; + +struct drm_dp_mst_branch { + struct kref kref; + u8 rad[8]; + u8 lct; + int num_ports; + int msg_slots; + struct list_head ports; + struct drm_dp_mst_port *port_parent; + struct drm_dp_mst_topology_mgr *mgr; + struct drm_dp_sideband_msg_tx *tx_slots[2]; + int last_seqno; + bool link_address_sent; + u8 guid[16]; +}; + +struct drm_dp_vcpi { + int vcpi; + int pbn; + int aligned_pbn; + int num_slots; +}; + +struct drm_dp_mst_port { + struct kref kref; + u8 port_num; + bool input; + bool mcs; + bool ddps; + u8 pdt; + bool ldps; + u8 dpcd_rev; + u8 num_sdp_streams; + u8 num_sdp_stream_sinks; + uint16_t available_pbn; + struct list_head next; + struct drm_dp_mst_branch *mstb; + struct drm_dp_aux aux; + struct drm_dp_mst_branch *parent; + struct drm_dp_vcpi vcpi; + struct drm_connector *connector; + struct drm_dp_mst_topology_mgr *mgr; + struct edid *cached_edid; + bool has_audio; +}; + +struct drm_dp_mst_topology_cbs { + struct drm_connector * (*add_connector)(struct drm_dp_mst_topology_mgr *, struct drm_dp_mst_port *, const char *); + void (*register_connector)(struct drm_connector *); + void (*destroy_connector)(struct drm_dp_mst_topology_mgr *, struct drm_connector *); + void (*hotplug)(struct drm_dp_mst_topology_mgr *); +}; + +struct drm_dp_sideband_msg_hdr { + u8 lct; + u8 lcr; + u8 rad[8]; + bool broadcast; + bool path_msg; + u8 msg_len; + bool somt; + bool eomt; + bool seqno; +}; + +struct drm_dp_sideband_msg_rx { + u8 chunk[48]; + u8 msg[256]; + u8 curchunk_len; + u8 curchunk_idx; + u8 curchunk_hdrlen; + u8 curlen; + bool have_somt; + bool have_eomt; + struct drm_dp_sideband_msg_hdr initial_hdr; +}; + +struct drm_dp_payload; + +struct drm_dp_mst_topology_mgr { + struct device *dev; + const struct drm_dp_mst_topology_cbs *cbs; + int max_dpcd_transaction_bytes; + struct drm_dp_aux *aux; + int max_payloads; + int conn_base_id; + struct drm_dp_sideband_msg_rx down_rep_recv; + struct drm_dp_sideband_msg_rx up_req_recv; + struct mutex___2 lock; + bool mst_state; + struct drm_dp_mst_branch *mst_primary; + u8 dpcd[15]; + u8 sink_count; + int pbn_div; + int total_slots; + int avail_slots; + int total_pbn; + struct mutex___2 qlock; + struct list_head tx_msg_downq; + bool tx_down_in_progress; + struct mutex___2 payload_lock; + struct drm_dp_vcpi **proposed_vcpis; + struct drm_dp_payload *payloads; + long unsigned int payload_mask; + long unsigned int vcpi_mask; + wait_queue_head_t tx_waitq; + struct work_struct work; + struct work_struct tx_work; + struct list_head destroy_connector_list; + struct mutex___2 destroy_connector_lock; + struct work_struct destroy_connector_work; +}; + +struct drm_dp_payload { + int payload_state; + int start_slot; + int num_slots; + int vcpi; +}; + +struct drm_dp_sideband_msg_reply_body { + u8 reply_type; + u8 req_type; + union ack_replies u; +}; + +struct drm_dp_sideband_msg_req_body { + u8 req_type; + union ack_req u; +}; + +struct drm_dp_sideband_msg_tx { + u8 msg[256]; + u8 chunk[48]; + u8 cur_offset; + u8 cur_len; + struct drm_dp_mst_branch *dst; + struct list_head next; + int seqno; + int state; + bool path_msg; + struct drm_dp_sideband_msg_reply_body reply; +}; + +struct drm_master; + +struct timeval; + +struct drm_mode_create_dumb; + +struct drm_ioctl_desc; + +struct drm_driver { + int (*load)(struct drm_device *, long unsigned int); + int (*firstopen)(struct drm_device *); + int (*open)(struct drm_device *, struct drm_file *); + void (*preclose)(struct drm_device *, struct drm_file *); + void (*postclose)(struct drm_device *, struct drm_file *); + void (*lastclose)(struct drm_device *); + int (*unload)(struct drm_device *); + int (*suspend)(struct drm_device *, pm_message_t); + int (*resume)(struct drm_device *); + int (*dma_ioctl)(struct drm_device *, void *, struct drm_file *); + int (*dma_quiescent)(struct drm_device *); + int (*context_dtor)(struct drm_device *, int); + int (*set_busid)(struct drm_device *, struct drm_master *); + u32 (*get_vblank_counter)(struct drm_device *, unsigned int); + int (*enable_vblank)(struct drm_device *, unsigned int); + void (*disable_vblank)(struct drm_device *, unsigned int); + int (*device_is_agp)(struct drm_device *); + int (*get_scanout_position)(struct drm_device *, unsigned int, unsigned int, int *, int *, ktime_t *, ktime_t *, const struct drm_display_mode *); + int (*get_vblank_timestamp)(struct drm_device *, unsigned int, int *, struct timeval *, unsigned int); + irqreturn_t (*irq_handler)(int, void *); + void (*irq_preinstall)(struct drm_device *); + int (*irq_postinstall)(struct drm_device *); + void (*irq_uninstall)(struct drm_device *); + int (*master_create)(struct drm_device *, struct drm_master *); + void (*master_destroy)(struct drm_device *, struct drm_master *); + int (*master_set)(struct drm_device *, struct drm_file *, bool); + void (*master_drop)(struct drm_device *, struct drm_file *, bool); + int (*debugfs_init)(struct drm_minor *); + void (*debugfs_cleanup)(struct drm_minor *); + void (*gem_free_object)(struct drm_gem_object *); + void (*gem_free_object_unlocked)(struct drm_gem_object *); + int (*gem_open_object)(struct drm_gem_object *, struct drm_file *); + void (*gem_close_object)(struct drm_gem_object *, struct drm_file *); + 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 dma_buf * (*gem_prime_export)(struct drm_device *, struct drm_gem_object *, int); + struct drm_gem_object * (*gem_prime_import)(struct drm_device *, struct dma_buf *); + int (*gem_prime_pin)(struct drm_gem_object *); + void (*gem_prime_unpin)(struct drm_gem_object *); + struct reservation_object * (*gem_prime_res_obj)(struct drm_gem_object *); + struct sg_table * (*gem_prime_get_sg_table)(struct drm_gem_object *); + struct drm_gem_object * (*gem_prime_import_sg_table)(struct drm_device *, struct dma_buf_attachment *, struct sg_table *); + void * (*gem_prime_vmap)(struct drm_gem_object *); + void (*gem_prime_vunmap)(struct drm_gem_object *, void *); + int (*gem_prime_mmap)(struct drm_gem_object *, struct vm_area_struct *); + void (*vgaarb_irq)(struct drm_device *, bool); + 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 (*dumb_destroy)(struct drm_file *, struct drm_device *, uint32_t); + const struct vm_operations_struct *gem_vm_ops; + int major; + int minor; + int patchlevel; + char *name; + char *desc; + char *date; + u32 driver_features; + int dev_priv_size; + const struct drm_ioctl_desc *ioctls; + int num_ioctls; + const struct file_operations *fops; + struct list_head legacy_dev_list; +}; + +struct drm_encoder_funcs { + void (*reset)(struct drm_encoder *); + void (*destroy)(struct drm_encoder *); +}; + +struct drm_encoder_helper_funcs { + void (*dpms)(struct drm_encoder *, int); + 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 *); + struct drm_crtc * (*get_crtc)(struct drm_encoder *); + enum drm_connector_status (*detect)(struct drm_encoder *, struct drm_connector *); + 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_encoder_slave_funcs; + +struct drm_encoder_slave { + struct drm_encoder base; + const struct drm_encoder_slave_funcs *slave_funcs; + void *slave_priv; + void *bus_priv; +}; + +struct drm_encoder_slave_funcs { + void (*set_config)(struct drm_encoder *, void *); + void (*destroy)(struct drm_encoder *); + void (*dpms)(struct drm_encoder *, int); + void (*save)(struct drm_encoder *); + void (*restore)(struct drm_encoder *); + bool (*mode_fixup)(struct drm_encoder *, const struct drm_display_mode *, struct drm_display_mode *); + int (*mode_valid)(struct drm_encoder *, struct drm_display_mode *); + void (*mode_set)(struct drm_encoder *, struct drm_display_mode *, struct drm_display_mode *); + enum drm_connector_status (*detect)(struct drm_encoder *, struct drm_connector *); + int (*get_modes)(struct drm_encoder *, struct drm_connector *); + int (*create_resources)(struct drm_encoder *, struct drm_connector *); + int (*set_property)(struct drm_encoder *, struct drm_connector *, struct drm_property *, uint64_t); +}; + +struct drm_event { + __u32 type; + __u32 length; +}; + +struct drm_event_vblank { + struct drm_event base; + __u64 user_data; + __u32 tv_sec; + __u32 tv_usec; + __u32 sequence; + __u32 reserved; +}; + +struct drm_fb_helper_connector { + struct drm_connector *connector; +}; + +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_fb_helper_crtc { + struct drm_mode_set mode_set; + struct drm_display_mode *desired_mode; + int x; + int y; +}; + +struct drm_fb_helper_surface_size; + +struct drm_fb_offset; + +struct drm_fb_helper_funcs { + void (*gamma_set)(struct drm_crtc *, u16, u16, u16, int); + void (*gamma_get)(struct drm_crtc *, u16 *, u16 *, u16 *, int); + int (*fb_probe)(struct drm_fb_helper *, struct drm_fb_helper_surface_size *); + bool (*initial_config)(struct drm_fb_helper *, struct drm_fb_helper_crtc **, struct drm_display_mode **, struct drm_fb_offset *, bool *, int, int); +}; + +struct drm_fb_helper_surface_size { + u32 fb_width; + u32 fb_height; + u32 surface_width; + u32 surface_height; + u32 surface_bpp; + u32 surface_depth; +}; + +struct drm_fb_offset { + int x; + int y; +}; + +struct drm_prime_file_private { + struct list_head head; + struct mutex___2 lock; +}; + +struct pid; + +struct drm_file { + unsigned int authenticated: 1; + unsigned int is_master: 1; + unsigned int stereo_allowed: 1; + unsigned int universal_planes: 1; + unsigned int atomic: 1; + unsigned int allowed_master: 1; + struct pid *pid; + kuid_t uid; + drm_magic_t magic; + struct list_head lhead; + struct drm_minor *minor; + long unsigned int lock_count; + struct idr object_idr; + spinlock_t table_lock; + struct file *filp; + void *driver_priv; + struct drm_master *master; + struct list_head fbs; + struct mutex___2 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___2 event_read_lock; + struct drm_prime_file_private prime; +}; + +struct drm_flip_task { + struct list_head node; + void *data; +}; + +struct drm_flip_work; + +typedef void (*drm_flip_func_t)(struct drm_flip_work *, void *); + +struct drm_flip_work { + const char *name; + drm_flip_func_t func; + struct work_struct worker; + struct list_head queued; + struct list_head commited; + spinlock_t lock; +}; + +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_open { + __u32 name; + __u32 handle; + __u64 size; +}; + +struct drm_get_cap { + __u64 capability; + __u64 value; +}; + +struct drm_global_item { + struct mutex___2 mutex; + void *object; + int refcount; +}; + +struct drm_hash_item { + struct hlist_node head; + long unsigned int key; +}; + +struct drm_hw_lock { + volatile unsigned int lock; + char padding[60]; +}; + +struct i2c_client; + +struct i2c_device_id; + +struct i2c_driver { + unsigned int class; + int (*attach_adapter)(struct i2c_adapter *); + int (*probe)(struct i2c_client *, const struct i2c_device_id *); + int (*remove)(struct i2c_client *); + void (*shutdown)(struct i2c_client *); + void (*alert)(struct i2c_client *, 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; +}; + +struct drm_i2c_encoder_driver { + struct i2c_driver i2c_driver; + int (*encoder_init)(struct i2c_client *, struct drm_device *, struct drm_encoder_slave *); +}; + +struct drm_i915_cmd_descriptor { + u32 flags; + struct { + u32 value; + u32 mask; + } cmd; + union { + u32 fixed; + u32 mask; + } length; + struct { + u32 offset; + u32 mask; + u32 step; + } reg; + struct { + u32 offset; + u32 mask; + u32 expected; + u32 condition_offset; + u32 condition_mask; + } bits[3]; +}; + +struct drm_i915_cmd_table { + const struct drm_i915_cmd_descriptor *table; + int count; +}; + +struct intel_crtc_state; + +struct intel_crtc; + +struct intel_initial_plane_config; + +struct intel_encoder; + +struct drm_i915_gem_object; + +struct drm_i915_gem_request; + +struct drm_i915_display_funcs { + int (*get_display_clock_speed)(struct drm_device *); + int (*get_fifo_size)(struct drm_device *, int); + int (*compute_pipe_wm)(struct intel_crtc_state *); + int (*compute_intermediate_wm)(struct drm_device *, struct intel_crtc *, struct intel_crtc_state *); + void (*initial_watermarks)(struct intel_crtc_state *); + void (*optimize_watermarks)(struct intel_crtc_state *); + void (*update_wm)(struct drm_crtc *); + int (*modeset_calc_cdclk)(struct drm_atomic_state *); + void (*modeset_commit_cdclk)(struct drm_atomic_state *); + bool (*get_pipe_config)(struct intel_crtc *, struct intel_crtc_state *); + void (*get_initial_plane_config)(struct intel_crtc *, struct intel_initial_plane_config *); + int (*crtc_compute_clock)(struct intel_crtc *, struct intel_crtc_state *); + void (*crtc_enable)(struct drm_crtc *); + void (*crtc_disable)(struct drm_crtc *); + void (*audio_codec_enable)(struct drm_connector *, struct intel_encoder *, const struct drm_display_mode *); + void (*audio_codec_disable)(struct intel_encoder *); + void (*fdi_link_train)(struct drm_crtc *); + void (*init_clock_gating)(struct drm_device *); + int (*queue_flip)(struct drm_device *, struct drm_crtc *, struct drm_framebuffer *, struct drm_i915_gem_object *, struct drm_i915_gem_request *, uint32_t); + void (*hpd_irq_setup)(struct drm_device *); + void (*load_csc_matrix)(struct drm_crtc_state *); + void (*load_luts)(struct drm_crtc_state *); +}; + +struct drm_i915_error_buffer { + u32 size; + u32 name; + u32 rseqno[5]; + u32 wseqno; + u64 gtt_offset; + u32 read_domains; + u32 write_domain; + s32 fence_reg: 6; + s32 pinned: 2; + u32 tiling: 2; + u32 dirty: 1; + u32 purgeable: 1; + u32 userptr: 1; + s32 ring: 4; + u32 cache_level: 3; +}; + +struct drm_i915_error_object { + int page_count; + u64 gtt_offset; + u32 *pages[0]; +}; + +struct drm_i915_error_request { + long int jiffies; + u32 seqno; + u32 tail; +}; + +struct drm_i915_error_ring { + bool valid; + bool waiting; + int hangcheck_score; + enum intel_ring_hangcheck_action hangcheck_action; + int num_requests; + u32 cpu_ring_head; + u32 cpu_ring_tail; + u32 last_seqno; + u32 semaphore_seqno[4]; + u32 start; + u32 tail; + u32 head; + u32 ctl; + u32 hws; + u32 ipeir; + u32 ipehr; + u32 instdone; + u32 bbstate; + u32 instpm; + u32 instps; + u32 seqno; + u64 bbaddr; + u64 acthd; + u32 fault_reg; + u64 faddr; + u32 rc_psmi; + u32 semaphore_mboxes[4]; + struct drm_i915_error_object *ringbuffer; + struct drm_i915_error_object *batchbuffer; + struct drm_i915_error_object *wa_batchbuffer; + struct drm_i915_error_object *ctx; + struct drm_i915_error_object *hws_page; + struct drm_i915_error_object *wa_ctx; + struct drm_i915_error_request *requests; + struct { + u32 gfx_mode; + union { + u64 pdp[4]; + u32 pp_dir_base; + }; + } vm_info; + pid_t pid; + char comm[16]; +}; + +struct timeval { + __kernel_time_t tv_sec; + __kernel_suseconds_t tv_usec; +}; + +struct intel_overlay_error_state; + +struct intel_display_error_state; + +struct drm_i915_error_state { + struct kref ref; + struct timeval time; + char error_msg[128]; + int iommu; + u32 reset_count; + u32 suspend_count; + u32 eir; + u32 pgtbl_er; + u32 ier; + u32 gtier[4]; + u32 ccid; + u32 derrmr; + u32 forcewake; + u32 error; + u32 err_int; + u32 fault_data0; + u32 fault_data1; + u32 done_reg; + u32 gac_eco; + u32 gam_ecochk; + u32 gab_ctl; + u32 gfx_mode; + u32 extra_instdone[4]; + u64 fence[32]; + struct intel_overlay_error_state *overlay; + struct intel_display_error_state *display; + struct drm_i915_error_object *semaphore_obj; + struct drm_i915_error_ring ring[5]; + struct drm_i915_error_buffer **active_bo; + struct drm_i915_error_buffer **pinned_bo; + u32 *active_bo_count; + u32 *pinned_bo_count; + u32 vm_count; +}; + +struct drm_i915_private; + +struct drm_i915_error_state_buf { + struct drm_i915_private *i915; + unsigned int bytes; + unsigned int size; + int err; + u8 *buf; + loff_t start; + loff_t pos; +}; + +struct drm_i915_fence_reg { + struct list_head lru_list; + struct drm_i915_gem_object *obj; + int pin_count; +}; + +struct intel_rps_client { + struct list_head link; + unsigned int boosts; +}; + +struct drm_i915_file_private { + struct drm_i915_private *dev_priv; + struct drm_file *file; + struct { + spinlock_t lock; + struct list_head request_list; + } mm; + struct idr context_idr; + struct intel_rps_client rps; + unsigned int bsd_ring; +}; + +struct drm_i915_gem_busy { + __u32 handle; + __u32 busy; +}; + +struct drm_i915_gem_caching { + __u32 handle; + __u32 caching; +}; + +struct drm_i915_gem_context_create { + __u32 ctx_id; + __u32 pad; +}; + +struct drm_i915_gem_context_destroy { + __u32 ctx_id; + __u32 pad; +}; + +struct drm_i915_gem_context_param { + __u32 ctx_id; + __u32 size; + __u64 param; + __u64 value; +}; + +struct drm_i915_gem_create { + __u64 size; + __u32 handle; + __u32 pad; +}; + +struct drm_i915_gem_exec_object { + __u32 handle; + __u32 relocation_count; + __u64 relocs_ptr; + __u64 alignment; + __u64 offset; +}; + +struct drm_i915_gem_exec_object2 { + __u32 handle; + __u32 relocation_count; + __u64 relocs_ptr; + __u64 alignment; + __u64 offset; + __u64 flags; + __u64 rsvd1; + __u64 rsvd2; +}; + +struct drm_i915_gem_execbuffer { + __u64 buffers_ptr; + __u32 buffer_count; + __u32 batch_start_offset; + __u32 batch_len; + __u32 DR1; + __u32 DR4; + __u32 num_cliprects; + __u64 cliprects_ptr; +}; + +struct drm_i915_gem_execbuffer2 { + __u64 buffers_ptr; + __u32 buffer_count; + __u32 batch_start_offset; + __u32 batch_len; + __u32 DR1; + __u32 DR4; + __u32 num_cliprects; + __u64 cliprects_ptr; + __u64 flags; + __u64 rsvd1; + __u64 rsvd2; +}; + +struct drm_i915_gem_get_aperture { + __u64 aper_size; + __u64 aper_available_size; +}; + +struct drm_i915_gem_get_tiling { + __u32 handle; + __u32 tiling_mode; + __u32 swizzle_mode; + __u32 phys_swizzle_mode; +}; + +struct drm_i915_gem_madvise { + __u32 handle; + __u32 madv; + __u32 retained; +}; + +struct drm_i915_gem_mmap { + __u32 handle; + __u32 pad; + __u64 offset; + __u64 size; + __u64 addr_ptr; + __u64 flags; +}; + +struct drm_i915_gem_mmap_gtt { + __u32 handle; + __u32 pad; + __u64 offset; +}; + +struct get_page { + struct scatterlist *sg; + int last; +}; + +struct i915_mm_struct; + +struct i915_mmu_object; + +struct i915_gem_userptr { + uintptr_t ptr; + unsigned int read_only: 1; + unsigned int workers: 4; + struct i915_mm_struct *mm; + struct i915_mmu_object *mmu_object; + struct work_struct *work; +}; + +struct drm_i915_gem_object_ops; + +struct drm_i915_gem_object { + struct drm_gem_object base; + const struct drm_i915_gem_object_ops *ops; + struct list_head vma_list; + struct drm_mm_node *stolen; + struct list_head global_list; + struct list_head engine_list[5]; + struct list_head obj_exec_link; + struct list_head batch_pool_link; + unsigned int active: 5; + unsigned int dirty: 1; + int fence_reg: 6; + unsigned int madv: 2; + unsigned int tiling_mode: 2; + unsigned int fence_dirty: 1; + unsigned int map_and_fenceable: 1; + unsigned int fault_mappable: 1; + long unsigned int gt_ro: 1; + unsigned int cache_level: 3; + unsigned int cache_dirty: 1; + int: 8; + unsigned int frontbuffer_bits: 24; + unsigned int pin_display; + struct sg_table *pages; + int pages_pin_count; + struct get_page get_page; + void *mapping; + struct drm_i915_gem_request *last_read_req[5]; + struct drm_i915_gem_request *last_write_req; + struct drm_i915_gem_request *last_fenced_req; + uint32_t stride; + long unsigned int framebuffer_references; + long unsigned int *bit_17; + union { + struct drm_dma_handle *phys_handle; + struct i915_gem_userptr userptr; + }; +}; + +struct drm_i915_gem_object_ops { + unsigned int flags; + int (*get_pages)(struct drm_i915_gem_object *); + void (*put_pages)(struct drm_i915_gem_object *); + int (*dmabuf_export)(struct drm_i915_gem_object *); + void (*release)(struct drm_i915_gem_object *); +}; + +struct drm_i915_gem_pread { + __u32 handle; + __u32 pad; + __u64 offset; + __u64 size; + __u64 data_ptr; +}; + +struct drm_i915_gem_pwrite { + __u32 handle; + __u32 pad; + __u64 offset; + __u64 size; + __u64 data_ptr; +}; + +struct drm_i915_gem_relocation_entry { + __u32 target_handle; + __u32 delta; + __u64 offset; + __u64 presumed_offset; + __u32 read_domains; + __u32 write_domain; +}; + +struct intel_engine_cs; + +struct intel_context; + +struct intel_ringbuffer; + +struct pid___2; + +struct drm_i915_gem_request { + struct kref ref; + struct drm_i915_private *i915; + struct intel_engine_cs *engine; + unsigned int reset_counter; + u32 previous_seqno; + u32 seqno; + u32 head; + u32 postfix; + u32 tail; + struct intel_context *ctx; + struct intel_ringbuffer *ringbuf; + struct drm_i915_gem_object *batch_obj; + long unsigned int emitted_jiffies; + struct list_head list; + struct drm_i915_file_private *file_priv; + struct list_head client_list; + struct pid___2 *pid; + struct list_head execlist_link; + int elsp_submitted; +}; + +struct drm_i915_gem_set_domain { + __u32 handle; + __u32 read_domains; + __u32 write_domain; +}; + +struct drm_i915_gem_set_tiling { + __u32 handle; + __u32 tiling_mode; + __u32 stride; + __u32 swizzle_mode; +}; + +struct drm_i915_gem_sw_finish { + __u32 handle; +}; + +struct drm_i915_gem_userptr { + __u64 user_ptr; + __u64 user_size; + __u32 flags; + __u32 handle; +}; + +struct drm_i915_gem_wait { + __u32 bo_handle; + __u32 flags; + __s64 timeout_ns; +}; + +struct drm_i915_get_pipe_from_crtc_id { + __u32 crtc_id; + __u32 pipe; +}; + +struct drm_i915_getparam { + __s32 param; + int *value; +}; + +typedef struct drm_i915_getparam drm_i915_getparam_t; + +struct drm_i915_getparam32 { + s32 param; + u32 value; +}; + +struct drm_i915_mocs_entry { + u32 control_value; + u16 l3cc_value; +}; + +struct drm_i915_mocs_table { + u32 size; + const struct drm_i915_mocs_entry *table; +}; + +struct intel_device_info { + u32 display_mmio_offset; + u16 device_id; + u8 num_pipes: 3; + u8 num_sprites[3]; + u8 gen; + u8 ring_mask; + u8 is_mobile: 1; + u8 is_i85x: 1; + u8 is_i915g: 1; + u8 is_i945gm: 1; + u8 is_g33: 1; + u8 need_gfx_hws: 1; + u8 is_g4x: 1; + u8 is_pineview: 1; + u8 is_broadwater: 1; + u8 is_crestline: 1; + u8 is_ivybridge: 1; + u8 is_valleyview: 1; + u8 is_cherryview: 1; + u8 is_haswell: 1; + u8 is_skylake: 1; + u8 is_broxton: 1; + u8 is_kabylake: 1; + u8 is_preliminary: 1; + u8 has_fbc: 1; + u8 has_pipe_cxsr: 1; + u8 has_hotplug: 1; + u8 cursor_needs_physical: 1; + u8 has_overlay: 1; + u8 overlay_needs_physical: 1; + u8 supports_tv: 1; + u8 has_llc: 1; + u8 has_snoop: 1; + u8 has_ddi: 1; + u8 has_fpga_dbg: 1; + int pipe_offsets[6]; + int trans_offsets[6]; + int palette_offsets[3]; + int cursor_offsets[3]; + u8 slice_total; + u8 subslice_total; + u8 subslice_per_slice; + u8 eu_total; + u8 eu_per_subslice; + u8 subslice_7eu[3]; + u8 has_slice_pg: 1; + u8 has_subslice_pg: 1; + u8 has_eu_pg: 1; + struct color_luts color; +}; + +struct intel_uncore_funcs { + void (*force_wake_get)(struct drm_i915_private *, enum forcewake_domains); + void (*force_wake_put)(struct drm_i915_private *, enum forcewake_domains); + uint8_t (*mmio_readb)(struct drm_i915_private *, i915_reg_t, bool); + uint16_t (*mmio_readw)(struct drm_i915_private *, i915_reg_t, bool); + uint32_t (*mmio_readl)(struct drm_i915_private *, i915_reg_t, bool); + uint64_t (*mmio_readq)(struct drm_i915_private *, i915_reg_t, bool); + void (*mmio_writeb)(struct drm_i915_private *, i915_reg_t, uint8_t, bool); + void (*mmio_writew)(struct drm_i915_private *, i915_reg_t, uint16_t, bool); + void (*mmio_writel)(struct drm_i915_private *, i915_reg_t, uint32_t, bool); + void (*mmio_writeq)(struct drm_i915_private *, i915_reg_t, uint64_t, bool); +}; + +struct intel_uncore_forcewake_domain { + struct drm_i915_private *i915; + enum forcewake_domain_id id; + enum forcewake_domains mask; + unsigned int wake_count; + struct hrtimer timer; + i915_reg_t reg_set; + u32 val_set; + u32 val_clear; + i915_reg_t reg_ack; + i915_reg_t reg_post; + u32 val_reset; +}; + +struct intel_uncore { + spinlock_t lock; + struct intel_uncore_funcs funcs; + unsigned int fifo_count; + enum forcewake_domains fw_domains; + struct intel_uncore_forcewake_domain fw_domain[3]; + int unclaimed_mmio_check; +}; + +struct i915_virtual_gpu { + bool active; +}; + +struct intel_guc_fw { + struct drm_device *guc_dev; + const char *guc_fw_path; + size_t guc_fw_size; + struct drm_i915_gem_object *guc_fw_obj; + enum intel_guc_fw_status guc_fw_fetch_status; + enum intel_guc_fw_status guc_fw_load_status; + uint16_t guc_fw_major_wanted; + uint16_t guc_fw_minor_wanted; + uint16_t guc_fw_major_found; + uint16_t guc_fw_minor_found; + uint32_t header_size; + uint32_t header_offset; + uint32_t rsa_size; + uint32_t rsa_offset; + uint32_t ucode_size; + uint32_t ucode_offset; +}; + +struct i915_guc_client; + +struct intel_guc { + struct intel_guc_fw guc_fw; + uint32_t log_flags; + struct drm_i915_gem_object *log_obj; + struct drm_i915_gem_object *ads_obj; + struct drm_i915_gem_object *ctx_pool_obj; + struct ida ctx_ids; + struct i915_guc_client *execbuf_client; + long unsigned int doorbell_bitmap[4]; + uint32_t db_cacheline; + uint64_t action_count; + uint32_t action_cmd; + uint32_t action_status; + uint32_t action_fail; + int32_t action_err; + uint64_t submissions[5]; + uint32_t last_seqno[5]; +}; + +struct intel_csr { + struct work_struct work; + const char *fw_path; + uint32_t *dmc_payload; + uint32_t dmc_fw_size; + uint32_t version; + uint32_t mmio_count; + i915_reg_t mmioaddr[8]; + uint32_t mmiodata[8]; + uint32_t dc_state; + uint32_t allowed_dc_mask; +}; + +struct i2c_algo_bit_data { + void *data; + void (*setsda)(void *, int); + void (*setscl)(void *, int); + int (*getsda)(void *); + int (*getscl)(void *); + int (*pre_xfer)(struct i2c_adapter *); + void (*post_xfer)(struct i2c_adapter *); + int udelay; + int timeout; +}; + +struct intel_gmbus { + struct i2c_adapter adapter; + u32 force_bit; + u32 reg0; + i915_reg_t gpio_reg; + struct i2c_algo_bit_data bit_algo; + struct drm_i915_private *dev_priv; +}; + +struct i915_gem_batch_pool { + struct drm_device *dev; + struct list_head cache_list[4]; +}; + +struct intel_hw_status_page { + u32 *page_addr; + unsigned int gfx_addr; + struct drm_i915_gem_object *obj; +}; + +struct i915_wa_ctx_bb { + u32 offset; + u32 size; +}; + +struct i915_ctx_workarounds { + struct i915_wa_ctx_bb indirect_ctx; + struct i915_wa_ctx_bb per_ctx; + struct drm_i915_gem_object *obj; +}; + +struct tasklet_struct { + struct tasklet_struct *next; + long unsigned int state; + atomic_t count; + void (*func)(long unsigned int); + long unsigned int data; +}; + +struct intel_ring_hangcheck { + u64 acthd; + u32 seqno; + unsigned int user_interrupts; + int score; + enum intel_ring_hangcheck_action action; + int deadlock; + u32 instdone[4]; +}; + +struct drm_i915_reg_table; + +struct intel_engine_cs { + const char *name; + enum intel_engine_id id; + unsigned int exec_id; + unsigned int hw_id; + unsigned int guc_id; + u32 mmio_base; + struct drm_device *dev; + struct intel_ringbuffer *buffer; + struct list_head buffers; + struct i915_gem_batch_pool batch_pool; + struct intel_hw_status_page status_page; + struct i915_ctx_workarounds wa_ctx; + unsigned int irq_refcount; + u32 irq_enable_mask; + struct drm_i915_gem_request *trace_irq_req; + bool (*irq_get)(struct intel_engine_cs *); + void (*irq_put)(struct intel_engine_cs *); + int (*init_hw)(struct intel_engine_cs *); + int (*init_context)(struct drm_i915_gem_request *); + void (*write_tail)(struct intel_engine_cs *, u32); + int (*flush)(struct drm_i915_gem_request *, u32, u32); + int (*add_request)(struct drm_i915_gem_request *); + void (*irq_seqno_barrier)(struct intel_engine_cs *); + u32 (*get_seqno)(struct intel_engine_cs *); + void (*set_seqno)(struct intel_engine_cs *, u32); + int (*dispatch_execbuffer)(struct drm_i915_gem_request *, u64, u32, unsigned int); + void (*cleanup)(struct intel_engine_cs *); + struct { + u32 sync_seqno[4]; + union { + struct { + u32 wait[5]; + i915_reg_t signal[5]; + } mbox; + u64 signal_ggtt[5]; + }; + int (*sync_to)(struct drm_i915_gem_request *, struct intel_engine_cs *, u32); + int (*signal)(struct drm_i915_gem_request *, unsigned int); + } semaphore; + struct tasklet_struct irq_tasklet; + spinlock_t execlist_lock; + struct list_head execlist_queue; + struct list_head execlist_retired_req_list; + unsigned int fw_domains; + unsigned int next_context_status_buffer; + unsigned int idle_lite_restore_wa; + bool disable_lite_restore_wa; + u32 ctx_desc_template; + u32 irq_keep_mask; + int (*emit_request)(struct drm_i915_gem_request *); + int (*emit_flush)(struct drm_i915_gem_request *, u32, u32); + int (*emit_bb_start)(struct drm_i915_gem_request *, u64, unsigned int); + struct list_head active_list; + struct list_head request_list; + u32 last_submitted_seqno; + unsigned int user_interrupts; + bool gpu_caches_dirty; + wait_queue_head_t irq_queue; + struct intel_context *last_context; + struct intel_ring_hangcheck hangcheck; + struct { + struct drm_i915_gem_object *obj; + u32 gtt_offset; + volatile u32 *cpu_page; + } scratch; + bool needs_cmd_parser; + struct hlist_head cmd_hash[512]; + const struct drm_i915_reg_table *reg_tables; + int reg_table_count; + u32 (*get_cmd_length_mask)(u32); +}; + +struct pm_qos_request { + struct plist_node node; + int pm_qos_class; + struct delayed_work work; +}; + +struct intel_digital_port; + +struct i915_hotplug { + struct work_struct hotplug_work; + struct { + long unsigned int last_jiffies; + int count; + enum { + HPD_ENABLED = 0, + HPD_DISABLED = 1, + HPD_MARK_DISABLED = 2, + } state; + } stats[9]; + u32 event_bits; + struct delayed_work reenable_work; + struct intel_digital_port *irq_port[5]; + u32 long_port_mask; + u32 short_port_mask; + struct work_struct dig_port_work; + struct workqueue_struct *dp_wq; +}; + +struct intel_fbc_state_cache { + struct { + unsigned int mode_flags; + uint32_t hsw_bdw_pixel_rate; + } crtc; + struct { + unsigned int rotation; + int src_w; + int src_h; + bool visible; + } plane; + struct { + u64 ilk_ggtt_offset; + uint32_t pixel_format; + unsigned int stride; + int fence_reg; + unsigned int tiling_mode; + } fb; +}; + +struct intel_fbc_reg_params { + struct { + enum pipe pipe; + enum plane plane; + unsigned int fence_y_offset; + } crtc; + struct { + u64 ggtt_offset; + uint32_t pixel_format; + unsigned int stride; + int fence_reg; + } fb; + int cfb_size; +}; + +struct intel_fbc_work { + bool scheduled; + u32 scheduled_vblank; + struct work_struct work; +}; + +struct intel_fbc { + struct mutex___2 lock; + unsigned int threshold; + unsigned int possible_framebuffer_bits; + unsigned int busy_bits; + unsigned int visible_pipes_mask; + struct intel_crtc *crtc; + struct drm_mm_node compressed_fb; + struct drm_mm_node *compressed_llb; + bool false_color; + bool enabled; + bool active; + struct intel_fbc_state_cache state_cache; + struct intel_fbc_reg_params params; + struct intel_fbc_work work; + const char *no_fbc_reason; +}; + +struct intel_dp; + +struct i915_drrs { + struct mutex___2 mutex; + struct delayed_work work; + struct intel_dp *dp; + unsigned int busy_frontbuffer_bits; + enum drrs_refresh_rate_type refresh_rate_type; + enum drrs_support_type type; +}; + +struct opregion_header; + +struct opregion_acpi; + +struct opregion_swsci; + +struct opregion_asle; + +struct intel_opregion { + struct opregion_header *header; + struct opregion_acpi *acpi; + struct opregion_swsci *swsci; + u32 swsci_gbda_sub_functions; + u32 swsci_sbcb_sub_functions; + struct opregion_asle *asle; + void *rvda; + const void *vbt; + u32 vbt_size; + u32 *lid_state; + struct work_struct asle_work; +}; + +struct sdvo_device_mapping { + u8 initialized; + u8 dvo_port; + u8 slave_addr; + u8 dvo_wiring; + u8 i2c_pin; + u8 ddc_pin; +}; + +struct intel_vbt_data { + struct drm_display_mode *lfp_lvds_vbt_mode; + struct drm_display_mode *sdvo_lvds_vbt_mode; + unsigned int int_tv_support: 1; + unsigned int lvds_dither: 1; + unsigned int lvds_vbt: 1; + unsigned int int_crt_support: 1; + unsigned int lvds_use_ssc: 1; + unsigned int display_clock_mode: 1; + unsigned int fdi_rx_polarity_inverted: 1; + unsigned int panel_type: 4; + int lvds_ssc_freq; + unsigned int bios_lvds_val; + enum drrs_support_type drrs_type; + struct { + int rate; + int lanes; + int preemphasis; + int vswing; + bool low_vswing; + bool initialized; + bool support; + int bpp; + struct edp_power_seq pps; + } edp; + struct { + bool full_link; + bool require_aux_wakeup; + int idle_frames; + enum psr_lines_to_wait lines_to_wait; + int tp1_wakeup_time; + int tp2_tp3_wakeup_time; + } psr; + struct { + u16 pwm_freq_hz; + bool present; + bool active_low_pwm; + u8 min_brightness; + } backlight; + struct { + u16 panel_id; + struct mipi_config *config; + struct mipi_pps_data *pps; + u8 seq_version; + u32 size; + u8 *data; + const u8 *sequence[12]; + } dsi; + int crt_ddc_pin; + int child_dev_num; + union child_device_config *child_dev; + struct ddi_vbt_port_info ddi_port_info[5]; + struct sdvo_device_mapping sdvo_mappings[2]; +}; + +struct i915_page_scratch; + +struct i915_page_table; + +struct i915_page_directory; + +struct i915_page_directory_pointer; + +struct i915_vma; + +struct i915_address_space { + struct drm_mm mm; + struct drm_device *dev; + struct list_head global_link; + u64 start; + u64 total; + bool is_ggtt; + struct i915_page_scratch *scratch_page; + struct i915_page_table *scratch_pt; + struct i915_page_directory *scratch_pd; + struct i915_page_directory_pointer *scratch_pdp; + struct list_head active_list; + struct list_head inactive_list; + gen6_pte_t (*pte_encode)(dma_addr_t, enum i915_cache_level, bool, u32); + int (*allocate_va_range)(struct i915_address_space *, uint64_t, uint64_t); + void (*clear_range)(struct i915_address_space *, uint64_t, uint64_t, bool); + void (*insert_entries)(struct i915_address_space *, struct sg_table *, uint64_t, enum i915_cache_level, u32); + void (*cleanup)(struct i915_address_space *); + void (*unbind_vma)(struct i915_vma *); + int (*bind_vma)(struct i915_vma *, enum i915_cache_level, u32); +}; + +struct io_mapping; + +struct i915_ggtt { + struct i915_address_space base; + size_t stolen_size; + size_t stolen_usable_size; + size_t stolen_reserved_base; + size_t stolen_reserved_size; + size_t size; + u64 mappable_end; + struct io_mapping *mappable; + phys_addr_t mappable_base; + void *gsm; + bool do_idle_maps; + int mtrr; + int (*probe)(struct i915_ggtt *); +}; + +struct shrink_control; + +struct shrinker { + long unsigned int (*count_objects)(struct shrinker *, struct shrink_control *); + long unsigned int (*scan_objects)(struct shrinker *, struct shrink_control *); + int seeks; + long int batch; + long unsigned int flags; + struct list_head list; + atomic_long_t *nr_deferred; +}; + +struct i915_hw_ppgtt; + +struct i915_gem_mm { + struct drm_mm stolen; + struct mutex___2 stolen_lock; + struct list_head bound_list; + struct list_head unbound_list; + long unsigned int stolen_base; + struct i915_hw_ppgtt *aliasing_ppgtt; + struct notifier_block oom_notifier; + struct notifier_block vmap_notifier; + struct shrinker shrinker; + bool shrinker_no_lock_stealing; + struct list_head fence_list; + struct delayed_work retire_work; + struct delayed_work idle_work; + bool interruptible; + bool busy; + unsigned int bsd_ring_dispatch_index; + uint32_t bit_6_swizzle_x; + uint32_t bit_6_swizzle_y; + spinlock_t object_stat_lock; + size_t object_memory; + u32 object_count; +}; + +struct intel_pipe_crc_entry; + +struct intel_pipe_crc { + spinlock_t lock; + bool opened; + struct intel_pipe_crc_entry *entries; + enum intel_pipe_crc_source source; + int head; + int tail; + wait_queue_head_t wq; +}; + +struct intel_dpll_hw_state { + uint32_t dpll; + uint32_t dpll_md; + uint32_t fp0; + uint32_t fp1; + uint32_t wrpll; + uint32_t spll; + uint32_t ctrl1; + uint32_t cfgcr1; + uint32_t cfgcr2; + uint32_t ebb0; + uint32_t ebb4; + uint32_t pll0; + uint32_t pll1; + uint32_t pll2; + uint32_t pll3; + uint32_t pll6; + uint32_t pll8; + uint32_t pll9; + uint32_t pll10; + uint32_t pcsdw12; +}; + +struct intel_shared_dpll_config { + unsigned int crtc_mask; + struct intel_dpll_hw_state hw_state; +}; + +struct intel_shared_dpll; + +struct intel_shared_dpll_funcs { + void (*mode_set)(struct drm_i915_private *, struct intel_shared_dpll *); + void (*enable)(struct drm_i915_private *, struct intel_shared_dpll *); + void (*disable)(struct drm_i915_private *, struct intel_shared_dpll *); + bool (*get_hw_state)(struct drm_i915_private *, struct intel_shared_dpll *, struct intel_dpll_hw_state *); +}; + +struct intel_shared_dpll { + struct intel_shared_dpll_config config; + unsigned int active_mask; + bool on; + const char *name; + enum intel_dpll_id id; + struct intel_shared_dpll_funcs funcs; + uint32_t flags; +}; + +struct i915_wa_reg { + i915_reg_t addr; + u32 value; + u32 mask; +}; + +struct i915_workarounds { + struct i915_wa_reg reg[28]; + u32 count; + u32 hw_whitelist_count[5]; +}; + +struct i915_frontbuffer_tracking { + struct mutex___2 lock; + unsigned int busy_bits; + unsigned int flip_bits; +}; + +struct intel_l3_parity { + u32 *remap_info[2]; + struct work_struct error_work; + int which_slice; +}; + +struct intel_rps_ei { + u32 cz_clock; + u32 render_c0; + u32 media_c0; +}; + +struct intel_gen6_power_mgmt { + struct work_struct work; + bool interrupts_enabled; + u32 pm_iir; + u8 cur_freq; + u8 min_freq_softlimit; + u8 max_freq_softlimit; + u8 max_freq; + u8 min_freq; + u8 idle_freq; + u8 efficient_freq; + u8 rp1_freq; + u8 rp0_freq; + u16 gpll_ref_freq; + u8 up_threshold; + u8 down_threshold; + int last_adj; + enum { + LOW_POWER = 0, + BETWEEN = 1, + HIGH_POWER = 2, + } power; + spinlock_t client_lock; + struct list_head clients; + bool client_boost; + bool enabled; + struct delayed_work delayed_resume_work; + unsigned int boosts; + struct intel_rps_client semaphores; + struct intel_rps_client mmioflips; + struct intel_rps_ei up_ei; + struct intel_rps_ei down_ei; + struct mutex___2 hw_lock; +}; + +struct intel_ilk_power_mgmt { + u8 cur_delay; + u8 min_delay; + u8 max_delay; + u8 fmax; + u8 fstart; + u64 last_count1; + long unsigned int last_time1; + long unsigned int chipset_power; + u64 last_count2; + u64 last_time2; + long unsigned int gfx_power; + u8 corr; + int c_m; + int r_t; +}; + +struct i915_power_well; + +struct i915_power_domains { + bool init_power_on; + bool initializing; + int power_well_count; + struct mutex___2 lock; + int domain_use_count[30]; + struct i915_power_well *power_wells; +}; + +struct i915_psr { + struct mutex___2 lock; + bool sink_support; + bool source_ok; + struct intel_dp *enabled; + bool active; + struct delayed_work work; + unsigned int busy_frontbuffer_bits; + bool psr2_support; + bool aux_frame_sync; + bool link_standby; +}; + +struct i915_gpu_error { + struct workqueue_struct *hangcheck_wq; + struct delayed_work hangcheck_work; + spinlock_t lock; + struct drm_i915_error_state *first_error; + long unsigned int missed_irq_rings; + atomic_t reset_counter; + wait_queue_head_t reset_queue; + u32 stop_rings; + unsigned int test_irq_rings; +}; + +struct i915_suspend_saved_registers { + u32 saveDSPARB; + u32 saveLVDS; + u32 savePP_ON_DELAYS; + u32 savePP_OFF_DELAYS; + u32 savePP_ON; + u32 savePP_OFF; + u32 savePP_CONTROL; + u32 savePP_DIVISOR; + u32 saveFBC_CONTROL; + u32 saveCACHE_MODE_0; + u32 saveMI_ARB_STATE; + u32 saveSWF0[16]; + u32 saveSWF1[16]; + u32 saveSWF3[3]; + uint64_t saveFENCE[32]; + u32 savePCH_PORT_HOTPLUG; + u16 saveGCDGMBUS; +}; + +struct vlv_s0ix_state { + u32 wr_watermark; + u32 gfx_prio_ctrl; + u32 arb_mode; + u32 gfx_pend_tlb0; + u32 gfx_pend_tlb1; + u32 lra_limits[13]; + u32 media_max_req_count; + u32 gfx_max_req_count; + u32 render_hwsp; + u32 ecochk; + u32 bsd_hwsp; + u32 blt_hwsp; + u32 tlb_rd_addr; + u32 g3dctl; + u32 gsckgctl; + u32 mbctl; + u32 ucgctl1; + u32 ucgctl3; + u32 rcgctl1; + u32 rcgctl2; + u32 rstctl; + u32 misccpctl; + u32 gfxpause; + u32 rpdeuhwtc; + u32 rpdeuc; + u32 ecobus; + u32 pwrdwnupctl; + u32 rp_down_timeout; + u32 rp_deucsw; + u32 rcubmabdtmr; + u32 rcedata; + u32 spare2gh; + u32 gt_imr; + u32 gt_ier; + u32 pm_imr; + u32 pm_ier; + u32 gt_scratch[8]; + u32 tilectl; + u32 gt_fifoctl; + u32 gtlc_wake_ctrl; + u32 gtlc_survive; + u32 pmwgicz; + u32 gu_ctl0; + u32 gu_ctl1; + u32 pcbr; + u32 clock_gate_dis2; +}; + +struct intel_wm_config { + unsigned int num_pipes_active; + bool sprites_enabled; + bool sprites_scaled; +}; + +struct skl_ddb_entry { + uint16_t start; + uint16_t end; +}; + +struct skl_ddb_allocation { + struct skl_ddb_entry pipe[3]; + struct skl_ddb_entry plane[12]; + struct skl_ddb_entry y_plane[12]; +}; + +struct skl_wm_values { + bool dirty[3]; + struct skl_ddb_allocation ddb; + uint32_t wm_linetime[3]; + uint32_t plane[96]; + uint32_t plane_trans[12]; +}; + +struct ilk_wm_values { + uint32_t wm_pipe[3]; + uint32_t wm_lp[3]; + uint32_t wm_lp_spr[3]; + uint32_t wm_linetime[3]; + bool enable_fbc_wm; + enum intel_ddb_partitioning partitioning; +}; + +struct vlv_pipe_wm { + uint16_t primary; + uint16_t sprite[2]; + uint8_t cursor; +}; + +struct vlv_sr_wm { + uint16_t plane; + uint8_t cursor; +}; + +struct vlv_wm_values { + struct vlv_pipe_wm pipe[3]; + struct vlv_sr_wm sr; + struct { + uint8_t cursor; + uint8_t sprite[2]; + uint8_t primary; + } ddl[3]; + uint8_t level; + bool cxsr; +}; + +struct i915_runtime_pm { + atomic_t wakeref_count; + atomic_t atomic_seq; + bool suspended; + bool irqs_enabled; +}; + +struct intel_overlay; + +struct intel_dpll_mgr; + +struct intel_fbdev; + +struct i915_execbuffer_params; + +struct drm_i915_private { + struct drm_device *dev; + struct kmem_cache *objects; + struct kmem_cache *vmas; + struct kmem_cache *requests; + const struct intel_device_info info; + int relative_constants_mode; + void *regs; + struct intel_uncore uncore; + struct i915_virtual_gpu vgpu; + struct intel_guc guc; + struct intel_csr csr; + struct intel_gmbus gmbus[7]; + struct mutex___2 gmbus_mutex; + uint32_t gpio_mmio_base; + uint32_t mipi_mmio_base; + uint32_t psr_mmio_base; + wait_queue_head_t gmbus_wait_queue; + struct pci_dev *bridge_dev; + struct intel_engine_cs engine[5]; + struct drm_i915_gem_object *semaphore_obj; + uint32_t last_seqno; + uint32_t next_seqno; + struct drm_dma_handle *status_page_dmah; + struct resource mch_res; + spinlock_t irq_lock; + spinlock_t mmio_flip_lock; + bool display_irqs_enabled; + struct pm_qos_request pm_qos; + struct mutex___2 sb_lock; + union { + u32 irq_mask; + u32 de_irq_mask[3]; + }; + u32 gt_irq_mask; + u32 pm_irq_mask; + u32 pm_rps_events; + u32 pipestat_irq_mask[3]; + struct i915_hotplug hotplug; + struct intel_fbc fbc; + struct i915_drrs drrs; + struct intel_opregion opregion; + struct intel_vbt_data vbt; + bool preserve_bios_swizzle; + struct intel_overlay *overlay; + struct mutex___2 backlight_lock; + bool no_aux_handshake; + struct mutex___2 pps_mutex; + struct drm_i915_fence_reg fence_regs[32]; + int num_fence_regs; + unsigned int fsb_freq; + unsigned int mem_freq; + unsigned int is_ddr3; + unsigned int skl_boot_cdclk; + unsigned int cdclk_freq; + unsigned int max_cdclk_freq; + unsigned int atomic_cdclk_freq; + unsigned int max_dotclk_freq; + unsigned int rawclk_freq; + unsigned int hpll_freq; + unsigned int czclk_freq; + struct workqueue_struct *wq; + struct drm_i915_display_funcs display; + enum intel_pch pch_type; + short unsigned int pch_id; + long unsigned int quirks; + enum modeset_restore modeset_restore; + struct mutex___2 modeset_restore_lock; + struct drm_atomic_state *modeset_restore_state; + struct list_head vm_list; + struct i915_ggtt ggtt; + struct i915_gem_mm mm; + struct hlist_head mm_structs[128]; + struct mutex___2 mm_lock; + struct drm_crtc *plane_to_crtc_mapping[3]; + struct drm_crtc *pipe_to_crtc_mapping[3]; + wait_queue_head_t pending_flip_queue; + struct intel_pipe_crc pipe_crc[3]; + int num_shared_dpll; + struct intel_shared_dpll shared_dplls[6]; + const struct intel_dpll_mgr *dpll_mgr; + struct mutex___2 dpll_lock; + unsigned int active_crtcs; + unsigned int min_pixclk[3]; + int dpio_phy_iosf_port[2]; + struct i915_workarounds workarounds; + struct i915_frontbuffer_tracking fb_tracking; + u16 orig_clock; + bool mchbar_need_disable; + struct intel_l3_parity l3_parity; + u32 edram_cap; + struct intel_gen6_power_mgmt rps; + struct intel_ilk_power_mgmt ips; + struct i915_power_domains power_domains; + struct i915_psr psr; + struct i915_gpu_error gpu_error; + struct drm_i915_gem_object *vlv_pctx; + struct intel_fbdev *fbdev; + struct work_struct fbdev_suspend_work; + struct drm_property *broadcast_rgb_property; + struct drm_property *force_audio_property; + struct i915_audio_component *audio_component; + bool audio_component_registered; + struct mutex___2 av_mutex; + uint32_t hw_context_size; + struct list_head context_list; + u32 fdi_rx_config; + u32 chv_phy_control; + u32 chv_dpll_md[3]; + u32 bxt_phy_grc; + u32 suspend_count; + bool suspended_to_idle; + struct i915_suspend_saved_registers regfile; + struct vlv_s0ix_state vlv_s0ix_state; + struct { + uint16_t pri_latency[5]; + uint16_t spr_latency[5]; + uint16_t cur_latency[5]; + uint16_t skl_latency[8]; + struct intel_wm_config config; + struct skl_wm_values skl_results; + union { + struct ilk_wm_values hw; + struct skl_wm_values skl_hw; + struct vlv_wm_values vlv; + }; + uint8_t max_level; + struct mutex___2 wm_mutex; + } wm; + struct i915_runtime_pm pm; + struct { + int (*execbuf_submit)(struct i915_execbuffer_params *, struct drm_i915_gem_execbuffer2 *, struct list_head *); + int (*init_engines)(struct drm_device *); + void (*cleanup_engine)(struct intel_engine_cs *); + void (*stop_engine)(struct intel_engine_cs *); + } gt; + struct intel_context *kernel_context; + bool chv_phy_assert[2]; + struct intel_encoder *dig_port_map[5]; +}; + +struct drm_i915_reg_descriptor { + i915_reg_t addr; + u32 mask; + u32 value; +}; + +struct drm_i915_reg_read { + __u64 offset; + __u64 val; +}; + +struct drm_i915_reg_table { + const struct drm_i915_reg_descriptor *regs; + int num_regs; + bool master; +}; + +struct drm_i915_reset_stats { + __u32 ctx_id; + __u32 flags; + __u32 reset_count; + __u32 batch_active; + __u32 batch_pending; + __u32 pad; +}; + +struct drm_info_list { + const char *name; + int (*show)(struct seq_file___2 *, void *); + u32 driver_features; + void *data; +}; + +struct drm_info_node { + struct list_head list; + struct drm_minor *minor; + const struct drm_info_list *info_ent; + struct dentry *dent; +}; + +struct drm_intel_overlay_attrs { + __u32 flags; + __u32 color_key; + __s32 brightness; + __u32 contrast; + __u32 saturation; + __u32 gamma0; + __u32 gamma1; + __u32 gamma2; + __u32 gamma3; + __u32 gamma4; + __u32 gamma5; +}; + +struct drm_intel_overlay_put_image { + __u32 flags; + __u32 bo_handle; + __u16 stride_Y; + __u16 stride_UV; + __u32 offset_Y; + __u32 offset_U; + __u32 offset_V; + __u16 src_width; + __u16 src_height; + __u16 src_scan_width; + __u16 src_scan_height; + __u32 crtc_id; + __u16 dst_x; + __u16 dst_y; + __u16 dst_width; + __u16 dst_height; +}; + +struct drm_intel_sprite_colorkey { + __u32 plane_id; + __u32 min_value; + __u32 channel_mask; + __u32 max_value; + __u32 flags; +}; + +typedef int drm_ioctl_t(struct drm_device *, void *, struct drm_file *); + +struct drm_ioctl_desc { + unsigned int cmd; + int flags; + drm_ioctl_t *func; + const char *name; +}; + +struct drm_irq_busid { + int irq; + int busnum; + int devnum; + int funcnum; +}; + +struct drm_lock { + int context; + enum drm_lock_flags flags; +}; + +struct drm_lock_data { + struct drm_hw_lock *hw_lock; + struct drm_file *file_priv; + wait_queue_head_t lock_queue; + long unsigned int lock_time; + spinlock_t spinlock; + uint32_t kernel_waiters; + uint32_t user_waiters; + int idle_has_lock; +}; + +struct drm_map { + long unsigned int offset; + long unsigned int size; + enum drm_map_type type; + enum drm_map_flags flags; + void *handle; + int mtrr; +}; + +struct drm_map32 { + u32 offset; + u32 size; + enum drm_map_type type; + enum drm_map_flags flags; + u32 handle; + int mtrr; +}; + +typedef struct drm_map32 drm_map32_t; + +struct drm_map_list { + struct list_head head; + struct drm_hash_item hash; + struct drm_local_map *map; + uint64_t user_token; + struct drm_master *master; +}; + +struct drm_master { + struct kref refcount; + struct drm_minor *minor; + char *unique; + int unique_len; + struct idr magic_map; + struct drm_lock_data lock; + void *driver_priv; +}; + +struct drm_minor { + int index; + int type; + struct device *kdev; + struct drm_device *dev; + struct dentry *debugfs_root; + struct list_head debugfs_list; + struct mutex___2 debugfs_lock; + struct drm_master *master; +}; + +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_fb_cmd2; + +struct drm_mode_config_funcs { + struct drm_framebuffer * (*fb_create)(struct drm_device *, struct drm_file *, const struct drm_mode_fb_cmd2 *); + void (*output_poll_changed)(struct drm_device *); + 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_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_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 { + __u32 crtc_id; + __u32 fb_id; + __u32 flags; + __u32 reserved; + __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_cmd232 { + u32 fb_id; + u32 width; + u32 height; + u32 pixel_format; + u32 flags; + u32 handles[4]; + u32 pitches[4]; + u32 offsets[4]; + u64 modifier[4]; +} __attribute__((packed)); + +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_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_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_rmfb_work { + struct work_struct work; + struct list_head fbs; +}; + +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 ww_acquire_ctx { + struct task_struct *task; + long unsigned int stamp; + unsigned int acquired; +}; + +struct drm_modeset_acquire_ctx { + struct ww_acquire_ctx ww_ctx; + struct drm_modeset_lock *contended; + struct list_head locked; + bool trylock_only; +}; + +struct drm_modeset_ctl { + __u32 crtc; + __u32 cmd; +}; + +struct drm_panel_funcs; + +struct drm_panel { + struct drm_device *drm; + struct drm_connector *connector; + struct device___2 *dev; + const struct drm_panel_funcs *funcs; + struct list_head list; +}; + +struct display_timing; + +struct drm_panel_funcs { + int (*disable)(struct drm_panel *); + int (*unprepare)(struct drm_panel *); + int (*prepare)(struct drm_panel *); + int (*enable)(struct drm_panel *); + int (*get_modes)(struct drm_panel *); + int (*get_timings)(struct drm_panel *, unsigned int, struct display_timing *); +}; + +struct drm_pending_event { + struct drm_event *event; + struct list_head link; + struct list_head pending_link; + struct drm_file *file_priv; + pid_t pid; + void (*destroy)(struct drm_pending_event *); +}; + +struct drm_pending_vblank_event { + struct drm_pending_event base; + unsigned int pipe; + struct drm_event_vblank event; +}; + +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; + 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; + const struct drm_plane_helper_funcs *helper_private; + struct drm_plane_state *state; +}; + +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); + int (*disable_plane)(struct drm_plane *); + 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 *); +}; + +struct drm_plane_helper_funcs { + int (*prepare_fb)(struct drm_plane *, const struct drm_plane_state *); + void (*cleanup_fb)(struct drm_plane *, const struct drm_plane_state *); + int (*atomic_check)(struct drm_plane *, struct drm_plane_state *); + void (*atomic_update)(struct drm_plane *, struct drm_plane_state *); + void (*atomic_disable)(struct drm_plane *, struct drm_plane_state *); +}; + +struct drm_plane_state { + struct drm_plane *plane; + struct drm_crtc *crtc; + struct drm_framebuffer *fb; + struct 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; + unsigned int rotation; + struct drm_atomic_state *state; +}; + +struct drm_prime_attachment { + struct sg_table *sgt; + enum dma_data_direction dir; +}; + +struct drm_prime_handle { + __u32 handle; + __u32 flags; + __s32 fd; +}; + +struct drm_prime_member { + struct list_head entry; + struct dma_buf *dma_buf; + uint32_t handle; +}; + +struct drm_prop_enum_list { + int type; + 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; + unsigned char data[0]; +}; + +struct drm_property_enum { + uint64_t value; + struct list_head head; + char name[32]; +}; + +struct drm_rect { + int x1; + int y1; + int x2; + int y2; +}; + +struct drm_scatter_gather { + long unsigned int size; + long unsigned int handle; +}; + +struct drm_scatter_gather32 { + u32 size; + u32 handle; +}; + +typedef struct drm_scatter_gather32 drm_scatter_gather32_t; + +struct drm_set_client_cap { + __u64 capability; + __u64 value; +}; + +struct drm_set_version { + int drm_di_major; + int drm_di_minor; + int drm_dd_major; + int drm_dd_minor; +}; + +struct drm_sg_mem { + long unsigned int handle; + void *virtual; + int pages; + struct page **pagelist; + dma_addr_t *busaddr; +}; + +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_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_update_draw { + drm_drawable_t handle; + unsigned int type; + unsigned int num; + long long unsigned int data; +}; + +struct drm_update_draw32 { + drm_drawable_t handle; + unsigned int type; + unsigned int num; + u64 data; +} __attribute__((packed)); + +typedef struct drm_update_draw32 drm_update_draw32_t; + +struct drm_vblank_crtc { + struct drm_device *dev; + wait_queue_head_t queue; + struct timer_list disable_timer; + u32 count; + struct timeval time[2]; + atomic_t refcount; + u32 last; + u32 last_wait; + unsigned int inmodeset; + unsigned int pipe; + int framedur_ns; + int linedur_ns; + bool enabled; +}; + +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_virtgpu_3d_box { + __u32 x; + __u32 y; + __u32 z; + __u32 w; + __u32 h; + __u32 d; +}; + +struct drm_virtgpu_3d_transfer_from_host { + __u32 bo_handle; + struct drm_virtgpu_3d_box box; + __u32 level; + __u32 offset; +}; + +struct drm_virtgpu_3d_transfer_to_host { + __u32 bo_handle; + struct drm_virtgpu_3d_box box; + __u32 level; + __u32 offset; +}; + +struct drm_virtgpu_3d_wait { + __u32 handle; + __u32 flags; +}; + +struct drm_virtgpu_execbuffer { + __u32 flags; + __u32 size; + __u64 command; + __u64 bo_handles; + __u32 num_bo_handles; + __u32 pad; +}; + +struct drm_virtgpu_get_caps { + __u32 cap_set_id; + __u32 cap_set_ver; + __u64 addr; + __u32 size; + __u32 pad; +}; + +struct drm_virtgpu_getparam { + __u64 param; + __u64 value; +}; + +struct drm_virtgpu_map { + __u64 offset; + __u32 handle; + __u32 pad; +}; + +struct drm_virtgpu_resource_create { + __u32 target; + __u32 format; + __u32 bind; + __u32 width; + __u32 height; + __u32 depth; + __u32 array_size; + __u32 last_level; + __u32 nr_samples; + __u32 flags; + __u32 bo_handle; + __u32 res_handle; + __u32 size; + __u32 stride; +}; + +struct drm_virtgpu_resource_info { + __u32 bo_handle; + __u32 res_handle; + __u32 size; + __u32 stride; +}; + +struct drm_vma_entry { + struct list_head head; + struct vm_area_struct *vma; + pid_t pid; +}; + +struct drm_vma_offset_file { + struct rb_node vm_rb; + struct file *vm_filp; + long unsigned int vm_count; +}; + +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 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 dn_route; + +struct dst_ops; + +struct lwtunnel_state; + +struct rtable; + +struct rt6_info; + +struct dst_entry { + struct callback_head callback_head; + struct dst_entry *child; + struct net_device *dev; + struct dst_ops *ops; + long unsigned int _metrics; + long unsigned int expires; + struct dst_entry *path; + struct dst_entry *from; + void *__pad1; + int (*input)(struct sk_buff *); + int (*output)(struct net *, struct sock *, struct sk_buff *); + short unsigned int flags; + short unsigned int pending_confirm; + short int error; + short int obsolete; + short unsigned int header_len; + short unsigned int trailer_len; + __u32 __pad2; + long int __pad_to_align_refcnt[2]; + atomic_t __refcnt; + int __use; + long unsigned int lastuse; + struct lwtunnel_state *lwtstate; + union { + struct dst_entry *next; + struct rtable *rt_next; + struct rt6_info *rt6_next; + struct dn_route *dn_next; + }; +}; + +struct neighbour; + +struct dst_ops { + short unsigned int family; + unsigned int gc_thresh; + int (*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 *, int); + struct dst_entry * (*negative_advice)(struct dst_entry *); + void (*link_failure)(struct sk_buff *); + void (*update_pmtu)(struct dst_entry *, struct sock *, struct sk_buff *, u32); + 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 *); + struct kmem_cache *kmem_cachep; + long: 64; + struct percpu_counter pcpuc_entries; + long: 64; + long: 64; + long: 64; +}; + +struct dw_dma_slave { + struct device *dma_dev; + u8 src_id; + u8 dst_id; + u8 m_master; + u8 p_master; +}; + +struct dyn_arch_ftrace {}; + +struct dyn_ftrace { + long unsigned int ip; + long unsigned int flags; + struct dyn_arch_ftrace arch; +}; + +struct e820map { + __u32 nr_map; + struct e820entry map[320]; +}; + +struct platform_driver; + +struct early_platform_driver { + const char *class_str; + struct platform_driver *pdrv; + struct list_head list; + int requested_id; + char *buffer; + int bufsize; +}; + +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; + __u32 padding[5]; +}; + +struct ktermios; + +struct uart_state; + +struct uart_ops; + +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 *, struct ktermios *); + unsigned int (*get_mctrl)(struct uart_port *); + void (*set_mctrl)(struct uart_port *, 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 serial_rs485 *); + 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 unused1; + unsigned int read_status_mask; + unsigned int ignore_status_mask; + struct uart_state *state; + struct uart_icount icount; + struct console *cons; + long unsigned int sysrq; + upf_t flags; + upstat_t status; + int hw_stopped; + unsigned int mctrl; + unsigned int timeout; + 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; + unsigned char hub6; + unsigned char suspended; + unsigned char irq_wake; + unsigned char unused[2]; + struct attribute_group *attr_group; + const struct attribute_group **tty_groups; + struct serial_rs485 rs485; + void *private_data; +}; + +struct earlycon_device { + struct console *con; + struct uart_port port; + char options[16]; + unsigned int baud; +}; + +struct earlycon_id { + char name[16]; + char compatible[128]; + int (*setup)(struct earlycon_device *, const char *); + long: 64; +}; + +struct eb_vmas { + struct list_head vmas; + int and; + union { + struct i915_vma *lut[0]; + struct hlist_head buckets[0]; + }; +}; + +struct est_timings { + u8 t1; + u8 t2; + u8 mfg_rsvd; +}; + +struct edid { + u8 header[8]; + u8 mfg_id[2]; + u8 prod_code[2]; + u32 serial; + u8 mfg_week; + u8 mfg_year; + u8 version; + u8 revision; + u8 input; + u8 width_cm; + u8 height_cm; + u8 gamma; + u8 features; + u8 red_green_lo; + u8 black_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 { + char vendor[4]; + int product_id; + u32 quirks; +}; + +struct edp_sdp_header { + u8 HB0; + u8 HB1; + u8 HB2; + u8 HB3; +}; + +struct edp_vsc_psr { + struct edp_sdp_header sdp_header; + u8 DB0; + u8 DB1; + u8 DB2; + u8 DB3; + u8 DB4; + u8 DB5; + u8 DB6; + u8 DB7; + u8 DB8_31[24]; +}; + +struct eeepc_cpufv { + int num; + int cur; +}; + +struct rfkill; + +struct led_trigger; + +struct led_classdev { + const char *name; + enum led_brightness brightness; + enum led_brightness max_brightness; + int 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 *); + struct device___2 *dev; + const struct attribute_group___2 **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; + void (*flash_resume)(struct led_classdev *); + struct work_struct set_brightness_work; + int delayed_set_value; + struct rw_semaphore___2 trigger_lock; + struct led_trigger *trigger; + struct list_head trig_list; + void *trigger_data; + bool activated; + struct mutex___2 led_access; +}; + +struct hotplug_slot; + +struct eeepc_laptop { + acpi_handle handle; + u32 cm_supported; + bool cpufv_disabled; + bool hotplug_disabled; + u16 event_count[128]; + struct platform_device *platform_device; + struct acpi_device *device; + struct backlight_device *backlight_device; + struct input_dev *inputdev; + struct rfkill *wlan_rfkill; + struct rfkill *bluetooth_rfkill; + struct rfkill *wwan3g_rfkill; + struct rfkill *wimax_rfkill; + struct hotplug_slot *hotplug_slot; + struct mutex hotplug_lock; + struct led_classdev tpd_led; + int tpd_led_wk; + struct workqueue_struct *led_workqueue; + struct work_struct tpd_led_work; +}; + +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 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_query_variable_info_t(u32, u64 *, u64 *, u64 *); + +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_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_set_virtual_address_map_t(long unsigned int, long unsigned int, u32, efi_memory_desc_t *); + +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; +}; + +struct efi { + efi_system_table_t *systab; + unsigned int runtime_version; + long unsigned int mps; + long unsigned int acpi; + long unsigned int acpi20; + long unsigned int smbios; + long unsigned int smbios3; + long unsigned int sal_systab; + long unsigned int boot_info; + long unsigned int hcdp; + long unsigned int uga; + long unsigned int uv_systab; + long unsigned int fw_vendor; + long unsigned int runtime; + long unsigned int config_table; + long unsigned int esrt; + long unsigned int properties_table; + long unsigned int mem_attr_table; + 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; + efi_set_virtual_address_map_t *set_virtual_address_map; + struct efi_memory_map memmap; + long unsigned int flags; +}; + +struct efi_generic_dev_path { + u8 type; + u8 sub_type; + u16 length; +}; + +struct efi_runtime_map_entry { + efi_memory_desc_t md; + struct kobject kobj; +}; + +struct efi_scratch { + u64 r15; + u64 prev_cr3; + pgd_t *efi_pgt; + bool use_pgd; + u64 phys_stack; +} __attribute__((packed)); + +struct efi_setup_data { + u64 fw_vendor; + u64 runtime; + u64 tables; + u64 smbios; + u64 reserved[8]; +}; + +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_variable { + efi_char16_t VariableName[512]; + efi_guid_t VendorGuid; + long unsigned int DataSize; + __u8 Data[1024]; + efi_status_t Status; + __u32 Attributes; +} __attribute__((packed)); + +struct efifb_dmi_info { + char *optname; + long unsigned int base; + int stride; + int width; + int height; + int flags; +}; + +struct efivar_entry; + +struct efivar_attribute { + struct attribute attr; + ssize_t (*show)(struct efivar_entry *, char *); + ssize_t (*store)(struct efivar_entry *, const char *, size_t); +}; + +struct efivar_entry { + struct efi_variable var; + struct list_head list; + struct kobject kobj; + bool scanning; + bool deleting; +}; + +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; +}; + +struct efivars { + spinlock_t lock; + struct kset *kset; + struct kobject *kobject; + const struct efivar_operations *ops; +}; + +struct ehci_caps { + u32 hc_capbase; + u32 hcs_params; + u32 hcc_params; + u8 portroute[8]; +}; + +struct ehci_dbg_port { + u32 control; + u32 pids; + u32 data03; + u32 data47; + u32 address; +}; + +struct ehci_dev { + u32 bus; + u32 slot; + u32 func; +}; + +struct ehci_regs { + u32 command; + u32 status; + u32 intr_enable; + u32 frame_index; + u32 segment; + u32 frame_list; + u32 async_next; + u32 reserved1[2]; + u32 txfill_tuning; + u32 reserved2[6]; + u32 configured_flag; + u32 port_status[0]; + u32 reserved3[9]; + u32 usbmode; + u32 reserved4[6]; + u32 hostpc[1]; + u32 reserved5[16]; + u32 usbmode_ex; +}; + +typedef int elevator_merge_fn(struct request_queue *, struct request **, struct bio *); + +typedef void elevator_merged_fn(struct request_queue *, struct request *, int); + +typedef void elevator_merge_req_fn(struct request_queue *, struct request *, struct request *); + +typedef int elevator_allow_merge_fn(struct request_queue *, struct request *, struct bio *); + +typedef void elevator_bio_merged_fn(struct request_queue *, struct request *, struct bio *); + +typedef int elevator_dispatch_fn(struct request_queue *, int); + +typedef void elevator_add_req_fn(struct request_queue *, struct request *); + +typedef void elevator_activate_req_fn(struct request_queue *, struct request *); + +typedef void elevator_deactivate_req_fn(struct request_queue *, struct request *); + +typedef void elevator_completed_req_fn(struct request_queue *, struct request *); + +typedef struct request *elevator_request_list_fn(struct request_queue *, struct request *); + +typedef void elevator_init_icq_fn(struct io_cq *); + +typedef void elevator_exit_icq_fn(struct io_cq *); + +typedef int elevator_set_req_fn(struct request_queue *, struct request *, struct bio *, gfp_t); + +typedef void elevator_put_req_fn(struct request *); + +typedef int elevator_may_queue_fn(struct request_queue *, int); + +struct elevator_type; + +typedef int elevator_init_fn(struct request_queue *, struct elevator_type *); + +struct elevator_queue; + +typedef void elevator_exit_fn(struct elevator_queue *); + +typedef void elevator_registered_fn(struct request_queue *); + +struct elevator_ops { + elevator_merge_fn *elevator_merge_fn; + elevator_merged_fn *elevator_merged_fn; + elevator_merge_req_fn *elevator_merge_req_fn; + elevator_allow_merge_fn *elevator_allow_merge_fn; + elevator_bio_merged_fn *elevator_bio_merged_fn; + elevator_dispatch_fn *elevator_dispatch_fn; + elevator_add_req_fn *elevator_add_req_fn; + elevator_activate_req_fn *elevator_activate_req_fn; + elevator_deactivate_req_fn *elevator_deactivate_req_fn; + elevator_completed_req_fn *elevator_completed_req_fn; + elevator_request_list_fn *elevator_former_req_fn; + elevator_request_list_fn *elevator_latter_req_fn; + elevator_init_icq_fn *elevator_init_icq_fn; + elevator_exit_icq_fn *elevator_exit_icq_fn; + elevator_set_req_fn *elevator_set_req_fn; + elevator_put_req_fn *elevator_put_req_fn; + elevator_may_queue_fn *elevator_may_queue_fn; + elevator_init_fn *elevator_init_fn; + elevator_exit_fn *elevator_exit_fn; + elevator_registered_fn *elevator_registered_fn; +}; + +struct elevator_queue { + struct elevator_type *type; + void *elevator_data; + struct kobject kobj; + struct mutex sysfs_lock; + unsigned int registered: 1; + struct hlist_head hash[64]; +}; + +struct elv_fs_entry; + +struct elevator_type { + struct kmem_cache *icq_cache; + struct elevator_ops ops; + size_t icq_size; + size_t icq_align; + struct elv_fs_entry *elevator_attrs; + char elevator_name[16]; + struct module *elevator_owner; + char icq_cache_name[21]; + 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; +}; + +union sigval { + int sival_int; + void *sival_ptr; +}; + +typedef union sigval sigval_t; + +struct siginfo { + int si_signo; + int si_errno; + int si_code; + union { + int _pad[28]; + struct { + __kernel_pid_t _pid; + __kernel_uid32_t _uid; + } _kill; + struct { + __kernel_timer_t _tid; + int _overrun; + char _pad[0]; + 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; + short int _addr_lsb; + union { + struct { + void *_lower; + void *_upper; + } _addr_bnd; + __u32 _pkey; + }; + } _sigfault; + struct { + long int _band; + int _fd; + } _sigpoll; + struct { + void *_call_addr; + int _syscall; + unsigned int _arch; + } _sigsys; + } _sifields; +}; + +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; + siginfo_t csigdata; + size_t size; + int thread_notes; +}; + +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; + compat_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 { + 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 timeval pr_utime; + struct timeval pr_stime; + struct timeval pr_cutime; + struct timeval pr_cstime; + elf_gregset_t pr_reg; + int pr_fpvalid; +}; + +struct elf_thread_core_info { + struct elf_thread_core_info *next; + struct task_struct___2 *task; + struct elf_prstatus prstatus; + struct memelfnote notes[0]; +}; + +struct elf_thread_core_info___2 { + struct elf_thread_core_info___2 *next; + struct task_struct___2 *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 trace_event_file; + +struct enable_trigger_data { + struct trace_event_file *file; + bool enable; + bool hist; +}; + +struct poolinfo; + +struct entropy_store { + const struct poolinfo *poolinfo; + __u32 *pool; + const char *name; + struct entropy_store *pull; + struct work_struct push_work; + long unsigned int last_pulled; + spinlock_t lock; + short unsigned int add_ptr; + short unsigned int input_rotate; + int entropy_count; + int entropy_total; + unsigned int initialized: 1; + unsigned int limit: 1; + unsigned int last_data_init: 1; + __u8 last_data[10]; +}; + +struct entry { + struct entry *next; + void *timer; + void *start_func; + void *expire_func; + pid_t pid; + long unsigned int count; + u32 flags; + char comm[17]; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; +}; + +union entry_union { + struct { + u32 w1; + u32 w2; + }; + struct IO_APIC_route_entry entry; +}; + +struct poll_table_struct; + +typedef void (*poll_queue_proc)(struct file___2 *, wait_queue_head_t *, struct poll_table_struct *); + +struct poll_table_struct { + poll_queue_proc _qproc; + long unsigned int _key; +}; + +typedef struct poll_table_struct poll_table; + +struct epitem; + +struct ep_pqueue { + poll_table pt; + struct epitem *epi; +}; + +struct epoll_event; + +struct ep_send_events_data { + int maxevents; + struct epoll_event *events; +}; + +struct epoll_filefd { + struct file *file; + int fd; +} __attribute__((packed)); + +struct epoll_event { + __u32 events; + __u64 data; +} __attribute__((packed)); + +struct eventpoll; + +struct epitem { + union { + struct rb_node rbn; + struct callback_head rcu; + }; + struct list_head rdllink; + struct epitem *next; + struct epoll_filefd ffd; + int nwait; + struct list_head pwqlist; + struct eventpoll *ep; + struct list_head fllink; + struct wakeup_source *ws; + struct epoll_event event; +}; + +struct eppoll_entry { + struct list_head llink; + struct epitem *base; + wait_queue_t wait; + wait_queue_head_t *whead; +}; + +struct equiv_cpu_entry { + u32 installed_cpu; + u32 fixed_errata_mask; + u32 fixed_errata_compare; + u16 equiv_cpu; + u16 res; +}; + +struct er_account { + raw_spinlock_t lock; + u64 config; + u64 reg; + atomic_t ref; +}; + +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 errormap { + char *name; + int val; + int namelen; + struct hlist_node list; +}; + +struct fastop; + +struct x86_emulate_ctxt; + +struct group_dual; + +struct gprefix; + +struct escape; + +struct instr_dual; + +struct mode_dual; + +struct opcode { + u64 flags: 56; + u64 intercept: 8; + union { + int (*execute)(struct x86_emulate_ctxt *); + const struct opcode *group; + const struct group_dual *gdual; + const struct gprefix *gprefix; + const struct escape *esc; + const struct instr_dual *idual; + const struct mode_dual *mdual; + void (*fastop)(struct fastop *); + } u; + int (*check_perm)(struct x86_emulate_ctxt *); +}; + +struct escape { + struct opcode op[8]; + struct opcode high[64]; +}; + +struct eseqiv_ctx { + spinlock_t lock; + unsigned int reqoff; + char salt[0]; +}; + +struct eseqiv_request_ctx { + struct scatterlist src[2]; + struct scatterlist dst[2]; + char tail[0]; +}; + +struct esre_entry; + +struct esre_attribute { + struct attribute attr; + ssize_t (*show)(struct esre_entry *, char *); + ssize_t (*store)(struct esre_entry *, const char *, size_t); +}; + +struct esre_entry { + union { + struct efi_system_resource_entry_v1 *esre1; + } esre; + struct kobject kobj; + struct list_head list; +}; + +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 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_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 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_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_flash { + __u32 cmd; + __u32 region; + char data[128]; +}; + +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_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; + __u32 reserved[8]; + __u32 link_mode_masks[0]; +}; + +struct ethtool_link_ksettings { + struct ethtool_link_settings base; + struct { + long unsigned int supported[1]; + long unsigned int advertising[1]; + long unsigned int lp_advertising[1]; + } link_modes; +}; + +struct ethtool_link_usettings { + struct ethtool_link_settings base; + struct { + __u32 supported[2]; + __u32 advertising[2]; + __u32 lp_advertising[2]; + } link_modes; +}; + +struct ethtool_modinfo { + __u32 cmd; + __u32 type; + __u32 eeprom_len; + __u32 reserved[8]; +}; + +struct ethtool_regs; + +struct ethtool_wolinfo; + +struct ethtool_ringparam; + +struct ethtool_pauseparam; + +struct ethtool_test; + +struct ethtool_stats; + +struct ethtool_rxnfc; + +struct ethtool_ts_info; + +struct ethtool_tunable; + +struct ethtool_ops { + int (*get_settings)(struct net_device *, struct ethtool_cmd *); + int (*set_settings)(struct net_device *, struct ethtool_cmd *); + 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_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 *); + int (*set_coalesce)(struct net_device *, struct ethtool_coalesce *); + void (*get_ringparam)(struct net_device *, struct ethtool_ringparam *); + int (*set_ringparam)(struct net_device *, struct ethtool_ringparam *); + 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 *, u32 *, u8 *, u8 *); + int (*set_rxfh)(struct net_device *, const u32 *, const u8 *, const u8); + 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 ethtool_ts_info *); + 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_eee *); + int (*set_eee)(struct net_device *, struct ethtool_eee *); + 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 *); +}; + +struct net_device___2; + +struct ethtool_ops___2 { + int (*get_settings)(struct net_device___2 *, struct ethtool_cmd *); + int (*set_settings)(struct net_device___2 *, struct ethtool_cmd *); + void (*get_drvinfo)(struct net_device___2 *, struct ethtool_drvinfo *); + int (*get_regs_len)(struct net_device___2 *); + void (*get_regs)(struct net_device___2 *, struct ethtool_regs *, void *); + void (*get_wol)(struct net_device___2 *, struct ethtool_wolinfo *); + int (*set_wol)(struct net_device___2 *, struct ethtool_wolinfo *); + u32 (*get_msglevel)(struct net_device___2 *); + void (*set_msglevel)(struct net_device___2 *, u32); + int (*nway_reset)(struct net_device___2 *); + u32 (*get_link)(struct net_device___2 *); + int (*get_eeprom_len)(struct net_device___2 *); + int (*get_eeprom)(struct net_device___2 *, struct ethtool_eeprom *, u8 *); + int (*set_eeprom)(struct net_device___2 *, struct ethtool_eeprom *, u8 *); + int (*get_coalesce)(struct net_device___2 *, struct ethtool_coalesce *); + int (*set_coalesce)(struct net_device___2 *, struct ethtool_coalesce *); + void (*get_ringparam)(struct net_device___2 *, struct ethtool_ringparam *); + int (*set_ringparam)(struct net_device___2 *, struct ethtool_ringparam *); + void (*get_pauseparam)(struct net_device___2 *, struct ethtool_pauseparam *); + int (*set_pauseparam)(struct net_device___2 *, struct ethtool_pauseparam *); + void (*self_test)(struct net_device___2 *, struct ethtool_test *, u64 *); + void (*get_strings)(struct net_device___2 *, u32, u8 *); + int (*set_phys_id)(struct net_device___2 *, enum ethtool_phys_id_state); + void (*get_ethtool_stats)(struct net_device___2 *, struct ethtool_stats *, u64 *); + int (*begin)(struct net_device___2 *); + void (*complete)(struct net_device___2 *); + u32 (*get_priv_flags)(struct net_device___2 *); + int (*set_priv_flags)(struct net_device___2 *, u32); + int (*get_sset_count)(struct net_device___2 *, int); + int (*get_rxnfc)(struct net_device___2 *, struct ethtool_rxnfc *, u32 *); + int (*set_rxnfc)(struct net_device___2 *, struct ethtool_rxnfc *); + int (*flash_device)(struct net_device___2 *, struct ethtool_flash *); + int (*reset)(struct net_device___2 *, u32 *); + u32 (*get_rxfh_key_size)(struct net_device___2 *); + u32 (*get_rxfh_indir_size)(struct net_device___2 *); + int (*get_rxfh)(struct net_device___2 *, u32 *, u8 *, u8 *); + int (*set_rxfh)(struct net_device___2 *, const u32 *, const u8 *, const u8); + void (*get_channels)(struct net_device___2 *, struct ethtool_channels *); + int (*set_channels)(struct net_device___2 *, struct ethtool_channels *); + int (*get_dump_flag)(struct net_device___2 *, struct ethtool_dump *); + int (*get_dump_data)(struct net_device___2 *, struct ethtool_dump *, void *); + int (*set_dump)(struct net_device___2 *, struct ethtool_dump *); + int (*get_ts_info)(struct net_device___2 *, struct ethtool_ts_info *); + int (*get_module_info)(struct net_device___2 *, struct ethtool_modinfo *); + int (*get_module_eeprom)(struct net_device___2 *, struct ethtool_eeprom *, u8 *); + int (*get_eee)(struct net_device___2 *, struct ethtool_eee *); + int (*set_eee)(struct net_device___2 *, struct ethtool_eee *); + int (*get_tunable)(struct net_device___2 *, const struct ethtool_tunable *, void *); + int (*set_tunable)(struct net_device___2 *, const struct ethtool_tunable *, const void *); + int (*get_per_queue_coalesce)(struct net_device___2 *, u32, struct ethtool_coalesce *); + int (*set_per_queue_coalesce)(struct net_device___2 *, u32, struct ethtool_coalesce *); + int (*get_link_ksettings)(struct net_device___2 *, struct ethtool_link_ksettings *); + int (*set_link_ksettings)(struct net_device___2 *, const struct ethtool_link_ksettings *); +}; + +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 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_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 ethtool_rxfh { + __u32 cmd; + __u32 rss_context; + __u32 indir_size; + __u32 key_size; + __u8 hfunc; + __u8 rsvd8[3]; + __u32 rsvd32; + __u32 rss_config[0]; +}; + +struct ethtool_rxnfc { + __u32 cmd; + __u32 flow_type; + __u64 data; + struct ethtool_rx_flow_spec fs; + __u32 rule_cnt; + __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_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_handler; + +struct input_handle { + void *private; + int open; + const char *name; + struct input_dev *dev; + struct input_handler *handler; + struct list_head d_node; + struct list_head h_node; +}; + +struct evdev_client; + +struct evdev { + int open; + struct input_handle handle; + wait_queue_head_t wait; + 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 { + struct timeval time; + __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; + struct fasync_struct *fasync; + struct evdev *evdev; + struct list_head node; + unsigned int clk_type; + bool revoked; + long unsigned int *evmasks[32]; + unsigned int bufsize; + struct input_event buffer[0]; +}; + +struct event_trigger_ops; + +struct event_trigger_data; + +struct event_command { + struct list_head list; + char *name; + enum event_trigger_type trigger_type; + int flags; + int (*func)(struct event_command *, struct trace_event_file *, char *, char *, char *); + int (*reg)(char *, struct event_trigger_ops *, struct event_trigger_data *, struct trace_event_file *); + void (*unreg)(char *, struct event_trigger_ops *, 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_counter { + u32 count; + u32 flags; +}; + +struct event_file_link { + struct trace_event_file *file; + struct list_head list; +}; + +struct filter_pred; + +struct event_filter { + int n_preds; + int a_preds; + struct filter_pred *preds; + struct filter_pred *root; + char *filter_string; +}; + +struct perf_event___2; + +struct perf_cpu_context; + +struct perf_event_context; + +typedef void (*event_f)(struct perf_event___2 *, struct perf_cpu_context *, struct perf_event_context *, void *); + +struct event_function_struct { + struct perf_event___2 *event; + event_f func; + void *data; +}; + +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; + 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 (*func)(struct event_trigger_data *, void *); + int (*init)(struct event_trigger_ops *, struct event_trigger_data *); + void (*free)(struct event_trigger_ops *, struct event_trigger_data *); + int (*print)(struct seq_file *, struct event_trigger_ops *, struct event_trigger_data *); +}; + +struct eventfd_ctx { + struct kref kref; + wait_queue_head_t wqh; + __u64 count; + unsigned int flags; +}; + +struct eventpoll { + spinlock_t lock; + struct mutex mtx; + wait_queue_head_t wq; + wait_queue_head_t poll_wait; + struct list_head rdllist; + struct rb_root rbr; + struct epitem *ovflist; + struct wakeup_source *ws; + struct user_struct *user; + struct file *file; + int visited; + struct list_head visited_list_link; +}; + +struct evrec_short { + unsigned char code; + unsigned char parm1; + unsigned char dev; + unsigned char parm2; +}; + +struct evrec_note { + unsigned char code; + unsigned char chn; + unsigned char note; + unsigned char vel; +}; + +struct evrec_long { + unsigned char code; + unsigned char dev; + unsigned char cmd; + unsigned char chn; + unsigned char p1; + unsigned char p2; + short unsigned int val; +}; + +struct evrec_voice { + unsigned char code; + unsigned char dev; + unsigned char cmd; + unsigned char chn; + unsigned char note; + unsigned char parm; + short unsigned int dummy; +}; + +struct evrec_timer { + unsigned char code; + unsigned char cmd; + unsigned char dummy1; + unsigned char dummy2; + unsigned int time; +}; + +struct evrec_extended { + unsigned char code; + unsigned char cmd; + unsigned char dev; + unsigned char chn; + unsigned char p1; + unsigned char p2; + unsigned char p3; + unsigned char p4; +}; + +struct evrec_sysex { + unsigned char code; + unsigned char dev; + unsigned char buf[6]; +}; + +union evrec { + struct evrec_short s; + struct evrec_note n; + struct evrec_long l; + struct evrec_voice v; + struct evrec_timer t; + struct evrec_extended e; + struct evrec_sysex x; + unsigned int echo; + unsigned char c[8]; +}; + +struct ewma_pkt_len { + long unsigned int internal; +}; + +struct exception_table_entry { + int insn; + int fixup; + int handler; +}; + +struct exceptional_entry_key { + struct address_space___2 *mapping; + long unsigned int index; +}; + +struct exec_proc_event { + __kernel_pid_t process_pid; + __kernel_pid_t process_tgid; +}; + +struct execute_work { + struct work_struct work; +}; + +struct exit_proc_event { + __kernel_pid_t process_pid; + __kernel_pid_t process_tgid; + __u32 exit_code; + __u32 exit_signal; +}; + +struct fid; + +struct iomap; + +struct iattr; + +struct export_operations { + int (*encode_fh)(struct inode___2 *, __u32 *, int *, struct inode___2 *); + struct dentry * (*fh_to_dentry)(struct super_block___2 *, struct fid *, int, int); + struct dentry * (*fh_to_parent)(struct super_block___2 *, struct fid *, int, int); + int (*get_name)(struct dentry *, char *, struct dentry *); + struct dentry * (*get_parent)(struct dentry *); + int (*commit_metadata)(struct inode___2 *); + int (*get_uuid)(struct super_block___2 *, u8 *, u32 *, u64 *); + int (*map_blocks)(struct inode___2 *, loff_t, u64, struct iomap *, bool, u32 *); + int (*commit_blocks)(struct inode___2 *, struct iomap *, int, struct iattr *); +}; + +struct msg_msg; + +struct ext_wait_queue { + struct task_struct *task; + struct list_head list; + struct msg_msg *msg; + int state; +}; + +struct extended_signature { + unsigned int sig; + unsigned int pf; + unsigned int cksum; +}; + +struct extended_sigtable { + unsigned int count; + unsigned int cksum; + unsigned int reserved[3]; + struct extended_signature sigs[0]; +}; + +struct external_name { + union { + atomic_t count; + struct callback_head head; + } u; + unsigned char name[0]; +}; + +struct snd_midi_event; + +struct snd_seq_event; + +struct extra_event_list { + int event; + int (*decode)(struct snd_midi_event *, unsigned char *, int, struct snd_seq_event *); +}; + +struct extra_reg { + unsigned int event; + unsigned int msr; + u64 config_mask; + u64 valid_mask; + int idx; + bool extra_msr_access; +}; + +struct f_owner_ex { + int type; + __kernel_pid_t pid; +}; + +struct fast_pool { + __u32 pool[4]; + long unsigned int last; + short unsigned int reg_idx; + unsigned char count; +}; + +struct request_sock; + +struct fastopen_queue { + struct request_sock *rskq_rst_head; + struct request_sock *rskq_rst_tail; + spinlock_t lock; + int qlen; + int max_qlen; +}; + +struct fasync_struct { + spinlock_t fa_lock; + int magic; + int fa_fd; + struct fasync_struct *fa_next; + struct file___2 *fa_file; + struct callback_head fa_rcu; +}; + +struct fasync_struct___2 { + spinlock_t fa_lock; + int magic; + int fa_fd; + struct fasync_struct___2 *fa_next; + struct file *fa_file; + struct callback_head fa_rcu; +}; + +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 fb_blit_caps { + u32 x; + u32 y; + 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_deferred_io { + long unsigned int delay; + struct mutex___2 lock; + struct list_head pagelist; + void (*first_io)(struct fb_info *); + void (*deferred_io)(struct fb_info *, struct list_head *); +}; + +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; + u32 blit_x; + u32 blit_y; + void (*writeio)(struct fb_info *, void *, void *, unsigned int); + void (*readio)(struct fb_info *, void *, void *, unsigned int); +}; + +struct fb_ops; + +struct fb_tile_ops; + +struct fb_info { + atomic_t count; + int node; + int flags; + struct mutex___2 lock; + struct mutex___2 mm_lock; + struct fb_var_screeninfo var; + struct fb_fix_screeninfo fix; + struct fb_monspecs monspecs; + struct work_struct queue; + struct fb_pixmap pixmap; + struct fb_pixmap sprite; + struct fb_cmap cmap; + struct list_head modelist; + struct fb_videomode *mode; + struct delayed_work deferred_work; + struct fb_deferred_io *fbdefio; + 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; + struct apertures_struct *apertures; + bool skip_vt_switch; +}; + +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___2 *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_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); + void (*cursor)(struct vc_data *, struct fb_info *, int, int, int, int); + int (*update_start)(struct fb_info *); + int (*rotate_font)(struct fb_info *, struct vc_data *); + struct fb_var_screeninfo var; + struct timer_list cursor_timer; + struct fb_cursor cursor_state; + struct display *p; + int currcon; + int cur_blink_jiffies; + int cursor_flash; + int cursor_reset; + int blank_state; + int graphics; + int save_graphics; + int flags; + int rotate; + int cur_rotate; + char *cursor_data; + u8 *fontbuffer; + u8 *fontdata; + u8 *cursor_src; + u32 cursor_size; + u32 fd_size; +}; + +struct fd { + struct file___2 *file; + unsigned int flags; +}; + +struct fd___2 { + struct file *file; + unsigned int flags; +}; + +struct fddi_8022_1_hdr { + __u8 dsap; + __u8 ssap; + __u8 ctrl; +}; + +struct fddi_8022_2_hdr { + __u8 dsap; + __u8 ssap; + __u8 ctrl_1; + __u8 ctrl_2; +}; + +struct fddi_snap_hdr { + __u8 dsap; + __u8 ssap; + __u8 ctrl; + __u8 oui[3]; + __be16 ethertype; +}; + +struct fddihdr { + __u8 fc; + __u8 daddr[6]; + __u8 saddr[6]; + union { + struct fddi_8022_1_hdr llc_8022_1; + struct fddi_8022_2_hdr llc_8022_2; + struct fddi_snap_hdr llc_snap; + } hdr; +} __attribute__((packed)); + +struct fdtable { + unsigned int max_fds; + struct file___2 **fd; + long unsigned int *close_on_exec; + long unsigned int *open_fds; + long unsigned int *full_fds_bits; + struct callback_head rcu; +}; + +struct fence_ops; + +struct fence { + struct kref refcount; + const struct fence_ops *ops; + struct callback_head rcu; + struct list_head cb_list; + spinlock_t *lock; + unsigned int context; + unsigned int seqno; + long unsigned int flags; + ktime_t timestamp; + int status; + struct list_head child_list; + struct list_head active_list; +}; + +struct fence_ops { + const char * (*get_driver_name)(struct fence *); + const char * (*get_timeline_name)(struct fence *); + bool (*enable_signaling)(struct fence *); + bool (*signaled)(struct fence *); + long int (*wait)(struct fence *, bool, long int); + void (*release)(struct fence *); + int (*fill_driver_data)(struct fence *, void *, int); + void (*fence_value_str)(struct fence *, char *, int); + void (*timeline_value_str)(struct fence *, char *, int); +}; + +struct fetch_cache { + u8 data[15]; + u8 *ptr; + u8 *end; +}; + +struct trace_seq; + +typedef int (*print_type_func_t)(struct trace_seq *, const char *, void *, void *); + +struct fetch_type { + const char *name; + size_t size; + int is_signed; + print_type_func_t print; + const char *fmt; + const char *fmttype; + fetch_func_t fetch[8]; +}; + +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___2 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 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; +}; + +struct ftrace_graph_ent_entry { + struct trace_entry ent; + struct ftrace_graph_ent graph_ent; +}; + +struct ftrace_graph_ret { + long unsigned int func; + long long unsigned int calltime; + long long unsigned int rettime; + long unsigned int overrun; + int depth; +}; + +struct ftrace_graph_ret_entry { + struct trace_entry ent; + struct ftrace_graph_ret ret; +}; + +struct fgraph_data { + struct fgraph_cpu_data *cpu_data; + struct ftrace_graph_ent_entry ent; + struct ftrace_graph_ret_entry ret; + int failed; + int cpu; +}; + +struct fib_rule { + struct list_head list; + int iifindex; + int oifindex; + u32 mark; + u32 mark_mask; + u32 flags; + u32 table; + u8 action; + u32 target; + __be64 tun_id; + struct fib_rule *ctarget; + struct net *fr_net; + atomic_t refcnt; + u32 pref; + int suppress_ifgroup; + int suppress_prefixlen; + char iifname[16]; + char oifname[16]; + struct callback_head rcu; +}; + +struct fib4_rule { + struct fib_rule common; + u8 dst_len; + u8 src_len; + u8 tos; + __be32 src; + __be32 srcmask; + __be32 dst; + __be32 dstmask; +}; + +struct fib6_node { + struct fib6_node *parent; + struct fib6_node *left; + struct fib6_node *right; + struct rt6_info *leaf; + __u16 fn_bit; + __u16 fn_flags; + int fn_sernum; + struct rt6_info *rr_ptr; +}; + +struct inet_peer; + +struct inet_peer_base { + struct inet_peer *root; + seqlock_t lock; + int total; +}; + +struct fib6_table { + struct hlist_node tb6_hlist; + u32 tb6_id; + rwlock_t tb6_lock; + struct fib6_node tb6_root; + struct inet_peer_base tb6_peers; +}; + +struct fib_info; + +struct fib_alias { + struct hlist_node fa_list; + struct fib_info *fa_info; + u8 fa_tos; + u8 fa_type; + u8 fa_state; + u8 fa_slen; + u32 tb_id; + s16 fa_default; + struct callback_head rcu; +}; + +struct nlmsghdr; + +struct nl_info { + struct nlmsghdr *nlh; + struct net *nl_net; + u32 portid; +}; + +struct rtnexthop; + +struct fib_config { + u8 fc_dst_len; + u8 fc_tos; + u8 fc_protocol; + u8 fc_scope; + u8 fc_type; + u32 fc_table; + __be32 fc_dst; + __be32 fc_gw; + int fc_oif; + u32 fc_flags; + u32 fc_priority; + __be32 fc_prefsrc; + 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 fnhe_hash_bucket; + +struct fib_nh { + struct net_device *nh_dev; + struct hlist_node nh_hash; + struct fib_info *nh_parent; + unsigned int nh_flags; + unsigned char nh_scope; + int nh_weight; + atomic_t nh_upper_bound; + int nh_oif; + __be32 nh_gw; + __be32 nh_saddr; + int nh_saddr_genid; + struct rtable **nh_pcpu_rth_output; + struct rtable *nh_rth_input; + struct fnhe_hash_bucket *nh_exceptions; + struct lwtunnel_state *nh_lwtstate; +}; + +struct fib_info { + struct hlist_node fib_hash; + struct hlist_node fib_lhash; + struct net *fib_net; + int fib_treeref; + atomic_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_priority; + u32 *fib_metrics; + int fib_nhs; + int fib_weight; + struct callback_head rcu; + struct fib_nh fib_nh[0]; +}; + +struct fib_lookup_arg { + void *lookup_ptr; + void *result; + struct fib_rule *rule; + int flags; +}; + +struct fib_nh_exception { + struct fib_nh_exception *fnhe_next; + int fnhe_genid; + __be32 fnhe_daddr; + u32 fnhe_pmtu; + __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_prop { + int error; + u8 scope; +}; + +struct fib_table; + +struct fib_result { + unsigned char prefixlen; + unsigned char nh_sel; + unsigned char type; + unsigned char scope; + u32 tclassid; + 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 seq_net_private { + struct net *net; +}; + +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_rule_hdr { + __u8 family; + __u8 dst_len; + __u8 src_len; + __u8 tos; + __u8 table; + __u8 res1; + __u8 res2; + __u8 action; + __u32 flags; +}; + +struct flowi; + +struct nla_policy; + +struct fib_rules_ops { + int family; + struct list_head list; + int rule_size; + int addr_size; + int unresolved_rules; + int nr_goto_rules; + int (*action)(struct fib_rule *, struct flowi *, int, struct fib_lookup_arg *); + bool (*suppress)(struct fib_rule *, 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 **); + 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; + const struct nla_policy *policy; + struct list_head rules_list; + struct module___2 *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 { + u32 block; + u16 partref; + u16 parent_partref; + u32 generation; + u32 parent_block; + u32 parent_generation; + } udf; + __u32 raw[0]; + }; +}; + +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 fown_struct { + rwlock_t lock; + struct pid___2 *pid; + enum pid_type pid_type; + kuid_t uid; + kuid_t euid; + int signum; +}; + +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 file___2 { + union { + struct llist_node fu_llist; + struct callback_head fu_rcuhead; + } f_u; + struct path f_path; + struct inode *f_inode; + const struct file_operations___2 *f_op; + spinlock_t f_lock; + atomic_long_t f_count; + unsigned int f_flags; + fmode_t f_mode; + struct mutex f_pos_lock; + loff_t f_pos; + struct fown_struct f_owner; + const struct cred *f_cred; + struct file_ra_state f_ra; + u64 f_version; + void *private_data; + struct list_head f_ep_links; + struct list_head f_tfile_llink; + struct address_space *f_mapping; +}; + +struct fown_struct___2 { + rwlock_t lock; + struct pid *pid; + enum pid_type pid_type; + kuid_t uid; + kuid_t euid; + int signum; +}; + +struct file { + union { + struct llist_node fu_llist; + struct callback_head fu_rcuhead; + } f_u; + struct path___2 f_path; + struct inode___2 *f_inode; + const struct file_operations *f_op; + spinlock_t f_lock; + atomic_long_t f_count; + unsigned int f_flags; + fmode_t f_mode; + struct mutex___2 f_pos_lock; + loff_t f_pos; + struct fown_struct___2 f_owner; + const struct cred___2 *f_cred; + struct file_ra_state f_ra; + u64 f_version; + void *private_data; + struct list_head f_ep_links; + struct list_head f_tfile_llink; + struct address_space___2 *f_mapping; +}; + +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 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 *fl_next; + struct list_head fl_list; + struct hlist_node fl_link; + struct list_head fl_block; + fl_owner_t fl_owner; + unsigned int fl_flags; + unsigned char fl_type; + unsigned int fl_pid; + int fl_link_cpu; + struct pid___2 *fl_nspid; + wait_queue_head_t fl_wait; + struct file___2 *fl_file; + loff_t fl_start; + loff_t fl_end; + struct fasync_struct *fl_fasync; + long unsigned int fl_break_time; + long unsigned int fl_downgrade_time; + 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; + } afs; + } fl_u; +}; + +struct file_lock_operations___2; + +struct lock_manager_operations___2; + +struct file_lock___2 { + struct file_lock___2 *fl_next; + struct list_head fl_list; + struct hlist_node fl_link; + struct list_head fl_block; + fl_owner_t fl_owner; + unsigned int fl_flags; + unsigned char fl_type; + unsigned int fl_pid; + int fl_link_cpu; + struct pid *fl_nspid; + wait_queue_head_t fl_wait; + struct file *fl_file; + loff_t fl_start; + loff_t fl_end; + struct fasync_struct___2 *fl_fasync; + long unsigned int fl_break_time; + long unsigned int fl_downgrade_time; + const struct file_lock_operations___2 *fl_ops; + const struct lock_manager_operations___2 *fl_lmops; + union { + struct nfs_lock_info nfs_fl; + struct nfs4_lock_info nfs4_fl; + struct { + struct list_head link; + int state; + } afs; + } 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_operations { + void (*fl_copy_lock)(struct file_lock *, struct file_lock *); + void (*fl_release_private)(struct file_lock *); +}; + +struct file_lock_operations___2 { + void (*fl_copy_lock)(struct file_lock___2 *, struct file_lock___2 *); + void (*fl_release_private)(struct file_lock___2 *); +}; + +struct pipe_inode_info___2; + +struct file_operations___2 { + struct module *owner; + loff_t (*llseek)(struct file___2 *, loff_t, int); + ssize_t (*read)(struct file___2 *, char *, size_t, loff_t *); + ssize_t (*write)(struct file___2 *, 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 (*iterate)(struct file___2 *, struct dir_context *); + int (*iterate_shared)(struct file___2 *, struct dir_context *); + unsigned int (*poll)(struct file___2 *, struct poll_table_struct *); + long int (*unlocked_ioctl)(struct file___2 *, unsigned int, long unsigned int); + long int (*compat_ioctl)(struct file___2 *, unsigned int, long unsigned int); + int (*mmap)(struct file___2 *, struct vm_area_struct___2 *); + int (*open)(struct inode *, struct file___2 *); + int (*flush)(struct file___2 *, fl_owner_t); + int (*release)(struct inode *, struct file___2 *); + int (*fsync)(struct file___2 *, loff_t, loff_t, int); + int (*aio_fsync)(struct kiocb *, int); + int (*fasync)(int, struct file___2 *, int); + int (*lock)(struct file___2 *, int, struct file_lock *); + ssize_t (*sendpage)(struct file___2 *, struct page___2 *, int, size_t, loff_t *, int); + long unsigned int (*get_unmapped_area)(struct file___2 *, long unsigned int, long unsigned int, long unsigned int, long unsigned int); + int (*check_flags)(int); + int (*flock)(struct file___2 *, int, struct file_lock *); + ssize_t (*splice_write)(struct pipe_inode_info___2 *, struct file___2 *, loff_t *, size_t, unsigned int); + ssize_t (*splice_read)(struct file___2 *, loff_t *, struct pipe_inode_info___2 *, size_t, unsigned int); + int (*setlease)(struct file___2 *, long int, struct file_lock **, void **); + long int (*fallocate)(struct file___2 *, int, loff_t, loff_t); + void (*show_fdinfo)(struct seq_file *, struct file___2 *); + ssize_t (*copy_file_range)(struct file___2 *, loff_t, struct file___2 *, loff_t, size_t, unsigned int); + int (*clone_file_range)(struct file___2 *, loff_t, struct file___2 *, loff_t, u64); + ssize_t (*dedupe_file_range)(struct file___2 *, u64, u64, struct file___2 *, u64); +}; + +struct poll_table_struct___2; + +struct file_operations { + struct module___2 *owner; + 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___2 *, struct iov_iter___2 *); + ssize_t (*write_iter)(struct kiocb___2 *, struct iov_iter___2 *); + int (*iterate)(struct file *, struct dir_context *); + int (*iterate_shared)(struct file *, struct dir_context *); + unsigned int (*poll)(struct file *, struct poll_table_struct___2 *); + 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___2 *, struct file *); + int (*flush)(struct file *, fl_owner_t); + int (*release)(struct inode___2 *, struct file *); + int (*fsync)(struct file *, loff_t, loff_t, int); + int (*aio_fsync)(struct kiocb___2 *, int); + int (*fasync)(int, struct file *, int); + int (*lock)(struct file *, int, struct file_lock___2 *); + ssize_t (*sendpage)(struct file *, struct page *, int, size_t, loff_t *, int); + 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___2 *); + 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); + int (*setlease)(struct file *, long int, struct file_lock___2 **, void **); + long int (*fallocate)(struct file *, int, loff_t, loff_t); + void (*show_fdinfo)(struct seq_file___2 *, struct file *); + ssize_t (*copy_file_range)(struct file *, loff_t, struct file *, loff_t, size_t, unsigned int); + int (*clone_file_range)(struct file *, loff_t, struct file *, loff_t, u64); + ssize_t (*dedupe_file_range)(struct file *, u64, u64, struct file *, u64); +}; + +struct file_region { + struct list_head link; + long int from; + long int to; +}; + +struct file_stats { + struct drm_i915_file_private *file_priv; + long unsigned int count; + u64 total; + u64 unbound; + u64 global; + u64 shared; + u64 active; + u64 inactive; +}; + +struct file_system_type { + const char *name; + int fs_flags; + struct dentry___2 * (*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 i_mutex_dir_key; +}; + +struct file_system_type___2 { + const char *name; + int fs_flags; + struct dentry * (*mount)(struct file_system_type___2 *, int, const char *, void *); + void (*kill_sb)(struct super_block___2 *); + struct module___2 *owner; + struct file_system_type___2 *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 i_mutex_dir_key; +}; + +struct filename { + const char *name; + const char *uptr; + struct audit_names *aname; + int refcnt; + const char iname[0]; +}; + +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; + 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___2 *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_preds_data { + struct filter_pred *preds; + int match; + void *rec; +}; + +struct filter_op { + int id; + char *string; + int precedence; +}; + +struct filter_parse_state { + struct filter_op *ops; + struct list_head opstack; + struct list_head postfix; + int lasterr; + int lasterr_pos; + struct { + char *string; + unsigned int cnt; + unsigned int tail; + } infix; + struct { + char string[256]; + int pos; + unsigned int tail; + } operand; +}; + +typedef int (*filter_pred_fn_t)(struct filter_pred *, void *); + +struct regex; + +typedef int (*regex_match_func)(char *, struct regex *, int); + +struct regex { + char pattern[256]; + int len; + int field_len; + regex_match_func match; +}; + +struct ftrace_event_field; + +struct filter_pred { + filter_pred_fn_t fn; + u64 val; + struct regex regex; + short unsigned int *ops; + struct ftrace_event_field *field; + int offset; + int not; + int op; + short unsigned int index; + short unsigned int parent; + short unsigned int left; + short unsigned int right; +}; + +struct kernel_symbol; + +struct find_symbol_arg { + const char *name; + bool gplok; + bool warn; + struct module *owner; + const long unsigned int *crc; + const struct kernel_symbol *sym; +}; + +struct firmware { + size_t size; + const u8 *data; + struct page___2 **pages; + void *priv; +}; + +struct firmware_cache; + +struct firmware_buf { + struct kref ref; + struct list_head list; + struct completion completion; + struct firmware_cache *fwc; + long unsigned int status; + void *data; + size_t size; + const char *fw_id; +}; + +struct firmware_cache { + spinlock_t lock; + struct list_head head; + int state; + spinlock_t name_lock; + struct list_head fw_names; + struct delayed_work work; + struct notifier_block pm_notify; +}; + +struct firmware_map_entry { + u64 start; + u64 end; + const char *type; + struct list_head list; + struct kobject kobj; +}; + +struct firmware_work { + struct work_struct work; + struct module *module; + const char *name; + struct device *device; + void *context; + void (*cont)(const struct firmware *, void *); + unsigned int opt_flags; +}; + +struct fixed_mtrr_segment { + u64 start; + u64 end; + int range_shift; + int range_start; +}; + +struct fixed_range_block { + int base_msr; + int ranges; +}; + +struct reciprocal_value { + u32 m; + u8 sh1; + u8 sh2; +}; + +struct flex_array_part; + +struct flex_array { + union { + struct { + int element_size; + int total_nr_elements; + int elems_per_part; + struct reciprocal_value reciprocal_elems; + struct flex_array_part *parts[0]; + }; + char padding[4096]; + }; +}; + +struct flex_array_part { + char elements[4096]; +}; + +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; +}; + +struct floppy_drive_params { + signed char cmos; + long unsigned int max_dtr; + long unsigned int hlt; + long unsigned int hut; + long unsigned int srt; + long unsigned int spinup; + long unsigned int spindown; + unsigned char spindown_offset; + unsigned char select_delay; + unsigned char rps; + unsigned char tracks; + long unsigned int timeout; + unsigned char interleave_sect; + struct floppy_max_errors max_errors; + char flags; + char read_track; + short int autodetect[8]; + int checkfreq; + int native_format; +}; + +struct floppy_drive_struct { + long unsigned int flags; + long unsigned int spinup_date; + long unsigned int select_date; + long unsigned int first_read_date; + short int probed_format; + short int track; + short int maxblock; + short int maxtrack; + int generation; + int keep_data; + int fd_ref; + int fd_device; + long unsigned int last_checked; + char *dmabuf; + int bufblocks; +}; + +struct floppy_fdc_state { + int spec1; + int spec2; + int dtr; + unsigned char version; + unsigned char dor; + long unsigned int address; + unsigned int rawcmd: 2; + unsigned int reset: 1; + unsigned int need_configure: 1; + unsigned int perp_mode: 2; + unsigned int has_fifo: 1; + unsigned int driver_version; + unsigned char track[4]; +}; + +struct floppy_struct { + unsigned int size; + unsigned int sect; + unsigned int head; + unsigned int track; + unsigned int stretch; + unsigned char gap; + unsigned char rate; + unsigned char spec1; + unsigned char fmt_gap; + const char *name; +}; + +struct floppy_write_errors { + unsigned int write_errors; + long unsigned int first_error_sector; + int first_error_generation; + long unsigned int last_error_sector; + int last_error_generation; + unsigned int badness; +}; + +struct flow_dissector { + unsigned int used_keys; + short unsigned int offset[11]; +}; + +struct flow_dissector_key { + enum flow_dissector_key_id key_id; + size_t offset; +}; + +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_tipc_addrs { + __be32 srcnode; +}; + +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_addrs tipcaddrs; + }; +}; + +struct flow_dissector_key_basic { + __be16 n_proto; + u8 ip_proto; + u8 padding; +}; + +struct flow_dissector_key_control { + u16 thoff; + u16 addr_type; + u32 flags; +}; + +struct flow_dissector_key_eth_addrs { + unsigned char dst[6]; + unsigned char src[6]; +}; + +struct flow_dissector_key_keyid { + __be32 keyid; +}; + +struct flow_dissector_key_ports { + union { + __be32 ports; + struct { + __be16 src; + __be16 dst; + }; + }; +}; + +struct flow_dissector_key_tags { + u32 vlan_id: 12; + u32 flow_label: 20; +}; + +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_keyid keyid; + struct flow_dissector_key_ports ports; + struct flow_dissector_key_addrs addrs; +}; + +struct flow_keys_digest { + u8 data[16]; +}; + +struct flowi_tunnel { + __be64 tun_id; +}; + +struct flowi_common { + int flowic_oif; + int flowic_iif; + __u32 flowic_mark; + __u8 flowic_tos; + __u8 flowic_scope; + __u8 flowic_proto; + __u8 flowic_flags; + __u32 flowic_secid; + struct flowi_tunnel flowic_tun_key; +}; + +union flowi_uli { + struct { + __be16 dport; + __be16 sport; + } ports; + struct { + __u8 type; + __u8 code; + } icmpt; + struct { + __le16 dport; + __le16 sport; + } dnports; + __be32 spi; + __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; +}; + +struct flowidn { + struct flowi_common __fl_common; + __le16 daddr; + __le16 saddr; + union flowi_uli uli; +}; + +struct flowi { + union { + struct flowi_common __fl_common; + struct flowi4 ip4; + struct flowi6 ip6; + struct flowidn dn; + } u; +}; + +struct flush_tlb_info { + struct mm_struct *flush_mm; + long unsigned int flush_start; + long unsigned int flush_end; +}; + +struct fnhe_hash_bucket { + struct fib_nh_exception *chain; +}; + +struct focaltech_finger_state { + bool active; + bool valid; + unsigned int x; + unsigned int y; +}; + +struct focaltech_hw_state { + struct focaltech_finger_state fingers[5]; + unsigned int width; + bool pressed; +}; + +struct focaltech_data { + unsigned int x_max; + unsigned int y_max; + struct focaltech_hw_state state; +}; + +struct fold_pred_data { + struct filter_pred *root; + int count; + int children; +}; + +struct font_desc { + int idx; + const char *name; + int width; + int height; + const void *data; + int pref; +}; + +struct fork_proc_event { + __kernel_pid_t parent_pid; + __kernel_pid_t parent_tgid; + __kernel_pid_t child_pid; + __kernel_pid_t child_tgid; +}; + +struct fregs_state { + u32 cwd; + u32 swd; + u32 twd; + u32 fip; + u32 fcs; + u32 foo; + u32 fos; + u32 st_space[20]; + u32 status; +}; + +struct fxregs_state { + u16 cwd; + u16 swd; + u16 twd; + u16 fop; + union { + struct { + u64 rip; + u64 rdp; + }; + struct { + u32 fip; + u32 fcs; + u32 foo; + u32 fos; + }; + }; + u32 mxcsr; + u32 mxcsr_mask; + u32 st_space[32]; + u32 xmm_space[64]; + u32 padding[12]; + union { + u32 padding1[12]; + u32 sw_reserved[12]; + }; +}; + +struct math_emu_info; + +struct swregs_state { + u32 cwd; + u32 swd; + u32 twd; + u32 fip; + u32 fcs; + u32 foo; + u32 fos; + u32 st_space[20]; + u8 ftop; + u8 changed; + u8 lookahead; + u8 no_update; + u8 rm; + u8 alimit; + struct math_emu_info *info; + u32 entry_eip; +}; + +struct xstate_header { + u64 xfeatures; + u64 xcomp_bv; + u64 reserved[6]; +}; + +struct xregs_state { + struct fxregs_state i387; + struct xstate_header header; + u8 extended_state_area[0]; +}; + +union fpregs_state { + struct fregs_state fsave; + struct fxregs_state fxsave; + struct swregs_state soft; + struct xregs_state xsave; + u8 __padding[4096]; +}; + +struct fprop_global { + struct percpu_counter events; + unsigned int period; + seqcount_t sequence; +}; + +struct fprop_local_single { + long unsigned int events; + unsigned int period; + raw_spinlock_t lock; +}; + +struct fpu { + unsigned int last_cpu; + unsigned char fpstate_active; + unsigned char fpregs_active; + unsigned char counter; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + union fpregs_state state; +}; + +typedef struct fpu *pto_T_____15; + +struct frag_hdr { + __u8 nexthdr; + __u8 reserved; + __be16 frag_off; + __be32 identification; +}; + +struct free_area { + struct list_head free_list[5]; + long unsigned int nr_free; +}; + +struct freezer { + struct cgroup_subsys_state css; + unsigned int state; +}; + +struct freq_desc { + u8 x86_family; + u8 x86_model; + u8 msr_plat; + u32 freqs[8]; +}; + +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; + __s32 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_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; + __u64 qs_pad2[8]; +}; + +struct fs_struct { + int users; + spinlock_t lock; + seqcount_t seq; + int umask; + int in_exec; + struct path root; + struct path pwd; +}; + +struct fsl_mc_msi_desc { + u16 msi_index; +}; + +struct fsnotify_event { + struct list_head list; + struct inode___2 *inode; + u32 mask; +}; + +struct inotify_group_private_data { + spinlock_t idr_lock; + struct idr idr; + struct user_struct *user; +}; + +struct fsnotify_ops; + +struct fsnotify_group { + atomic_t refcnt; + const struct fsnotify_ops *ops; + struct mutex___2 notification_mutex; + struct list_head notification_list; + wait_queue_head_t notification_waitq; + unsigned int q_len; + unsigned int max_events; + unsigned int priority; + struct mutex___2 mark_mutex; + atomic_t num_marks; + struct list_head marks_list; + struct fasync_struct *fsn_fa; + struct fsnotify_event *overflow_event; + union { + void *private; + struct inotify_group_private_data inotify_data; + }; +}; + +struct fsnotify_ops { + int (*handle_event)(struct fsnotify_group *, struct inode___2 *, struct fsnotify_mark *, struct fsnotify_mark *, u32, void *, int, const unsigned char *, u32); + void (*free_group_priv)(struct fsnotify_group *); + void (*freeing_mark)(struct fsnotify_mark *, struct fsnotify_group *); + void (*free_event)(struct fsnotify_event *); +}; + +struct seq_buf { + char *buffer; + size_t size; + size_t len; + loff_t readpos; +}; + +struct trace_seq { + unsigned char buffer[4096]; + struct seq_buf seq; + int full; +}; + +struct trace_array; + +struct tracer; + +struct trace_buffer; + +struct ring_buffer_iter; + +struct trace_iterator { + struct trace_array *tr; + struct tracer *trace; + struct trace_buffer *trace_buffer; + void *private; + int cpu_file; + struct mutex mutex; + struct ring_buffer_iter **buffer_iter; + long unsigned int iter_flags; + struct trace_seq tmp_seq; + cpumask_var_t started; + 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 read; +}; + +union ftrace_code_union { + char code[5]; + struct { + unsigned char e8; + int offset; + } __attribute__((packed)); +}; + +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; + int is_signed; +}; + +struct ftrace_hash; + +struct ftrace_func_command { + struct list_head list; + char *name; + int (*func)(struct ftrace_hash *, char *, char *, char *, int); +}; + +struct ftrace_func_entry { + struct hlist_node hlist; + long unsigned int ip; +}; + +struct ftrace_probe_ops; + +struct ftrace_func_probe { + struct hlist_node node; + struct ftrace_probe_ops *ops; + long unsigned int flags; + long unsigned int ip; + void *data; + struct list_head free_list; +}; + +struct ftrace_glob { + char *search; + unsigned int len; + int type; +}; + +struct seq_operations; + +struct ftrace_graph_data { + long unsigned int *table; + size_t size; + int *count; + const struct seq_operations *seq_ops; +}; + +struct ftrace_hash { + long unsigned int size_bits; + struct hlist_head *buckets; + long unsigned int count; + struct callback_head rcu; +}; + +struct trace_parser { + bool cont; + char *buffer; + unsigned int idx; + unsigned int size; +}; + +struct ftrace_page; + +struct ftrace_ops; + +struct ftrace_iterator { + loff_t pos; + loff_t func_pos; + struct ftrace_page *pg; + struct dyn_ftrace *func; + struct ftrace_func_probe *probe; + struct trace_parser parser; + struct ftrace_hash *hash; + struct ftrace_ops *ops; + int hidx; + int idx; + unsigned int flags; +}; + +union ftrace_op_code_union { + char code[7]; + struct { + char op[3]; + int offset; + } __attribute__((packed)); +}; + +typedef void (*ftrace_func_t)(long unsigned int, long unsigned int, struct ftrace_ops *, struct pt_regs *); + +struct ftrace_ops_hash { + struct ftrace_hash *notrace_hash; + struct ftrace_hash *filter_hash; + struct mutex regex_lock; +}; + +struct ftrace_ops { + ftrace_func_t func; + struct ftrace_ops *next; + long unsigned int flags; + void *private; + ftrace_func_t saved_func; + int *disabled; + 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 ftrace_ops___2; + +typedef void (*ftrace_func_t___2)(long unsigned int, long unsigned int, struct ftrace_ops___2 *, struct pt_regs *); + +struct ftrace_ops_hash___2 { + struct ftrace_hash *notrace_hash; + struct ftrace_hash *filter_hash; + struct mutex___2 regex_lock; +}; + +struct ftrace_ops___2 { + ftrace_func_t___2 func; + struct ftrace_ops___2 *next; + long unsigned int flags; + void *private; + ftrace_func_t___2 saved_func; + int *disabled; + struct ftrace_ops_hash___2 local_hash; + struct ftrace_ops_hash___2 *func_hash; + struct ftrace_ops_hash___2 old_hash; + long unsigned int trampoline; + long unsigned int trampoline_size; +}; + +struct ftrace_page { + struct ftrace_page *next; + struct dyn_ftrace *records; + int index; + int size; +}; + +struct ftrace_pid { + struct list_head list; + struct pid___2 *pid; +}; + +struct ftrace_probe_ops { + void (*func)(long unsigned int, long unsigned int, void **); + int (*init)(struct ftrace_probe_ops *, long unsigned int, void **); + void (*free)(struct ftrace_probe_ops *, long unsigned int, void **); + int (*print)(struct seq_file *, long unsigned int, struct ftrace_probe_ops *, void *); +}; + +struct ftrace_rec_iter { + struct ftrace_page *pg; + int index; +}; + +struct ftrace_ret_stack { + long unsigned int ret; + long unsigned int func; + long long unsigned int calltime; + long long unsigned int subtime; + long unsigned int fp; +}; + +struct ftrace_stack { + long unsigned int calls[512]; +}; + +struct function_filter_data { + struct ftrace_ops *ops; + int first_filter; + int first_notrace; +}; + +struct fuse_access_in { + uint32_t mask; + uint32_t padding; +}; + +struct fuse_arg { + unsigned int size; + void *value; +}; + +struct fuse_in_arg { + unsigned int size; + const void *value; +}; + +struct fuse_args { + struct { + struct { + uint32_t opcode; + uint64_t nodeid; + } h; + unsigned int numargs; + struct fuse_in_arg args[3]; + } in; + struct { + unsigned int argvar: 1; + unsigned int numargs; + struct fuse_arg args[2]; + } out; +}; + +struct fuse_attr { + uint64_t ino; + uint64_t size; + uint64_t blocks; + uint64_t atime; + uint64_t mtime; + uint64_t ctime; + uint32_t atimensec; + uint32_t mtimensec; + uint32_t ctimensec; + uint32_t mode; + uint32_t nlink; + uint32_t uid; + uint32_t gid; + uint32_t rdev; + uint32_t blksize; + uint32_t padding; +}; + +struct fuse_attr_out { + uint64_t attr_valid; + uint32_t attr_valid_nsec; + uint32_t dummy; + struct fuse_attr attr; +}; + +struct fuse_batch_forget_in { + uint32_t count; + uint32_t dummy; +}; + +struct fuse_bmap_in { + uint64_t block; + uint32_t blocksize; + uint32_t padding; +}; + +struct fuse_bmap_out { + uint64_t block; +}; + +struct fuse_forget_one { + uint64_t nodeid; + uint64_t nlookup; +}; + +struct fuse_forget_link { + struct fuse_forget_one forget_one; + struct fuse_forget_link *next; +}; + +struct fuse_iqueue { + unsigned int connected; + wait_queue_head_t waitq; + u64 reqctr; + struct list_head pending; + struct list_head interrupts; + struct fuse_forget_link forget_list_head; + struct fuse_forget_link *forget_list_tail; + int forget_batch; + struct fasync_struct *fasync; +}; + +struct fuse_req; + +struct fuse_conn { + spinlock_t lock; + atomic_t count; + atomic_t dev_count; + struct callback_head rcu; + kuid_t user_id; + kgid_t group_id; + unsigned int flags; + unsigned int max_read; + unsigned int max_write; + struct fuse_iqueue iq; + u64 khctr; + struct rb_root polled_files; + unsigned int max_background; + unsigned int congestion_threshold; + unsigned int num_background; + unsigned int active_background; + struct list_head bg_queue; + int initialized; + int blocked; + wait_queue_head_t blocked_waitq; + wait_queue_head_t reserved_req_waitq; + unsigned int connected; + unsigned int conn_error: 1; + unsigned int conn_init: 1; + unsigned int async_read: 1; + unsigned int atomic_o_trunc: 1; + unsigned int export_support: 1; + unsigned int bdi_initialized: 1; + unsigned int writeback_cache: 1; + unsigned int no_open: 1; + unsigned int no_fsync: 1; + unsigned int no_fsyncdir: 1; + unsigned int no_flush: 1; + unsigned int no_setxattr: 1; + unsigned int no_getxattr: 1; + unsigned int no_listxattr: 1; + unsigned int no_removexattr: 1; + unsigned int no_lock: 1; + unsigned int no_access: 1; + unsigned int no_create: 1; + unsigned int no_interrupt: 1; + unsigned int no_bmap: 1; + unsigned int no_poll: 1; + unsigned int big_writes: 1; + unsigned int dont_mask: 1; + unsigned int no_flock: 1; + unsigned int no_fallocate: 1; + unsigned int no_rename2: 1; + unsigned int auto_inval_data: 1; + unsigned int do_readdirplus: 1; + unsigned int readdirplus_auto: 1; + unsigned int async_dio: 1; + unsigned int no_lseek: 1; + atomic_t num_waiting; + unsigned int minor; + struct backing_dev_info bdi; + struct list_head entry; + dev_t dev; + struct dentry *ctl_dentry[5]; + int ctl_ndents; + u32 scramble_key[4]; + struct fuse_req *destroy_req; + u64 attr_version; + void (*release)(struct fuse_conn *); + struct super_block *sb; + struct rw_semaphore killsb; + struct list_head devices; +}; + +struct pipe_buffer; + +struct fuse_copy_state { + int write; + struct fuse_req *req; + struct iov_iter *iter; + struct pipe_buffer *pipebufs; + struct pipe_buffer *currbuf; + struct pipe_inode_info___2 *pipe; + long unsigned int nr_segs; + struct page *pg; + unsigned int len; + unsigned int offset; + unsigned int move_pages: 1; +}; + +struct fuse_create_in { + uint32_t flags; + uint32_t mode; + uint32_t umask; + uint32_t padding; +}; + +struct fuse_pqueue { + unsigned int connected; + spinlock_t lock; + struct list_head processing; + struct list_head io; +}; + +struct fuse_dev { + struct fuse_conn *fc; + struct fuse_pqueue pq; + struct list_head entry; +}; + +struct fuse_dirent { + uint64_t ino; + uint64_t off; + uint32_t namelen; + uint32_t type; + char name[0]; +}; + +struct fuse_entry_out { + uint64_t nodeid; + uint64_t generation; + uint64_t entry_valid; + uint64_t attr_valid; + uint32_t entry_valid_nsec; + uint32_t attr_valid_nsec; + struct fuse_attr attr; +}; + +struct fuse_direntplus { + struct fuse_entry_out entry_out; + struct fuse_dirent dirent; +}; + +struct fuse_fallocate_in { + uint64_t fh; + uint64_t offset; + uint64_t length; + uint32_t mode; + uint32_t padding; +}; + +struct fuse_file { + struct fuse_conn *fc; + struct fuse_req *reserved_req; + u64 kh; + u64 fh; + u64 nodeid; + atomic_t count; + u32 open_flags; + struct list_head write_entry; + struct rb_node polled_node; + wait_queue_head_t poll_wait; + bool flock: 1; +}; + +struct fuse_file_lock { + uint64_t start; + uint64_t end; + uint32_t type; + uint32_t pid; +}; + +struct fuse_fill_data { + struct fuse_req *req; + struct file___2 *file; + struct inode___2 *inode; + unsigned int nr_pages; +}; + +struct fuse_fill_wb_data { + struct fuse_req *req; + struct fuse_file *ff; + struct inode___2 *inode; + struct page **orig_pages; +}; + +struct fuse_flush_in { + uint64_t fh; + uint32_t unused; + uint32_t padding; + uint64_t lock_owner; +}; + +struct fuse_forget_in { + uint64_t nlookup; +}; + +struct fuse_fsync_in { + uint64_t fh; + uint32_t fsync_flags; + uint32_t padding; +}; + +struct fuse_getattr_in { + uint32_t getattr_flags; + uint32_t dummy; + uint64_t fh; +}; + +struct fuse_getxattr_in { + uint32_t size; + uint32_t padding; +}; + +struct fuse_getxattr_out { + uint32_t size; + uint32_t padding; +}; + +struct fuse_in_header { + uint32_t len; + uint32_t opcode; + uint64_t unique; + uint64_t nodeid; + uint32_t uid; + uint32_t gid; + uint32_t pid; + uint32_t padding; +}; + +struct fuse_in { + struct fuse_in_header h; + unsigned int argpages: 1; + unsigned int numargs; + struct fuse_in_arg args[3]; +}; + +struct fuse_init_in { + uint32_t major; + uint32_t minor; + uint32_t max_readahead; + uint32_t flags; +}; + +struct fuse_init_out { + uint32_t major; + uint32_t minor; + uint32_t max_readahead; + uint32_t flags; + uint16_t max_background; + uint16_t congestion_threshold; + uint32_t max_write; + uint32_t time_gran; + uint32_t unused[9]; +}; + +struct inode_operations___2; + +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___2 *i_op; + struct super_block *i_sb; + struct address_space *i_mapping; + long unsigned int i_ino; + union { + const unsigned int i_nlink; + unsigned int __i_nlink; + }; + dev_t i_rdev; + loff_t i_size; + struct timespec i_atime; + struct timespec i_mtime; + struct timespec i_ctime; + spinlock_t i_lock; + short unsigned int i_bytes; + unsigned int i_blkbits; + blkcnt_t i_blocks; + long unsigned int 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 list_head i_lru; + struct list_head i_sb_list; + union { + struct hlist_head i_dentry; + struct callback_head i_rcu; + }; + u64 i_version; + atomic_t i_count; + atomic_t i_dio_count; + atomic_t i_writecount; + const struct file_operations___2 *i_fop; + struct file_lock_context *i_flctx; + struct address_space i_data; + struct list_head i_devices; + union { + struct pipe_inode_info___2 *i_pipe; + struct block_device *i_bdev; + struct cdev *i_cdev; + char *i_link; + unsigned int i_dir_seq; + }; + __u32 i_generation; + __u32 i_fsnotify_mask; + struct hlist_head i_fsnotify_marks; + void *i_private; +}; + +struct fuse_inode { + struct inode inode; + u64 nodeid; + u64 nlookup; + struct fuse_forget_link *forget; + u64 i_time; + umode_t orig_i_mode; + u64 orig_ino; + u64 attr_version; + struct list_head write_files; + struct list_head queued_writes; + int writectr; + wait_queue_head_t page_waitq; + struct list_head writepages; + long unsigned int state; +}; + +struct fuse_inode_handle { + u64 nodeid; + u32 generation; +}; + +struct fuse_interrupt_in { + uint64_t unique; +}; + +struct fuse_io_priv { + struct kref refcnt; + int async; + spinlock_t lock; + unsigned int reqs; + ssize_t bytes; + size_t size; + __u64 offset; + bool write; + int err; + struct kiocb *iocb; + struct file___2 *file; + struct completion *done; +}; + +struct fuse_ioctl_in { + uint64_t fh; + uint32_t flags; + uint32_t cmd; + uint64_t arg; + uint32_t in_size; + uint32_t out_size; +}; + +struct fuse_ioctl_iovec { + uint64_t base; + uint64_t len; +}; + +struct fuse_ioctl_out { + int32_t result; + uint32_t flags; + uint32_t in_iovs; + uint32_t out_iovs; +}; + +struct fuse_kstatfs { + uint64_t blocks; + uint64_t bfree; + uint64_t bavail; + uint64_t files; + uint64_t ffree; + uint32_t bsize; + uint32_t namelen; + uint32_t frsize; + uint32_t padding; + uint32_t spare[6]; +}; + +struct fuse_link_in { + uint64_t oldnodeid; +}; + +struct fuse_lk_in { + uint64_t fh; + uint64_t owner; + struct fuse_file_lock lk; + uint32_t lk_flags; + uint32_t padding; +}; + +struct fuse_lk_out { + struct fuse_file_lock lk; +}; + +struct fuse_lseek_in { + uint64_t fh; + uint64_t offset; + uint32_t whence; + uint32_t padding; +}; + +struct fuse_lseek_out { + uint64_t offset; +}; + +struct fuse_mkdir_in { + uint32_t mode; + uint32_t umask; +}; + +struct fuse_mknod_in { + uint32_t mode; + uint32_t rdev; + uint32_t umask; + uint32_t padding; +}; + +struct fuse_mount_data { + int fd; + unsigned int rootmode; + kuid_t user_id; + kgid_t group_id; + unsigned int fd_present: 1; + unsigned int rootmode_present: 1; + unsigned int user_id_present: 1; + unsigned int group_id_present: 1; + unsigned int flags; + unsigned int max_read; + unsigned int blksize; +}; + +struct fuse_notify_delete_out { + uint64_t parent; + uint64_t child; + uint32_t namelen; + uint32_t padding; +}; + +struct fuse_notify_inval_entry_out { + uint64_t parent; + uint32_t namelen; + uint32_t padding; +}; + +struct fuse_notify_inval_inode_out { + uint64_t ino; + int64_t off; + int64_t len; +}; + +struct fuse_notify_poll_wakeup_out { + uint64_t kh; +}; + +struct fuse_notify_retrieve_in { + uint64_t dummy1; + uint64_t offset; + uint32_t size; + uint32_t dummy2; + uint64_t dummy3; + uint64_t dummy4; +}; + +struct fuse_notify_retrieve_out { + uint64_t notify_unique; + uint64_t nodeid; + uint64_t offset; + uint32_t size; + uint32_t padding; +}; + +struct fuse_notify_store_out { + uint64_t nodeid; + uint64_t offset; + uint32_t size; + uint32_t padding; +}; + +struct fuse_open_in { + uint32_t flags; + uint32_t unused; +}; + +struct fuse_open_out { + uint64_t fh; + uint32_t open_flags; + uint32_t padding; +}; + +struct fuse_out_header { + uint32_t len; + int32_t error; + uint64_t unique; +}; + +struct fuse_out { + struct fuse_out_header h; + unsigned int argvar: 1; + unsigned int argpages: 1; + unsigned int page_zeroing: 1; + unsigned int page_replace: 1; + unsigned int numargs; + struct fuse_arg args[2]; +}; + +struct fuse_page_desc { + unsigned int length; + unsigned int offset; +}; + +struct fuse_poll_in { + uint64_t fh; + uint64_t kh; + uint32_t flags; + uint32_t events; +}; + +struct fuse_poll_out { + uint32_t revents; + uint32_t padding; +}; + +struct fuse_read_in { + uint64_t fh; + uint64_t offset; + uint32_t size; + uint32_t read_flags; + uint64_t lock_owner; + uint32_t flags; + uint32_t padding; +}; + +struct fuse_release_in { + uint64_t fh; + uint32_t flags; + uint32_t release_flags; + uint64_t lock_owner; +}; + +struct fuse_rename2_in { + uint64_t newdir; + uint32_t flags; + uint32_t padding; +}; + +struct fuse_write_in { + uint64_t fh; + uint64_t offset; + uint32_t size; + uint32_t write_flags; + uint64_t lock_owner; + uint32_t flags; + uint32_t padding; +}; + +struct fuse_write_out { + uint32_t size; + uint32_t padding; +}; + +struct fuse_req { + struct list_head list; + struct list_head intr_entry; + atomic_t count; + u64 intr_unique; + long unsigned int flags; + struct fuse_in in; + struct fuse_out out; + wait_queue_head_t waitq; + union { + struct { + struct fuse_release_in in; + struct inode___2 *inode; + } release; + struct fuse_init_in init_in; + struct fuse_init_out init_out; + struct cuse_init_in cuse_init_in; + struct { + struct fuse_read_in in; + u64 attr_ver; + } read; + struct { + struct fuse_write_in in; + struct fuse_write_out out; + struct fuse_req *next; + } write; + struct fuse_notify_retrieve_in retrieve_in; + } misc; + struct page **pages; + struct fuse_page_desc *page_descs; + unsigned int max_pages; + struct page *inline_pages[1]; + struct fuse_page_desc inline_page_descs[1]; + unsigned int num_pages; + struct fuse_file *ff; + struct inode___2 *inode; + struct fuse_io_priv *io; + struct list_head writepages_entry; + void (*end)(struct fuse_conn *, struct fuse_req *); + struct file___2 *stolen_file; +}; + +struct fuse_setattr_in { + uint32_t valid; + uint32_t padding; + uint64_t fh; + uint64_t size; + uint64_t lock_owner; + uint64_t atime; + uint64_t mtime; + uint64_t ctime; + uint32_t atimensec; + uint32_t mtimensec; + uint32_t ctimensec; + uint32_t mode; + uint32_t unused4; + uint32_t uid; + uint32_t gid; + uint32_t unused5; +}; + +struct fuse_setxattr_in { + uint32_t size; + uint32_t flags; +}; + +struct fuse_statfs_out { + struct fuse_kstatfs st; +}; + +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 { + long unsigned int pgoff; + struct inode *inode; + int offset; + } shared; + struct { + long unsigned int address; + struct mm_struct *mm; + int offset; + } private; + struct { + long unsigned int word; + void *ptr; + int offset; + } both; +}; + +struct futex_pi_state { + struct list_head list; + struct rt_mutex pi_mutex; + struct task_struct *owner; + atomic_t refcount; + union futex_key key; +}; + +struct rt_mutex_waiter; + +struct futex_q { + struct plist_node list; + struct task_struct *task; + spinlock_t *lock_ptr; + union futex_key key; + struct futex_pi_state *pi_state; + struct rt_mutex_waiter *rt_waiter; + union futex_key *requeue_pi_key; + u32 bitset; +}; + +struct fw_cache_entry { + struct list_head list; + const char *name; +}; + +struct fw_cfg_file { + u32 size; + u16 select; + u16 reserved; + char name[56]; +}; + +struct fw_cfg_sysfs_entry; + +struct fw_cfg_sysfs_attribute { + struct attribute attr; + ssize_t (*show)(struct fw_cfg_sysfs_entry *, char *); +}; + +struct fw_cfg_sysfs_entry { + struct kobject kobj; + struct fw_cfg_file f; + struct list_head list; +}; + +struct fw_name_devm { + long unsigned int magic; + const char *name; +}; + +struct gate_struct64 { + u16 offset_low; + u16 segment; + unsigned int ist: 3; + unsigned int zero0: 5; + unsigned int type: 5; + unsigned int dpl: 2; + unsigned int p: 1; + u16 offset_middle; + u32 offset_high; + u32 zero1; +}; + +typedef struct gate_struct64 gate_desc; + +struct gatt_mask { + long unsigned int mask; + u32 type; +}; + +struct gcm_instance_ctx { + struct crypto_skcipher_spawn ctr; + struct crypto_ahash_spawn ghash; +}; + +struct gdt_page { + struct desc_struct gdt[16]; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + 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 gen_estimator { + struct list_head list; + struct gnet_stats_basic_packed *bstats; + struct gnet_stats_rate_est64 *rate_est; + spinlock_t *stats_lock; + int ewma_log; + u32 last_packets; + long unsigned int avpps; + u64 last_bytes; + u64 avbps; + struct callback_head e_rcu; + struct rb_node node; + struct gnet_stats_basic_cpu *cpu_bstats; + struct callback_head head; +}; + +struct gen_estimator_head { + struct timer_list timer; + struct list_head list; +}; + +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 *); + +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_t avail; + phys_addr_t phys_addr; + long unsigned int start_addr; + long unsigned int end_addr; + long unsigned int bits[0]; +}; + +struct partition_meta_info; + +struct hd_struct { + sector_t start_sect; + sector_t nr_sects; + seqcount_t nr_sects_seq; + sector_t alignment_offset; + unsigned int discard_alignment; + struct device __dev; + struct kobject *holder_dir; + int policy; + int partno; + struct partition_meta_info *info; + long unsigned int stamp; + atomic_t in_flight[2]; + struct disk_stats *dkstats; + struct percpu_ref ref; + struct callback_head callback_head; +}; + +struct timer_rand_state; + +struct gendisk { + int major; + int first_minor; + int minors; + char disk_name[32]; + char * (*devnode)(struct gendisk *, umode_t *); + unsigned int events; + unsigned int async_events; + struct disk_part_tbl *part_tbl; + struct hd_struct part0; + const struct block_device_operations *fops; + struct request_queue *queue; + void *private_data; + int flags; + struct device *driverfs_dev; + struct kobject *slave_dir; + struct timer_rand_state *random; + atomic_t sync_io; + struct disk_events *ev; + int node_id; + struct badblocks *bb; +}; + +struct generic_bl_info { + const char *name; + int max_intensity; + int default_intensity; + int limit_mask; + void (*set_bl_intensity)(int); + void (*kick_battery)(void); +}; + +struct genl_ops; + +struct genl_info; + +struct genl_multicast_group; + +struct genl_family { + unsigned int id; + unsigned int hdrsize; + char name[16]; + unsigned int version; + unsigned int maxattr; + bool netnsok; + bool parallel_ops; + int (*pre_doit)(const struct genl_ops *, struct sk_buff *, struct genl_info *); + void (*post_doit)(const struct genl_ops *, struct sk_buff *, struct genl_info *); + int (*mcast_bind)(struct net *, int); + void (*mcast_unbind)(struct net *, int); + struct nlattr **attrbuf; + const struct genl_ops *ops; + const struct genl_multicast_group *mcgrps; + unsigned int n_ops; + unsigned int n_mcgrps; + unsigned int mcgrp_offset; + struct list_head family_list; + struct module *module; +}; + +struct genlmsghdr; + +struct genl_info { + u32 snd_seq; + u32 snd_portid; + struct nlmsghdr *nlhdr; + struct genlmsghdr *genlhdr; + void *userhdr; + struct nlattr **attrs; + possible_net_t _net; + void *user_ptr[2]; +}; + +struct genl_multicast_group { + char name[16]; +}; + +struct netlink_callback; + +struct genl_ops { + const struct nla_policy *policy; + 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 *); + u8 cmd; + u8 internal_flags; + u8 flags; +}; + +struct genlmsghdr { + __u8 cmd; + __u8 version; + __u16 reserved; +}; + +struct genpool_data_align { + int align; +}; + +struct genpool_data_fixed { + long unsigned int offset; +}; + +struct get_pages_work { + struct work_struct work; + struct drm_i915_gem_object *obj; + struct task_struct *task; +}; + +struct getcpu_cache { + long unsigned int blob[16]; +}; + +struct linux_dirent; + +struct getdents_callback { + struct dir_context ctx; + struct linux_dirent *current_dir; + struct linux_dirent *previous; + int count; + int error; +}; + +struct getdents_callback___2 { + struct dir_context ctx; + char *name; + u64 ino; + int found; + int sequence; +}; + +struct getdents_callback64 { + struct dir_context ctx; + struct linux_dirent64 *current_dir; + struct linux_dirent64 *previous; + int count; + int error; +}; + +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 gf128mul_4k { + be128 t[256]; +}; + +struct gf128mul_64k { + struct gf128mul_4k *t[16]; +}; + +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; +}; + +struct ghash_ctx { + struct gf128mul_4k *gf128; +}; + +struct ghash_desc_ctx { + u8 buffer[16]; + u32 bytes; +}; + +struct gmbus_pin { + const char *name; + i915_reg_t reg; +}; + +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_dump___2 { + spinlock_t *lock; + struct sk_buff___2 *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 u64_stats_sync {}; + +struct gnet_stats_basic_cpu { + struct gnet_stats_basic_packed bstats; + struct u64_stats_sync syncp; +}; + +struct gnet_stats_rate_est { + __u32 bps; + __u32 pps; +}; + +struct gpio_map { + u16 base_offset; + bool init; +}; + +struct gprefix { + struct opcode pfx_no; + struct opcode pfx_66; + struct opcode pfx_f2; + struct opcode pfx_f3; +}; + +struct gre_base_hdr { + __be16 flags; + __be16 protocol; +}; + +struct gre_hdr { + __be16 flags; + __be16 proto; +}; + +struct group_dual { + struct opcode mod012[8]; + struct opcode mod3[8]; +}; + +struct group_filter { + __u32 gf_interface; + long: 0; + struct __kernel_sockaddr_storage gf_group; + __u32 gf_fmode; + __u32 gf_numsrc; + struct __kernel_sockaddr_storage gf_slist[1]; +}; + +struct group_for_pci_data { + struct pci_dev *pdev; + struct iommu_group *group; +}; + +struct group_info { + atomic_t usage; + int ngroups; + int nblocks; + kgid_t small_block[32]; + kgid_t *blocks[0]; +}; + +struct group_req { + __u32 gr_interface; + long: 0; + struct __kernel_sockaddr_storage gr_group; +}; + +struct group_source_req { + __u32 gsr_interface; + long: 0; + struct __kernel_sockaddr_storage gsr_group; + struct __kernel_sockaddr_storage gsr_source; +}; + +struct gsb_buffer { + u8 status; + u8 len; + union { + u16 wdata; + u8 bdata; + u8 data[0]; + }; +}; + +struct guc_ads { + u32 reg_state_addr; + u32 reg_state_buffer; + u32 golden_context_lrca; + u32 scheduler_policies; + u32 reserved0[3]; + u32 eng_state_size[5]; + u32 reserved2[4]; +}; + +struct guc_execlist_context { + u32 context_desc; + u32 context_id; + u32 ring_status; + u32 ring_lcra; + u32 ring_begin; + u32 ring_end; + u32 ring_next_free_location; + u32 ring_current_tail_pointer_value; + u8 engine_state_submit_value; + u8 engine_state_wait_value; + u16 pagefault_count; + u16 engine_submit_queue_count; +} __attribute__((packed)); + +struct guc_context_desc { + u32 sched_common_area; + u32 context_id; + u32 pas_id; + u8 engines_used; + u64 db_trigger_cpu; + u32 db_trigger_uk; + u64 db_trigger_phy; + u16 db_id; + struct guc_execlist_context lrc[5]; + u8 attribute; + u32 priority; + u32 wq_sampled_tail_offset; + u32 wq_total_submit_enqueues; + u32 process_desc; + u32 wq_addr; + u32 wq_size; + u32 engine_presence; + u8 engine_suspended; + u8 reserved0[3]; + u64 reserved1[1]; + u64 desc_private; +} __attribute__((packed)); + +struct guc_css_header { + uint32_t module_type; + uint32_t header_size_dw; + uint32_t header_version; + uint32_t module_id; + uint32_t module_vendor; + union { + struct { + uint8_t day; + uint8_t month; + uint16_t year; + }; + uint32_t date; + }; + uint32_t size_dw; + uint32_t key_size_dw; + uint32_t modulus_size_dw; + uint32_t exponent_size_dw; + union { + struct { + uint8_t hour; + uint8_t min; + uint16_t sec; + }; + uint32_t time; + }; + char username[8]; + char buildnumber[12]; + uint32_t device_id; + uint32_t guc_sw_version; + uint32_t prod_preprod_fw; + uint32_t reserved[12]; + uint32_t header_info; +}; + +struct guc_doorbell_info { + u32 db_status; + u32 cookie; + u32 reserved[14]; +}; + +union guc_doorbell_qw { + struct { + u32 db_status; + u32 cookie; + }; + u64 value_qw; +}; + +struct guc_mmio_regset { + struct { + u32 offset; + u32 value; + u32 flags; + } registers[25]; + u32 values_valid; + u32 number_of_registers; +}; + +struct guc_mmio_reg_state { + struct guc_mmio_regset global_reg; + struct guc_mmio_regset engine_reg[5]; + struct { + u32 mmio_start; + u32 offsets[12]; + u32 count; + } mmio_white_list[5]; +}; + +struct guc_policy { + u32 execution_quantum; + u32 reserved1; + u32 preemption_time; + u32 fault_time; + u32 policy_flags; + u32 reserved[2]; +}; + +struct guc_policies { + struct guc_policy policy[20]; + u32 dpc_promote_time; + u32 is_valid; + u32 max_num_work_items; + u32 reserved[19]; +}; + +struct guc_process_desc { + u32 context_id; + u64 db_base_addr; + u32 head; + u32 tail; + u32 error_offset; + u64 wq_base_addr; + u32 wq_size_bytes; + u32 wq_status; + u32 engine_presence; + u32 priority; + u32 reserved[30]; +} __attribute__((packed)); + +struct guc_wq_item { + u32 header; + u32 context_desc; + u32 ring_tail; + u32 fence_id; +}; + +struct x86_exception { + u8 vector; + bool error_code_valid; + u16 error_code; + bool nested_page_fault; + u64 address; +}; + +struct guest_walker32 { + int level; + unsigned int max_level; + gfn_t table_gfn[2]; + u32 ptes[2]; + u32 prefetch_ptes[8]; + gpa_t pte_gpa[2]; + u32 *ptep_user[2]; + bool pte_writable[2]; + unsigned int pt_access; + unsigned int pte_access; + gfn_t gfn; + struct x86_exception fault; +}; + +struct guest_walker64 { + int level; + unsigned int max_level; + gfn_t table_gfn[4]; + u64 ptes[4]; + u64 prefetch_ptes[8]; + gpa_t pte_gpa[4]; + u64 *ptep_user[4]; + bool pte_writable[4]; + unsigned int pt_access; + unsigned int pte_access; + gfn_t gfn; + struct x86_exception fault; +}; + +struct guest_walkerEPT { + int level; + unsigned int max_level; + gfn_t table_gfn[4]; + u64 ptes[4]; + u64 prefetch_ptes[8]; + gpa_t pte_gpa[4]; + u64 *ptep_user[4]; + bool pte_writable[4]; + unsigned int pt_access; + unsigned int pte_access; + gfn_t gfn; + struct x86_exception fault; +}; + +struct hash { + int ino; + int minor; + int major; + umode_t mode; + struct hash *next; + char name[4098]; +}; + +struct hash_cell { + struct list_head name_list; + struct list_head uuid_list; + char *name; + char *uuid; + struct mapped_device *md; + struct dm_table___2 *new_map; +}; + +struct hd_geometry { + unsigned char heads; + unsigned char sectors; + short unsigned int cylinders; + long unsigned int start; +}; + +struct hda_amp_list { + hda_nid_t nid; + unsigned char dir; + unsigned char idx; +}; + +struct hda_beep { + struct input_dev *dev; + struct hda_codec *codec; + char phys[32]; + int tone; + hda_nid_t nid; + unsigned int registered: 1; + unsigned int enabled: 1; + unsigned int linear_tone: 1; + unsigned int playing: 1; + struct work_struct beep_work; + struct mutex mutex; + void (*power_hook)(struct hda_beep *, bool); +}; + +struct hda_ctl_ops; + +struct hda_bind_ctls { + struct hda_ctl_ops *ops; + long unsigned int values[0]; +}; + +struct hdac_widget_tree; + +struct regmap; + +struct hdac_device { + struct device dev; + int type; + struct hdac_bus *bus; + unsigned int addr; + struct list_head list; + hda_nid_t afg; + hda_nid_t mfg; + unsigned int vendor_id; + unsigned int subsystem_id; + unsigned int revision_id; + unsigned int afg_function_id; + unsigned int mfg_function_id; + unsigned int afg_unsol: 1; + unsigned int mfg_unsol: 1; + unsigned int power_caps; + const char *vendor_name; + const char *chip_name; + int (*exec_verb)(struct hdac_device *, unsigned int, unsigned int, unsigned int *); + unsigned int num_nodes; + hda_nid_t start_nid; + hda_nid_t end_nid; + atomic_t in_pm; + bool link_power_control: 1; + struct hdac_widget_tree *widgets; + struct regmap *regmap; + struct snd_array vendor_verbs; + bool lazy_cache: 1; + bool caps_overwriting: 1; + bool cache_coef: 1; +}; + +struct hda_codec_ops { + int (*build_controls)(struct hda_codec *); + int (*build_pcms)(struct hda_codec *); + int (*init)(struct hda_codec *); + void (*free)(struct hda_codec *); + void (*unsol_event)(struct hda_codec *, unsigned int); + void (*set_power_state)(struct hda_codec *, hda_nid_t, unsigned int); + int (*suspend)(struct hda_codec *); + int (*resume)(struct hda_codec *); + int (*check_power_status)(struct hda_codec *, hda_nid_t); + void (*reboot_notify)(struct hda_codec *); + void (*stream_pm)(struct hda_codec *, hda_nid_t, bool); +}; + +struct hda_device_id; + +struct snd_hwdep; + +struct snd_info_buffer; + +struct hda_fixup; + +struct hda_codec { + struct hdac_device core; + struct hda_bus *bus; + struct snd_card *card; + unsigned int addr; + u32 probe_id; + const struct hda_device_id *preset; + const char *modelname; + struct hda_codec_ops patch_ops; + struct list_head pcm_list_head; + void *spec; + struct hda_beep *beep; + unsigned int beep_mode; + u32 *wcaps; + struct snd_array mixers; + struct snd_array nids; + struct list_head conn_list; + struct mutex spdif_mutex; + struct mutex control_mutex; + struct snd_array spdif_out; + unsigned int spdif_in_enable; + const hda_nid_t *slave_dig_outs; + struct snd_array init_pins; + struct snd_array driver_pins; + struct snd_array cvt_setups; + struct mutex user_mutex; + struct snd_hwdep *hwdep; + unsigned int in_freeing: 1; + unsigned int registered: 1; + unsigned int spdif_status_reset: 1; + unsigned int pin_amp_workaround: 1; + unsigned int single_adc_amp: 1; + unsigned int no_sticky_stream: 1; + unsigned int pins_shutup: 1; + unsigned int no_trigger_sense: 1; + unsigned int no_jack_detect: 1; + unsigned int inv_eapd: 1; + unsigned int inv_jack_detect: 1; + unsigned int pcm_format_first: 1; + unsigned int cached_write: 1; + unsigned int dp_mst: 1; + unsigned int dump_coef: 1; + unsigned int power_save_node: 1; + unsigned int auto_runtime_pm: 1; + long unsigned int power_on_acct; + long unsigned int power_off_acct; + long unsigned int power_jiffies; + unsigned int (*power_filter)(struct hda_codec *, hda_nid_t, unsigned int); + void (*proc_widget_hook)(struct snd_info_buffer *, struct hda_codec *, hda_nid_t); + struct snd_array jacktbl; + long unsigned int jackpoll_interval; + struct delayed_work jackpoll_work; + struct snd_array jacks; + int depop_delay; + int fixup_id; + const struct hda_fixup *fixup_list; + const char *fixup_name; + struct snd_array verbs; +}; + +struct hdac_driver { + struct device_driver driver; + int type; + const struct hda_device_id *id_table; + int (*match)(struct hdac_device *, struct hdac_driver *); + void (*unsol_event)(struct hdac_device *, unsigned int); +}; + +struct hda_codec_driver { + struct hdac_driver core; + const struct hda_device_id *id; +}; + +struct hda_conn_list { + struct list_head list; + int len; + hda_nid_t nid; + hda_nid_t conns[0]; +}; + +struct hda_controller_ops { + int (*disable_msi_reset_irq)(struct azx *); + int (*substream_alloc_pages)(struct azx *, struct snd_pcm_substream *, size_t); + int (*substream_free_pages)(struct azx *, struct snd_pcm_substream *); + void (*pcm_mmap_prepare)(struct snd_pcm_substream *, struct vm_area_struct___2 *); + int (*position_check)(struct azx *, struct azx_dev *); + int (*link_power)(struct azx *, bool); +}; + +struct snd_ctl_elem_info; + +typedef int snd_kcontrol_info_t(struct snd_kcontrol *, struct snd_ctl_elem_info *); + +typedef int snd_kcontrol_get_t(struct snd_kcontrol *, struct snd_ctl_elem_value *); + +typedef int snd_kcontrol_put_t(struct snd_kcontrol *, struct snd_ctl_elem_value *); + +typedef int snd_kcontrol_tlv_rw_t(struct snd_kcontrol *, int, unsigned int, unsigned int *); + +struct hda_ctl_ops { + snd_kcontrol_info_t *info; + snd_kcontrol_get_t *get; + snd_kcontrol_put_t *put; + snd_kcontrol_tlv_rw_t *tlv; +}; + +struct hda_cvt_setup { + hda_nid_t nid; + u8 stream_tag; + u8 channel_id; + u16 format_id; + unsigned char active; + unsigned char dirty; +}; + +struct hda_device_id { + __u32 vendor_id; + __u32 rev_id; + __u8 api_version; + const char *name; + long unsigned int driver_data; +}; + +struct hda_pintbl; + +struct hda_verb; + +struct hda_fixup { + int type; + bool chained: 1; + bool chained_before: 1; + int chain_id; + union { + const struct hda_pintbl *pins; + const struct hda_verb *verbs; + void (*func)(struct hda_codec *, const struct hda_fixup *, int); + } v; +}; + +struct hda_intel { + struct azx chip; + struct work_struct irq_pending_work; + struct completion probe_wait; + struct work_struct probe_work; + struct list_head list; + unsigned int irq_pending_warned: 1; + unsigned int probe_continued: 1; + unsigned int use_vga_switcheroo: 1; + unsigned int vga_switcheroo_registered: 1; + unsigned int init_failed: 1; + struct dev_pm_domain hdmi_pm_domain; + bool need_i915_power: 1; +}; + +typedef void (*hda_jack_callback_fn)(struct hda_codec *, struct hda_jack_callback *); + +struct hda_jack_callback { + hda_nid_t nid; + hda_jack_callback_fn func; + unsigned int private_data; + struct hda_jack_callback *next; +}; + +struct snd_jack; + +struct hda_jack_tbl { + hda_nid_t nid; + unsigned char tag; + struct hda_jack_callback *callback; + unsigned int pin_sense; + unsigned int jack_detect: 1; + unsigned int jack_dirty: 1; + unsigned int phantom_jack: 1; + unsigned int block_report: 1; + hda_nid_t gating_jack; + hda_nid_t gated_jack; + int type; + struct snd_jack *jack; +}; + +struct hda_model_fixup { + const int id; + const char *name; +}; + +struct hda_nid_item { + struct snd_kcontrol *kctl; + unsigned int index; + hda_nid_t nid; + short unsigned int flags; +}; + +struct hda_pcm_ops { + int (*open)(struct hda_pcm_stream *, struct hda_codec *, struct snd_pcm_substream *); + int (*close)(struct hda_pcm_stream *, struct hda_codec *, struct snd_pcm_substream *); + int (*prepare)(struct hda_pcm_stream *, struct hda_codec *, unsigned int, unsigned int, struct snd_pcm_substream *); + int (*cleanup)(struct hda_pcm_stream *, struct hda_codec *, struct snd_pcm_substream *); + unsigned int (*get_delay)(struct hda_pcm_stream *, struct hda_codec *, struct snd_pcm_substream *); +}; + +struct snd_pcm_chmap_elem; + +struct hda_pcm_stream { + unsigned int substreams; + unsigned int channels_min; + unsigned int channels_max; + hda_nid_t nid; + u32 rates; + u64 formats; + unsigned int maxbps; + const struct snd_pcm_chmap_elem *chmap; + struct hda_pcm_ops ops; +}; + +struct hda_pcm { + char *name; + struct hda_pcm_stream stream[2]; + unsigned int pcm_type; + int device; + struct snd_pcm *pcm; + bool own_chmap; + struct hda_codec *codec; + struct kref kref; + struct list_head list; +}; + +struct hda_pincfg { + hda_nid_t nid; + unsigned char ctrl; + unsigned char target; + unsigned int cfg; +}; + +struct hda_pintbl { + hda_nid_t nid; + u32 val; +}; + +struct hda_rate_tbl { + unsigned int hz; + unsigned int alsa_bits; + unsigned int hda_fmt; +}; + +struct hda_spdif_out { + hda_nid_t nid; + unsigned int status; + short unsigned int ctls; +}; + +struct hda_vendor_id { + unsigned int id; + const char *name; +}; + +struct hda_verb { + hda_nid_t nid; + u32 verb; + u32 param; +}; + +struct hda_verb_ioctl { + u32 verb; + u32 res; +}; + +struct hdac_bus_ops { + int (*command)(struct hdac_bus *, unsigned int); + int (*get_response)(struct hdac_bus *, unsigned int, unsigned int *); + int (*link_power)(struct hdac_bus *, bool); +}; + +struct hdac_cea_channel_speaker_allocation { + int ca_index; + int speakers[8]; + int channels; + int spk_mask; +}; + +struct hdac_chmap; + +struct hdac_chmap_ops { + int (*chmap_cea_alloc_validate_get_type)(struct hdac_chmap *, struct hdac_cea_channel_speaker_allocation *, int); + void (*cea_alloc_to_tlv_chmap)(struct hdac_chmap *, struct hdac_cea_channel_speaker_allocation *, unsigned int *, int); + int (*chmap_validate)(struct hdac_chmap *, int, int, unsigned char *); + int (*get_spk_alloc)(struct hdac_device *, int); + void (*get_chmap)(struct hdac_device *, int, unsigned char *); + void (*set_chmap)(struct hdac_device *, int, unsigned char *, int); + bool (*is_pcm_attached)(struct hdac_device *, int); + int (*pin_get_slot_channel)(struct hdac_device *, hda_nid_t, int); + int (*pin_set_slot_channel)(struct hdac_device *, hda_nid_t, int, int); + void (*set_channel_count)(struct hdac_device *, hda_nid_t, int); +}; + +struct hdac_chmap { + unsigned int channels_max; + struct hdac_chmap_ops ops; + struct hdac_device *hdac; +}; + +struct hdac_io_ops { + void (*reg_writel)(u32, u32 *); + u32 (*reg_readl)(u32 *); + void (*reg_writew)(u16, u16 *); + u16 (*reg_readw)(u16 *); + void (*reg_writeb)(u8, u8 *); + u8 (*reg_readb)(u8 *); + int (*dma_alloc_pages)(struct hdac_bus *, int, size_t, struct snd_dma_buffer *); + void (*dma_free_pages)(struct hdac_bus *, struct snd_dma_buffer *); +}; + +struct hdac_widget_tree { + struct kobject *root; + struct kobject *afg; + struct kobject **nodes; +}; + +struct hdmi_any_infoframe { + enum hdmi_infoframe_type type; + unsigned char version; + unsigned char length; +}; + +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_avi_infoframe { + enum hdmi_infoframe_type type; + unsigned char version; + unsigned char length; + 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; + bool itc; + 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; + unsigned char pixel_repeat; + 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; +}; + +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 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); +}; + +struct header_ops___2 { + int (*create)(struct sk_buff___2 *, struct net_device___2 *, short unsigned int, const void *, const void *, unsigned int); + int (*parse)(const struct sk_buff___2 *, unsigned char *); + int (*cache)(const struct neighbour *, struct hh_cache *, __be16); + void (*cache_update)(struct hh_cache *, const struct net_device___2 *, const unsigned char *); + bool (*validate)(const char *, unsigned int); +}; + +struct hh_cache { + u16 hh_len; + u16 __pad; + seqlock_t hh_lock; + long unsigned int hh_data[4]; +}; + +struct hib_bio_batch { + atomic_t count; + wait_queue_head_t wait; + int error; +}; + +struct hlist_bl_head { + struct hlist_bl_node *first; +}; + +struct hlist_nulls_node; + +struct hlist_nulls_head { + struct hlist_nulls_node *first; +}; + +struct hlist_nulls_node { + struct hlist_nulls_node *next; + struct hlist_nulls_node **pprev; +}; + +struct hmac_ctx { + struct crypto_shash *hash; +}; + +struct hpp_type0 { + u32 revision; + u8 cache_line_size; + u8 latency_timer; + u8 enable_serr; + u8 enable_perr; +}; + +struct hpp_type1 { + u32 revision; + u8 max_mem_read; + u8 avg_max_split; + u16 tot_max_split; +}; + +struct hpp_type2 { + u32 revision; + u32 unc_err_mask_and; + u32 unc_err_mask_or; + u32 unc_err_sever_and; + u32 unc_err_sever_or; + u32 cor_err_mask_and; + u32 cor_err_mask_or; + u32 adv_err_cap_and; + u32 adv_err_cap_or; + u16 pci_exp_devctl_and; + u16 pci_exp_devctl_or; + u16 pci_exp_lnkctl_and; + u16 pci_exp_lnkctl_or; + u32 sec_unc_err_sever_and; + u32 sec_unc_err_sever_or; + u32 sec_unc_err_mask_and; + u32 sec_unc_err_mask_or; +}; + +struct hotplug_params { + struct hpp_type0 *t0; + struct hpp_type1 *t1; + struct hpp_type2 *t2; + struct hpp_type0 type0_data; + struct hpp_type1 type1_data; + struct hpp_type2 type2_data; +}; + +struct hotplug_slot_ops; + +struct hotplug_slot_info; + +struct pci_slot; + +struct hotplug_slot { + struct hotplug_slot_ops *ops; + struct hotplug_slot_info *info; + void (*release)(struct hotplug_slot *); + void *private; + struct list_head slot_list; + struct pci_slot *pci_slot; +}; + +struct hotplug_slot_info { + u8 power_status; + u8 attention_status; + u8 latch_status; + u8 adapter_status; +}; + +struct hotplug_slot_ops { + struct module___2 *owner; + const char *mod_name; + 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 *, int); +}; + +struct hpet_timer { + u64 hpet_config; + union { + u64 _hpet_hc64; + u32 _hpet_hc32; + long unsigned int _hpet_compare; + } _u1; + u64 hpet_fsb[2]; +}; + +struct hpet { + u64 hpet_cap; + u64 res0; + u64 hpet_config; + u64 res1; + u64 hpet_isr; + u64 res2[25]; + union { + u64 _hpet_mc64; + u32 _hpet_mc32; + long unsigned int _hpet_mc; + } _u0; + u64 res3; + struct hpet_timer hpet_timers[1]; +}; + +struct hpet_data { + long unsigned int hd_phys_address; + void *hd_address; + short unsigned int hd_nirqs; + unsigned int hd_state; + unsigned int hd_irq[32]; +}; + +struct hpet_dev { + struct clock_event_device evt; + unsigned int num; + int cpu; + unsigned int irq; + unsigned int flags; + char name[10]; + long: 64; + long: 64; + long: 64; + long: 64; +}; + +struct hpets; + +struct hpet_dev___2 { + struct hpets *hd_hpets; + struct hpet *hd_hpet; + struct hpet_timer *hd_timer; + long unsigned int hd_ireqfreq; + long unsigned int hd_irqdata; + wait_queue_head_t hd_waitqueue; + struct fasync_struct___2 *hd_async_queue; + unsigned int hd_flags; + unsigned int hd_irq; + unsigned int hd_hdwirq; + char hd_name[7]; +}; + +struct hpet_info { + long unsigned int hi_ireqfreq; + long unsigned int hi_flags; + short unsigned int hi_hpet; + short unsigned int hi_timer; +}; + +struct hpet_work_struct { + struct delayed_work work; + struct completion complete; +}; + +struct hpets { + struct hpets *hp_next; + struct hpet *hp_hpet; + long unsigned int hp_hpet_phys; + struct clocksource *hp_clocksource; + long long unsigned int hp_tick_freq; + long unsigned int hp_delta; + unsigned int hp_ntimer; + unsigned int hp_which; + struct hpet_dev___2 hp_dev[1]; +}; + +struct hrtimer_cpu_base; + +struct hrtimer_clock_base { + struct hrtimer_cpu_base *cpu_base; + int index; + clockid_t clockid; + struct timerqueue_head active; + ktime_t (*get_time)(void); + ktime_t offset; + long: 64; + long: 64; +}; + +struct hrtimer_cpu_base { + raw_spinlock_t lock; + seqcount_t seq; + struct hrtimer *running; + unsigned int cpu; + unsigned int active_bases; + unsigned int clock_was_set_seq; + bool migration_enabled; + bool nohz_active; + unsigned int in_hrtirq: 1; + unsigned int hres_active: 1; + unsigned int hang_detected: 1; + ktime_t expires_next; + struct hrtimer *next_timer; + unsigned int nr_events; + unsigned int nr_retries; + unsigned int nr_hangs; + unsigned int max_hang_time; + struct hrtimer_clock_base clock_base[4]; +}; + +struct hrtimer_sleeper { + struct hrtimer timer; + struct task_struct *task; +}; + +struct hs_primary_descriptor { + char foo[8]; + char type[1]; + char id[5]; + char version[1]; + char unused1[1]; + char system_id[32]; + char volume_id[32]; + char unused2[8]; + char volume_space_size[8]; + char unused3[32]; + char volume_set_size[4]; + char volume_sequence_number[4]; + char logical_block_size[4]; + char path_table_size[8]; + char type_l_path_table[4]; + char unused4[28]; + char root_directory_record[34]; +}; + +struct hs_volume_descriptor { + char foo[8]; + char type[1]; + char id[5]; + char version[1]; + char data[2033]; +}; + +struct hstate { + int next_nid_to_alloc; + int next_nid_to_free; + unsigned int 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[64]; + unsigned int nr_huge_pages_node[64]; + unsigned int free_huge_pages_node[64]; + unsigned int surplus_huge_pages_node[64]; + char name[32]; +}; + +struct hsu_dma_chan; + +struct hsu_dma { + struct dma_device dma; + struct hsu_dma_chan *chan; + short unsigned int nr_channels; +}; + +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 virt_dma_desc *cyclic; +}; + +struct hsu_dma_desc; + +struct hsu_dma_chan { + struct virt_dma_chan vchan; + void *reg; + enum dma_transfer_direction direction; + struct dma_slave_config config; + struct hsu_dma_desc *desc; +}; + +struct hsu_dma_chip { + struct device___2 *dev; + int irq; + void *regs; + unsigned int length; + unsigned int offset; + struct hsu_dma *hsu; +}; + +struct virt_dma_desc { + struct dma_async_tx_descriptor tx; + struct list_head node; +}; + +struct hsu_dma_sg; + +struct hsu_dma_desc { + struct virt_dma_desc vdesc; + enum dma_transfer_direction direction; + struct hsu_dma_sg *sg; + unsigned int nents; + size_t length; + unsigned int active; + enum dma_status status; +}; + +struct hsu_dma_sg { + dma_addr_t addr; + unsigned int len; +}; + +struct hsu_dma_slave { + struct device *dma_dev; + int chan_id; +}; + +union hsw_tsx_tuning { + struct { + u32 cycles_last_block: 32; + u32 hle_abort: 1; + u32 rtm_abort: 1; + u32 instruction_abort: 1; + u32 non_instruction_abort: 1; + u32 retry: 1; + u32 data_conflict: 1; + u32 capacity_writes: 1; + u32 capacity_reads: 1; + }; + u64 value; +}; + +struct hsw_wrpll_rnp { + unsigned int p; + unsigned int n2; + unsigned int r2; +}; + +struct ht_irq_msg; + +typedef void ht_irq_update_t(struct pci_dev *, int, struct ht_irq_msg *); + +struct ht_irq_msg { + u32 address_lo; + u32 address_hi; +}; + +struct ht_irq_cfg { + struct pci_dev *dev; + ht_irq_update_t *update; + unsigned int pos; + unsigned int idx; + struct ht_irq_msg msg; +}; + +struct pcpu_freelist_node { + struct pcpu_freelist_node *next; +}; + +struct htab_elem { + union { + struct hlist_node hash_node; + struct bpf_htab *htab; + struct pcpu_freelist_node fnode; + }; + struct callback_head rcu; + 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 hugetlbfs_config { + kuid_t uid; + kgid_t gid; + umode_t mode; + long int max_hpages; + long int nr_inodes; + struct hstate *hstate; + long int min_hpages; +}; + +struct shared_policy { + struct rb_root root; + rwlock_t lock; +}; + +struct hugetlbfs_inode_info { + struct shared_policy policy; + struct inode vfs_inode; +}; + +struct hugetlbfs_sb_info { + long int max_inodes; + long int free_inodes; + spinlock_t stat_lock; + struct hstate *hstate; + struct hugepage_subpool *spool; +}; + +union hv_message_flags { + __u8 asu8; + struct { + __u8 msg_pending: 1; + __u8 reserved: 7; + }; +}; + +union hv_port_id { + __u32 asu32; + struct { + __u32 id: 24; + __u32 reserved: 8; + } u; +}; + +struct hv_message_header { + __u32 message_type; + __u8 payload_size; + union hv_message_flags message_flags; + __u8 reserved[2]; + union { + __u64 sender; + union hv_port_id port; + }; +}; + +struct hv_message { + struct hv_message_header header; + union { + __u64 payload[30]; + } u; +}; + +struct hv_message_page { + struct hv_message sint_message[16]; +}; + +struct hv_ops { + int (*get_chars)(uint32_t, char *, int); + int (*put_chars)(uint32_t, const char *, int); + 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 *, int); +}; + +struct hv_timer_message_payload { + __u32 timer_index; + __u32 reserved; + __u64 expiration_time; + __u64 delivery_time; +}; + +struct tty_buffer { + union { + struct tty_buffer *next; + struct llist_node free; + }; + int used; + int size; + int commit; + int read; + int flags; + long unsigned int data[0]; +}; + +struct llist_head { + struct llist_node *first; +}; + +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 { + struct tty_bufhead buf; + struct tty_struct *tty; + struct tty_struct *itty; + const struct tty_port_operations *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; + unsigned char low_latency: 1; + struct mutex mutex; + struct mutex buf_mutex; + unsigned char *xmit_buf; + unsigned int close_delay; + unsigned int closing_wait; + int drain_delay; + struct kref kref; +}; + +struct hvc_struct { + struct tty_port port; + spinlock_t lock; + int index; + int do_wakeup; + char *outbuf; + 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; +}; + +struct hw_perf_event_extra { + u64 config; + unsigned int reg; + int alloc; + int idx; +}; + +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 { + struct hrtimer hrtimer; + }; + struct { + struct list_head tp_list; + }; + struct { + int cqm_state; + u32 cqm_rmid; + int is_group_event; + struct list_head cqm_events_entry; + struct list_head cqm_groups_entry; + struct list_head cqm_group_entry; + }; + struct { + int itrace_started; + }; + struct { + u64 pwr_acc; + u64 ptsc; + }; + struct { + struct arch_hw_breakpoint info; + struct list_head bp_list; + }; + }; + struct task_struct *target; + void *addr_filters; + long unsigned int addr_filters_gen; + int state; + local64_t prev_count; + u64 sample_period; + u64 last_period; + local64_t period_left; + u64 interrupts_seq; + u64 interrupts; + u64 freq_time_stamp; + u64 freq_count_stamp; +}; + +struct hw_perf_event___2 { + 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 { + struct hrtimer hrtimer; + }; + struct { + struct list_head tp_list; + }; + struct { + int cqm_state; + u32 cqm_rmid; + int is_group_event; + struct list_head cqm_events_entry; + struct list_head cqm_groups_entry; + struct list_head cqm_group_entry; + }; + struct { + int itrace_started; + }; + struct { + u64 pwr_acc; + u64 ptsc; + }; + struct { + struct arch_hw_breakpoint info; + struct list_head bp_list; + }; + }; + struct task_struct___2 *target; + void *addr_filters; + long unsigned int addr_filters_gen; + int state; + local64_t prev_count; + u64 sample_period; + u64 last_period; + local64_t period_left; + u64 interrupts_seq; + u64 interrupts; + u64 freq_time_stamp; + u64 freq_count_stamp; +}; + +struct hwmon_device { + const char *name; + struct device dev; +}; + +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 hwtstamp_config { + int flags; + int tx_type; + int rx_filter; +}; + +struct hypervisor_x86 { + const char *name; + uint32_t (*detect)(void); + void (*set_cpu_features)(struct cpuinfo_x86 *); + void (*init_platform)(void); + bool (*x2apic_available)(void); +}; + +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_algorithm { + int (*master_xfer)(struct i2c_adapter *, struct i2c_msg *, int); + int (*smbus_xfer)(struct i2c_adapter *, u16, short unsigned int, char, u8, int, union i2c_smbus_data *); + u32 (*functionality)(struct i2c_adapter *); +}; + +struct i2c_board_info { + char type[20]; + short unsigned int flags; + short unsigned int addr; + void *platform_data; + struct dev_archdata *archdata; + struct device_node *of_node; + struct fwnode_handle *fwnode; + 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 (*prepare_recovery)(struct i2c_adapter *); + void (*unprepare_recovery)(struct i2c_adapter *); + int scl_gpio; + int sda_gpio; +}; + +struct i2c_client { + short unsigned int flags; + short unsigned int addr; + char name[20]; + struct i2c_adapter *adapter; + struct device dev; + int irq; + struct list_head detected; +}; + +struct i2c_cmd_arg { + unsigned int cmd; + void *arg; +}; + +struct i2c_device_id { + char name[20]; + kernel_ulong_t driver_data; +}; + +struct i2c_devinfo { + struct list_head list; + int busnum; + struct i2c_board_info board_info; +}; + +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_rdwr_ioctl_data { + struct i2c_msg *msgs; + __u32 nmsgs; +}; + +struct i2c_rdwr_aligned { + struct i2c_rdwr_ioctl_data cmd; + struct i2c_msg msgs[0]; +}; + +struct i2c_rdwr_ioctl_data32 { + compat_caddr_t msgs; + u32 nmsgs; +}; + +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; +}; + +struct i801_priv { + struct i2c_adapter adapter; + long unsigned int smba; + unsigned char original_hstcfg; + struct pci_dev *pci_dev; + unsigned int features; + wait_queue_head_t waitq; + u8 status; + u8 cmd; + bool is_read; + int count; + int len; + u8 *data; + struct platform_device *tco_pdev; + bool acpi_reserved; + struct mutex acpi_lock; +}; + +struct i8042_port { + struct serio *serio; + int irq; + bool exists; + bool driver_bound; + signed char mux; +}; + +struct i915_audio_component_ops; + +struct i915_audio_component_audio_ops; + +struct i915_audio_component { + struct device *dev; + int aud_sample_rate[5]; + const struct i915_audio_component_ops *ops; + const struct i915_audio_component_audio_ops *audio_ops; +}; + +struct i915_audio_component_audio_ops { + void *audio_ptr; + void (*pin_eld_notify)(void *, int); +}; + +struct i915_audio_component_ops { + struct module *owner; + void (*get_power)(struct device *); + void (*put_power)(struct device *); + void (*codec_wake_override)(struct device *, bool); + int (*get_cdclk_freq)(struct device *); + int (*sync_audio_rate)(struct device *, int, int); + int (*get_eld)(struct device *, int, bool *, unsigned char *, int); +}; + +struct i915_ctx_hang_stats { + unsigned int batch_pending; + unsigned int batch_active; + long unsigned int guilty_ts; + long unsigned int ban_period_seconds; + bool banned; +}; + +struct i915_debugfs_files { + const char *name; + const struct file_operations___2 *fops; +}; + +struct i915_error_state_file_priv { + struct drm_device *dev; + struct drm_i915_error_state *error; +}; + +struct i915_execbuffer_params { + struct drm_device *dev; + struct drm_file *file; + uint32_t dispatch_flags; + uint32_t args_batch_start_offset; + uint64_t batch_obj_vm_offset; + struct intel_engine_cs *engine; + struct drm_i915_gem_object *batch_obj; + struct intel_context *ctx; + struct drm_i915_gem_request *request; +}; + +struct intel_rotation_info { + unsigned int uv_offset; + uint32_t pixel_format; + unsigned int uv_start_page; + struct { + unsigned int width; + unsigned int height; + } plane[2]; +}; + +struct i915_ggtt_view { + enum i915_ggtt_view_type type; + union { + struct { + u64 offset; + unsigned int size; + } partial; + struct intel_rotation_info rotated; + } params; + struct sg_table *pages; +}; + +struct i915_guc_client { + struct drm_i915_gem_object *client_obj; + void *client_base; + struct intel_context *owner; + struct intel_guc *guc; + uint32_t priority; + uint32_t ctx_index; + uint32_t proc_desc_offset; + uint32_t doorbell_offset; + uint32_t cookie; + uint16_t doorbell_id; + uint16_t padding; + uint32_t wq_offset; + uint32_t wq_size; + uint32_t wq_tail; + uint32_t unused; + uint64_t submissions[5]; + uint32_t q_fail; + uint32_t b_fail; + int retcode; + int spare; +}; + +struct i915_page_dma { + struct page *page; + union { + dma_addr_t daddr; + uint32_t ggtt_offset; + }; +}; + +struct i915_pml4 { + struct i915_page_dma base; + long unsigned int used_pml4es[8]; + struct i915_page_directory_pointer *pdps[512]; +}; + +struct i915_page_directory_pointer { + struct i915_page_dma base; + long unsigned int *used_pdpes; + struct i915_page_directory **page_directory; +}; + +struct i915_page_directory { + struct i915_page_dma base; + long unsigned int *used_pdes; + struct i915_page_table *page_table[512]; +}; + +struct i915_hw_ppgtt { + struct i915_address_space base; + struct kref ref; + struct drm_mm_node node; + long unsigned int pd_dirty_rings; + union { + struct i915_pml4 pml4; + struct i915_page_directory_pointer pdp; + struct i915_page_directory pd; + }; + struct drm_i915_file_private *file_priv; + gen6_pte_t *pd_addr; + int (*enable)(struct i915_hw_ppgtt *); + int (*switch_mm)(struct i915_hw_ppgtt *, struct drm_i915_gem_request *); + void (*debug_dump)(struct i915_hw_ppgtt *, struct seq_file___2 *); +}; + +struct i915_mmu_notifier; + +struct i915_mm_struct { + struct mm_struct *mm; + struct drm_i915_private *i915; + struct i915_mmu_notifier *mn; + struct hlist_node node; + struct kref kref; + struct work_struct work; +}; + +struct mmu_notifier_ops; + +struct mmu_notifier { + struct hlist_node hlist; + const struct mmu_notifier_ops *ops; +}; + +struct i915_mmu_notifier { + spinlock_t lock; + struct hlist_node node; + struct mmu_notifier mn; + struct rb_root objects; + struct workqueue_struct *wq; +}; + +struct interval_tree_node { + struct rb_node rb; + long unsigned int start; + long unsigned int last; + long unsigned int __subtree_last; +}; + +struct i915_mmu_object { + struct i915_mmu_notifier *mn; + struct drm_i915_gem_object *obj; + struct interval_tree_node it; + struct list_head link; + struct work_struct work; + bool attached; +}; + +struct i915_page_scratch { + struct i915_page_dma base; +}; + +struct i915_page_table { + struct i915_page_dma base; + long unsigned int *used_ptes; +}; + +struct i915_params { + int modeset; + int panel_ignore_lid; + int semaphores; + int lvds_channel_mode; + int panel_use_ssc; + int vbt_sdvo_panel_type; + int enable_rc6; + int enable_dc; + int enable_fbc; + int enable_ppgtt; + int enable_execlists; + int enable_psr; + unsigned int preliminary_hw_support; + int disable_power_well; + int enable_ips; + int invert_brightness; + int enable_cmd_parser; + int guc_log_level; + int use_mmio_flip; + int mmio_debug; + int edp_vswing; + unsigned int inject_load_failure; + bool enable_hangcheck; + bool fastboot; + bool prefault_disable; + bool load_detect_test; + bool reset; + bool disable_display; + bool enable_guc_submission; + bool verbose_state_checks; + bool nuclear_pageflip; + bool enable_dp_mst; +}; + +struct i915_power_well_ops; + +struct i915_power_well { + const char *name; + bool always_on; + int count; + bool hw_enabled; + long unsigned int domains; + long unsigned int data; + const struct i915_power_well_ops *ops; +}; + +struct i915_power_well_ops { + void (*sync_hw)(struct drm_i915_private *, struct i915_power_well *); + void (*enable)(struct drm_i915_private *, struct i915_power_well *); + void (*disable)(struct drm_i915_private *, struct i915_power_well *); + bool (*is_enabled)(struct drm_i915_private *, struct i915_power_well *); +}; + +struct i915_vma { + struct drm_mm_node node; + struct drm_i915_gem_object *obj; + struct i915_address_space *vm; + unsigned int bound: 4; + bool is_ggtt: 1; + struct i915_ggtt_view ggtt_view; + struct list_head vm_link; + struct list_head obj_link; + struct list_head exec_list; + struct hlist_node exec_node; + long unsigned int exec_handle; + struct drm_i915_gem_exec_object2 *exec_entry; + unsigned int pin_count: 4; +}; + +struct iattr___2 { + unsigned int ia_valid; + umode_t ia_mode; + kuid_t ia_uid; + kgid_t ia_gid; + loff_t ia_size; + struct timespec ia_atime; + struct timespec ia_mtime; + struct timespec ia_ctime; + struct file___2 *ia_file; +}; + +struct iattr { + unsigned int ia_valid; + umode_t ia_mode; + kuid_t ia_uid; + kgid_t ia_gid; + loff_t ia_size; + struct timespec ia_atime; + struct timespec ia_mtime; + struct timespec ia_ctime; + struct file *ia_file; +}; + +struct ic_device { + struct ic_device *next; + struct net_device *dev; + short unsigned int flags; + short int able; + __be32 xid; +}; + +struct ich_laptop { + u16 device; + u16 subvendor; + u16 subdevice; +}; + +struct snd_pcm_ops; + +struct ich_pcm_table { + char *suffix; + struct snd_pcm_ops *playback_ops; + struct snd_pcm_ops *capture_ops; + size_t prealloc_size; + size_t prealloc_max_size; + int ac97_idx; +}; + +struct ich_reg_info { + unsigned int int_sta_mask; + unsigned int offset; +}; + +struct ichdev { + unsigned int ichd; + long unsigned int reg_offset; + u32 *bdbar; + unsigned int bdbar_addr; + struct snd_pcm_substream *substream; + unsigned int physbuf; + unsigned int size; + unsigned int fragsize; + unsigned int fragsize1; + unsigned int position; + unsigned int pos_shift; + unsigned int last_pos; + int frags; + int lvi; + int lvi_frag; + int civ; + int ack; + int ack_reload; + unsigned int ack_bit; + unsigned int roff_sr; + unsigned int roff_picb; + unsigned int int_sta_mask; + unsigned int ali_slot; + struct ac97_pcm *pcm; + int pcm_open_flag; + unsigned int page_attr_changed: 1; + unsigned int suspended: 1; +}; + +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; + } 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 { + bool (*handler)(struct sk_buff *); + short int error; +}; + +struct icmp_err { + int errno; + unsigned int fatal: 1; +}; + +struct icmp_filter { + __u32 data; +}; + +struct icmp_mib { + long unsigned int mibs[28]; +}; + +struct icmpmsg_mib { + atomic_long_t mibs[512]; +}; + +struct icmpv6_mib_device { + atomic_long_t mibs[6]; +}; + +struct icmpv6msg_mib_device { + atomic_long_t mibs[512]; +}; + +struct id_proc_event { + __kernel_pid_t process_pid; + __kernel_pid_t process_tgid; + union { + __u32 ruid; + __u32 rgid; + } r; + union { + __u32 euid; + __u32 egid; + } e; +}; + +struct ida_bitmap { + long int nr_busy; + long unsigned int bitmap[15]; +}; + +struct idr_layer { + int prefix; + int layer; + struct idr_layer *ary[256]; + int count; + union { + long unsigned int bitmap[4]; + struct callback_head callback_head; + }; +}; + +typedef struct idr_layer *pto_T_____16; + +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_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; + 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 ifa_cacheinfo { + __u32 ifa_prefered; + __u32 ifa_valid; + __u32 cstamp; + __u32 tstamp; +}; + +struct inet6_dev; + +struct ifacaddr6 { + struct in6_addr aca_addr; + struct inet6_dev *aca_idev; + struct rt6_info *aca_rt; + struct ifacaddr6 *aca_next; + int aca_users; + atomic_t aca_refcnt; + long unsigned int aca_cstamp; + long unsigned int aca_tstamp; +}; + +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 ifreq; + +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_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; +}; + +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; +}; + +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 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 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 timer_list mca_timer; + unsigned int mca_flags; + int mca_users; + atomic_t mca_refcnt; + spinlock_t mca_lock; + long unsigned int mca_cstamp; + long unsigned int mca_tstamp; +}; + +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 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 unused3; + 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; + __be16 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; + __be16 csum; + __be16 resv2; + __be16 ngrec; + struct igmpv3_grec grec[0]; +}; + +struct ilk_wm_maximums { + uint16_t pri; + uint16_t spr; + uint16_t cur; + uint16_t fbc; +}; + +struct imc_uncore_pci_dev { + __u32 pci_id; + struct pci_driver *driver; +}; + +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_rtmsg32 { + 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 ipv4_devconf { + void *sysctl; + int data[31]; + long unsigned int state[1]; +}; + +struct in_ifaddr; + +struct neigh_parms; + +struct in_device { + struct net_device *dev; + atomic_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; + unsigned char mr_qrv; + unsigned char mr_gq_running; + unsigned char 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 hash; + struct in_ifaddr *ifa_next; + struct in_device *ifa_dev; + struct callback_head callback_head; + __be32 ifa_local; + __be32 ifa_address; + __be32 ifa_mask; + __be32 ifa_broadcast; + unsigned char ifa_scope; + unsigned char ifa_prefixlen; + __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 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 { + __s32 forwarding; + __s32 hop_limit; + __s32 mtu6; + __s32 accept_ra; + __s32 accept_redirects; + __s32 autoconf; + __s32 dad_transmits; + __s32 rtr_solicits; + __s32 rtr_solicit_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_max_retry; + __s32 max_desync_factor; + __s32 max_addresses; + __s32 accept_ra_defrtr; + __s32 accept_ra_min_hop_limit; + __s32 accept_ra_pinfo; + __s32 ignore_routes_with_linkdown; + __s32 proxy_ndp; + __s32 accept_source_route; + __s32 accept_ra_from_local; + __s32 disable_ipv6; + __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; + struct ipv6_stable_secret stable_secret; + __s32 use_oif_addrs_only; + __s32 keep_addr_on_down; + 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; + struct list_head addr_list; + struct ifmcaddr6 *mc_list; + struct ifmcaddr6 *mc_tomb; + spinlock_t mc_lock; + 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 timer_list mc_gq_timer; + struct timer_list mc_ifc_timer; + struct timer_list mc_dad_timer; + struct ifacaddr6 *ac_list; + rwlock_t lock; + atomic_t refcnt; + __u32 if_flags; + int dead; + u8 rndid[8]; + struct timer_list regen_timer; + 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; + __u8 rs_probes; + __u8 addr_gen_mode; + long unsigned int tstamp; + struct callback_head rcu; +}; + +struct inet6_skb_parm { + int iif; + __be16 ra; + __u16 dst0; + __u16 srcrt; + __u16 dst1; + __u16 lastopt; + __u16 nhoff; + __u16 flags; + __u16 frag_max_size; +}; + +union inet_addr { + __u32 all[4]; + __be32 ip; + __be32 ip6[4]; + struct in_addr in; + struct in6_addr in6; +}; + +struct inet_bind_bucket { + possible_net_t ib_net; + short unsigned int port; + signed char fastreuse; + signed char fastreuseport; + kuid_t fastuid; + int num_owners; + struct hlist_node node; + struct hlist_head owners; +}; + +struct inet_bind_hashbucket { + spinlock_t lock; + struct hlist_head chain; +}; + +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; + 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; + }; + int skc_tx_queue_mapping; + union { + int skc_incoming_cpu; + u32 skc_rcv_wnd; + u32 skc_tw_rcv_nxt; + }; + atomic_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___2 *page; + __u32 offset; + __u32 size; +}; + +struct sock_cgroup_data {}; + +struct mem_cgroup; + +struct sk_filter; + +struct socket_wq; + +struct socket; + +struct sock_reuseport; + +struct sock { + struct sock_common __sk_common; + socket_lock_t sk_lock; + struct sk_buff_head sk_receive_queue; + struct { + atomic_t rmem_alloc; + int len; + struct sk_buff *head; + struct sk_buff *tail; + } sk_backlog; + int sk_forward_alloc; + __u32 sk_txhash; + unsigned int sk_napi_id; + unsigned int sk_ll_usec; + atomic_t sk_drops; + int sk_rcvbuf; + struct sk_filter *sk_filter; + union { + struct socket_wq *sk_wq; + struct socket_wq *sk_wq_raw; + }; + struct dst_entry *sk_rx_dst; + struct dst_entry *sk_dst_cache; + atomic_t sk_wmem_alloc; + atomic_t sk_omem_alloc; + int sk_sndbuf; + struct sk_buff_head sk_write_queue; + unsigned int sk_padding: 2; + unsigned int sk_no_check_tx: 1; + unsigned int sk_no_check_rx: 1; + unsigned int sk_userlocks: 4; + unsigned int sk_protocol: 8; + unsigned int sk_type: 16; + int sk_wmem_queued; + gfp_t sk_allocation; + u32 sk_pacing_rate; + u32 sk_max_pacing_rate; + netdev_features_t sk_route_caps; + netdev_features_t sk_route_nocaps; + int sk_gso_type; + unsigned int sk_gso_max_size; + u16 sk_gso_max_segs; + int sk_rcvlowat; + long unsigned int sk_lingertime; + struct sk_buff_head sk_error_queue; + struct proto *sk_prot_creator; + rwlock_t sk_callback_lock; + int sk_err; + int sk_err_soft; + u32 sk_ack_backlog; + u32 sk_max_ack_backlog; + __u32 sk_priority; + __u32 sk_mark; + struct pid___2 *sk_peer_pid; + const struct cred *sk_peer_cred; + long int sk_rcvtimeo; + long int sk_sndtimeo; + struct timer_list sk_timer; + ktime_t sk_stamp; + u16 sk_tsflags; + u8 sk_shutdown; + u32 sk_tskey; + struct socket *sk_socket; + void *sk_user_data; + struct page_frag sk_frag; + struct sk_buff *sk_send_head; + __s32 sk_peek_off; + int sk_write_pending; + struct sock_cgroup_data sk_cgrp_data; + struct mem_cgroup *sk_memcg; + void (*sk_state_change)(struct sock *); + void (*sk_data_ready)(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 callback_head sk_rcu; +}; + +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; + char priority; +}; + +struct inet_cork_full { + struct inet_cork base; + struct flowi fl; +}; + +struct ip_mc_socklist; + +struct inet_sock { + struct sock sk; + __be32 inet_saddr; + __s16 uc_ttl; + __u16 cmsg_flags; + __be16 inet_sport; + __u16 inet_id; + struct ip_options_rcu *inet_opt; + int rx_dst_ifindex; + __u8 tos; + __u8 min_ttl; + __u8 mc_ttl; + __u8 pmtudisc; + __u8 recverr: 1; + __u8 is_icsk: 1; + __u8 freebind: 1; + __u8 hdrincl: 1; + __u8 mc_loop: 1; + __u8 transparent: 1; + __u8 mc_all: 1; + __u8 nodefrag: 1; + __u8 bind_address_no_port: 1; + __u8 rcv_tos; + __u8 convert_csum; + int uc_index; + int mc_index; + __be32 mc_addr; + 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 tcp_congestion_ops; + +struct inet_connection_sock_af_ops; + +struct inet_connection_sock { + struct inet_sock icsk_inet; + struct request_sock_queue icsk_accept_queue; + struct inet_bind_bucket *icsk_bind_hash; + long unsigned int icsk_timeout; + struct timer_list icsk_retransmit_timer; + struct timer_list icsk_delack_timer; + __u32 icsk_rto; + __u32 icsk_pmtu_cookie; + const struct tcp_congestion_ops *icsk_ca_ops; + const struct inet_connection_sock_af_ops *icsk_af_ops; + unsigned int (*icsk_sync_mss)(struct sock *, u32); + __u8 icsk_ca_state: 6; + __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 blocked; + __u32 ato; + long unsigned int timeout; + __u32 lrcvtime; + __u16 last_seg_size; + __u16 rcv_mss; + } icsk_ack; + struct { + int enabled; + int search_high; + int search_low; + int probe_size; + u32 probe_timestamp; + } icsk_mtup; + u32 icsk_user_timeout; + u64 icsk_ca_priv[8]; +}; + +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 net_frag_header_len; + u16 sockaddr_len; + int (*setsockopt)(struct sock *, int, int, char *, unsigned int); + int (*getsockopt)(struct sock *, int, int, char *, int *); + int (*compat_setsockopt)(struct sock *, int, int, char *, unsigned int); + int (*compat_getsockopt)(struct sock *, int, int, char *, int *); + void (*addr2sockaddr)(struct sock *, struct sockaddr *); + int (*bind_conflict)(const struct sock *, const struct inet_bind_bucket *, bool); + void (*mtu_reduced)(struct sock *); +}; + +struct inet_ehash_bucket { + struct hlist_nulls_head chain; +}; + +struct inet_frag_bucket { + struct hlist_head chain; + spinlock_t chain_lock; +}; + +struct netns_frags; + +struct inet_frag_queue { + spinlock_t lock; + struct timer_list timer; + struct hlist_node list; + atomic_t refcnt; + struct sk_buff *fragments; + struct sk_buff *fragments_tail; + ktime_t stamp; + int len; + int meat; + __u8 flags; + u16 max_size; + struct netns_frags *net; + struct hlist_node list_evictor; +}; + +struct inet_frags { + struct inet_frag_bucket hash[1024]; + struct work_struct frags_work; + unsigned int next_bucket; + long unsigned int last_rebuild_jiffies; + bool rebuild; + u32 rnd; + seqlock_t rnd_seqlock; + int qsize; + unsigned int (*hashfn)(const struct inet_frag_queue *); + bool (*match)(const struct inet_frag_queue *, const void *); + void (*constructor)(struct inet_frag_queue *, const void *); + void (*destructor)(struct inet_frag_queue *); + void (*frag_expire)(long unsigned int); + struct kmem_cache *frags_cachep; + const char *frags_cache_name; +}; + +struct inet_listen_hashbucket { + spinlock_t lock; + struct hlist_head head; +}; + +struct inet_hashinfo { + struct inet_ehash_bucket *ehash; + spinlock_t *ehash_locks; + unsigned int ehash_mask; + unsigned int ehash_locks_mask; + struct inet_bind_hashbucket *bhash; + unsigned int bhash_size; + struct kmem_cache *bind_bucket_cachep; + long: 64; + long: 64; + struct inet_listen_hashbucket listening_hash[32]; +}; + +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 inet_peer *avl_left; + struct inet_peer *avl_right; + struct inetpeer_addr daddr; + __u32 avl_height; + u32 metrics[16]; + u32 rate_tokens; + long unsigned int rate_last; + union { + struct list_head gc_list; + struct callback_head gc_rcu; + }; + union { + struct { + atomic_t rid; + }; + struct callback_head rcu; + struct inet_peer *gc_next; + }; + __u32 dtime; + atomic_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 request_sock { + struct sock_common __req_common; + struct request_sock *dl_next; + u16 mss; + u8 num_retrans; + u8 cookie_ts: 1; + u8 num_timeout: 7; + u32 ts_recent; + struct timer_list rsk_timer; + const struct request_sock_ops *rsk_ops; + struct sock *sk; + u32 *saved_syn; + u32 secid; + u32 peer_secid; +}; + +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; + u32 ir_mark; + union { + struct ip_options_rcu *opt; + struct sk_buff *pktopts; + }; +}; + +struct inet_skb_parm { + int iif; + struct ip_options opt; + unsigned char flags; + u16 frag_max_size; +}; + +struct inet_timewait_death_row { + atomic_t tw_count; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + struct inet_hashinfo *hashinfo; + int sysctl_tw_recycle; + 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; + int tw_timeout; + volatile unsigned char tw_substate; + unsigned char tw_rcv_wscale; + __be16 tw_sport; + unsigned int tw_kill: 1; + unsigned int tw_transparent: 1; + unsigned int tw_flowlabel: 20; + unsigned int tw_pad: 2; + unsigned int tw_tos: 8; + struct timer_list tw_timer; + struct inet_bind_bucket *tw_tb; +}; + +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 kstat; + +struct inode_operations___2 { + struct dentry___2 * (*lookup)(struct inode *, struct dentry___2 *, unsigned int); + const char * (*get_link)(struct dentry___2 *, struct inode *, struct delayed_call *); + int (*permission)(struct inode *, int); + struct posix_acl * (*get_acl)(struct inode *, int); + int (*readlink)(struct dentry___2 *, char *, int); + int (*create)(struct inode *, struct dentry___2 *, umode_t, bool); + int (*link)(struct dentry___2 *, struct inode *, struct dentry___2 *); + int (*unlink)(struct inode *, struct dentry___2 *); + int (*symlink)(struct inode *, struct dentry___2 *, const char *); + int (*mkdir)(struct inode *, struct dentry___2 *, umode_t); + int (*rmdir)(struct inode *, struct dentry___2 *); + int (*mknod)(struct inode *, struct dentry___2 *, umode_t, dev_t); + int (*rename)(struct inode *, struct dentry___2 *, struct inode *, struct dentry___2 *); + int (*rename2)(struct inode *, struct dentry___2 *, struct inode *, struct dentry___2 *, unsigned int); + int (*setattr)(struct dentry___2 *, struct iattr___2 *); + int (*getattr)(struct vfsmount *, struct dentry___2 *, struct kstat *); + int (*setxattr)(struct dentry___2 *, struct inode *, const char *, const void *, size_t, int); + ssize_t (*getxattr)(struct dentry___2 *, struct inode *, const char *, void *, size_t); + ssize_t (*listxattr)(struct dentry___2 *, char *, size_t); + int (*removexattr)(struct dentry___2 *, const char *); + int (*fiemap)(struct inode *, struct fiemap_extent_info *, u64, u64); + int (*update_time)(struct inode *, struct timespec *, int); + int (*atomic_open)(struct inode *, struct dentry___2 *, struct file___2 *, unsigned int, umode_t, int *); + int (*tmpfile)(struct inode *, struct dentry___2 *, umode_t); + int (*set_acl)(struct inode *, struct posix_acl *, int); + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; +}; + +struct inode_operations { + struct dentry * (*lookup)(struct inode___2 *, struct dentry *, unsigned int); + const char * (*get_link)(struct dentry *, struct inode___2 *, struct delayed_call *); + int (*permission)(struct inode___2 *, int); + struct posix_acl * (*get_acl)(struct inode___2 *, int); + int (*readlink)(struct dentry *, char *, int); + int (*create)(struct inode___2 *, struct dentry *, umode_t, bool); + int (*link)(struct dentry *, struct inode___2 *, struct dentry *); + int (*unlink)(struct inode___2 *, struct dentry *); + int (*symlink)(struct inode___2 *, struct dentry *, const char *); + int (*mkdir)(struct inode___2 *, struct dentry *, umode_t); + int (*rmdir)(struct inode___2 *, struct dentry *); + int (*mknod)(struct inode___2 *, struct dentry *, umode_t, dev_t); + int (*rename)(struct inode___2 *, struct dentry *, struct inode___2 *, struct dentry *); + int (*rename2)(struct inode___2 *, struct dentry *, struct inode___2 *, struct dentry *, unsigned int); + int (*setattr)(struct dentry *, struct iattr *); + int (*getattr)(struct vfsmount *, struct dentry *, struct kstat *); + int (*setxattr)(struct dentry *, struct inode___2 *, const char *, const void *, size_t, int); + ssize_t (*getxattr)(struct dentry *, struct inode___2 *, const char *, void *, size_t); + ssize_t (*listxattr)(struct dentry *, char *, size_t); + int (*removexattr)(struct dentry *, const char *); + int (*fiemap)(struct inode___2 *, struct fiemap_extent_info *, u64, u64); + int (*update_time)(struct inode___2 *, struct timespec *, int); + int (*atomic_open)(struct inode___2 *, struct dentry *, struct file *, unsigned int, umode_t, int *); + int (*tmpfile)(struct inode___2 *, struct dentry *, umode_t); + int (*set_acl)(struct inode___2 *, struct posix_acl *, int); + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; +}; + +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; + 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_mt; + +struct input_value; + +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; + 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___2 mutex; + unsigned int users; + bool going_away; + struct device___2 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; +}; + +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 driver_info; +}; + +struct input_devres { + struct input_dev *input; +}; + +struct input_event_compat { + struct compat_timeval time; + __u16 type; + __u16 code; + __s32 value; +}; + +struct input_handler { + void *private; + void (*event)(struct input_handle *, unsigned int, unsigned int, int); + void (*events)(struct input_handle *, const 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 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_led { + struct led_classdev cdev; + struct input_handle *handle; + unsigned int code; +}; + +struct input_leds { + struct input_handle handle; + unsigned int num_leds; + struct input_led leds[0]; +}; + +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_polled_dev { + void *private; + void (*open)(struct input_polled_dev *); + void (*close)(struct input_polled_dev *); + void (*poll)(struct input_polled_dev *); + unsigned int poll_interval; + unsigned int poll_interval_max; + unsigned int poll_interval_min; + struct input_dev *input; + struct delayed_work work; + bool devres_managed; +}; + +struct input_polled_devres { + struct input_polled_dev *polldev; +}; + +struct input_res { + const char *name; + int w; + int h; +}; + +union input_seq_state { + struct { + short unsigned int pos; + bool mutex_acquired; + }; + void *p; +}; + +struct input_value { + __u16 type; + __u16 code; + __s32 value; +}; + +struct insert_entries { + struct i915_address_space *vm; + struct sg_table *st; + uint64_t start; + enum i915_cache_level level; + u32 flags; +}; + +struct insn_field { + union { + insn_value_t value; + insn_byte_t bytes[4]; + }; + unsigned char got; + unsigned char nbytes; +}; + +struct insn { + struct insn_field prefixes; + struct insn_field rex_prefix; + struct insn_field vex_prefix; + struct insn_field opcode; + struct insn_field modrm; + struct insn_field sib; + struct insn_field displacement; + union { + struct insn_field immediate; + struct insn_field moffset1; + struct insn_field immediate1; + }; + union { + struct insn_field moffset2; + struct insn_field immediate2; + }; + insn_attr_t attr; + unsigned char opnd_bytes; + unsigned char addr_bytes; + unsigned char length; + unsigned char x86_64; + const insn_byte_t *kaddr; + const insn_byte_t *end_kaddr; + const insn_byte_t *next_byte; +}; + +struct instr_dual { + struct opcode mod012; + struct opcode mod3; +}; + +struct intel8x0 { + unsigned int device_type; + int irq; + void *addr; + void *bmaddr; + struct pci_dev *pci; + struct snd_card *card; + int pcm_devs; + struct snd_pcm *pcm[6]; + struct ichdev ichd[6]; + unsigned int multi4: 1; + unsigned int multi6: 1; + unsigned int multi8: 1; + unsigned int dra: 1; + unsigned int smp20bit: 1; + unsigned int in_ac97_init: 1; + unsigned int in_sdin_init: 1; + unsigned int in_measurement: 1; + unsigned int fix_nocache: 1; + unsigned int buggy_irq: 1; + unsigned int xbox: 1; + unsigned int buggy_semaphore: 1; + unsigned int inside_vm: 1; + int spdif_idx; + unsigned int sdm_saved; + struct snd_ac97_bus *ac97_bus; + struct snd_ac97 *ac97[3]; + unsigned int ac97_sdin[3]; + unsigned int max_codecs; + unsigned int ncodecs; + unsigned int *codec_bit; + unsigned int codec_isr_bits; + unsigned int codec_ready_bits; + spinlock_t reg_lock; + u32 bdbars_count; + struct snd_dma_buffer bdbars; + u32 int_sta_reg; + u32 int_sta_mask; +}; + +struct intel_agp_driver_description { + unsigned int chip_id; + char *name; + const struct agp_bridge_driver *driver; +}; + +struct intel_atomic_state { + struct drm_atomic_state base; + unsigned int cdclk; + unsigned int dev_cdclk; + bool dpll_set; + bool modeset; + unsigned int active_crtcs; + unsigned int min_pixclk[3]; + struct intel_shared_dpll_config shared_dpll[6]; + struct intel_wm_config wm_config; + bool skip_intermediate_wm; +}; + +struct pwm_device; + +struct intel_connector; + +struct intel_panel { + struct drm_display_mode *fixed_mode; + struct drm_display_mode *downclock_mode; + int fitting_mode; + struct { + bool present; + u32 level; + u32 min; + u32 max; + bool enabled; + bool combination_mode; + bool active_low_pwm; + bool util_pin_active_low; + u8 controller; + struct pwm_device *pwm; + struct backlight_device *device; + int (*setup)(struct intel_connector *, enum pipe); + uint32_t (*get)(struct intel_connector *); + void (*set)(struct intel_connector *, uint32_t); + void (*disable)(struct intel_connector *); + void (*enable)(struct intel_connector *); + uint32_t (*hz_to_pwm)(struct intel_connector *, uint32_t); + void (*power)(struct intel_connector *, bool); + } backlight; +}; + +struct intel_connector { + struct drm_connector base; + struct intel_encoder *encoder; + bool (*get_hw_state)(struct intel_connector *); + void (*unregister)(struct intel_connector *); + struct intel_panel panel; + struct edid *edid; + struct edid *detect_edid; + u8 polled; + void *port; + struct intel_dp *mst_port; +}; + +struct intel_context { + struct kref ref; + int user_handle; + uint8_t remap_slice; + struct drm_i915_private *i915; + int flags; + struct drm_i915_file_private *file_priv; + struct i915_ctx_hang_stats hang_stats; + struct i915_hw_ppgtt *ppgtt; + struct { + struct drm_i915_gem_object *rcs_state; + bool initialized; + } legacy_hw_ctx; + struct { + struct drm_i915_gem_object *state; + struct intel_ringbuffer *ringbuf; + int pin_count; + struct i915_vma *lrc_vma; + u64 lrc_desc; + uint32_t *lrc_reg_state; + } engine[5]; + struct list_head link; +}; + +struct intel_encoder { + struct drm_encoder base; + enum intel_output_type type; + unsigned int cloneable; + void (*hot_plug)(struct intel_encoder *); + bool (*compute_config)(struct intel_encoder *, struct intel_crtc_state *); + void (*pre_pll_enable)(struct intel_encoder *); + void (*pre_enable)(struct intel_encoder *); + void (*enable)(struct intel_encoder *); + void (*mode_set)(struct intel_encoder *); + void (*disable)(struct intel_encoder *); + void (*post_disable)(struct intel_encoder *); + void (*post_pll_disable)(struct intel_encoder *); + bool (*get_hw_state)(struct intel_encoder *, enum pipe *); + void (*get_config)(struct intel_encoder *, struct intel_crtc_state *); + void (*suspend)(struct intel_encoder *); + int crtc_mask; + enum hpd_pin hpd_pin; +}; + +struct intel_crt { + struct intel_encoder base; + struct intel_connector *connector; + bool force_hotplug_required; + i915_reg_t adpa_reg; +}; + +struct intel_wm_level { + bool enable; + uint32_t pri_val; + uint32_t spr_val; + uint32_t cur_val; + uint32_t fbc_val; +}; + +struct intel_pipe_wm { + struct intel_wm_level wm[5]; + struct intel_wm_level raw_wm[5]; + uint32_t linetime; + bool fbc_wm_enabled; + bool pipe_enabled; + bool sprites_enabled; + bool sprites_scaled; +}; + +struct skl_wm_level { + bool plane_en[4]; + uint16_t plane_res_b[4]; + uint8_t plane_res_l[4]; +}; + +struct skl_pipe_wm { + struct skl_wm_level wm[8]; + struct skl_wm_level trans_wm; + uint32_t linetime; +}; + +struct vlv_wm_state { + struct vlv_pipe_wm wm[3]; + struct vlv_sr_wm sr[3]; + uint8_t num_active_planes; + uint8_t num_levels; + uint8_t level; + bool cxsr; +}; + +struct intel_unpin_work; + +struct intel_crtc { + struct drm_crtc base; + enum pipe pipe; + enum plane plane; + u8 lut_r[256]; + u8 lut_g[256]; + u8 lut_b[256]; + bool active; + long unsigned int enabled_power_domains; + bool lowfreq_avail; + struct intel_overlay *overlay; + struct intel_unpin_work *unpin_work; + atomic_t unpin_work_count; + u32 dspaddr_offset; + int adjusted_x; + int adjusted_y; + uint32_t cursor_addr; + uint32_t cursor_cntl; + uint32_t cursor_size; + uint32_t cursor_base; + struct intel_crtc_state *config; + unsigned int reset_counter; + bool cpu_fifo_underrun_disabled; + bool pch_fifo_underrun_disabled; + struct { + union { + struct intel_pipe_wm ilk; + struct skl_pipe_wm skl; + } active; + bool cxsr_allowed; + } wm; + int scanline_offset; + struct { + unsigned int start_vbl_count; + ktime_t start_vbl_time; + int min_vbl; + int max_vbl; + int scanline_start; + } debug; + int num_scalers; + struct vlv_wm_state wm_state; +}; + +struct intel_scaler { + int in_use; + uint32_t mode; +}; + +struct intel_crtc_scaler_state { + struct intel_scaler scalers[2]; + unsigned int scaler_users; + int scaler_id; +}; + +struct intel_link_m_n { + uint32_t tu; + uint32_t gmch_m; + uint32_t gmch_n; + uint32_t link_m; + uint32_t link_n; +}; + +struct intel_crtc_state { + struct drm_crtc_state base; + long unsigned int quirks; + unsigned int fb_bits; + bool update_pipe; + bool disable_cxsr; + bool update_wm_pre; + bool update_wm_post; + bool fb_changed; + int pipe_src_w; + int pipe_src_h; + bool has_pch_encoder; + bool has_infoframe; + enum transcoder cpu_transcoder; + bool limited_color_range; + bool has_dp_encoder; + bool has_dsi_encoder; + bool has_hdmi_sink; + bool has_audio; + bool dither; + bool clock_set; + bool sdvo_tv_clock; + bool bw_constrained; + struct dpll dpll; + struct intel_shared_dpll *shared_dpll; + uint32_t ddi_pll_sel; + struct intel_dpll_hw_state dpll_hw_state; + struct { + u32 ctrl; + u32 div; + } dsi_pll; + int pipe_bpp; + struct intel_link_m_n dp_m_n; + struct intel_link_m_n dp_m2_n2; + bool has_drrs; + int port_clock; + unsigned int pixel_multiplier; + uint8_t lane_count; + struct { + u32 control; + u32 pgm_ratios; + u32 lvds_border_bits; + } gmch_pfit; + struct { + u32 pos; + u32 size; + bool enabled; + bool force_thru; + } pch_pfit; + int fdi_lanes; + struct intel_link_m_n fdi_m_n; + bool ips_enabled; + bool enable_fbc; + bool double_wide; + bool dp_encoder_is_mst; + int pbn; + struct intel_crtc_scaler_state scaler_state; + enum pipe hsw_workaround_pipe; + bool disable_lp_wm; + struct { + union { + struct intel_pipe_wm ilk; + struct skl_pipe_wm skl; + } optimal; + struct intel_pipe_wm intermediate; + bool need_postvbl_update; + } wm; + uint32_t gamma_mode; +}; + +struct intel_css_header { + uint32_t module_type; + uint32_t header_len; + uint32_t header_ver; + uint32_t module_id; + uint32_t module_vendor; + uint32_t date; + uint32_t size; + uint32_t key_size; + uint32_t modulus_size; + uint32_t exponent_size; + uint32_t reserved1[12]; + uint32_t version; + uint32_t reserved2[8]; + uint32_t kernel_header_info; +}; + +struct intel_cursor_error_state { + u32 control; + u32 position; + u32 base; + u32 size; +}; + +struct intel_dp_mst_encoder; + +struct intel_dp { + i915_reg_t output_reg; + i915_reg_t aux_ch_ctl_reg; + i915_reg_t aux_ch_data_reg[5]; + uint32_t DP; + int link_rate; + uint8_t lane_count; + uint8_t sink_count; + bool has_audio; + bool detect_done; + enum hdmi_force_audio force_audio; + bool limited_color_range; + bool color_range_auto; + uint8_t dpcd[15]; + uint8_t psr_dpcd[2]; + uint8_t downstream_ports[16]; + uint8_t num_sink_rates; + int sink_rates[8]; + struct drm_dp_aux aux; + uint8_t train_set[4]; + int panel_power_up_delay; + int panel_power_down_delay; + int panel_power_cycle_delay; + int backlight_on_delay; + int backlight_off_delay; + struct delayed_work panel_vdd_work; + bool want_panel_vdd; + long unsigned int last_power_on; + long unsigned int last_backlight_off; + ktime_t panel_power_off_time; + struct notifier_block edp_notifier; + enum pipe pps_pipe; + struct edp_power_seq pps_delays; + bool can_mst; + bool is_mst; + int active_mst_links; + struct intel_connector *attached_connector; + struct intel_dp_mst_encoder *mst_encoders[3]; + struct drm_dp_mst_topology_mgr mst_mgr; + uint32_t (*get_aux_clock_divider)(struct intel_dp *, int); + uint32_t (*get_aux_send_ctl)(struct intel_dp *, bool, int, uint32_t); + void (*prepare_link_retrain)(struct intel_dp *); + bool train_set_valid; + long unsigned int compliance_test_type; + long unsigned int compliance_test_data; + bool compliance_test_active; +}; + +struct intel_hdmi { + i915_reg_t hdmi_reg; + int ddc_bus; + struct { + enum drm_dp_dual_mode_type type; + int max_tmds_clock; + } dp_dual_mode; + bool limited_color_range; + bool color_range_auto; + bool has_hdmi_sink; + bool has_audio; + enum hdmi_force_audio force_audio; + bool rgb_quant_range_selectable; + enum hdmi_picture_aspect aspect_ratio; + struct intel_connector *attached_connector; + void (*write_infoframe)(struct drm_encoder *, enum hdmi_infoframe_type, const void *, ssize_t); + void (*set_infoframes)(struct drm_encoder *, bool, const struct drm_display_mode *); + bool (*infoframe_enabled)(struct drm_encoder *, const struct intel_crtc_state *); +}; + +struct intel_digital_port { + struct intel_encoder base; + enum port port; + u32 saved_port_bits; + struct intel_dp dp; + struct intel_hdmi hdmi; + enum irqreturn (*hpd_pulse)(struct intel_digital_port *, bool); + bool release_cl2_override; + uint8_t max_lanes; + const struct drm_connector *audio_connector; +}; + +struct intel_pipe_error_state { + bool power_domain_on; + u32 source; + u32 stat; +}; + +struct intel_plane_error_state { + u32 control; + u32 stride; + u32 size; + u32 pos; + u32 addr; + u32 surface; + u32 tile_offset; +}; + +struct intel_transcoder_error_state { + bool power_domain_on; + enum transcoder cpu_transcoder; + u32 conf; + u32 htotal; + u32 hblank; + u32 hsync; + u32 vtotal; + u32 vblank; + u32 vsync; +}; + +struct intel_display_error_state { + u32 power_well_driver; + int num_transcoders; + struct intel_cursor_error_state cursor[3]; + struct intel_pipe_error_state pipe[3]; + struct intel_plane_error_state plane[3]; + struct intel_transcoder_error_state transcoder[4]; +}; + +struct intel_dmc_header { + uint32_t signature; + unsigned char header_len; + unsigned char header_ver; + uint16_t dmcc_ver; + uint32_t project; + uint32_t fw_size; + uint32_t fw_version; + uint32_t mmio_count; + uint32_t mmioaddr[8]; + uint32_t mmiodata[8]; + unsigned char dfile[32]; + uint32_t reserved1[2]; +}; + +struct intel_dmi_quirk { + void (*hook)(struct drm_device *); + const struct dmi_system_id (*dmi_id_list)[0]; +}; + +struct intel_dp_mst_encoder { + struct intel_encoder base; + enum pipe pipe; + struct intel_digital_port *primary; + struct intel_connector *connector; +}; + +struct intel_dpll_mgr { + const struct dpll_info *dpll_info; + struct intel_shared_dpll * (*get_dpll)(struct intel_crtc *, struct intel_crtc_state *, struct intel_encoder *); +}; + +struct gpio_desc; + +struct intel_dsi_host; + +struct intel_dsi { + struct intel_encoder base; + struct drm_panel *panel; + struct intel_dsi_host *dsi_hosts[5]; + struct gpio_desc *gpio_panel; + struct intel_connector *attached_connector; + u16 ports; + bool hs; + int channel; + u16 operation_mode; + unsigned int lane_count; + enum mipi_dsi_pixel_format pixel_format; + u32 video_mode_format; + u8 eotp_pkt; + u8 clock_stop; + u8 escape_clk_div; + u8 dual_link; + u8 pixel_overlap; + u32 port_bits; + u32 bw_timer; + u32 dphy_reg; + u32 video_frmt_cfg_bits; + u16 lp_byte_clk; + u16 lp_rx_timeout; + u16 turn_arnd_val; + u16 rst_timer_val; + u16 hs_to_lp_count; + u16 clk_lp_to_hs_count; + u16 clk_hs_to_lp_count; + u16 init_count; + u32 pclk; + u16 burst_mode_ratio; + u16 backlight_off_delay; + u16 backlight_on_delay; + u16 panel_on_delay; + u16 panel_off_delay; + u16 panel_pwr_cycle_delay; +}; + +struct mipi_dsi_host_ops; + +struct mipi_dsi_host { + struct device___2 *dev; + const struct mipi_dsi_host_ops *ops; + struct list_head list; +}; + +struct mipi_dsi_device; + +struct intel_dsi_host { + struct mipi_dsi_host base; + struct intel_dsi *intel_dsi; + enum port port; + struct mipi_dsi_device *device; +}; + +struct intel_dsm_priv { + acpi_handle dhandle; +}; + +struct intel_dvo_dev_ops; + +struct intel_dvo_device { + const char *name; + int type; + i915_reg_t dvo_reg; + i915_reg_t dvo_srcdim_reg; + u32 gpio; + int slave_addr; + const struct intel_dvo_dev_ops *dev_ops; + void *dev_priv; + struct i2c_adapter *i2c_bus; +}; + +struct intel_dvo { + struct intel_encoder base; + struct intel_dvo_device dev; + struct intel_connector *attached_connector; + bool panel_wants_dither; +}; + +struct intel_dvo_dev_ops { + bool (*init)(struct intel_dvo_device *, struct i2c_adapter *); + void (*create_resources)(struct intel_dvo_device *); + void (*dpms)(struct intel_dvo_device *, bool); + int (*mode_valid)(struct intel_dvo_device *, struct drm_display_mode *); + void (*prepare)(struct intel_dvo_device *); + void (*commit)(struct intel_dvo_device *); + void (*mode_set)(struct intel_dvo_device *, const struct drm_display_mode *, const struct drm_display_mode *); + enum drm_connector_status (*detect)(struct intel_dvo_device *); + bool (*get_hw_state)(struct intel_dvo_device *); + struct drm_display_mode * (*get_modes)(struct intel_dvo_device *); + void (*destroy)(struct intel_dvo_device *); + void (*dump_regs)(struct intel_dvo_device *); +}; + +struct intel_excl_states { + enum intel_excl_state_type state[64]; + bool sched_started; +}; + +struct intel_excl_cntrs { + raw_spinlock_t lock; + struct intel_excl_states states[2]; + union { + u16 has_exclusive[2]; + u32 exclusive_present; + }; + int refcnt; + unsigned int core_id; +}; + +struct intel_framebuffer; + +struct intel_fbdev { + struct drm_fb_helper helper; + struct intel_framebuffer *fb; + int preferred_bpp; +}; + +struct intel_framebuffer { + struct drm_framebuffer base; + struct drm_i915_gem_object *obj; + struct intel_rotation_info rot_info; +}; + +struct intel_fw_info { + uint16_t reserved1; + char stepping; + char substepping; + uint32_t offset; + uint32_t reserved2; +}; + +struct intel_gtt_driver { + unsigned int gen: 8; + unsigned int is_g33: 1; + unsigned int is_pineview: 1; + unsigned int is_ironlake: 1; + unsigned int has_pgtbl_enable: 1; + unsigned int dma_mask_size: 8; + int (*setup)(void); + void (*cleanup)(void); + void (*write_entry)(dma_addr_t, unsigned int, unsigned int); + bool (*check_flags)(unsigned int); + void (*chipset_flush)(void); +}; + +struct intel_gtt_driver_description { + unsigned int gmch_chip_id; + char *name; + const struct intel_gtt_driver *gtt_driver; +}; + +struct intel_initial_plane_config { + struct intel_framebuffer *fb; + unsigned int tiling; + int size; + u32 base; +}; + +struct iommu_flush { + void (*flush_context)(struct intel_iommu *, u16, u16, u8, u64); + void (*flush_iotlb)(struct intel_iommu *, u16, u64, unsigned int, u64); +}; + +struct root_entry; + +struct q_inval; + +struct intel_iommu { + void *reg; + u64 reg_phys; + u64 reg_size; + u64 cap; + u64 ecap; + u32 gcmd; + raw_spinlock_t register_lock; + int seq_id; + int agaw; + int msagaw; + unsigned int irq; + unsigned int pr_irq; + u16 segment; + unsigned char name[13]; + long unsigned int *domain_ids; + struct dmar_domain ***domains; + spinlock_t lock; + struct root_entry *root_entry; + struct iommu_flush flush; + struct q_inval *qi; + u32 *iommu_state; + struct device___2 *iommu_dev; + int node; + u32 flags; +}; + +struct intel_limit { + intel_range_t dot; + intel_range_t vco; + intel_range_t n; + intel_range_t m; + intel_range_t m1; + intel_range_t m2; + intel_range_t p; + intel_range_t p1; + intel_p2_t p2; +}; + +typedef struct intel_limit intel_limit_t; + +struct intel_load_detect_pipe { + struct drm_atomic_state *restore_state; +}; + +struct intel_lvds_connector { + struct intel_connector base; + struct notifier_block lid_notifier; +}; + +struct intel_lvds_encoder { + struct intel_encoder base; + bool is_dual_link; + i915_reg_t reg; + u32 a3_power; + struct intel_lvds_connector *attached_connector; +}; + +struct intel_mmio_flip { + struct work_struct work; + struct drm_i915_private *i915; + struct drm_i915_gem_request *req; + struct intel_crtc *crtc; + unsigned int rotation; +}; + +struct intel_overlay { + struct drm_device *dev; + struct intel_crtc *crtc; + struct drm_i915_gem_object *vid_bo; + struct drm_i915_gem_object *old_vid_bo; + bool active; + bool pfit_active; + u32 pfit_vscale_ratio; + u32 color_key: 24; + u32 color_key_enabled: 1; + u32 brightness; + u32 contrast; + u32 saturation; + u32 old_xscale; + u32 old_yscale; + u32 flip_addr; + struct drm_i915_gem_object *reg_bo; + struct drm_i915_gem_request *last_flip_req; + void (*flip_tail)(struct intel_overlay *); +}; + +struct overlay_registers { + u32 OBUF_0Y; + u32 OBUF_1Y; + u32 OBUF_0U; + u32 OBUF_0V; + u32 OBUF_1U; + u32 OBUF_1V; + u32 OSTRIDE; + u32 YRGB_VPH; + u32 UV_VPH; + u32 HORZ_PH; + u32 INIT_PHS; + u32 DWINPOS; + u32 DWINSZ; + u32 SWIDTH; + u32 SWIDTHSW; + u32 SHEIGHT; + u32 YRGBSCALE; + u32 UVSCALE; + u32 OCLRC0; + u32 OCLRC1; + u32 DCLRKV; + u32 DCLRKM; + u32 SCLRKVH; + u32 SCLRKVL; + u32 SCLRKEN; + u32 OCONFIG; + u32 OCMD; + u32 RESERVED1; + u32 OSTART_0Y; + u32 OSTART_1Y; + u32 OSTART_0U; + u32 OSTART_0V; + u32 OSTART_1U; + u32 OSTART_1V; + u32 OTILEOFF_0Y; + u32 OTILEOFF_1Y; + u32 OTILEOFF_0U; + u32 OTILEOFF_0V; + u32 OTILEOFF_1U; + u32 OTILEOFF_1V; + u32 FASTHSCALE; + u32 UVSCALEV; + u32 RESERVEDC[86]; + u16 Y_VCOEFS[51]; + u16 RESERVEDD[77]; + u16 Y_HCOEFS[85]; + u16 RESERVEDE[171]; + u16 UV_VCOEFS[51]; + u16 RESERVEDF[77]; + u16 UV_HCOEFS[51]; + u16 RESERVEDG[77]; +}; + +struct intel_overlay_error_state { + struct overlay_registers regs; + long unsigned int base; + u32 dovsta; + u32 isr; +}; + +struct intel_package_header { + unsigned char header_len; + unsigned char header_ver; + unsigned char reserved[10]; + uint32_t num_entries; + struct intel_fw_info fw_info[20]; +}; + +struct intel_pipe_crc_entry { + uint32_t frame; + uint32_t crc[5]; +}; + +struct intel_plane_wm_parameters { + uint32_t horiz_pixels; + uint32_t vert_pixels; + uint8_t bytes_per_pixel; + uint8_t y_bytes_per_pixel; + bool enabled; + bool scaled; + u64 tiling; + unsigned int rotation; + uint16_t fifo_size; +}; + +struct intel_plane_state; + +struct intel_plane { + struct drm_plane base; + int plane; + enum pipe pipe; + bool can_scale; + int max_downscale; + uint32_t frontbuffer_bit; + struct intel_plane_wm_parameters wm; + void (*update_plane)(struct drm_plane *, const struct intel_crtc_state *, const struct intel_plane_state *); + void (*disable_plane)(struct drm_plane *, struct drm_crtc *); + int (*check_plane)(struct drm_plane *, struct intel_crtc_state *, struct intel_plane_state *); +}; + +struct intel_plane_state { + struct drm_plane_state base; + struct drm_rect src; + struct drm_rect dst; + struct drm_rect clip; + bool visible; + int scaler_id; + struct drm_intel_sprite_colorkey ckey; + struct drm_i915_gem_request *wait_req; +}; + +struct intel_pqr_state { + u32 rmid; + u32 closid; + int rmid_usecnt; +}; + +struct intel_quirk { + int device; + int subsystem_vendor; + int subsystem_device; + void (*hook)(struct drm_device *); +}; + +struct intel_rapl_init_fun { + bool apply_quirk; + int cntr_mask; + struct attribute **attrs; +}; + +struct intel_renderstate_rodata { + const u32 *reloc; + const u32 *batch; + const u32 batch_items; +}; + +struct intel_ringbuffer { + struct drm_i915_gem_object *obj; + void *virtual_start; + struct i915_vma *vma; + struct intel_engine_cs *engine; + struct list_head link; + u32 head; + u32 tail; + int space; + int size; + int effective_size; + int reserved_size; + u32 last_retired_head; +}; + +struct intel_sdvo_caps { + u8 vendor_id; + u8 device_id; + u8 device_rev_id; + u8 sdvo_version_major; + u8 sdvo_version_minor; + unsigned int sdvo_inputs_mask: 2; + unsigned int smooth_scaling: 1; + unsigned int sharp_scaling: 1; + unsigned int up_scaling: 1; + unsigned int down_scaling: 1; + unsigned int stall_support: 1; + unsigned int pad: 1; + u16 output_flags; +}; + +struct intel_sdvo { + struct intel_encoder base; + struct i2c_adapter *i2c; + u8 slave_addr; + long: 0; + struct i2c_adapter ddc; + i915_reg_t sdvo_reg; + uint16_t controlled_output; + struct intel_sdvo_caps caps; + long: 0; + int pixel_clock_min; + int pixel_clock_max; + uint16_t attached_output; + uint16_t hotplug_active; + uint32_t color_range; + bool color_range_auto; + int: 0; + enum hdmi_picture_aspect aspect_ratio; + bool is_tv; + int: 0; + enum port port; + int tv_format_index; + bool is_hdmi; + bool has_hdmi_monitor; + bool has_hdmi_audio; + bool rgb_quant_range_selectable; + bool is_lvds; + long: 0; + struct drm_display_mode *sdvo_lvds_fixed_mode; + uint8_t ddc_bus; + uint8_t dtd_sdvo_flags; + long: 0; +} __attribute__((packed)); + +struct intel_sdvo_connector { + struct intel_connector base; + uint16_t output_flag; + enum hdmi_force_audio force_audio; + u8 tv_format_supported[19]; + int format_supported_num; + struct drm_property *tv_format; + struct drm_property *left; + struct drm_property *right; + struct drm_property *top; + struct drm_property *bottom; + struct drm_property *hpos; + struct drm_property *vpos; + struct drm_property *contrast; + struct drm_property *saturation; + struct drm_property *hue; + struct drm_property *sharpness; + struct drm_property *flicker_filter; + struct drm_property *flicker_filter_adaptive; + struct drm_property *flicker_filter_2d; + struct drm_property *tv_chroma_filter; + struct drm_property *tv_luma_filter; + struct drm_property *dot_crawl; + struct drm_property *brightness; + u32 left_margin; + u32 right_margin; + u32 top_margin; + u32 bottom_margin; + u32 max_hscan; + u32 max_vscan; + u32 max_hpos; + u32 cur_hpos; + u32 max_vpos; + u32 cur_vpos; + u32 cur_brightness; + u32 max_brightness; + u32 cur_contrast; + u32 max_contrast; + u32 cur_saturation; + u32 max_saturation; + u32 cur_hue; + u32 max_hue; + u32 cur_sharpness; + u32 max_sharpness; + u32 cur_flicker_filter; + u32 max_flicker_filter; + u32 cur_flicker_filter_adaptive; + u32 max_flicker_filter_adaptive; + u32 cur_flicker_filter_2d; + u32 max_flicker_filter_2d; + u32 cur_tv_chroma_filter; + u32 max_tv_chroma_filter; + u32 cur_tv_luma_filter; + u32 max_tv_luma_filter; + u32 cur_dot_crawl; + u32 max_dot_crawl; +}; + +struct intel_sdvo_dtd { + struct { + u16 clock; + u8 h_active; + u8 h_blank; + u8 h_high; + u8 v_active; + u8 v_blank; + u8 v_high; + } part1; + struct { + u8 h_sync_off; + u8 h_sync_width; + u8 v_sync_off_width; + u8 sync_off_width_high; + u8 dtd_flags; + u8 sdvo_flags; + u8 v_sync_off_high; + u8 reserved; + } part2; +}; + +struct intel_sdvo_encode { + u8 dvi_rev; + u8 hdmi_rev; +}; + +struct intel_sdvo_enhancements_reply { + unsigned int flicker_filter: 1; + unsigned int flicker_filter_adaptive: 1; + unsigned int flicker_filter_2d: 1; + unsigned int saturation: 1; + unsigned int hue: 1; + unsigned int brightness: 1; + unsigned int contrast: 1; + unsigned int overscan_h: 1; + unsigned int overscan_v: 1; + unsigned int hpos: 1; + unsigned int vpos: 1; + unsigned int sharpness: 1; + unsigned int dot_crawl: 1; + unsigned int dither: 1; + unsigned int tv_chroma_filter: 1; + unsigned int tv_luma_filter: 1; +} __attribute__((packed)); + +struct intel_sdvo_get_trained_inputs_response { + unsigned int input0_trained: 1; + unsigned int input1_trained: 1; + unsigned int pad: 6; +} __attribute__((packed)); + +struct intel_sdvo_in_out_map { + u16 in0; + u16 in1; +}; + +struct intel_sdvo_pixel_clock_range { + u16 min; + u16 max; +}; + +struct intel_sdvo_preferred_input_timing_args { + u16 clock; + u16 width; + u16 height; + u8 interlace: 1; + u8 scaled: 1; + u8 pad: 6; +} __attribute__((packed)); + +struct intel_sdvo_sdtv_resolution_request { + unsigned int ntsc_m: 1; + unsigned int ntsc_j: 1; + unsigned int ntsc_443: 1; + unsigned int pal_b: 1; + unsigned int pal_d: 1; + unsigned int pal_g: 1; + unsigned int pal_h: 1; + unsigned int pal_i: 1; + unsigned int pal_m: 1; + unsigned int pal_n: 1; + unsigned int pal_nc: 1; + unsigned int pal_60: 1; + unsigned int secam_b: 1; + unsigned int secam_d: 1; + unsigned int secam_g: 1; + unsigned int secam_k: 1; + unsigned int secam_k1: 1; + unsigned int secam_l: 1; + unsigned int secam_60: 1; + unsigned int pad: 5; +} __attribute__((packed)); + +struct intel_sdvo_set_target_input_args { + unsigned int target_1: 1; + unsigned int pad: 7; +} __attribute__((packed)); + +struct intel_sdvo_tv_format { + unsigned int ntsc_m: 1; + unsigned int ntsc_j: 1; + unsigned int ntsc_443: 1; + unsigned int pal_b: 1; + unsigned int pal_d: 1; + unsigned int pal_g: 1; + unsigned int pal_h: 1; + unsigned int pal_i: 1; + unsigned int pal_m: 1; + unsigned int pal_n: 1; + unsigned int pal_nc: 1; + unsigned int pal_60: 1; + unsigned int secam_b: 1; + unsigned int secam_d: 1; + unsigned int secam_g: 1; + unsigned int secam_k: 1; + unsigned int secam_k1: 1; + unsigned int secam_l: 1; + unsigned int secam_60: 1; + unsigned int hdtv_std_smpte_240m_1080i_59: 1; + unsigned int hdtv_std_smpte_240m_1080i_60: 1; + unsigned int hdtv_std_smpte_260m_1080i_59: 1; + unsigned int hdtv_std_smpte_260m_1080i_60: 1; + unsigned int hdtv_std_smpte_274m_1080i_50: 1; + unsigned int hdtv_std_smpte_274m_1080i_59: 1; + unsigned int hdtv_std_smpte_274m_1080i_60: 1; + unsigned int hdtv_std_smpte_274m_1080p_23: 1; + unsigned int hdtv_std_smpte_274m_1080p_24: 1; + unsigned int hdtv_std_smpte_274m_1080p_25: 1; + unsigned int hdtv_std_smpte_274m_1080p_29: 1; + unsigned int hdtv_std_smpte_274m_1080p_30: 1; + unsigned int hdtv_std_smpte_274m_1080p_50: 1; + unsigned int hdtv_std_smpte_274m_1080p_59: 1; + unsigned int hdtv_std_smpte_274m_1080p_60: 1; + unsigned int hdtv_std_smpte_295m_1080i_50: 1; + unsigned int hdtv_std_smpte_295m_1080p_50: 1; + unsigned int hdtv_std_smpte_296m_720p_59: 1; + unsigned int hdtv_std_smpte_296m_720p_60: 1; + unsigned int hdtv_std_smpte_296m_720p_50: 1; + unsigned int hdtv_std_smpte_293m_480p_59: 1; + unsigned int hdtv_std_smpte_170m_480i_59: 1; + unsigned int hdtv_std_iturbt601_576i_50: 1; + unsigned int hdtv_std_iturbt601_576p_50: 1; + unsigned int hdtv_std_eia_7702a_480i_60: 1; + unsigned int hdtv_std_eia_7702a_480p_60: 1; + unsigned int pad: 3; +} __attribute__((packed)); + +struct intel_shared_regs { + struct er_account regs[5]; + int refcnt; + unsigned int core_id; +}; + +struct intel_stolen_funcs { + size_t (*size)(int, int, int); + u32 (*base)(int, int, int, size_t); +}; + +struct intel_tv { + struct intel_encoder base; + int type; + const char *tv_format; + int margin[4]; + u32 save_TV_H_CTL_1; + u32 save_TV_H_CTL_2; + u32 save_TV_H_CTL_3; + u32 save_TV_V_CTL_1; + u32 save_TV_V_CTL_2; + u32 save_TV_V_CTL_3; + u32 save_TV_V_CTL_4; + u32 save_TV_V_CTL_5; + u32 save_TV_V_CTL_6; + u32 save_TV_V_CTL_7; + u32 save_TV_SC_CTL_1; + u32 save_TV_SC_CTL_2; + u32 save_TV_SC_CTL_3; + u32 save_TV_CSC_Y; + u32 save_TV_CSC_Y2; + u32 save_TV_CSC_U; + u32 save_TV_CSC_U2; + u32 save_TV_CSC_V; + u32 save_TV_CSC_V2; + u32 save_TV_CLR_KNOBS; + u32 save_TV_CLR_LEVEL; + u32 save_TV_WIN_POS; + u32 save_TV_WIN_SIZE; + u32 save_TV_FILTER_CTL_1; + u32 save_TV_FILTER_CTL_2; + u32 save_TV_FILTER_CTL_3; + u32 save_TV_H_LUMA[60]; + u32 save_TV_H_CHROMA[60]; + u32 save_TV_V_LUMA[43]; + u32 save_TV_V_CHROMA[43]; + u32 save_TV_DAC; + u32 save_TV_CTL; +}; + +struct intel_uncore_extra_reg { + raw_spinlock_t lock; + u64 config; + u64 config1; + u64 config2; + atomic_t ref; +}; + +struct intel_uncore_pmu; + +struct intel_uncore_box { + int pci_phys_id; + int pkgid; + int n_active; + int n_events; + int cpu; + long unsigned int flags; + atomic_t refcnt; + struct perf_event *events[9]; + struct perf_event *event_list[9]; + struct event_constraint *event_constraint[9]; + long unsigned int active_mask[1]; + u64 tags[9]; + struct pci_dev *pci_dev; + struct intel_uncore_pmu *pmu; + u64 hrtimer_duration; + struct hrtimer hrtimer; + struct list_head list; + struct list_head active_list; + void *io_addr; + struct intel_uncore_extra_reg shared_regs[0]; +}; + +struct intel_uncore_init_fun { + void (*cpu_init)(void); + int (*pci_init)(void); +}; + +struct intel_uncore_ops { + void (*init_box)(struct intel_uncore_box *); + void (*exit_box)(struct intel_uncore_box *); + void (*disable_box)(struct intel_uncore_box *); + void (*enable_box)(struct intel_uncore_box *); + void (*disable_event)(struct intel_uncore_box *, struct perf_event *); + void (*enable_event)(struct intel_uncore_box *, struct perf_event *); + u64 (*read_counter)(struct intel_uncore_box *, struct perf_event *); + int (*hw_config)(struct intel_uncore_box *, struct perf_event *); + struct event_constraint * (*get_constraint)(struct intel_uncore_box *, struct perf_event *); + void (*put_constraint)(struct intel_uncore_box *, struct perf_event *); +}; + +struct perf_cpu_context___2; + +struct perf_event_context___2; + +struct pmu { + struct list_head entry; + struct module *module; + struct device *dev; + const struct attribute_group **attr_groups; + const char *name; + int type; + int capabilities; + int *pmu_disable_count; + struct perf_cpu_context___2 *pmu_cpu_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 *); + void (*event_unmapped)(struct perf_event *); + 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_context___2 *, bool); + size_t task_ctx_size; + u64 (*count)(struct perf_event *); + void * (*setup_aux)(int, void **, int, bool); + void (*free_aux)(void *); + int (*addr_filters_validate)(struct list_head *); + void (*addr_filters_sync)(struct perf_event *); + int (*filter_match)(struct perf_event *); +}; + +struct intel_uncore_type; + +struct intel_uncore_pmu { + struct pmu pmu; + char name[32]; + int pmu_idx; + int func_id; + bool registered; + atomic_t activeboxes; + struct intel_uncore_type *type; + struct intel_uncore_box **boxes; +}; + +struct uncore_event_desc; + +struct intel_uncore_type { + const char *name; + int num_counters; + int num_boxes; + int perf_ctr_bits; + int fixed_ctr_bits; + unsigned int perf_ctr; + unsigned int event_ctl; + unsigned int event_mask; + unsigned int fixed_ctr; + unsigned int fixed_ctl; + unsigned int box_ctl; + unsigned int msr_offset; + unsigned int num_shared_regs: 8; + unsigned int single_fixed: 1; + unsigned int pair_ctr_ctl: 1; + unsigned int *msr_offsets; + struct event_constraint unconstrainted; + struct event_constraint *constraints; + struct intel_uncore_pmu *pmus; + struct intel_uncore_ops *ops; + struct uncore_event_desc *event_descs; + const struct attribute_group *attr_groups[4]; + struct pmu *pmu; +}; + +struct intel_unpin_work { + struct work_struct work; + struct drm_crtc *crtc; + struct drm_framebuffer *old_fb; + struct drm_i915_gem_object *pending_flip_obj; + struct drm_pending_vblank_event *event; + atomic_t pending; + u32 flip_count; + u32 gtt_offset; + struct drm_i915_gem_request *flip_queued_req; + u32 flip_queued_vblank; + u32 flip_ready_vblank; + bool enable_stall_check; +}; + +struct intel_watermark_params { + long unsigned int fifo_size; + long unsigned int max_wm; + long unsigned int default_wm; + long unsigned int guard_size; + long unsigned int cacheline_size; +}; + +union intel_x86_pebs_dse { + u64 val; + struct { + unsigned int ld_dse: 4; + unsigned int ld_stlb_miss: 1; + unsigned int ld_locked: 1; + unsigned int ld_reserved: 26; + }; + struct { + unsigned int st_l1d_hit: 1; + unsigned int st_reserved1: 3; + unsigned int st_stlb_miss: 1; + unsigned int st_locked: 1; + unsigned int st_reserved2: 26; + }; +}; + +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 io { + long unsigned int error_bits; + atomic_t count; + struct dm_io_client *client; + io_notify_fn callback; + void *context; + void *vma_invalidate_address; + long unsigned int vma_invalidate_size; + long: 64; +}; + +struct io_apic { + unsigned int index; + unsigned int unused[3]; + unsigned int data; + unsigned int unused2[11]; + unsigned int eoi; +}; + +struct io_context { + atomic_long_t refcount; + atomic_t active_ref; + atomic_t nr_tasks; + spinlock_t lock; + short unsigned int ioprio; + int nr_batch_requests; + long unsigned int last_waited; + struct radix_tree_root icq_tree; + struct io_cq *icq_hint; + struct hlist_head icq_list; + struct work_struct release_work; +}; + +struct io_window_t { + u_int InUse; + u_int Config; + struct resource *res; +}; + +typedef struct io_window_t io_window_t; + +struct mpc_ioapic { + unsigned char type; + unsigned char apicid; + unsigned char apicver; + unsigned char flags; + unsigned int apicaddr; +}; + +struct mp_ioapic_gsi { + u32 gsi_base; + u32 gsi_end; +}; + +struct irq_domain_ops; + +struct ioapic_domain_cfg { + enum ioapic_domain_type type; + const struct irq_domain_ops *ops; + struct device_node *dev; +}; + +struct ioapic { + int nr_registers; + struct IO_APIC_route_entry *saved_registers; + struct mpc_ioapic mp_config; + struct mp_ioapic_gsi gsi_config; + struct ioapic_domain_cfg irqdomain_cfg; + struct irq_domain *irqdomain; + struct resource *iomem_res; +}; + +struct iocb { + __u64 aio_data; + __u32 aio_key; + __u32 aio_reserved1; + __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 { + sector_t blkno; + loff_t offset; + u64 length; + int type; +}; + +struct iommu_callback_data { + const struct iommu_ops *ops; +}; + +struct iommu_cmd { + u32 data[4]; +}; + +struct iommu_dev_data { + struct list_head list; + struct list_head dev_data_list; + struct protection_domain *domain; + u16 devid; + u16 alias; + bool iommu_v2; + bool passthrough; + struct { + bool enabled; + int qdep; + } ats; + bool pri_tlp; + u32 errata; +}; + +struct iommu_device { + struct list_head list; + struct device___2 *dev; + char *name; +}; + +struct iommu_dm_region { + struct list_head list; + phys_addr_t start; + size_t length; + int prot; +}; + +struct iommu_group { + struct kobject___2 kobj; + struct kobject___2 *devices_kobj; + struct list_head devices; + struct mutex___2 mutex; + struct blocking_notifier_head notifier; + void *iommu_data; + void (*iommu_data_release)(void *); + char *name; + int id; + struct iommu_domain *default_domain; + struct iommu_domain *domain; +}; + +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_pool { + long unsigned int start; + long unsigned int end; + long unsigned int hint; + spinlock_t lock; +}; + +struct iommu_map_table { + long unsigned int table_map_base; + long unsigned int table_shift; + long unsigned int nr_pools; + void (*lazy_flush)(struct iommu_map_table *); + long unsigned int poolsize; + struct iommu_pool pools[16]; + u32 flags; + struct iommu_pool large_pool; + long unsigned int *map; +}; + +struct of_phandle_args; + +struct iommu_ops { + bool (*capable)(enum iommu_cap); + struct iommu_domain * (*domain_alloc)(unsigned int); + void (*domain_free)(struct iommu_domain *); + int (*attach_dev)(struct iommu_domain *, struct device *); + void (*detach_dev)(struct iommu_domain *, struct device *); + int (*map)(struct iommu_domain *, long unsigned int, phys_addr_t, size_t, int); + size_t (*unmap)(struct iommu_domain *, long unsigned int, size_t); + size_t (*map_sg)(struct iommu_domain *, long unsigned int, struct scatterlist *, unsigned int, int); + phys_addr_t (*iova_to_phys)(struct iommu_domain *, dma_addr_t); + int (*add_device)(struct device *); + void (*remove_device)(struct device *); + struct iommu_group * (*device_group)(struct device *); + int (*domain_get_attr)(struct iommu_domain *, enum iommu_attr, void *); + int (*domain_set_attr)(struct iommu_domain *, enum iommu_attr, void *); + void (*get_dm_regions)(struct device *, struct list_head *); + void (*put_dm_regions)(struct device *, struct list_head *); + int (*domain_window_enable)(struct iommu_domain *, u32, phys_addr_t, u64, int); + void (*domain_window_disable)(struct iommu_domain *, u32); + int (*domain_set_windows)(struct iommu_domain *, u32); + u32 (*domain_get_windows)(struct iommu_domain *); + int (*of_xlate)(struct device *, struct of_phandle_args *); + long unsigned int pgsize_bitmap; +}; + +struct iommu_table { + const struct cal_chipset_ops *chip_ops; + long unsigned int it_base; + long unsigned int it_hint; + long unsigned int *it_map; + void *bbar; + u64 tar_val; + struct timer_list watchdog_timer; + spinlock_t it_lock; + unsigned int it_size; + unsigned char it_busno; +}; + +typedef int (*initcall_t)(void); + +struct iommu_table_entry { + initcall_t detect; + initcall_t depend; + void (*early_init)(void); + void (*late_init)(void); + int flags; +}; + +struct iov_iter { + int type; + size_t iov_offset; + size_t count; + union { + const struct iovec *iov; + const struct kvec *kvec; + const struct bio_vec *bvec; + }; + long unsigned int nr_segs; +}; + +struct iova { + struct rb_node node; + long unsigned int pfn_hi; + long unsigned int pfn_lo; +}; + +struct iova_cpu_rcache { + spinlock_t lock; + struct iova_magazine *loaded; + struct iova_magazine *prev; +}; + +struct iova_magazine { + long unsigned int size; + long unsigned int pfns[128]; +}; + +struct ip4_create_arg { + struct iphdr *iph; + u32 user; + int vif; +}; + +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___2 *pid; + kuid_t uid; + } owner; + long unsigned int lastuse; + long unsigned int expires; + struct net *fl_net; +}; + +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 ip6_sf_socklist { + unsigned int sl_max; + unsigned int sl_count; + struct in6_addr sl_addr[0]; +}; + +struct ip_tunnel_encap; + +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 *); +}; + +struct ip_auth_hdr { + __u8 nexthdr; + __u8 hdrlen; + __be16 reserved; + __be32 spi; + __be32 seq_no; + __u8 auth_data[0]; +}; + +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; + atomic_t refcnt; + spinlock_t lock; + char tm_running; + char reporter; + char unsolicit_count; + char loaded; + unsigned char gsquery; + unsigned char crcount; + 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; + __be32 imsf_slist[1]; +}; + +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; +}; + +struct ip_sf_list { + struct ip_sf_list *sf_next; + __be32 sf_inaddr; + long unsigned int sf_count[2]; + 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_encap { + u16 type; + u16 flags; + __be16 sport; + __be16 dport; +}; + +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 *); +}; + +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; + __be16 tun_flags; + u8 tos; + u8 ttl; + __be32 label; + __be16 tp_src; + __be16 tp_dst; +}; + +struct ip_tunnel_info { + struct ip_tunnel_key key; + u8 options_len; + u8 mode; +}; + +struct ip_tunnel_parm { + char name[16]; + int link; + __be16 i_flags; + __be16 o_flags; + __be32 i_key; + __be32 o_key; + struct iphdr iph; +}; + +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 next_id; +}; + +struct ipc_namespace { + atomic_t count; + struct ipc_ids ids[3]; + int sem_ctls[4]; + int used_sems; + unsigned int msg_ctlmax; + unsigned int msg_ctlmnb; + unsigned int msg_ctlmni; + atomic_t msg_bytes; + atomic_t 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 user_namespace *user_ns; + 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___2 *, void *); +}; + +struct ipc_proc_iter { + struct ipc_namespace *ns; + struct ipc_proc_iface *iface; +}; + +struct ipc_rcu { + struct callback_head rcu; + atomic_t refcount; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; +}; + +struct sockcm_cookie { + u32 mark; + u16 tsflags; +}; + +struct ipcm_cookie { + struct sockcm_cookie sockc; + __be32 addr; + int oif; + struct ip_options_rcu *opt; + __u8 tx_flags; + __u8 ttl; + __s16 tos; + char priority; +}; + +struct ipfrag_skb_cb { + struct inet_skb_parm h; + int offset; +}; + +struct mr_table; + +struct ipmr_mfc_iter { + struct seq_net_private p; + struct mr_table *mrt; + struct list_head *cache; + int ct; +}; + +struct ipmr_vif_iter { + struct seq_net_private p; + struct mr_table *mrt; + int ct; +}; + +struct ipq { + struct inet_frag_queue q; + u32 user; + __be32 saddr; + __be32 daddr; + __be16 id; + u8 protocol; + u8 ecn; + u16 max_df_size; + int iif; + int vif; + unsigned int rid; + struct inet_peer *peer; +}; + +struct ipstats_mib { + u64 mibs[36]; + struct u64_stats_sync syncp; +}; + +struct ipv6_ac_socklist { + struct in6_addr acl_addr; + int acl_ifindex; + struct ipv6_ac_socklist *acl_next; +}; + +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; + struct ipv6_mc_socklist *next; + rwlock_t sflock; + unsigned int sfmode; + struct ip6_sf_socklist *sflist; + struct callback_head rcu; +}; + +struct ipv6_opt_hdr { + __u8 nexthdr; + __u8 hdrlen; +}; + +struct ipv6_pinfo { + struct in6_addr saddr; + struct in6_pktinfo sticky_pktinfo; + const struct in6_addr *daddr_cache; + __be32 flow_label; + __u32 frag_size; + __u16 __unused_1: 7; + __s16 hop_limit: 9; + __u16 mc_loop: 1; + __u16 __unused_2: 6; + __s16 mcast_hops: 9; + 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; + } bits; + __u16 all; + } rxopt; + __u16 recverr: 1; + __u16 sndflow: 1; + __u16 repflow: 1; + __u16 pmtudisc: 3; + __u16 padding: 1; + __u16 srcprefs: 3; + __u16 dontfrag: 1; + __u16 autoflowlabel: 1; + __u8 min_hopcount; + __u8 tclass; + __be32 rcv_flowinfo; + __u32 dst_cookie; + __u32 rx_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_rt_hdr { + __u8 nexthdr; + __u8 hdrlen; + __u8 type; + __u8 segments_left; +}; + +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 *); + int (*ipv6_dst_lookup)(struct net *, struct sock *, struct dst_entry **, struct flowi6 *); + void (*udpv6_encap_enable)(void); + void (*ndisc_send_na)(struct net_device *, const struct in6_addr *, const struct in6_addr *, bool, bool, bool, bool); + struct neigh_table *nd_tbl; +}; + +struct ipv6_txoptions { + atomic_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; + struct in6_addr saddr; + struct in6_addr daddr; +}; + +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_alloc_info { + enum irq_alloc_type type; + u32 flags; + const struct cpumask *mask; + union { + int unused; + struct { + int hpet_id; + int hpet_index; + void *hpet_data; + }; + struct { + struct pci_dev *msi_dev; + irq_hw_number_t msi_hwirq; + }; + struct { + int ioapic_id; + int ioapic_pin; + int ioapic_node; + u32 ioapic_trigger: 1; + u32 ioapic_polarity: 1; + u32 ioapic_valid: 1; + struct IO_APIC_route_entry *ioapic_entry; + }; + struct { + int dmar_id; + void *dmar_data; + }; + struct { + int ht_pos; + int ht_idx; + struct pci_dev *ht_dev; + void *ht_update; + }; + }; +}; + +typedef struct irq_alloc_info msi_alloc_info_t; + +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 irq_data; + +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_cpu_online)(struct irq_data *); + void (*irq_cpu_offline)(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 *); + 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; + long unsigned int polarity; +}; + +struct irq_desc; + +typedef void (*irq_flow_handler_t)(struct irq_desc *); + +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 type_cache; + u32 polarity_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 msi_desc; + +struct irq_common_data { + unsigned int state_use_accessors; + unsigned int node; + void *handler_data; + struct msi_desc *msi_desc; + cpumask_var_t affinity; +}; + +struct irq_data { + u32 mask; + unsigned int irq; + long unsigned int hwirq; + struct irq_common_data *common; + struct irq_chip *chip; + struct irq_domain *domain; + struct irq_data *parent_data; + void *chip_data; +}; + +struct irqaction; + +struct irq_desc { + struct irq_common_data irq_common_data; + struct irq_data irq_data; + unsigned int *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 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; + cpumask_var_t pending_mask; + long unsigned int threads_oneshot; + atomic_t threads_active; + wait_queue_head_t wait_for_threads; + unsigned int nr_actions; + unsigned int no_suspend_depth; + unsigned int cond_suspend_depth; + unsigned int force_resume_depth; + struct proc_dir_entry *dir; + struct callback_head rcu; + int parent_irq; + struct module *owner; + const char *name; + long: 64; + long: 64; +}; + +typedef struct irq_desc *pto_T_____17; + +typedef struct irq_desc *vector_irq_t[256]; + +struct irq_devres { + unsigned int irq; + void *dev_id; +}; + +struct irq_domain_chip_generic; + +struct irq_domain { + struct list_head link; + const char *name; + const struct irq_domain_ops *ops; + void *host_data; + unsigned int flags; + struct fwnode_handle *fwnode; + enum irq_domain_bus_token bus_token; + struct irq_domain_chip_generic *gc; + struct irq_domain *parent; + irq_hw_number_t hwirq_max; + unsigned int revmap_direct_max_irq; + unsigned int revmap_size; + struct radix_tree_root revmap_tree; + unsigned int linear_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; + struct irq_chip_generic *gc[0]; +}; + +struct irq_fwspec; + +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); + void (*activate)(struct irq_domain *, struct irq_data *); + void (*deactivate)(struct irq_domain *, struct irq_data *); + int (*translate)(struct irq_domain *, struct irq_fwspec *, long unsigned int *, unsigned int *); +}; + +struct irq_fwspec { + struct fwnode_handle *fwnode; + int param_count; + u32 param[16]; +}; + +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_info___2 { + u8 bus; + u8 devfn; + struct { + u8 link; + u16 bitmap; + } __attribute__((packed)) irq[4]; + u8 slot; + u8 rfu; +}; + +struct irq_pin_list { + struct list_head list; + int apic; + int pin; +}; + +struct irq_remap_table { + spinlock_t lock; + unsigned int min_index; + u32 *table; +}; + +struct irq_router { + char *name; + u16 vendor; + u16 device; + int (*get)(struct pci_dev *, struct pci_dev *, int); + int (*set)(struct pci_dev *, struct pci_dev *, int, int); +}; + +struct irq_router_handler { + u16 vendor; + int (*probe)(struct irq_router *, struct pci_dev *, u16); +}; + +struct irq_routing_table { + u32 signature; + u16 version; + u16 size; + u8 rtr_bus; + u8 rtr_devfn; + u16 exclusive_irqs; + u16 rtr_vendor; + u16 rtr_device; + u32 miniport_data; + u8 rfu[11]; + u8 checksum; + struct irq_info___2 slots[0]; +}; + +union irq_stack_union { + char irq_stack[16384]; + struct { + char gs_base[40]; + long unsigned int stack_canary; + }; +}; + +struct irq_work { + long unsigned int flags; + struct llist_node llnode; + void (*func)(struct irq_work *); +}; + +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; + char *name; + void *data; +}; + +struct iso9660_options { + unsigned int rock: 1; + unsigned int joliet: 1; + unsigned int cruft: 1; + unsigned int hide: 1; + unsigned int showassoc: 1; + unsigned int nocompress: 1; + unsigned int overriderockperm: 1; + unsigned int uid_set: 1; + unsigned int gid_set: 1; + unsigned int utf8: 1; + unsigned char map; + unsigned char check; + unsigned int blocksize; + umode_t fmode; + umode_t dmode; + kgid_t gid; + kuid_t uid; + char *iocharset; + s32 session; + s32 sbsector; +}; + +struct iso_directory_record { + char length[1]; + char ext_attr_length[1]; + char extent[8]; + char size[8]; + char date[7]; + char flags[1]; + char file_unit_size[1]; + char interleave[1]; + char volume_sequence_number[4]; + unsigned char name_len[1]; + char name[0]; +}; + +struct iso_inode_info { + long unsigned int i_iget5_block; + long unsigned int i_iget5_offset; + unsigned int i_first_extent; + unsigned char i_file_format; + unsigned char i_format_parm[3]; + long unsigned int i_next_section_block; + long unsigned int i_next_section_offset; + off_t i_section_size; + struct inode___2 vfs_inode; +}; + +struct iso_primary_descriptor { + char type[1]; + char id[5]; + char version[1]; + char unused1[1]; + char system_id[32]; + char volume_id[32]; + char unused2[8]; + char volume_space_size[8]; + char unused3[32]; + char volume_set_size[4]; + char volume_sequence_number[4]; + char logical_block_size[4]; + char path_table_size[8]; + char type_l_path_table[4]; + char opt_type_l_path_table[4]; + char type_m_path_table[4]; + char opt_type_m_path_table[4]; + char root_directory_record[34]; + char volume_set_id[128]; + char publisher_id[128]; + char preparer_id[128]; + char application_id[128]; + char copyright_file_id[37]; + char abstract_file_id[37]; + char bibliographic_file_id[37]; + char creation_date[17]; + char modification_date[17]; + char expiration_date[17]; + char effective_date[17]; + char file_structure_version[1]; + char unused4[1]; + char application_data[512]; + char unused5[653]; +}; + +struct iso_supplementary_descriptor { + char type[1]; + char id[5]; + char version[1]; + char flags[1]; + char system_id[32]; + char volume_id[32]; + char unused2[8]; + char volume_space_size[8]; + char escape[32]; + char volume_set_size[4]; + char volume_sequence_number[4]; + char logical_block_size[4]; + char path_table_size[8]; + char type_l_path_table[4]; + char opt_type_l_path_table[4]; + char type_m_path_table[4]; + char opt_type_m_path_table[4]; + char root_directory_record[34]; + char volume_set_id[128]; + char publisher_id[128]; + char preparer_id[128]; + char application_id[128]; + char copyright_file_id[37]; + char abstract_file_id[37]; + char bibliographic_file_id[37]; + char creation_date[17]; + char modification_date[17]; + char expiration_date[17]; + char effective_date[17]; + char file_structure_version[1]; + char unused4[1]; + char application_data[512]; + char unused5[653]; +}; + +struct iso_volume_descriptor { + char type[1]; + char id[5]; + char version[1]; + char data[2041]; +}; + +struct isoch_data { + u32 maxbw; + u32 n; + u32 y; + u32 l; + u32 rq; + struct agp_3_5_dev *dev; +}; + +struct isofs_fid { + u32 block; + u16 offset; + u16 parent_offset; + u32 generation; + u32 parent_block; + u32 parent_generation; +}; + +struct isofs_iget5_callback_data { + long unsigned int block; + long unsigned int offset; +}; + +struct nls_table; + +struct isofs_sb_info { + long unsigned int s_ninodes; + long unsigned int s_nzones; + long unsigned int s_firstdatazone; + long unsigned int s_log_zone_size; + long unsigned int s_max_size; + int s_rock_offset; + unsigned char s_joliet_level; + unsigned char s_mapping; + unsigned int s_high_sierra: 1; + unsigned int s_rock: 2; + unsigned int s_utf8: 1; + unsigned int s_cruft: 1; + unsigned int s_nocompress: 1; + unsigned int s_hide: 1; + unsigned int s_showassoc: 1; + unsigned int s_overriderockperm: 1; + unsigned int s_uid_set: 1; + unsigned int s_gid_set: 1; + umode_t s_fmode; + umode_t s_dmode; + kgid_t s_gid; + kuid_t s_uid; + struct nls_table *s_nls_iocharset; +}; + +struct itco_wdt_platform_data { + char name[32]; + unsigned int version; +}; + +struct itimerspec { + struct timespec it_interval; + struct timespec it_value; +}; + +struct itimerval { + struct timeval it_interval; + struct timeval it_value; +}; + +struct ivch_priv { + bool quiet; + uint16_t width; + uint16_t height; + uint16_t reg_backup[24]; +}; + +struct ivhd_entry { + u8 type; + u16 devid; + u8 flags; + u32 ext; + u32 hidh; + u64 cid; + u8 uidf; + u8 uidl; + u8 uid; +} __attribute__((packed)); + +struct ivhd_header { + u8 type; + u8 flags; + u16 length; + u16 devid; + u16 cap_ptr; + u64 mmio_phys; + u16 pci_seg; + u16 info; + u32 efr_attr; + u64 efr_reg; + u64 res; +}; + +struct ivmd_header { + u8 type; + u8 flags; + u16 length; + u16 devid; + u16 aux; + u64 resv; + u64 range_start; + u64 range_length; +}; + +struct jit_context { + int cleanup_addr; + bool seen_ld_abs; + bool seen_ax_reg; +}; + +struct rand_data; + +struct jitterentropy { + spinlock_t jent_lock; + struct rand_data *entropy_collector; +}; + +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); + +typedef int (*kprobe_fault_handler_t)(struct kprobe *, struct pt_regs *, int); + +typedef int (*kprobe_break_handler_t)(struct kprobe *, struct pt_regs *); + +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_fault_handler_t fault_handler; + kprobe_break_handler_t break_handler; + kprobe_opcode_t opcode; + struct arch_specific_insn ainsn; + u32 flags; +}; + +struct jprobe { + struct kprobe kp; + void *entry; +}; + +union jump_code_union { + char code[5]; + struct { + char jump; + int offset; + } __attribute__((packed)); +}; + +struct jump_entry { + jump_label_t code; + jump_label_t target; + jump_label_t key; +}; + +struct timex; + +struct k_itimer; + +struct restart_block; + +struct k_clock { + int (*clock_getres)(const clockid_t, struct timespec *); + int (*clock_set)(const clockid_t, const struct timespec *); + int (*clock_get)(const clockid_t, struct timespec *); + int (*clock_adj)(const clockid_t, struct timex *); + int (*timer_create)(struct k_itimer *); + int (*nsleep)(const clockid_t, int, struct timespec *, struct timespec *); + long int (*nsleep_restart)(struct restart_block *); + int (*timer_set)(struct k_itimer *, int, struct itimerspec *, struct itimerspec *); + int (*timer_del)(struct k_itimer *); + void (*timer_get)(struct k_itimer *, struct itimerspec *); +}; + +struct signal_struct; + +struct sigqueue; + +struct k_itimer { + struct list_head list; + struct hlist_node t_hash; + spinlock_t it_lock; + clockid_t it_clock; + timer_t it_id; + int it_overrun; + int it_overrun_last; + int it_requeue_pending; + int it_sigev_notify; + struct signal_struct *it_signal; + union { + struct pid___2 *it_pid; + struct task_struct *it_process; + }; + struct sigqueue *sigq; + union { + struct { + struct hrtimer timer; + ktime_t interval; + } real; + struct cpu_timer_list cpu; + struct { + unsigned int clock; + unsigned int node; + long unsigned int incr; + long unsigned int expires; + } mmtimer; + struct { + struct alarm alarmtimer; + ktime_t interval; + } alarm; + struct callback_head rcu; + } it; +}; + +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; + long unsigned int value; + unsigned int nameoff; + char type; + char name[128]; + char module_name[56]; + int exported; +}; + +struct led_trigger { + const char *name; + void (*activate)(struct led_classdev *); + void (*deactivate)(struct led_classdev *); + rwlock_t leddev_list_lock; + struct list_head led_cdevs; + struct list_head next_trig; +}; + +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]; +}; + +typedef void (*dm_kcopyd_notify_fn)(int, long unsigned int, void *); + +struct kcopyd_job { + struct dm_kcopyd_client *kc; + struct list_head list; + long unsigned int flags; + int read_err; + long unsigned int write_err; + int rw; + struct dm_io_region source; + unsigned int num_dests; + struct dm_io_region dests[8]; + struct page_list *pages; + dm_kcopyd_notify_fn fn; + void *context; + struct mutex lock; + atomic_t sub_jobs; + sector_t progress; + struct kcopyd_job *master_job; +}; + +struct kcore_list { + struct list_head list; + long unsigned int addr; + size_t size; + int type; +}; + +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 kernel_cpustat { + u64 cpustat[10]; +}; + +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___2; + +struct kparam_array___2; + +struct kernel_param___2 { + const char *name; + struct module___2 *mod; + const struct kernel_param_ops___2 *ops; + const u16 perm; + s8 level; + u8 flags; + union { + void *arg; + const struct kparam_string *str; + const struct kparam_array___2 *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_param_ops___2 { + unsigned int flags; + int (*set)(const char *, const struct kernel_param___2 *); + int (*get)(char *, const struct kernel_param___2 *); + void (*free)(void *); +}; + +struct kernel_stat { + long unsigned int irqs_sum; + unsigned int softirqs[10]; +}; + +struct kernel_symbol { + long unsigned int value; + const char *name; +}; + +struct kernel_vm86_regs { + struct pt_regs pt; + short unsigned int es; + short unsigned int __esh; + short unsigned int ds; + short unsigned int __dsh; + short unsigned int fs; + short unsigned int __fsh; + short unsigned int gs; + short unsigned int __gsh; +}; + +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_attr___2 { + const struct kernfs_ops___2 *ops; + struct kernfs_open_node *open; + loff_t size; + struct kernfs_node___2 *notify_next; +}; + +struct kernfs_elem_dir { + long unsigned int subdirs; + struct rb_root children; + struct kernfs_root *root; +}; + +struct kernfs_elem_dir___2 { + long unsigned int subdirs; + struct rb_root children; + struct kernfs_root___2 *root; +}; + +struct kernfs_elem_symlink { + struct kernfs_node *target_kn; +}; + +struct kernfs_elem_symlink___2 { + struct kernfs_node___2 *target_kn; +}; + +struct simple_xattrs { + struct list_head head; + spinlock_t lock; +}; + +struct kernfs_iattrs { + struct iattr___2 ia_iattr; + void *ia_secdata; + u32 ia_secdata_len; + struct simple_xattrs xattrs; +}; + +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; + union { + struct kernfs_elem_dir dir; + struct kernfs_elem_symlink symlink; + struct kernfs_elem_attr attr; + }; + void *priv; + short unsigned int flags; + umode_t mode; + unsigned int ino; + struct kernfs_iattrs *iattr; +}; + +struct kernfs_node___2 { + atomic_t count; + atomic_t active; + struct kernfs_node___2 *parent; + const char *name; + struct rb_node rb; + const void *ns; + unsigned int hash; + union { + struct kernfs_elem_dir___2 dir; + struct kernfs_elem_symlink___2 symlink; + struct kernfs_elem_attr___2 attr; + }; + void *priv; + short unsigned int flags; + umode_t mode; + unsigned int ino; + struct kernfs_iattrs *iattr; +}; + +struct vm_operations_struct___2; + +struct kernfs_open_file { + struct kernfs_node *kn; + struct file___2 *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; + const struct vm_operations_struct___2 *vm_ops; +}; + +struct kernfs_open_file___2 { + struct kernfs_node___2 *kn; + struct file *file; + void *priv; + struct mutex___2 mutex; + struct mutex___2 prealloc_mutex; + int event; + struct list_head list; + char *prealloc_buf; + size_t atomic_write_len; + bool mmapped; + const struct vm_operations_struct *vm_ops; +}; + +struct kernfs_open_node { + atomic_t refcnt; + atomic_t event; + wait_queue_head_t poll; + struct list_head files; +}; + +struct kernfs_ops { + 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); + int (*mmap)(struct kernfs_open_file *, struct vm_area_struct___2 *); +}; + +struct kernfs_ops___2 { + int (*seq_show)(struct seq_file___2 *, void *); + void * (*seq_start)(struct seq_file___2 *, loff_t *); + void * (*seq_next)(struct seq_file___2 *, void *, loff_t *); + void (*seq_stop)(struct seq_file___2 *, void *); + ssize_t (*read)(struct kernfs_open_file___2 *, char *, size_t, loff_t); + size_t atomic_write_len; + bool prealloc; + ssize_t (*write)(struct kernfs_open_file___2 *, char *, size_t, loff_t); + int (*mmap)(struct kernfs_open_file___2 *, struct vm_area_struct *); +}; + +struct kernfs_syscall_ops; + +struct kernfs_root { + struct kernfs_node *kn; + unsigned int flags; + struct ida ino_ida; + struct kernfs_syscall_ops *syscall_ops; + struct list_head supers; + wait_queue_head_t deactivate_waitq; +}; + +struct kernfs_syscall_ops___2; + +struct kernfs_root___2 { + struct kernfs_node___2 *kn; + unsigned int flags; + struct ida ino_ida; + struct kernfs_syscall_ops___2 *syscall_ops; + struct list_head supers; + wait_queue_head_t deactivate_waitq; +}; + +struct kernfs_super_info { + struct super_block *sb; + struct kernfs_root *root; + const void *ns; + struct list_head node; +}; + +struct kernfs_syscall_ops { + int (*remount_fs)(struct kernfs_root *, int *, char *); + 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 kernfs_syscall_ops___2 { + int (*remount_fs)(struct kernfs_root___2 *, int *, char *); + int (*show_options)(struct seq_file___2 *, struct kernfs_root___2 *); + int (*mkdir)(struct kernfs_node___2 *, const char *, umode_t); + int (*rmdir)(struct kernfs_node___2 *); + int (*rename)(struct kernfs_node___2 *, struct kernfs_node___2 *, const char *); + int (*show_path)(struct seq_file___2 *, struct kernfs_node___2 *, struct kernfs_root___2 *); +}; + +struct kexec_segment { + union { + void *buf; + void *kbuf; + }; + size_t bufsz; + long unsigned int mem; + size_t memsz; +}; + +struct key_type; + +struct keyring_index_key { + struct key_type *type; + const char *description; + size_t desc_len; +}; + +union key_payload { + void *rcu_data0; + void *data[4]; +}; + +struct key_user; + +struct key { + atomic_t usage; + key_serial_t serial; + union { + struct list_head graveyard_link; + struct rb_node serial_node; + }; + struct rw_semaphore sem; + struct key_user *user; + void *security; + union { + time_t expiry; + time_t revoked_at; + }; + time_t last_used_at; + kuid_t uid; + kgid_t gid; + key_perm_t perm; + short unsigned int quotalen; + short unsigned int datalen; + long unsigned int flags; + union { + struct keyring_index_key index_key; + struct { + struct key_type *type; + char *description; + }; + }; + union { + union key_payload payload; + struct { + struct list_head name_link; + struct assoc_array keys; + }; + int reject_error; + }; + int (*restrict_link)(struct key *, const struct key_type *, const union key_payload *); +}; + +struct key___2 { + atomic_t usage; + key_serial_t serial; + union { + struct list_head graveyard_link; + struct rb_node serial_node; + }; + struct rw_semaphore___2 sem; + struct key_user *user; + void *security; + union { + time_t expiry; + time_t revoked_at; + }; + time_t last_used_at; + kuid_t uid; + kgid_t gid; + key_perm_t perm; + short unsigned int quotalen; + short unsigned int datalen; + long unsigned int flags; + union { + struct keyring_index_key index_key; + struct { + struct key_type *type; + char *description; + }; + }; + union { + union key_payload payload; + struct { + struct list_head name_link; + struct assoc_array keys; + }; + int reject_error; + }; + int (*restrict_link)(struct key___2 *, const struct key_type *, const union key_payload *); +}; + +struct key_construction { + struct key___2 *key; + struct key___2 *authkey; +}; + +struct key_entry { + int type; + u32 code; + union { + u16 keycode; + struct { + u8 code; + u8 value; + } sw; + }; +}; + +struct key_match_data { + bool (*cmp)(const struct key___2 *, const struct key_match_data *); + const void *raw_data; + void *preparsed; + unsigned int lookup_type; +}; + +struct key_preparsed_payload { + char *description; + union key_payload payload; + const void *data; + size_t datalen; + size_t quotalen; + time_t expiry; +}; + +typedef int (*request_key_actor_t)(struct key_construction *, const char *, void *); + +struct key_type { + const char *name; + size_t def_datalen; + int (*vet_description)(const char *); + int (*preparse)(struct key_preparsed_payload *); + void (*free_preparse)(struct key_preparsed_payload *); + int (*instantiate)(struct key___2 *, struct key_preparsed_payload *); + int (*update)(struct key___2 *, struct key_preparsed_payload *); + int (*match_preparse)(struct key_match_data *); + void (*match_free)(struct key_match_data *); + void (*revoke)(struct key___2 *); + void (*destroy)(struct key___2 *); + void (*describe)(const struct key___2 *, struct seq_file *); + long int (*read)(const struct key___2 *, char *, size_t); + request_key_actor_t request_key; + struct list_head link; + struct lock_class_key lock_class; +}; + +struct key_user { + struct rb_node node; + struct mutex___2 cons_lock; + spinlock_t lock; + atomic_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 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 { + __s32 private; + __s32 prime; + __s32 base; +}; + +struct keyring_read_iterator_context { + size_t qty; + 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___2 *cred; + struct key_match_data match_data; + unsigned int flags; + int (*iterator)(const void *, void *); + int skipped_ret; + bool possessed; + key_ref_t result; + struct timespec now; +}; + +struct kimage_arch { + pud_t *pud; + pmd_t *pmd; + pte_t *pte; + long unsigned int backup_src_start; + long unsigned int backup_src_sz; + long unsigned int backup_load_addr; + void *elf_headers; + long unsigned int elf_headers_sz; + long unsigned int elf_load_addr; +}; + +struct kimage { + kimage_entry_t head; + kimage_entry_t *entry; + kimage_entry_t *last_entry; + long unsigned int start; + struct page___2 *control_code_page; + struct page___2 *swap_page; + 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; +}; + +struct kiocb___2 { + struct file *ki_filp; + loff_t ki_pos; + void (*ki_complete)(struct kiocb___2 *, long int, long int); + void *private; + int ki_flags; +}; + +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 page___2 **ring_pages; + long int nr_pages; + struct work_struct free_work; + struct ctx_rq_wait *rq_wait; + long: 64; + 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; + }; + 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 page___2 *internal_pages[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 kmalloced_param { + struct list_head list; + char val[0]; +}; + +struct kmem_cache_order_objects { + long unsigned int x; +}; + +struct kmem_cache_cpu; + +struct kmem_cache_node; + +struct kmem_cache { + struct kmem_cache_cpu *cpu_slab; + long unsigned int flags; + long unsigned int min_partial; + int size; + int object_size; + int offset; + int cpu_partial; + struct kmem_cache_order_objects oo; + struct kmem_cache_order_objects max; + struct kmem_cache_order_objects min; + gfp_t allocflags; + int refcount; + void (*ctor)(void *); + int inuse; + int align; + int reserved; + const char *name; + struct list_head list; + int red_left_pad; + struct kobject kobj; + int remote_node_defrag_ratio; + struct kmem_cache_node *node[64]; +}; + +struct kmem_cache_cpu { + void **freelist; + long unsigned int tid; + struct page *page; + struct page *partial; +}; + +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 kmsg_dumper { + struct list_head list; + void (*dump)(struct kmsg_dumper *, enum kmsg_dump_reason); + enum kmsg_dump_reason max_reason; + bool active; + bool registered; + u32 cur_idx; + u32 next_idx; + u64 cur_seq; + u64 next_seq; +}; + +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 sysfs_ops; + +struct kobj_type { + void (*release)(struct kobject *); + const struct sysfs_ops *sysfs_ops; + struct attribute **default_attrs; + const struct kobj_ns_type_operations * (*child_ns_type)(struct kobject *); + const void * (*namespace)(struct kobject *); +}; + +struct sysfs_ops___2; + +struct kobj_type___2 { + void (*release)(struct kobject___2 *); + const struct sysfs_ops___2 *sysfs_ops; + struct attribute **default_attrs; + const struct kobj_ns_type_operations * (*child_ns_type)(struct kobject___2 *); + const void * (*namespace)(struct kobject___2 *); +}; + +struct kobj_uevent_env { + char *argv[3]; + char *envp[32]; + 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_array___2 { + unsigned int max; + unsigned int elemsize; + unsigned int *num; + const struct kernel_param_ops___2 *ops; + void *elem; +}; + +struct kparam_string { + unsigned int maxlen; + char *string; +}; + +typedef struct kprobe *pto_T_____18; + +struct kprobe_blacklist_entry { + struct list_head list; + long unsigned int start_addr; + long unsigned int end_addr; +}; + +struct prev_kprobe { + struct kprobe *kp; + long unsigned int status; + long unsigned int old_flags; + long unsigned int saved_flags; +}; + +struct kprobe_ctlblk { + long unsigned int kprobe_status; + long unsigned int kprobe_old_flags; + long unsigned int kprobe_saved_flags; + long unsigned int *jprobe_saved_sp; + struct pt_regs jprobe_saved_regs; + kprobe_opcode_t jprobes_stack[64]; + struct prev_kprobe prev_kprobe; +}; + +struct kprobe_insn_cache { + struct mutex mutex; + void * (*alloc)(void); + void (*free)(void *); + 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 { + struct kprobe kp; + kretprobe_handler_t handler; + kretprobe_handler_t entry_handler; + int maxactive; + int nmissed; + size_t data_size; + struct hlist_head free_instances; + raw_spinlock_t lock; +}; + +struct kretprobe_blackpoint { + const char *name; + void *addr; +}; + +struct kretprobe_instance { + struct hlist_node hlist; + struct kretprobe *rp; + kprobe_opcode_t *ret_addr; + struct task_struct *task; + 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___2; + +struct kset___2 { + struct list_head list; + spinlock_t list_lock; + struct kobject___2 kobj; + const struct kset_uevent_ops___2 *uevent_ops; +}; + +struct kset_uevent_ops { + int (* const filter)(struct kset *, struct kobject *); + const char * (* const name)(struct kset *, struct kobject *); + int (* const uevent)(struct kset *, struct kobject *, struct kobj_uevent_env *); +}; + +struct kset_uevent_ops___2 { + int (* const filter)(struct kset___2 *, struct kobject___2 *); + const char * (* const name)(struct kset___2 *, struct kobject___2 *); + int (* const uevent)(struct kset___2 *, struct kobject___2 *, struct kobj_uevent_env *); +}; + +struct ksignal { + struct k_sigaction ka; + siginfo_t info; + int sig; +}; + +struct kstat { + u64 ino; + dev_t dev; + umode_t mode; + unsigned int nlink; + kuid_t uid; + kgid_t gid; + dev_t rdev; + loff_t size; + struct timespec atime; + struct timespec mtime; + struct timespec ctime; + long unsigned int blksize; + long long unsigned int blocks; +}; + +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 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; + void *data; + struct completion parked; + struct completion exited; +}; + +struct kthread_create_info { + int (*threadfn)(void *); + void *data; + int node; + struct task_struct *result; + struct completion *done; + struct list_head list; +}; + +struct kthread_flush_work { + struct kthread_work work; + struct completion done; +}; + +struct kthread_worker { + spinlock_t lock; + struct list_head work_list; + struct task_struct *task; + struct kthread_work *current_work; +}; + +typedef ktime_t pto_T_____19; + +struct rcu_batch { + struct callback_head *head; + struct callback_head **tail; +}; + +struct srcu_struct_array; + +struct srcu_struct { + long unsigned int completed; + struct srcu_struct_array *per_cpu_ref; + spinlock_t queue_lock; + bool running; + struct rcu_batch batch_queue; + struct rcu_batch batch_check0; + struct rcu_batch batch_check1; + struct rcu_batch batch_done; + struct delayed_work work; +}; + +struct kvm_vm_stat { + u32 mmu_shadow_zapped; + u32 mmu_pte_write; + u32 mmu_pte_updated; + u32 mmu_pde_zapped; + u32 mmu_flooded; + u32 mmu_recycled; + u32 mmu_cache_miss; + u32 mmu_unsync; + u32 remote_tlb_flush; + u32 lpages; +}; + +struct kvm_vcpu; + +struct kvm_page_track_notifier_node { + struct hlist_node node; + void (*track_write)(struct kvm_vcpu *, gpa_t, const u8 *, int); +}; + +struct kvm_page_track_notifier_head { + struct srcu_struct track_srcu; + struct hlist_head track_notifier_list; +}; + +struct kvm_xen_hvm_config { + __u32 flags; + __u32 msr; + __u64 blob_addr_32; + __u64 blob_addr_64; + __u8 blob_size_32; + __u8 blob_size_64; + __u8 pad2[30]; +}; + +struct kvm_hv { + u64 hv_guest_os_id; + u64 hv_hypercall; + u64 hv_tsc_page; + u64 hv_crash_param[5]; + u64 hv_crash_ctl; +}; + +struct kvm_pic; + +struct kvm_ioapic; + +struct kvm_pit; + +struct kvm_apic_map; + +struct kvm_arch { + unsigned int n_used_mmu_pages; + unsigned int n_requested_mmu_pages; + unsigned int n_max_mmu_pages; + unsigned int indirect_shadow_pages; + long unsigned int mmu_valid_gen; + struct hlist_head mmu_page_hash[1024]; + struct list_head active_mmu_pages; + struct list_head zapped_obsolete_pages; + struct kvm_page_track_notifier_node mmu_sp_tracker; + struct kvm_page_track_notifier_head track_notifier_head; + struct list_head assigned_dev_head; + struct iommu_domain *iommu_domain; + bool iommu_noncoherent; + atomic_t noncoherent_dma_count; + atomic_t assigned_device_count; + struct kvm_pic *vpic; + struct kvm_ioapic *vioapic; + struct kvm_pit *vpit; + atomic_t vapics_in_nmi_mode; + struct mutex apic_map_lock; + struct kvm_apic_map *apic_map; + unsigned int tss_addr; + bool apic_access_page_done; + gpa_t wall_clock; + bool ept_identity_pagetable_done; + gpa_t ept_identity_map_addr; + long unsigned int irq_sources_bitmap; + s64 kvmclock_offset; + raw_spinlock_t tsc_write_lock; + u64 last_tsc_nsec; + u64 last_tsc_write; + u32 last_tsc_khz; + u64 cur_tsc_nsec; + u64 cur_tsc_write; + u64 cur_tsc_offset; + u64 cur_tsc_generation; + int nr_vcpus_matched_tsc; + spinlock_t pvclock_gtod_sync_lock; + bool use_master_clock; + u64 master_kernel_ns; + cycle_t master_cycle_now; + struct delayed_work kvmclock_update_work; + struct delayed_work kvmclock_sync_work; + struct kvm_xen_hvm_config xen_hvm_config; + struct hlist_head mask_notifier_list; + struct kvm_hv hyperv; + bool boot_vcpu_runs_old_kvmclock; + u32 bsp_vcpu_id; + u64 disabled_quirks; + bool irqchip_split; + u8 nr_reserved_ioapic_pins; + bool disabled_lapic_found; + u32 ldr_mode; + struct page___2 *avic_logical_id_table_page; + struct page___2 *avic_physical_id_table_page; +}; + +struct kvm_memslots; + +struct kvm_io_bus; + +struct kvm_coalesced_mmio_ring; + +struct kvm_irq_routing_table; + +struct kvm_stat_data; + +struct kvm { + spinlock_t mmu_lock; + struct mutex slots_lock; + struct mm_struct *mm; + struct kvm_memslots *memslots[2]; + struct srcu_struct srcu; + struct srcu_struct irq_srcu; + struct kvm_vcpu *vcpus[255]; + atomic_t online_vcpus; + int last_boosted_vcpu; + struct list_head vm_list; + struct mutex lock; + struct kvm_io_bus *buses[4]; + 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; + atomic_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_notifier_seq; + long int mmu_notifier_count; + long int tlbs_dirty; + struct list_head devices; + struct dentry___2 *debugfs_dentry; + struct kvm_stat_data **debugfs_stat_data; +}; + +struct kvm_lapic; + +struct kvm_apic_map { + struct callback_head rcu; + u8 mode; + struct kvm_lapic *phys_map[256]; + struct kvm_lapic *logical_map[256]; +}; + +struct kvm_arch_async_pf { + u32 token; + gfn_t gfn; + long unsigned int cr3; + bool direct_map; +}; + +struct kvm_rmap_head; + +struct kvm_lpage_info; + +struct kvm_arch_memory_slot { + struct kvm_rmap_head *rmap[3]; + struct kvm_lpage_info *lpage_info[2]; + short unsigned int *gfn_track[1]; +}; + +struct kvm_async_pf { + struct work_struct work; + struct list_head link; + struct list_head queue; + struct kvm_vcpu *vcpu; + struct mm_struct *mm; + gva_t gva; + long unsigned int addr; + struct kvm_arch_async_pf arch; + bool wakeup_all; +}; + +struct kvm_clock_data { + __u64 clock; + __u32 flags; + __u32 pad[9]; +}; + +struct kvm_coalesced_mmio { + __u64 phys_addr; + __u32 len; + __u32 pad; + __u8 data[8]; +}; + +struct kvm_coalesced_mmio_zone { + __u64 addr; + __u32 size; + __u32 pad; +}; + +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 kvm_cpuid_entry { + __u32 function; + __u32 eax; + __u32 ebx; + __u32 ecx; + __u32 edx; + __u32 padding; +}; + +struct kvm_cpuid { + __u32 nent; + __u32 padding; + struct kvm_cpuid_entry entries[0]; +}; + +struct kvm_cpuid_entry2 { + __u32 function; + __u32 index; + __u32 flags; + __u32 eax; + __u32 ebx; + __u32 ecx; + __u32 edx; + __u32 padding[3]; +}; + +struct kvm_cpuid2 { + __u32 nent; + __u32 padding; + struct kvm_cpuid_entry2 entries[0]; +}; + +struct kvm_cpuid_param { + u32 func; + u32 idx; + bool has_leaf_count; + bool (*qualifier)(const struct kvm_cpuid_param *); +}; + +struct kvm_create_device { + __u32 type; + __u32 fd; + __u32 flags; +}; + +struct kvm_debug_exit_arch { + __u32 exception; + __u32 pad; + __u64 pc; + __u64 dr6; + __u64 dr7; +}; + +struct kvm_debugregs { + __u64 db[4]; + __u64 dr6; + __u64 dr7; + __u64 flags; + __u64 reserved[9]; +}; + +struct kvm_device_ops; + +struct kvm_device { + 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 (*destroy)(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); +}; + +struct kvm_dirty_log { + __u32 slot; + __u32 padding1; + union { + void *dirty_bitmap; + __u64 padding2; + }; +}; + +struct kvm_dtable { + __u64 base; + __u16 limit; + __u16 padding[3]; +}; + +struct kvm_enable_cap { + __u32 cap; + __u32 flags; + __u64 args[4]; + __u8 pad[64]; +}; + +struct kvm_event_hw_type_mapping { + u8 eventsel; + u8 unit_mask; + unsigned int event_type; +}; + +struct kvm_fpu { + __u8 fpr[128]; + __u16 fcw; + __u16 fsw; + __u8 ftwx; + __u8 pad1; + __u16 last_opcode; + __u64 last_ip; + __u64 last_dp; + __u8 xmm[256]; + __u32 mxcsr; + __u32 pad2; +}; + +struct kvm_guest_debug_arch { + __u64 debugreg[8]; +}; + +struct kvm_guest_debug { + __u32 control; + __u32 pad; + struct kvm_guest_debug_arch arch; +}; + +struct kvm_hv_sint { + u32 vcpu; + u32 sint; +}; + +struct kvm_hyperv_exit { + __u32 type; + union { + struct { + __u32 msr; + __u64 control; + __u64 evt_page; + __u64 msg_page; + } synic; + struct { + __u64 input; + __u64 result; + __u64 params[2]; + } hcall; + } u; +}; + +struct kvm_interrupt { + __u32 irq; +}; + +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 *); +}; + +union kvm_ioapic_redirect_entry { + u64 bits; + struct { + u8 vector; + u8 delivery_mode: 3; + u8 dest_mode: 1; + u8 delivery_status: 1; + u8 polarity: 1; + u8 remote_irr: 1; + u8 trig_mode: 1; + u8 mask: 1; + u8 reserve: 7; + u8 reserved[4]; + u8 dest_id; + } fields; +}; + +struct rtc_status { + int pending_eoi; + struct dest_map dest_map; +}; + +struct kvm_ioapic { + u64 base_address; + u32 ioregsel; + u32 id; + u32 irr; + u32 pad; + union kvm_ioapic_redirect_entry redirtbl[24]; + long unsigned int irq_states[24]; + struct kvm_io_device dev; + struct kvm *kvm; + void (*ack_notifier)(void *, int); + spinlock_t lock; + struct rtc_status rtc_status; + struct delayed_work eoi_inject; + u32 irq_eoi[24]; + u32 irr_delivered; +}; + +struct kvm_ioapic_state { + __u64 base_address; + __u32 ioregsel; + __u32 id; + __u32 irr; + __u32 pad; + union { + __u64 bits; + struct { + __u8 vector; + __u8 delivery_mode: 3; + __u8 dest_mode: 1; + __u8 delivery_status: 1; + __u8 polarity: 1; + __u8 remote_irr: 1; + __u8 trig_mode: 1; + __u8 mask: 1; + __u8 reserve: 7; + __u8 reserved[4]; + __u8 dest_id; + } fields; + } redirtbl[24]; +}; + +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_mask_notifier { + void (*func)(struct kvm_irq_mask_notifier *, bool); + int irq; + struct hlist_node link; +}; + +struct kvm_irq_routing_irqchip { + __u32 irqchip; + __u32 pin; +}; + +struct kvm_irq_routing_msi { + __u32 address_lo; + __u32 address_hi; + __u32 data; + __u32 pad; +}; + +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_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; + __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[72]; + u32 nr_rt_entries; + struct hlist_head map[0]; +}; + +struct kvm_pic_state { + __u8 last_irr; + __u8 irr; + __u8 imr; + __u8 isr; + __u8 priority_add; + __u8 irq_base; + __u8 read_reg_select; + __u8 poll; + __u8 special_mask; + __u8 init_state; + __u8 auto_eoi; + __u8 rotate_on_auto_eoi; + __u8 special_fully_nested_mode; + __u8 init4; + __u8 elcr; + __u8 elcr_mask; +}; + +struct kvm_irqchip { + __u32 chip_id; + __u32 pad; + union { + char dummy[512]; + struct kvm_pic_state pic; + struct kvm_ioapic_state ioapic; + } chip; +}; + +struct kvm_irqfd { + __u32 fd; + __u32 gsi; + __u32 flags; + __u32 resamplefd; + __u8 pad[16]; +}; + +struct msi_msg { + u32 address_lo; + u32 address_hi; + u32 data; +}; + +struct kvm_s390_adapter_int { + u64 ind_addr; + u64 summary_addr; + u64 ind_offset; + u32 summary_offset; + u32 adapter_id; +}; + +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 msi_msg msi; + struct kvm_s390_adapter_int adapter; + struct kvm_hv_sint hv_sint; + }; + struct hlist_node link; +}; + +struct kvm_kernel_irqfd_resampler; + +struct kvm_kernel_irqfd { + struct kvm *kvm; + wait_queue_t wait; + struct kvm_kernel_irq_routing_entry irq_entry; + seqcount_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_kpic_state { + u8 last_irr; + u8 irr; + u8 imr; + u8 isr; + u8 priority_add; + u8 irq_base; + u8 read_reg_select; + u8 poll; + u8 special_mask; + u8 init_state; + u8 auto_eoi; + u8 rotate_on_auto_eoi; + u8 special_fully_nested_mode; + u8 init4; + u8 elcr; + u8 elcr_mask; + u8 isr_ack; + struct kvm_pic *pics_state; +}; + +struct kvm_kpit_channel_state { + u32 count; + u16 latched_count; + u8 count_latched; + u8 status_latched; + u8 status; + u8 read_state; + u8 write_state; + u8 write_latch; + u8 rw_mode; + u8 mode; + u8 bcd; + u8 gate; + ktime_t count_load_time; +}; + +struct kvm_kpit_state { + struct kvm_kpit_channel_state channels[3]; + u32 flags; + bool is_periodic; + s64 period; + struct hrtimer timer; + u32 speaker_data_on; + struct mutex lock; + atomic_t reinject; + atomic_t pending; + atomic_t irq_ack; + struct kvm_irq_ack_notifier irq_ack_notifier; +}; + +struct kvm_timer { + struct hrtimer timer; + s64 period; + u32 timer_mode; + u32 timer_mode_mask; + u64 tscdeadline; + u64 expired_tscdeadline; + atomic_t pending; +}; + +struct kvm_lapic { + long unsigned int base_address; + struct kvm_io_device dev; + struct kvm_timer lapic_timer; + u32 divide_count; + struct kvm_vcpu *vcpu; + bool sw_enabled; + bool irr_pending; + bool lvt0_in_nmi_mode; + s16 isr_count; + int highest_isr_cache; + void *regs; + gpa_t vapic_addr; + struct gfn_to_hva_cache vapic_cache; + long unsigned int pending_events; + unsigned int sipi_vector; +}; + +struct kvm_lapic_irq { + u32 vector; + u16 delivery_mode; + u16 dest_mode; + bool level; + u16 trig_mode; + u32 shorthand; + u32 dest_id; + bool msi_redir_hint; +}; + +struct kvm_lapic_state { + char regs[1024]; +}; + +struct kvm_ldttss_desc { + u16 limit0; + u16 base0; + unsigned int base1: 8; + unsigned int type: 5; + unsigned int dpl: 2; + unsigned int p: 1; + unsigned int limit1: 4; + unsigned int zero0: 3; + unsigned int g: 1; + unsigned int base2: 8; + u32 base3; + u32 zero1; +}; + +struct kvm_lpage_info { + int disallow_lpage; +}; + +struct kvm_memory_slot { + 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; +}; + +struct kvm_memslots { + u64 generation; + struct kvm_memory_slot memslots[512]; + short int id_to_index[512]; + atomic_t lru_slot; + int used_slots; +}; + +struct kvm_mmio_fragment { + gpa_t gpa; + void *data; + unsigned int len; +}; + +union kvm_mmu_page_role { + unsigned int word; + struct { + unsigned int level: 4; + unsigned int cr4_pae: 1; + unsigned int quadrant: 2; + unsigned int direct: 1; + unsigned int access: 3; + unsigned int invalid: 1; + unsigned int nxe: 1; + unsigned int cr0_wp: 1; + unsigned int smep_andnot_wp: 1; + unsigned int smap_andnot_wp: 1; + char: 8; + unsigned int smm: 8; + }; +}; + +struct rsvd_bits_validate { + u64 rsvd_bits_mask[8]; + u64 bad_mt_xwr; +}; + +struct kvm_mmu_page; + +struct kvm_mmu { + void (*set_cr3)(struct kvm_vcpu *, long unsigned int); + long unsigned int (*get_cr3)(struct kvm_vcpu *); + u64 (*get_pdptr)(struct kvm_vcpu *, int); + int (*page_fault)(struct kvm_vcpu *, gva_t, u32, bool); + void (*inject_page_fault)(struct kvm_vcpu *, struct x86_exception *); + gpa_t (*gva_to_gpa)(struct kvm_vcpu *, gva_t, u32, struct x86_exception *); + gpa_t (*translate_gpa)(struct kvm_vcpu *, gpa_t, u32, struct x86_exception *); + int (*sync_page)(struct kvm_vcpu *, struct kvm_mmu_page *); + void (*invlpg)(struct kvm_vcpu *, gva_t); + void (*update_pte)(struct kvm_vcpu *, struct kvm_mmu_page *, u64 *, const void *); + hpa_t root_hpa; + int root_level; + int shadow_root_level; + union kvm_mmu_page_role base_role; + bool direct_map; + u8 permissions[16]; + u32 pkru_mask; + u64 *pae_root; + u64 *lm_root; + struct rsvd_bits_validate shadow_zero_check; + struct rsvd_bits_validate guest_rsvd_check; + u8 last_nonleaf_level; + bool nx; + u64 pdptrs[4]; +}; + +struct kvm_mmu_memory_cache { + int nobjs; + void *objects[40]; +}; + +struct kvm_rmap_head { + long unsigned int val; +}; + +struct kvm_mmu_page { + struct list_head link; + struct hlist_node hash_link; + gfn_t gfn; + union kvm_mmu_page_role role; + u64 *spt; + gfn_t *gfns; + bool unsync; + int root_count; + unsigned int unsync_children; + struct kvm_rmap_head parent_ptes; + long unsigned int mmu_valid_gen; + long unsigned int unsync_child_bitmap[8]; + atomic_t write_flooding_count; +}; + +struct mmu_page_and_offset { + struct kvm_mmu_page *sp; + unsigned int idx; +}; + +struct kvm_mmu_pages { + struct mmu_page_and_offset page[16]; + unsigned int nr; +}; + +struct kvm_mp_state { + __u32 mp_state; +}; + +struct kvm_msi { + __u32 address_lo; + __u32 address_hi; + __u32 data; + __u32 flags; + __u8 pad[16]; +}; + +struct kvm_msr_entry { + __u32 index; + __u32 reserved; + __u64 data; +}; + +struct kvm_msr_list { + __u32 nmsrs; + __u32 indices[0]; +}; + +struct kvm_msrs { + __u32 nmsrs; + __u32 pad; + struct kvm_msr_entry entries[0]; +}; + +struct kvm_mtrr_range { + u64 base; + u64 mask; + struct list_head node; +}; + +struct kvm_mtrr { + struct kvm_mtrr_range var_ranges[8]; + mtrr_type fixed_ranges[88]; + u64 deftype; + struct list_head head; +}; + +struct kvm_pic { + spinlock_t lock; + bool wakeup_needed; + unsigned int pending_acks; + struct kvm *kvm; + struct kvm_kpic_state pics[2]; + int output; + struct kvm_io_device dev_master; + struct kvm_io_device dev_slave; + struct kvm_io_device dev_eclr; + void (*ack_notifier)(void *, int); + long unsigned int irq_states[16]; +}; + +struct kvm_pio_request { + long unsigned int count; + int in; + int port; + int size; +}; + +struct kvm_pit { + struct kvm_io_device dev; + struct kvm_io_device speaker_dev; + struct kvm *kvm; + struct kvm_kpit_state pit_state; + int irq_source_id; + struct kvm_irq_mask_notifier mask_notifier; + struct kthread_worker worker; + struct task_struct *worker_task; + struct kthread_work expired; +}; + +struct kvm_pit_channel_state { + __u32 count; + __u16 latched_count; + __u8 count_latched; + __u8 status_latched; + __u8 status; + __u8 read_state; + __u8 write_state; + __u8 write_latch; + __u8 rw_mode; + __u8 mode; + __u8 bcd; + __u8 gate; + __s64 count_load_time; +}; + +struct kvm_pit_config { + __u32 flags; + __u32 pad[15]; +}; + +struct kvm_pit_state { + struct kvm_pit_channel_state channels[3]; +}; + +struct kvm_pit_state2 { + struct kvm_pit_channel_state channels[3]; + __u32 flags; + __u32 reserved[9]; +}; + +struct kvm_pmc { + enum pmc_type type; + u8 idx; + u64 counter; + u64 eventsel; + struct perf_event *perf_event; + struct kvm_vcpu *vcpu; +}; + +struct kvm_pmu { + unsigned int nr_arch_gp_counters; + unsigned int nr_arch_fixed_counters; + unsigned int available_event_types; + u64 fixed_ctr_ctrl; + u64 global_ctrl; + u64 global_status; + u64 global_ovf_ctrl; + u64 counter_bitmask[2]; + u64 global_ctrl_mask; + u64 reserved_bits; + u8 version; + struct kvm_pmc gp_counters[32]; + struct kvm_pmc fixed_counters[3]; + struct irq_work irq_work; + u64 reprogram_pmi; +}; + +struct msr_data; + +struct kvm_pmu_ops { + unsigned int (*find_arch_event)(struct kvm_pmu *, u8, u8); + unsigned int (*find_fixed_event)(int); + bool (*pmc_is_enabled)(struct kvm_pmc *); + struct kvm_pmc * (*pmc_idx_to_pmc)(struct kvm_pmu *, int); + struct kvm_pmc * (*msr_idx_to_pmc)(struct kvm_vcpu *, unsigned int); + int (*is_valid_msr_idx)(struct kvm_vcpu *, unsigned int); + bool (*is_valid_msr)(struct kvm_vcpu *, u32); + int (*get_msr)(struct kvm_vcpu *, u32, u64 *); + int (*set_msr)(struct kvm_vcpu *, struct msr_data *); + void (*refresh)(struct kvm_vcpu *); + void (*init)(struct kvm_vcpu *); + void (*reset)(struct kvm_vcpu *); +}; + +struct kvm_queued_exception { + bool pending; + bool has_error_code; + bool reinject; + u8 nr; + u32 error_code; +}; + +struct kvm_queued_interrupt { + bool pending; + bool soft; + u8 nr; +}; + +struct kvm_regs { + __u64 rax; + __u64 rbx; + __u64 rcx; + __u64 rdx; + __u64 rsi; + __u64 rdi; + __u64 rsp; + __u64 rbp; + __u64 r8; + __u64 r9; + __u64 r10; + __u64 r11; + __u64 r12; + __u64 r13; + __u64 r14; + __u64 r15; + __u64 rip; + __u64 rflags; +}; + +struct kvm_reinject_control { + __u8 pit_reinject; + __u8 reserved[31]; +}; + +struct kvm_sync_regs {}; + +struct kvm_run { + __u8 request_interrupt_window; + __u8 padding1[7]; + __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; + } 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 nr; + __u64 args[6]; + __u64 ret; + __u32 longmode; + __u32 pad; + } 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 { + __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; + __u64 flags; + } 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; + char padding[256]; + }; + __u64 kvm_valid_regs; + __u64 kvm_dirty_regs; + union { + struct kvm_sync_regs regs; + char padding[2048]; + } s; +}; + +struct kvm_save_segment { + u16 selector; + long unsigned int base; + u32 limit; + u32 ar; +}; + +struct kvm_segment { + __u64 base; + __u32 limit; + __u16 selector; + __u8 type; + __u8 present; + __u8 dpl; + __u8 db; + __u8 s; + __u8 l; + __u8 g; + __u8 avl; + __u8 unusable; + __u8 padding; +}; + +struct kvm_shadow_walk_iterator { + u64 addr; + hpa_t shadow_addr; + u64 *sptep; + int level; + unsigned int index; +}; + +struct kvm_shared_msr_values { + u64 host; + u64 curr; +}; + +struct user_return_notifier { + void (*on_user_return)(struct user_return_notifier *); + struct hlist_node link; +}; + +struct kvm_shared_msrs { + struct user_return_notifier urn; + bool registered; + struct kvm_shared_msr_values values[16]; +}; + +struct kvm_shared_msrs_global { + int nr; + u32 msrs[16]; +}; + +struct kvm_signal_mask { + __u32 len; + __u8 sigset[0]; +}; + +struct kvm_sregs { + struct kvm_segment cs; + struct kvm_segment ds; + struct kvm_segment es; + struct kvm_segment fs; + struct kvm_segment gs; + struct kvm_segment ss; + struct kvm_segment tr; + struct kvm_segment ldt; + struct kvm_dtable gdt; + struct kvm_dtable idt; + __u64 cr0; + __u64 cr2; + __u64 cr3; + __u64 cr4; + __u64 cr8; + __u64 efer; + __u64 apic_base; + __u64 interrupt_bitmap[4]; +}; + +struct kvm_stat_data { + int offset; + struct kvm *kvm; +}; + +struct kvm_stats_debugfs_item { + const char *name; + int offset; + enum kvm_stat_kind kind; +}; + +struct kvm_steal_time { + __u64 steal; + __u32 version; + __u32 flags; + __u32 pad[12]; +}; + +struct kvm_task_sleep_head { + raw_spinlock_t lock; + struct hlist_head list; +}; + +struct swait_queue_head { + raw_spinlock_t lock; + struct list_head task_list; +}; + +struct kvm_task_sleep_node { + struct hlist_node link; + struct swait_queue_head wq; + u32 token; + int cpu; + bool halted; +}; + +struct kvm_tpr_access_ctl { + __u32 enabled; + __u32 flags; + __u32 reserved[8]; +}; + +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_vapic_addr { + __u64 vapic_addr; +}; + +struct preempt_ops; + +struct preempt_notifier { + struct hlist_node link; + struct preempt_ops *ops; +}; + +struct kvm_vcpu_stat { + u32 pf_fixed; + u32 pf_guest; + u32 tlb_flush; + u32 invlpg; + u32 exits; + u32 io_exits; + u32 mmio_exits; + u32 signal_exits; + u32 irq_window_exits; + u32 nmi_window_exits; + u32 halt_exits; + u32 halt_successful_poll; + u32 halt_attempted_poll; + u32 halt_poll_invalid; + u32 halt_wakeup; + u32 request_irq_exits; + u32 irq_exits; + u32 host_state_reload; + u32 efer_reload; + u32 fpu_reload; + u32 insn_emulation; + u32 insn_emulation_fail; + u32 hypercalls; + u32 irq_injections; + u32 nmi_injections; +}; + +struct segmented_address { + ulong ea; + unsigned int seg; +}; + +struct operand { + enum { + OP_REG = 0, + OP_MEM = 1, + OP_MEM_STR = 2, + OP_IMM = 3, + OP_XMM = 4, + OP_MM = 5, + OP_NONE___2 = 6, + } type; + unsigned int bytes; + unsigned int count; + union { + long unsigned int orig_val; + u64 orig_val64; + }; + union { + long unsigned int *reg; + struct segmented_address mem; + unsigned int xmm; + unsigned int mm; + } addr; + long: 64; + union { + long unsigned int val; + u64 val64; + char valptr[16]; + sse128_t vec_val; + u64 mm_val; + void *data; + }; +}; + +struct read_cache { + u8 data[1024]; + long unsigned int pos; + long unsigned int end; +}; + +struct x86_emulate_ops; + +struct x86_emulate_ctxt { + const struct x86_emulate_ops *ops; + long unsigned int eflags; + long unsigned int eip; + enum x86emul_mode mode; + int interruptibility; + int emul_flags; + bool perm_ok; + bool ud; + bool have_exception; + struct x86_exception exception; + u8 opcode_len; + u8 b; + u8 intercept; + u8 op_bytes; + u8 ad_bytes; + struct operand src; + struct operand src2; + struct operand dst; + int (*execute)(struct x86_emulate_ctxt *); + int (*check_perm)(struct x86_emulate_ctxt *); + bool rip_relative; + u8 rex_prefix; + u8 lock_prefix; + u8 rep_prefix; + u32 regs_valid; + u32 regs_dirty; + u8 modrm; + u8 modrm_mod; + u8 modrm_reg; + u8 modrm_rm; + u8 modrm_seg; + u8 seg_override; + u64 d; + long unsigned int _eip; + long: 64; + struct operand memop; + long unsigned int _regs[17]; + struct operand *memopp; + struct fetch_cache fetch; + struct read_cache io_read; + struct read_cache mem_read; +}; + +struct pvclock_vcpu_time_info { + u32 version; + u32 pad0; + u64 tsc_timestamp; + u64 system_time; + u32 tsc_to_system_mul; + s8 tsc_shift; + u8 flags; + u8 pad[2]; +}; + +struct kvm_vcpu_hv_synic { + u64 version; + u64 control; + u64 msg_page; + u64 evt_page; + atomic64_t sint[16]; + atomic_t sint_to_gsi[16]; + long unsigned int auto_eoi_bitmap[4]; + long unsigned int vec_bitmap[4]; + bool active; +}; + +struct kvm_vcpu_hv_stimer { + struct hrtimer timer; + int index; + u64 config; + u64 count; + u64 exp_time; + struct hv_message msg; + bool msg_pending; +}; + +struct kvm_vcpu_hv { + u64 hv_vapic; + s64 runtime_offset; + struct kvm_vcpu_hv_synic synic; + struct kvm_hyperv_exit exit; + struct kvm_vcpu_hv_stimer stimer[4]; + long unsigned int stimer_pending_bitmap[1]; +}; + +struct kvm_vcpu_arch { + long unsigned int regs[17]; + u32 regs_avail; + u32 regs_dirty; + long unsigned int cr0; + long unsigned int cr0_guest_owned_bits; + long unsigned int cr2; + long unsigned int cr3; + long unsigned int cr4; + long unsigned int cr4_guest_owned_bits; + long unsigned int cr8; + u32 hflags; + u64 efer; + u64 apic_base; + struct kvm_lapic *apic; + bool apicv_active; + long unsigned int ioapic_handled_vectors[4]; + long unsigned int apic_attention; + int32_t apic_arb_prio; + int mp_state; + u64 ia32_misc_enable_msr; + u64 smbase; + bool tpr_access_reporting; + u64 ia32_xss; + struct kvm_mmu mmu; + struct kvm_mmu nested_mmu; + struct kvm_mmu *walk_mmu; + struct kvm_mmu_memory_cache mmu_pte_list_desc_cache; + struct kvm_mmu_memory_cache mmu_page_cache; + struct kvm_mmu_memory_cache mmu_page_header_cache; + long: 64; + long: 64; + struct fpu guest_fpu; + u64 xcr0; + u64 guest_supported_xcr0; + u32 guest_xstate_size; + struct kvm_pio_request pio; + void *pio_data; + u8 event_exit_inst_len; + struct kvm_queued_exception exception; + struct kvm_queued_interrupt interrupt; + int halt_request; + int cpuid_nent; + struct kvm_cpuid_entry2 cpuid_entries[80]; + int maxphyaddr; + long: 64; + struct x86_emulate_ctxt emulate_ctxt; + bool emulate_regs_need_sync_to_vcpu; + bool emulate_regs_need_sync_from_vcpu; + int (*complete_userspace_io)(struct kvm_vcpu *); + gpa_t time; + struct pvclock_vcpu_time_info hv_clock; + unsigned int hw_tsc_khz; + struct gfn_to_hva_cache pv_time; + bool pv_time_enabled; + bool pvclock_set_guest_stopped_request; + struct { + u64 msr_val; + u64 last_steal; + struct gfn_to_hva_cache stime; + struct kvm_steal_time steal; + } st; + u64 last_guest_tsc; + u64 last_host_tsc; + u64 tsc_offset_adjustment; + u64 this_tsc_nsec; + u64 this_tsc_write; + u64 this_tsc_generation; + bool tsc_catchup; + bool tsc_always_catchup; + s8 virtual_tsc_shift; + u32 virtual_tsc_mult; + u32 virtual_tsc_khz; + s64 ia32_tsc_adjust_msr; + u64 tsc_scaling_ratio; + atomic_t nmi_queued; + unsigned int nmi_pending; + bool nmi_injected; + bool smi_pending; + struct kvm_mtrr mtrr_state; + u64 pat; + unsigned int switch_db_regs; + long unsigned int db[4]; + long unsigned int dr6; + long unsigned int dr7; + long unsigned int eff_db[4]; + long unsigned int guest_debug_dr7; + u64 mcg_cap; + u64 mcg_status; + u64 mcg_ctl; + u64 *mce_banks; + u64 mmio_gva; + unsigned int access; + gfn_t mmio_gfn; + u64 mmio_gen; + struct kvm_pmu pmu; + long unsigned int singlestep_rip; + struct kvm_vcpu_hv hyperv; + cpumask_var_t wbinvd_dirty_mask; + long unsigned int last_retry_eip; + long unsigned int last_retry_addr; + struct { + bool halted; + gfn_t gfns[64]; + struct gfn_to_hva_cache data; + u64 msr_val; + u32 id; + bool send_user_only; + } apf; + struct { + u64 length; + u64 status; + } osvw; + struct { + u64 msr_val; + struct gfn_to_hva_cache data; + } pv_eoi; + bool write_fault_to_shadow_pgtable; + long unsigned int exit_qualification; + struct { + bool pv_unhalted; + } pv; + int pending_ioapic_eoi; + int pending_external_vector; + long: 64; + long: 64; + long: 64; +}; + +struct kvm_vcpu { + struct kvm *kvm; + struct preempt_notifier preempt_notifier; + int cpu; + int vcpu_id; + int srcu_idx; + int mode; + long unsigned int requests; + long unsigned int guest_debug; + int pre_pcpu; + struct list_head blocked_vcpu_list; + struct mutex mutex; + struct kvm_run *run; + int fpu_active; + int guest_fpu_loaded; + int guest_xcr0_loaded; + unsigned char fpu_counter; + struct swait_queue_head wq; + struct pid___2 *pid; + int sigset_active; + sigset_t sigset; + struct kvm_vcpu_stat stat; + 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 { + u32 queued; + struct list_head queue; + struct list_head done; + spinlock_t lock; + } async_pf; + struct { + bool in_spin_loop; + bool dy_eligible; + } spin_loop; + bool preempted; + long: 64; + long: 64; + struct kvm_vcpu_arch arch; +}; + +typedef struct kvm_vcpu *pto_T_____20; + +struct kvm_vcpu_events { + struct { + __u8 injected; + __u8 nr; + __u8 has_error_code; + __u8 pad; + __u32 error_code; + } exception; + struct { + __u8 injected; + __u8 nr; + __u8 soft; + __u8 shadow; + } interrupt; + struct { + __u8 injected; + __u8 pending; + __u8 masked; + __u8 pad; + } nmi; + __u32 sipi_vector; + __u32 flags; + struct { + __u8 smm; + __u8 pending; + __u8 smm_inside_nmi; + __u8 latched_init; + } smi; + __u32 reserved[9]; +}; + +struct kvm_vcpu_pv_apf_data { + __u32 reason; + __u8 pad[60]; + __u32 enabled; +}; + +struct kvm_vfio { + struct list_head group_list; + struct mutex lock; + bool noncoherent; +}; + +struct vfio_group; + +struct kvm_vfio_group { + struct list_head node; + struct vfio_group *vfio_group; +}; + +struct kvm_vmx_segment_field { + unsigned int selector; + unsigned int base; + unsigned int limit; + unsigned int ar_bytes; +}; + +struct kvm_x86_mce { + __u64 status; + __u64 addr; + __u64 misc; + __u64 mcg_status; + __u8 bank; + __u8 pad1[7]; + __u64 pad2[3]; +}; + +struct x86_instruction_info; + +struct kvm_x86_ops { + int (*cpu_has_kvm_support)(void); + int (*disabled_by_bios)(void); + int (*hardware_enable)(void); + void (*hardware_disable)(void); + void (*check_processor_compatibility)(void *); + int (*hardware_setup)(void); + void (*hardware_unsetup)(void); + bool (*cpu_has_accelerated_tpr)(void); + bool (*cpu_has_high_real_mode_segbase)(void); + void (*cpuid_update)(struct kvm_vcpu *); + int (*vm_init)(struct kvm *); + void (*vm_destroy)(struct kvm *); + struct kvm_vcpu * (*vcpu_create)(struct kvm *, unsigned int); + void (*vcpu_free)(struct kvm_vcpu *); + void (*vcpu_reset)(struct kvm_vcpu *, bool); + void (*prepare_guest_switch)(struct kvm_vcpu *); + void (*vcpu_load)(struct kvm_vcpu *, int); + void (*vcpu_put)(struct kvm_vcpu *); + void (*update_bp_intercept)(struct kvm_vcpu *); + int (*get_msr)(struct kvm_vcpu *, struct msr_data *); + int (*set_msr)(struct kvm_vcpu *, struct msr_data *); + u64 (*get_segment_base)(struct kvm_vcpu *, int); + void (*get_segment)(struct kvm_vcpu *, struct kvm_segment *, int); + int (*get_cpl)(struct kvm_vcpu *); + void (*set_segment)(struct kvm_vcpu *, struct kvm_segment *, int); + void (*get_cs_db_l_bits)(struct kvm_vcpu *, int *, int *); + void (*decache_cr0_guest_bits)(struct kvm_vcpu *); + void (*decache_cr3)(struct kvm_vcpu *); + void (*decache_cr4_guest_bits)(struct kvm_vcpu *); + void (*set_cr0)(struct kvm_vcpu *, long unsigned int); + void (*set_cr3)(struct kvm_vcpu *, long unsigned int); + int (*set_cr4)(struct kvm_vcpu *, long unsigned int); + void (*set_efer)(struct kvm_vcpu *, u64); + void (*get_idt)(struct kvm_vcpu *, struct desc_ptr *); + void (*set_idt)(struct kvm_vcpu *, struct desc_ptr *); + void (*get_gdt)(struct kvm_vcpu *, struct desc_ptr *); + void (*set_gdt)(struct kvm_vcpu *, struct desc_ptr *); + u64 (*get_dr6)(struct kvm_vcpu *); + void (*set_dr6)(struct kvm_vcpu *, long unsigned int); + void (*sync_dirty_debug_regs)(struct kvm_vcpu *); + void (*set_dr7)(struct kvm_vcpu *, long unsigned int); + void (*cache_reg)(struct kvm_vcpu *, enum kvm_reg); + long unsigned int (*get_rflags)(struct kvm_vcpu *); + void (*set_rflags)(struct kvm_vcpu *, long unsigned int); + u32 (*get_pkru)(struct kvm_vcpu *); + void (*fpu_activate)(struct kvm_vcpu *); + void (*fpu_deactivate)(struct kvm_vcpu *); + void (*tlb_flush)(struct kvm_vcpu *); + void (*run)(struct kvm_vcpu *); + int (*handle_exit)(struct kvm_vcpu *); + void (*skip_emulated_instruction)(struct kvm_vcpu *); + void (*set_interrupt_shadow)(struct kvm_vcpu *, int); + u32 (*get_interrupt_shadow)(struct kvm_vcpu *); + void (*patch_hypercall)(struct kvm_vcpu *, unsigned char *); + void (*set_irq)(struct kvm_vcpu *); + void (*set_nmi)(struct kvm_vcpu *); + void (*queue_exception)(struct kvm_vcpu *, unsigned int, bool, u32, bool); + void (*cancel_injection)(struct kvm_vcpu *); + int (*interrupt_allowed)(struct kvm_vcpu *); + int (*nmi_allowed)(struct kvm_vcpu *); + bool (*get_nmi_mask)(struct kvm_vcpu *); + void (*set_nmi_mask)(struct kvm_vcpu *, bool); + void (*enable_nmi_window)(struct kvm_vcpu *); + void (*enable_irq_window)(struct kvm_vcpu *); + void (*update_cr8_intercept)(struct kvm_vcpu *, int, int); + bool (*get_enable_apicv)(void); + void (*refresh_apicv_exec_ctrl)(struct kvm_vcpu *); + void (*hwapic_irr_update)(struct kvm_vcpu *, int); + void (*hwapic_isr_update)(struct kvm_vcpu *, int); + void (*load_eoi_exitmap)(struct kvm_vcpu *, u64 *); + void (*set_virtual_x2apic_mode)(struct kvm_vcpu *, bool); + void (*set_apic_access_page_addr)(struct kvm_vcpu *, hpa_t); + void (*deliver_posted_interrupt)(struct kvm_vcpu *, int); + void (*sync_pir_to_irr)(struct kvm_vcpu *); + int (*set_tss_addr)(struct kvm *, unsigned int); + int (*get_tdp_level)(void); + u64 (*get_mt_mask)(struct kvm_vcpu *, gfn_t, bool); + int (*get_lpage_level)(void); + bool (*rdtscp_supported)(void); + bool (*invpcid_supported)(void); + void (*adjust_tsc_offset_guest)(struct kvm_vcpu *, s64); + void (*set_tdp_cr3)(struct kvm_vcpu *, long unsigned int); + void (*set_supported_cpuid)(u32, struct kvm_cpuid_entry2 *); + bool (*has_wbinvd_exit)(void); + u64 (*read_tsc_offset)(struct kvm_vcpu *); + void (*write_tsc_offset)(struct kvm_vcpu *, u64); + u64 (*read_l1_tsc)(struct kvm_vcpu *, u64); + void (*get_exit_info)(struct kvm_vcpu *, u64 *, u64 *); + int (*check_intercept)(struct kvm_vcpu *, struct x86_instruction_info *, enum x86_intercept_stage); + void (*handle_external_intr)(struct kvm_vcpu *); + bool (*mpx_supported)(void); + bool (*xsaves_supported)(void); + int (*check_nested_events)(struct kvm_vcpu *, bool); + void (*sched_in)(struct kvm_vcpu *, int); + void (*slot_enable_log_dirty)(struct kvm *, struct kvm_memory_slot *); + void (*slot_disable_log_dirty)(struct kvm *, struct kvm_memory_slot *); + void (*flush_log_dirty)(struct kvm *); + void (*enable_log_dirty_pt_masked)(struct kvm *, struct kvm_memory_slot *, gfn_t, long unsigned int); + const struct kvm_pmu_ops *pmu_ops; + int (*pre_block)(struct kvm_vcpu *); + void (*post_block)(struct kvm_vcpu *); + void (*vcpu_blocking)(struct kvm_vcpu *); + void (*vcpu_unblocking)(struct kvm_vcpu *); + int (*update_pi_irte)(struct kvm *, unsigned int, uint32_t, bool); + void (*apicv_post_state_restore)(struct kvm_vcpu *); +}; + +struct kvm_xcr { + __u32 xcr; + __u32 reserved; + __u64 value; +}; + +struct kvm_xcrs { + __u32 nr_xcrs; + __u32 flags; + struct kvm_xcr xcrs[16]; + __u64 padding[16]; +}; + +struct kvm_xsave { + __u32 region[1024]; +}; + +union l1_cache { + struct { + unsigned int line_size: 8; + unsigned int lines_per_tag: 8; + unsigned int assoc: 8; + unsigned int size_in_kb: 8; + }; + unsigned int val; +}; + +union l2_cache { + struct { + unsigned int line_size: 8; + unsigned int lines_per_tag: 4; + unsigned int assoc: 4; + unsigned int size_in_kb: 16; + }; + unsigned int val; +}; + +union l3_cache { + struct { + unsigned int line_size: 8; + unsigned int lines_per_tag: 4; + unsigned int assoc: 4; + unsigned int res: 2; + unsigned int size_encoded: 14; + }; + unsigned int val; +}; + +struct latch_tree_node { + struct rb_node node[2]; +}; + +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_t seq; + struct rb_root tree[2]; +}; + +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; + struct list_head tasks; +}; + +struct ld_semaphore { + long int 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___2 *task; +}; + +struct ldt_struct { + struct desc_struct *entries; + int size; +}; + +struct ldttss_desc64 { + u16 limit0; + u16 base0; + unsigned int base1: 8; + unsigned int type: 5; + unsigned int dpl: 2; + unsigned int p: 1; + unsigned int limit1: 4; + unsigned int zero0: 3; + unsigned int g: 1; + unsigned int base2: 8; + u32 base3; + u32 zero1; +}; + +typedef struct ldttss_desc64 ldt_desc; + +typedef struct ldttss_desc64 tss_desc; + +struct legacy_pic { + int nr_legacy_irqs; + struct irq_chip *chip; + void (*mask)(unsigned int); + void (*unmask)(unsigned int); + void (*mask_all)(void); + void (*restore_mask)(void); + void (*init)(int); + int (*probe)(void); + int (*irq_pending)(unsigned int); + void (*make_irq)(unsigned int); +}; + +struct lglock { + arch_spinlock_t *lock; +}; + +struct lifebook_data { + struct input_dev *dev2; + char phys[32]; +}; + +struct limit_names { + const char *name; + const char *unit; +}; + +struct linear_c { + struct dm_dev *dev; + sector_t start; +}; + +struct linear_priv { + int cvt_endian; + unsigned int src_ofs; + unsigned int dst_ofs; + unsigned int copy_ofs; + unsigned int dst_bytes; + unsigned int copy_bytes; + unsigned int flip; +}; + +struct linger { + int l_onoff; + int l_linger; +}; + +struct link_ctl_info { + snd_ctl_elem_type_t type; + int count; + int min_val; + int max_val; +}; + +struct link_master { + struct list_head slaves; + struct link_ctl_info info; + int val; + unsigned int tlv[4]; + void (*hook)(void *, int); + void *hook_private_data; +}; + +struct snd_ctl_elem_id { + unsigned int numid; + snd_ctl_elem_iface_t iface; + unsigned int device; + unsigned int subdevice; + unsigned char name[44]; + unsigned int index; +}; + +struct snd_ctl_file; + +struct snd_kcontrol_volatile { + struct snd_ctl_file *owner; + unsigned int access; +}; + +struct snd_kcontrol { + struct list_head list; + struct snd_ctl_elem_id id; + unsigned int count; + snd_kcontrol_info_t *info; + snd_kcontrol_get_t *get; + snd_kcontrol_put_t *put; + union { + snd_kcontrol_tlv_rw_t *c; + const unsigned int *p; + } tlv; + long unsigned int private_value; + void *private_data; + void (*private_free)(struct snd_kcontrol *); + struct snd_kcontrol_volatile vd[0]; +}; + +struct link_slave { + struct list_head list; + struct link_master *master; + struct link_ctl_info info; + int vals[2]; + unsigned int flags; + struct snd_kcontrol *kctl; + struct snd_kcontrol slave; +}; + +struct linked_page { + struct linked_page *next; + char data[4088]; +}; + +struct linux_binprm; + +struct linux_binfmt { + struct list_head lh; + struct module *module; + int (*load_binary)(struct linux_binprm *); + int (*load_shlib)(struct file___2 *); + int (*core_dump)(struct coredump_params *); + long unsigned int min_coredump; +}; + +struct linux_binprm { + char buf[128]; + struct vm_area_struct___2 *vma; + long unsigned int vma_pages; + struct mm_struct *mm; + long unsigned int p; + unsigned int cred_prepared: 1; + unsigned int cap_effective: 1; + unsigned int recursion_depth; + struct file___2 *file; + struct cred *cred; + int unsafe; + unsigned int per_clear; + int argc; + int envc; + const char *filename; + const char *interp; + unsigned int interp_flags; + unsigned int interp_data; + long unsigned int loader; + long unsigned int exec; +}; + +struct linux_dirent { + long unsigned int d_ino; + long unsigned int d_off; + short unsigned int d_reclen; + char d_name[1]; +}; + +struct linux_dirent64 { + u64 d_ino; + s64 d_off; + short unsigned int d_reclen; + unsigned char d_type; + char d_name[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[117]; +}; + +struct list_lru_node; + +struct list_lru { + struct list_lru_node *node; +}; + +struct list_lru_one { + struct list_head list; + long int nr_items; +}; + +struct list_lru_node { + spinlock_t lock; + struct list_lru_one lru; + long: 64; + 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 { + Elf64_Ehdr *hdr; + long unsigned int len; + Elf64_Shdr *sechdrs; + char *secstrings; + char *strtab; + long unsigned int symoffs; + long unsigned int stroffs; + struct _ddebug *debug; + unsigned int num_debug; + bool sig_ok; + long unsigned int mod_kallsyms_init_off; + struct { + unsigned int sym; + unsigned int str; + unsigned int mod; + unsigned int vers; + unsigned int info; + unsigned int pcpu; + } index; +}; + +struct vmcs; + +struct loaded_vmcs { + struct vmcs *vmcs; + int cpu; + int launched; + struct list_head loaded_vmcss_on_cpu_link; +}; + +struct location; + +struct loc_track { + long unsigned int max; + long unsigned int count; + struct location *loc; +}; + +struct local_ports { + seqlock_t lock; + int range[2]; + bool warned; +}; + +struct locate_info { + long unsigned int found_index; + bool stop; +}; + +struct location { + long unsigned int count; + long unsigned int addr; + 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[1]; + nodemask_t nodes; +}; + +struct lock_manager_operations { + int (*lm_compare_owner)(struct file_lock *, struct file_lock *); + long unsigned int (*lm_owner_key)(struct file_lock *); + 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_break)(struct file_lock *); + int (*lm_change)(struct file_lock *, int, struct list_head *); + void (*lm_setup)(struct file_lock *, void **); +}; + +struct lock_manager_operations___2 { + int (*lm_compare_owner)(struct file_lock___2 *, struct file_lock___2 *); + long unsigned int (*lm_owner_key)(struct file_lock___2 *); + fl_owner_t (*lm_get_owner)(fl_owner_t); + void (*lm_put_owner)(fl_owner_t); + void (*lm_notify)(struct file_lock___2 *); + int (*lm_grant)(struct file_lock___2 *, int); + bool (*lm_break)(struct file_lock___2 *); + int (*lm_change)(struct file_lock___2 *, int, struct list_head *); + void (*lm_setup)(struct file_lock___2 *, void **); +}; + +struct locks_iterator { + int li_cpu; + loff_t li_pos; +}; + +struct log_header_core { + uint32_t magic; + uint32_t version; + uint64_t nr_regions; +}; + +struct log_header_disk; + +struct log_c { + struct dm_target *ti; + int touched_dirtied; + int touched_cleaned; + int flush_failed; + uint32_t region_size; + unsigned int region_count; + region_t sync_count; + unsigned int bitset_uint32_count; + uint32_t *clean_bits; + uint32_t *sync_bits; + uint32_t *recovering_bits; + int sync_search; + enum sync sync; + struct dm_io_request io_req; + int log_dev_failed; + int log_dev_flush_failed; + struct dm_dev *log_dev; + struct log_header_core header; + struct dm_io_region header_location; + struct log_header_disk *disk_header; +}; + +struct log_header_disk { + __le32 magic; + __le32 version; + __le64 nr_regions; +}; + +struct logo_data { + int depth; + int needs_directpalette; + int needs_truepalette; + int needs_cmapreset; + const struct linux_logo *logo; +}; + +struct loop_cmd { + struct kthread_work work; + struct request *rq; + struct list_head list; + bool use_aio; + struct kiocb iocb; +}; + +struct loop_func_table; + +struct loop_device { + int lo_number; + atomic_t lo_refcnt; + loff_t lo_offset; + loff_t lo_sizelimit; + int lo_flags; + int (*transfer)(struct loop_device *, int, struct page___2 *, unsigned int, struct page___2 *, unsigned int, int, sector_t); + char lo_file_name[64]; + char lo_crypt_name[64]; + char lo_encrypt_key[32]; + int lo_encrypt_key_size; + struct loop_func_table *lo_encryption; + __u32 lo_init[2]; + kuid_t lo_key_owner; + int (*ioctl)(struct loop_device *, int, long unsigned int); + struct file___2 *lo_backing_file; + struct block_device *lo_device; + unsigned int lo_blocksize; + void *key_data; + gfp_t old_gfp_mask; + spinlock_t lo_lock; + int lo_state; + struct mutex lo_ctl_mutex; + struct kthread_worker worker; + struct task_struct *worker_task; + bool use_dio; + struct request_queue *lo_queue; + struct blk_mq_tag_set tag_set; + struct gendisk *lo_disk; +}; + +struct loop_info64; + +struct loop_func_table { + int number; + int (*transfer)(struct loop_device *, int, struct page___2 *, unsigned int, struct page___2 *, unsigned int, int, sector_t); + int (*init)(struct loop_device *, const struct loop_info64 *); + int (*release)(struct loop_device *); + int (*ioctl)(struct loop_device *, int, long unsigned int); + struct module *owner; +}; + +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_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 zone_reclaim_stat { + long unsigned int recent_rotated[2]; + long unsigned int recent_scanned[2]; +}; + +struct lruvec { + struct list_head lists[5]; + struct zone_reclaim_stat reclaim_stat; + atomic_long_t inactive_age; +}; + +struct lwtunnel_encap_ops { + int (*build_state)(struct net_device *, struct nlattr *, unsigned int, const void *, 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 *); +}; + +struct lwtunnel_state { + __u16 type; + __u16 flags; + atomic_t refcnt; + int (*orig_output)(struct net *, struct sock *, struct sk_buff *); + int (*orig_input)(struct sk_buff *); + int len; + __u8 data[0]; +}; + +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; +}; + +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 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 machine_ops { + void (*restart)(char *); + void (*halt)(void); + void (*power_off)(void); + void (*shutdown)(void); + void (*crash_shutdown)(struct pt_regs *); + void (*emergency_restart)(void); +}; + +struct mafield { + const char *prefix; + int field; +}; + +struct map_attribute { + struct attribute attr; + ssize_t (*show)(struct efi_runtime_map_entry *, char *); +}; + +struct map_files_info { + fmode_t mode; + long unsigned int len; + unsigned char name[34]; +}; + +struct map_range { + long unsigned int start; + long unsigned int end; + unsigned int page_size_mask; +}; + +struct mapped_device { + struct srcu_struct io_barrier; + struct mutex suspend_lock; + void *map; + struct list_head table_devices; + struct mutex table_devices_lock; + long unsigned int flags; + struct request_queue *queue; + int numa_node_id; + unsigned int type; + struct mutex type_lock; + atomic_t holders; + atomic_t open_count; + struct dm_target___2 *immutable_target; + struct target_type *immutable_target_type; + struct gendisk *disk; + char name[16]; + void *interface_ptr; + atomic_t pending[2]; + wait_queue_head_t wait; + struct work_struct work; + spinlock_t deferred_lock; + struct bio_list deferred; + wait_queue_head_t eventq; + atomic_t event_nr; + atomic_t uevent_seq; + struct list_head uevent_list; + spinlock_t uevent_lock; + unsigned int internal_suspend_count; + struct workqueue_struct *wq; + mempool_t *io_pool; + mempool_t *rq_pool; + struct bio_set *bs; + struct super_block *frozen_sb; + struct hd_geometry geometry; + struct block_device *bdev; + struct dm_kobject_holder kobj_holder; + struct bio flush_bio; + struct dm_stats stats; + struct kthread_worker kworker; + struct task_struct *kworker_task; + unsigned int seq_rq_merge_deadline_usecs; + int last_rq_rw; + sector_t last_rq_pos; + ktime_t last_rq_start_time; + struct blk_mq_tag_set *tag_set; + bool use_blk_mq: 1; + bool init_tio_pdu: 1; +}; + +struct master { + struct list_head node; + bool bound; + const struct component_master_ops *ops; + struct device *dev; + struct component_match *match; +}; + +struct match_token { + int token; + const char *pattern; +}; + +struct math_emu_info { + long int ___orig_eip; + struct pt_regs *regs; +}; + +struct microcode_intel; + +struct mc_saved_data { + unsigned int num_saved; + struct microcode_intel **mc_saved; +}; + +struct mca_config { + bool dont_log_ce; + bool cmci_disabled; + bool lmce_disabled; + bool ignore_ce; + bool disabled; + bool ser; + bool recovery; + bool bios_cmci_threshold; + u8 banks; + s8 bootlog; + int tolerant; + int monarch_timeout; + int panic_timeout; + u32 rip_msr; +}; + +struct mca_msr_regs { + u32 (*ctl)(int); + u32 (*status)(int); + u32 (*addr)(int); + u32 (*misc)(int); +}; + +struct mce { + __u64 status; + __u64 misc; + __u64 addr; + __u64 mcgstatus; + __u64 ip; + __u64 tsc; + __u64 time; + __u8 cpuvendor; + __u8 inject_flags; + __u8 severity; + __u8 pad; + __u32 cpuid; + __u8 cs; + __u8 bank; + __u8 cpu; + __u8 finished; + __u32 extcpu; + __u32 socketid; + __u32 apicid; + __u64 mcgcap; +}; + +struct mce_bank { + u64 ctl; + unsigned char init; + struct device_attribute attr; + char attrname[16]; +}; + +struct mce_evt_llist { + struct llist_node llnode; + struct mce mce; +}; + +struct mce_log { + char signature[12]; + unsigned int len; + unsigned int next; + unsigned int flags; + unsigned int recordlen; + struct mce entry[32]; +}; + +struct mce_vendor_flags { + __u64 overflow_recov: 1; + __u64 succor: 1; + __u64 smca: 1; + __u64 __reserved_0: 61; +}; + +struct mcs_spinlock { + struct mcs_spinlock *next; + int locked; + int count; +}; + +struct md5_state { + u32 hash[4]; + u32 block[16]; + u64 byte_count; +}; + +struct md_rdev; + +struct md_cluster_operations { + int (*join)(struct mddev *, int); + int (*leave)(struct mddev *); + int (*slot_number)(struct mddev *); + int (*resync_info_update)(struct mddev *, sector_t, sector_t); + int (*metadata_update_start)(struct mddev *); + int (*metadata_update_finish)(struct mddev *); + void (*metadata_update_cancel)(struct mddev *); + int (*resync_start)(struct mddev *); + int (*resync_finish)(struct mddev *); + int (*area_resyncing)(struct mddev *, int, sector_t, sector_t); + int (*add_new_disk)(struct mddev *, struct md_rdev *); + void (*add_new_disk_cancel)(struct mddev *); + int (*new_disk_ack)(struct mddev *, bool); + int (*remove_disk)(struct mddev *, struct md_rdev *); + void (*load_bitmaps)(struct mddev *, int); + int (*gather_bitmaps)(struct md_rdev *); + int (*lock_all_bitmaps)(struct mddev *); + void (*unlock_all_bitmaps)(struct mddev *); +}; + +struct md_personality { + char *name; + int level; + struct list_head list; + struct module *owner; + void (*make_request)(struct mddev *, struct bio *); + int (*run)(struct mddev *); + void (*free)(struct mddev *, void *); + void (*status)(struct seq_file *, struct mddev *); + void (*error_handler)(struct mddev *, struct md_rdev *); + int (*hot_add_disk)(struct mddev *, struct md_rdev *); + int (*hot_remove_disk)(struct mddev *, struct md_rdev *); + int (*spare_active)(struct mddev *); + sector_t (*sync_request)(struct mddev *, sector_t, int *); + int (*resize)(struct mddev *, sector_t); + sector_t (*size)(struct mddev *, sector_t, int); + int (*check_reshape)(struct mddev *); + int (*start_reshape)(struct mddev *); + void (*finish_reshape)(struct mddev *); + void (*quiesce)(struct mddev *, int); + void * (*takeover)(struct mddev *); + int (*congested)(struct mddev *, int); +}; + +struct md_rdev { + struct list_head same_set; + sector_t sectors; + struct mddev *mddev; + int last_events; + struct block_device *meta_bdev; + struct block_device *bdev; + struct page___2 *sb_page; + struct page___2 *bb_page; + int sb_loaded; + __u64 sb_events; + sector_t data_offset; + sector_t new_data_offset; + sector_t sb_start; + int sb_size; + int preferred_minor; + struct kobject kobj; + long unsigned int flags; + wait_queue_head_t blocked_wait; + int desc_nr; + int raid_disk; + int new_raid_disk; + int saved_raid_disk; + union { + sector_t recovery_offset; + sector_t journal_tail; + }; + atomic_t nr_pending; + atomic_t read_errors; + struct timespec last_read_error; + atomic_t corrected_errors; + struct work_struct del_work; + struct kernfs_node *sysfs_state; + struct badblocks badblocks; +}; + +struct md_sysfs_entry { + struct attribute attr; + ssize_t (*show)(struct mddev *, char *); + ssize_t (*store)(struct mddev *, const char *, size_t); +}; + +struct md_thread { + void (*run)(struct md_thread *); + struct mddev *mddev; + wait_queue_head_t wqueue; + long unsigned int flags; + struct task_struct *tsk; + long unsigned int timeout; + void *private; +}; + +struct md_cluster_info; + +struct mddev { + void *private; + struct md_personality *pers; + dev_t unit; + int md_minor; + struct list_head disks; + long unsigned int flags; + int suspended; + atomic_t active_io; + int ro; + int sysfs_active; + struct gendisk *gendisk; + struct kobject kobj; + int hold_active; + int major_version; + int minor_version; + int patch_version; + int persistent; + int external; + char metadata_type[17]; + int chunk_sectors; + time64_t ctime; + time64_t utime; + int level; + int layout; + char clevel[16]; + int raid_disks; + int max_disks; + sector_t dev_sectors; + sector_t array_sectors; + int external_size; + __u64 events; + int can_decrease_events; + char uuid[16]; + sector_t reshape_position; + int delta_disks; + int new_level; + int new_layout; + int new_chunk_sectors; + int reshape_backwards; + struct md_thread *thread; + struct md_thread *sync_thread; + char *last_sync_action; + sector_t curr_resync; + sector_t curr_resync_completed; + long unsigned int resync_mark; + sector_t resync_mark_cnt; + sector_t curr_mark_cnt; + sector_t resync_max_sectors; + atomic64_t resync_mismatches; + sector_t suspend_lo; + sector_t suspend_hi; + int sync_speed_min; + int sync_speed_max; + int parallel_resync; + int ok_start_degraded; + long unsigned int recovery; + int recovery_disabled; + int in_sync; + struct mutex open_mutex; + struct mutex reconfig_mutex; + atomic_t active; + atomic_t openers; + int changed; + int degraded; + atomic_t recovery_active; + wait_queue_head_t recovery_wait; + sector_t recovery_cp; + sector_t resync_min; + sector_t resync_max; + struct kernfs_node *sysfs_state; + struct kernfs_node *sysfs_action; + struct work_struct del_work; + spinlock_t lock; + wait_queue_head_t sb_wait; + atomic_t pending_writes; + unsigned int safemode; + unsigned int safemode_delay; + struct timer_list safemode_timer; + atomic_t writes_pending; + struct request_queue *queue; + struct bitmap *bitmap; + struct { + struct file___2 *file; + loff_t offset; + long unsigned int space; + loff_t default_offset; + long unsigned int default_space; + struct mutex mutex; + long unsigned int chunksize; + long unsigned int daemon_sleep; + long unsigned int max_write_behind; + int external; + int nodes; + char cluster_name[64]; + } bitmap_info; + atomic_t max_corr_read_errors; + struct list_head all_mddevs; + struct attribute_group *to_remove; + struct bio_set *bio_set; + struct bio *flush_bio; + atomic_t flush_pending; + struct work_struct flush_work; + struct work_struct event_work; + void (*sync_super)(struct mddev *, struct md_rdev *); + struct md_cluster_info *cluster_info; + unsigned int good_device_nr; +}; + +struct mii_bus; + +struct mdio_device { + struct device dev; + const struct dev_pm_ops___2 *pm_ops; + struct mii_bus *bus; + int (*bus_match)(struct device *, struct device_driver *); + void (*device_free)(struct mdio_device *); + void (*device_remove)(struct mdio_device *); + int addr; + int flags; +}; + +struct mii_bus___2; + +struct mdio_device___2 { + struct device___2 dev; + const struct dev_pm_ops *pm_ops; + struct mii_bus___2 *bus; + int (*bus_match)(struct device___2 *, struct device_driver___2 *); + void (*device_free)(struct mdio_device___2 *); + void (*device_remove)(struct mdio_device___2 *); + int addr; + int flags; +}; + +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 *); +}; + +struct mdio_driver_common___2 { + struct device_driver___2 driver; + int flags; +}; + +struct mdp_device_descriptor_s { + __u32 number; + __u32 major; + __u32 minor; + __u32 raid_disk; + __u32 state; + __u32 reserved[27]; +}; + +typedef struct mdp_device_descriptor_s mdp_disk_t; + +struct mdp_superblock_1 { + __le32 magic; + __le32 major_version; + __le32 feature_map; + __le32 pad0; + __u8 set_uuid[16]; + char set_name[32]; + __le64 ctime; + __le32 level; + __le32 layout; + __le64 size; + __le32 chunksize; + __le32 raid_disks; + __le32 bitmap_offset; + __le32 new_level; + __le64 reshape_position; + __le32 delta_disks; + __le32 new_layout; + __le32 new_chunk; + __le32 new_offset; + __le64 data_offset; + __le64 data_size; + __le64 super_offset; + union { + __le64 recovery_offset; + __le64 journal_tail; + }; + __le32 dev_number; + __le32 cnt_corrected_read; + __u8 device_uuid[16]; + __u8 devflags; + __u8 bblog_shift; + __le16 bblog_size; + __le32 bblog_offset; + __le64 utime; + __le64 events; + __le64 resync_offset; + __le32 sb_csum; + __le32 max_dev; + __u8 pad3[32]; + __le16 dev_roles[0]; +}; + +struct mdp_superblock_s { + __u32 md_magic; + __u32 major_version; + __u32 minor_version; + __u32 patch_version; + __u32 gvalid_words; + __u32 set_uuid0; + __u32 ctime; + __u32 level; + __u32 size; + __u32 nr_disks; + __u32 raid_disks; + __u32 md_minor; + __u32 not_persistent; + __u32 set_uuid1; + __u32 set_uuid2; + __u32 set_uuid3; + __u32 gstate_creserved[16]; + __u32 utime; + __u32 state; + __u32 active_disks; + __u32 working_disks; + __u32 failed_disks; + __u32 spare_disks; + __u32 sb_csum; + __u32 events_lo; + __u32 events_hi; + __u32 cp_events_lo; + __u32 cp_events_hi; + __u32 recovery_cp; + __u64 reshape_position; + __u32 new_level; + __u32 delta_disks; + __u32 new_layout; + __u32 new_chunk; + __u32 gstate_sreserved[14]; + __u32 layout; + __u32 chunk_size; + __u32 root_pv; + __u32 root_block; + __u32 pstate_reserved[60]; + mdp_disk_t disks[27]; + __u32 reserved[0]; + mdp_disk_t this_disk; +}; + +typedef struct mdp_superblock_s mdp_super_t; + +struct mdu_array_info_s { + int major_version; + int minor_version; + int patch_version; + unsigned int ctime; + int level; + int size; + int nr_disks; + int raid_disks; + int md_minor; + int not_persistent; + unsigned int utime; + int state; + int active_disks; + int working_disks; + int failed_disks; + int spare_disks; + int layout; + int chunk_size; +}; + +typedef struct mdu_array_info_s mdu_array_info_t; + +struct mdu_bitmap_file_s { + char pathname[4096]; +}; + +typedef struct mdu_bitmap_file_s mdu_bitmap_file_t; + +struct mdu_disk_info_s { + int number; + int major; + int minor; + int raid_disk; + int state; +}; + +typedef struct mdu_disk_info_s mdu_disk_info_t; + +struct mdu_version_s { + int major; + int minor; + int patchlevel; +}; + +typedef struct mdu_version_s mdu_version_t; + +struct mem_cgroup_reclaim_cookie { + struct zone *zone; + int priority; + unsigned int generation; +}; + +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 quota_format_type___2; + +struct mem_dqinfo___2 { + struct quota_format_type___2 *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_extent { + struct list_head hook; + long unsigned int start; + long unsigned int end; +}; + +struct mem_section { + long unsigned int section_mem_map; + long unsigned int *pageblock_flags; +}; + +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 anonymous_thp; + long unsigned int swap; + long unsigned int shared_hugetlb; + long unsigned int private_hugetlb; + u64 pss; + u64 swap_pss; + bool check_shmem_swap; +}; + +struct mem_zone_bm_rtree { + struct list_head list; + struct list_head nodes; + struct list_head leaves; + long unsigned int start_pfn; + long unsigned int end_pfn; + struct rtree_node *rtree; + int levels; + unsigned int blocks; +}; + +struct memblock_region; + +struct memblock_type { + long unsigned int cnt; + long unsigned int max; + phys_addr_t total_size; + struct memblock_region *regions; +}; + +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; + long unsigned int flags; + int nid; +}; + +struct memdev { + const char *name; + umode_t mode; + const struct file_operations *fops; + fmode_t fmode; +}; + +struct memmap_attribute { + struct attribute attr; + ssize_t (*show)(struct firmware_map_entry *, char *); +}; + +struct memory_bitmap { + struct list_head zones; + struct linked_page *p_list; + struct bm_position cur; +}; + +struct memory_block { + long unsigned int start_section_nr; + long unsigned int end_section_nr; + long unsigned int state; + int section_count; + int online_type; + int phys_device; + void *hw; + int (*phys_callback)(struct memory_block *); + struct device dev; +}; + +struct memory_isolate_notify { + long unsigned int start_pfn; + unsigned int nr_pages; + unsigned int pages_found; +}; + +struct memory_notify { + long unsigned int start_pfn; + long unsigned int nr_pages; + int status_change_nid_normal; + int status_change_nid_high; + int status_change_nid; +}; + +struct mempolicy { + atomic_t refcnt; + short unsigned int mode; + short unsigned int flags; + union { + short int preferred_node; + nodemask_t nodes; + } v; + union { + nodemask_t cpuset_mems_allowed; + nodemask_t user_nodemask; + } w; +}; + +struct mempolicy_operations { + int (*create)(struct mempolicy *, const nodemask_t *); + void (*rebind)(struct mempolicy *, const nodemask_t *, enum mpol_rebind_step); +}; + +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; +}; + +struct memtype { + u64 start; + u64 end; + u64 subtree_max_end; + enum page_cache_mode type; + struct rb_node rb; +}; + +struct menu_device { + int last_state_idx; + int needs_update; + unsigned int next_timer_us; + unsigned int predicted_us; + unsigned int bucket; + unsigned int correction_factor[12]; + 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 metadata_dst { + struct dst_entry dst; + union { + struct ip_tunnel_info tun_info; + } u; +}; + +struct mfc_cache { + struct list_head list; + __be32 mfc_mcastgrp; + __be32 mfc_origin; + vifi_t 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; + long unsigned int bytes; + long unsigned int pkt; + long unsigned int wrong_if; + unsigned char ttls[32]; + } res; + } mfc_un; + struct callback_head rcu; +}; + +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 microcode_header_amd { + u32 data_code; + u32 patch_id; + u16 mc_patch_data_id; + u8 mc_patch_data_len; + u8 init_flag; + u32 mc_patch_data_checksum; + u32 nb_dev_id; + u32 sb_dev_id; + u16 processor_rev_id; + u8 nb_rev_id; + u8 sb_rev_id; + u8 bios_api_rev; + u8 reserved1[3]; + u32 match_reg[8]; +}; + +struct microcode_amd { + struct microcode_header_amd hdr; + unsigned int mpb[0]; +}; + +struct microcode_header_intel { + unsigned int hdrver; + unsigned int rev; + unsigned int date; + unsigned int sig; + unsigned int cksum; + unsigned int ldrver; + unsigned int pf; + unsigned int datasize; + unsigned int totalsize; + unsigned int reserved[3]; +}; + +struct microcode_intel { + struct microcode_header_intel hdr; + unsigned int bits[0]; +}; + +struct microcode_ops { + enum ucode_state (*request_microcode_user)(int, const void *, size_t); + enum ucode_state (*request_microcode_fw)(int, struct device *, bool); + void (*microcode_fini_cpu)(int); + int (*apply_microcode)(int); + int (*collect_cpu_info)(int, struct cpu_signature *); +}; + +struct uart_8250_port; + +struct uart_8250_dma { + int (*tx_dma)(struct uart_8250_port *); + int (*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; + 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 mid8250_board; + +struct mid8250 { + int line; + int dma_index; + struct pci_dev *dma_dev; + struct uart_8250_dma dma; + struct mid8250_board *board; + struct hsu_dma_chip dma_chip; +}; + +struct mid8250_board { + unsigned int flags; + long unsigned int freq; + unsigned int base_baud; + int (*setup)(struct mid8250 *, struct uart_port *); + void (*exit)(struct mid8250 *); +}; + +struct midi_info { + char name[30]; + int device; + unsigned int capabilities; + int dev_type; + int dummies[18]; +}; + +struct migration_arg { + struct task_struct *task; + int dest_cpu; +}; + +struct migration_swap_arg { + struct task_struct *src_task; + struct task_struct *dst_task; + int src_cpu; + int dst_cpu; +}; + +struct mii_bus { + struct module *owner; + const char *name; + char id[17]; + void *priv; + int (*read)(struct mii_bus *, int, int); + int (*write)(struct mii_bus *, int, int, u16); + int (*reset)(struct mii_bus *); + 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]; +}; + +struct mii_bus___2 { + struct module___2 *owner; + const char *name; + char id[17]; + void *priv; + int (*read)(struct mii_bus___2 *, int, int); + int (*write)(struct mii_bus___2 *, int, int, u16); + int (*reset)(struct mii_bus___2 *); + struct mutex___2 mdio_lock; + struct device___2 *parent; + enum { + MDIOBUS_ALLOCATED___2 = 1, + MDIOBUS_REGISTERED___2 = 2, + MDIOBUS_UNREGISTERED___2 = 3, + MDIOBUS_RELEASED___2 = 4, + } state; + struct device___2 dev; + struct mdio_device___2 *mdio_map[32]; + u32 phy_mask; + u32 phy_ignore_ta_mask; + int irq[32]; +}; + +struct mii_ioctl_data { + __u16 phy_id; + __u16 reg_num; + __u16 val_in; + __u16 val_out; +}; + +struct min_max_quirk { + const char * const *pnp_ids; + struct { + long unsigned int min; + long unsigned int max; + } board_id; + int x_min; + int x_max; + int y_min; + int y_max; +}; + +struct minimode { + short int w; + short int h; + short int r; + short int rb; +}; + +struct mipi_dsi_device { + struct mipi_dsi_host *host; + struct device___2 dev; + char name[20]; + unsigned int channel; + unsigned int lanes; + enum mipi_dsi_pixel_format format; + long unsigned int mode_flags; +}; + +struct mipi_dsi_device_info { + char type[20]; + u32 channel; + struct device_node___2 *node; +}; + +struct mipi_dsi_driver { + struct device_driver___2 driver; + int (*probe)(struct mipi_dsi_device *); + int (*remove)(struct mipi_dsi_device *); + void (*shutdown)(struct mipi_dsi_device *); +}; + +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_packet { + size_t size; + u8 header[4]; + size_t payload_length; + const u8 *payload; +}; + +struct mirror_set; + +struct mirror { + struct mirror_set *ms; + atomic_t error_count; + long unsigned int error_type; + struct dm_dev *dev; + sector_t offset; +}; + +struct mirror_set { + struct dm_target *ti; + struct list_head list; + uint64_t features; + spinlock_t lock; + struct bio_list reads; + struct bio_list writes; + struct bio_list failures; + struct bio_list holds; + struct dm_region_hash *rh; + struct dm_kcopyd_client *kcopyd_client; + struct dm_io_client *io_client; + region_t nr_regions; + int in_sync; + int log_failure; + int leg_failure; + atomic_t suspend; + atomic_t default_mirror; + struct workqueue_struct *kmirrord_wq; + struct work_struct kmirrord_work; + struct timer_list timer; + long unsigned int timer_pending; + struct work_struct trigger_event; + unsigned int nr_mirrors; + struct mirror mirror[0]; +}; + +struct miscdevice { + int minor; + const char *name; + const struct file_operations___2 *fops; + struct list_head list; + struct device *parent; + struct device *this_device; + const struct attribute_group **groups; + const char *nodename; + umode_t mode; +}; + +struct mixer_info { + char id[16]; + char name[32]; + int modify_counter; + int fillers[10]; +}; + +typedef struct mixer_info mixer_info; + +struct ml_effect_state { + struct ff_effect *effect; + long unsigned int flags; + int count; + long unsigned int play_at; + long unsigned int stop_at; + long unsigned int adj_at; +}; + +struct ml_device { + void *private; + struct ml_effect_state states[16]; + int gain; + struct timer_list timer; + struct input_dev *dev; + int (*play_effect)(struct input_dev *, void *, struct ff_effect *); +}; + +struct mm_rss_stat { + atomic_long_t count[4]; +}; + +struct uprobes_state {}; + +struct mmu_notifier_mm; + +struct mm_struct { + struct vm_area_struct___2 *mmap; + struct rb_root mm_rb; + u32 vmacache_seqnum; + long unsigned int (*get_unmapped_area)(struct file___2 *, long unsigned int, long unsigned int, long unsigned int, long unsigned int); + long unsigned int mmap_base; + long unsigned int mmap_legacy_base; + long unsigned int task_size; + long unsigned int highest_vm_end; + pgd_t *pgd; + atomic_t mm_users; + atomic_t mm_count; + atomic_long_t nr_ptes; + atomic_long_t nr_pmds; + int map_count; + spinlock_t page_table_lock; + struct rw_semaphore mmap_sem; + struct list_head mmlist; + long unsigned int hiwater_rss; + long unsigned int hiwater_vm; + long unsigned int total_vm; + long unsigned int locked_vm; + long unsigned int pinned_vm; + long unsigned int data_vm; + long unsigned int exec_vm; + long unsigned int stack_vm; + long unsigned int def_flags; + 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[46]; + struct mm_rss_stat rss_stat; + struct linux_binfmt *binfmt; + cpumask_var_t cpu_vm_mask_var; + mm_context_t context; + long unsigned int flags; + struct core_state *core_state; + spinlock_t ioctx_lock; + struct kioctx_table *ioctx_table; + struct file___2 *exe_file; + struct mmu_notifier_mm *mmu_notifier_mm; + bool tlb_flush_pending; + struct uprobes_state uprobes_state; + atomic_long_t hugetlb_usage; + struct work_struct async_put_work; +}; + +struct mm_struct___2 { + struct vm_area_struct *mmap; + struct rb_root mm_rb; + u32 vmacache_seqnum; + long unsigned int (*get_unmapped_area)(struct file *, long unsigned int, long unsigned int, long unsigned int, long unsigned int); + long unsigned int mmap_base; + long unsigned int mmap_legacy_base; + long unsigned int task_size; + long unsigned int highest_vm_end; + pgd_t *pgd; + atomic_t mm_users; + atomic_t mm_count; + atomic_long_t nr_ptes; + atomic_long_t nr_pmds; + int map_count; + spinlock_t page_table_lock; + struct rw_semaphore___2 mmap_sem; + struct list_head mmlist; + long unsigned int hiwater_rss; + long unsigned int hiwater_vm; + long unsigned int total_vm; + long unsigned int locked_vm; + long unsigned int pinned_vm; + long unsigned int data_vm; + long unsigned int exec_vm; + long unsigned int stack_vm; + long unsigned int def_flags; + 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[46]; + struct mm_rss_stat rss_stat; + struct linux_binfmt *binfmt; + cpumask_var_t cpu_vm_mask_var; + mm_context_t___2 context; + long unsigned int flags; + struct core_state___2 *core_state; + spinlock_t ioctx_lock; + struct kioctx_table *ioctx_table; + struct file *exe_file; + struct mmu_notifier_mm *mmu_notifier_mm; + bool tlb_flush_pending; + struct uprobes_state uprobes_state; + atomic_long_t hugetlb_usage; + struct work_struct async_put_work; +}; + +typedef struct mm_struct *pto_T_____21; + +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, 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 *); + struct mm_struct___2 *mm; + struct vm_area_struct *vma; + void *private; +}; + +struct mmap_arg_struct32 { + unsigned int addr; + unsigned int len; + unsigned int prot; + unsigned int flags; + unsigned int fd; + unsigned int offset; +}; + +struct mminit_pfnnid_cache { + long unsigned int last_start; + long unsigned int last_end; + int last_nid; +}; + +struct mmiotrace_map { + resource_size_t phys; + long unsigned int virt; + long unsigned int len; + int map_id; + unsigned char opcode; +}; + +struct mmiotrace_rw { + resource_size_t phys; + long unsigned int value; + long unsigned int pc; + int map_id; + unsigned char opcode; + unsigned char width; +}; + +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_gather_batch { + struct mmu_gather_batch *next; + unsigned int nr; + unsigned int max; + struct page___2 *pages[0]; +}; + +struct mmu_gather { + struct mm_struct *mm; + long unsigned int start; + long unsigned int end; + unsigned int fullmm: 1; + unsigned int need_flush_all: 1; + struct mmu_gather_batch *active; + struct mmu_gather_batch local; + struct page___2 *__pages[8]; + unsigned int batch_count; +}; + +struct mmu_notifier_mm { + struct hlist_head list; + spinlock_t lock; +}; + +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); + void (*change_pte)(struct mmu_notifier *, struct mm_struct *, long unsigned int, pte_t); + void (*invalidate_page)(struct mmu_notifier *, struct mm_struct *, long unsigned int); + void (*invalidate_range_start)(struct mmu_notifier *, struct mm_struct *, long unsigned int, long unsigned int); + void (*invalidate_range_end)(struct mmu_notifier *, struct mm_struct *, long unsigned int, long unsigned int); + void (*invalidate_range)(struct mmu_notifier *, struct mm_struct *, long unsigned int, long unsigned int); +}; + +struct mmu_page_path { + struct kvm_mmu_page *parent[4]; + unsigned int idx[4]; +}; + +struct mount; + +struct mnt_namespace { + atomic_t count; + struct ns_common ns; + struct mount *root; + struct list_head list; + struct user_namespace *user_ns; + u64 seq; + wait_queue_head_t poll; + u64 event; +}; + +struct mnt_pcp { + int mnt_count; + int mnt_writers; +}; + +struct mod_arch_specific {}; + +struct mod_initfree { + struct callback_head rcu; + void *module_init; +}; + +struct mod_kallsyms { + Elf64_Sym *symtab; + unsigned int num_symtab; + char *strtab; +}; + +struct mod_tree_node { + struct module *mod; + struct latch_tree_node node; +}; + +struct mod_tree_node___2 { + struct module___2 *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 mode_dual { + struct opcode mode32; + struct opcode mode64; +}; + +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_layout { + void *base; + unsigned int size; + unsigned int text_size; + unsigned int ro_size; + struct mod_tree_node mtn; +}; + +struct module_attribute; + +struct module_sect_attrs; + +struct module_notes_attrs; + +struct tracepoint; + +struct trace_event_call; + +struct trace_enum_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 long unsigned int *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 long unsigned int *gpl_crcs; + bool async_probe_requested; + const struct kernel_symbol *gpl_future_syms; + const long unsigned int *gpl_future_crcs; + unsigned int num_gpl_future_syms; + unsigned int num_exentries; + struct exception_table_entry *extable; + int (*init)(void); + long: 64; + long: 64; + long: 64; + long: 64; + struct module_layout core_layout; + struct module_layout init_layout; + struct mod_arch_specific arch; + 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; + unsigned int num_tracepoints; + struct tracepoint * const *tracepoints_ptrs; + 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_enum_map **trace_enums; + unsigned int num_trace_enums; + unsigned int num_ftrace_callsites; + long unsigned int *ftrace_callsites; + struct list_head source_list; + struct list_head target_list; + void (*exit)(void); + atomic_t refcnt; +}; + +struct module_kobject___2 { + struct kobject___2 kobj; + struct module___2 *mod; + struct kobject___2 *drivers_dir; + struct module_param_attrs *mp; + struct completion *kobj_completion; +}; + +struct module_layout___2 { + void *base; + unsigned int size; + unsigned int text_size; + unsigned int ro_size; + struct mod_tree_node___2 mtn; +}; + +struct module_attribute___2; + +struct trace_event_call___2; + +struct module___2 { + enum module_state state; + struct list_head list; + char name[56]; + struct module_kobject___2 mkobj; + struct module_attribute___2 *modinfo_attrs; + const char *version; + const char *srcversion; + struct kobject___2 *holders_dir; + const struct kernel_symbol *syms; + const long unsigned int *crcs; + unsigned int num_syms; + struct mutex___2 param_lock; + struct kernel_param___2 *kp; + unsigned int num_kp; + unsigned int num_gpl_syms; + const struct kernel_symbol *gpl_syms; + const long unsigned int *gpl_crcs; + bool async_probe_requested; + const struct kernel_symbol *gpl_future_syms; + const long unsigned int *gpl_future_crcs; + unsigned int num_gpl_future_syms; + unsigned int num_exentries; + struct exception_table_entry *extable; + int (*init)(void); + long: 64; + long: 64; + long: 64; + long: 64; + struct module_layout___2 core_layout; + struct module_layout___2 init_layout; + struct mod_arch_specific arch; + 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; + unsigned int num_tracepoints; + struct tracepoint * const *tracepoints_ptrs; + 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___2 **trace_events; + unsigned int num_trace_events; + struct trace_enum_map **trace_enums; + unsigned int num_trace_enums; + unsigned int num_ftrace_callsites; + long unsigned int *ftrace_callsites; + struct list_head source_list; + struct list_head target_list; + void (*exit)(void); + atomic_t refcnt; +}; + +struct module_attribute { + struct attribute attr; + ssize_t (*show)(struct module_attribute *, struct module_kobject *, char *); + ssize_t (*store)(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_attribute___2 { + struct attribute attr; + ssize_t (*show)(struct module_attribute___2 *, struct module_kobject___2 *, char *); + ssize_t (*store)(struct module_attribute___2 *, struct module_kobject___2 *, const char *, size_t); + void (*setup)(struct module___2 *, const char *); + int (*test)(struct module___2 *); + void (*free)(struct module___2 *); +}; + +struct module_notes_attrs { + struct kobject *dir; + unsigned int notes; + struct bin_attribute___2 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_sect_attr { + struct module_attribute mattr; + char *name; + long unsigned int address; +}; + +struct module_sect_attrs { + struct attribute_group grp; + unsigned int nsections; + struct module_sect_attr attrs[0]; +}; + +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 vfsmount { + struct dentry___2 *mnt_root; + struct super_block *mnt_sb; + int mnt_flags; +}; + +struct mountpoint; + +struct mount { + struct hlist_node mnt_hash; + struct mount *mnt_parent; + struct dentry___2 *mnt_mountpoint; + struct vfsmount mnt; + union { + 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; + struct hlist_node mnt_mp_list; + struct hlist_head mnt_fsnotify_marks; + __u32 mnt_fsnotify_mask; + int mnt_id; + int mnt_group_id; + int mnt_expiry_mark; + struct hlist_head mnt_pins; + struct fs_pin mnt_umount; + struct dentry___2 *mnt_ex_mountpoint; +}; + +struct mountpoint { + struct hlist_node m_hash; + struct dentry___2 *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; + signed char 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 mp_chip_data { + struct list_head irq_2_pin; + struct IO_APIC_route_entry entry; + int trigger; + int polarity; + u32 count; + bool isa_irq; +}; + +struct mpage_data { + struct bio *bio; + sector_t last_block_in_bio; + get_block_t *get_block; + unsigned int use_writepage; +}; + +struct mpc_bus { + unsigned char type; + unsigned char busid; + unsigned char bustype[6]; +}; + +struct mpc_cpu { + unsigned char type; + unsigned char apicid; + unsigned char apicver; + unsigned char cpuflag; + unsigned int cpufeature; + unsigned int featureflag; + unsigned int reserved[2]; +}; + +struct mpc_intsrc { + unsigned char type; + unsigned char irqtype; + short unsigned int irqflag; + unsigned char srcbus; + unsigned char srcbusirq; + unsigned char dstapic; + unsigned char dstirq; +}; + +struct mpc_lintsrc { + unsigned char type; + unsigned char irqtype; + short unsigned int irqflag; + unsigned char srcbusid; + unsigned char srcbusirq; + unsigned char destapic; + unsigned char destapiclint; +}; + +struct mpc_table { + char signature[4]; + short unsigned int length; + char spec; + char checksum; + char oem[8]; + char productid[12]; + unsigned int oemptr; + short unsigned int oemsize; + short unsigned int oemcount; + unsigned int lapic; + unsigned int reserved; +}; + +struct mpf_intel { + char signature[4]; + unsigned int physptr; + unsigned char length; + unsigned char specification; + unsigned char checksum; + unsigned char feature1; + unsigned char feature2; + unsigned char feature3; + unsigned char feature4; + unsigned char feature5; +}; + +struct mpls_label { + __be32 entry; +}; + +struct mpx_bndcsr { + u64 bndcfgu; + u64 bndstatus; +}; + +struct mq_sched { + struct Qdisc **qdiscs; +}; + +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 posix_msg_tree_node *node_cache; + struct mq_attr attr; + struct sigevent notify; + struct pid___2 *notify_owner; + struct user_namespace *notify_user_ns; + struct user_struct *user; + struct sock *notify_sock; + struct sk_buff *notify_cookie; + struct ext_wait_queue e_wait_q[2]; + long unsigned int qsize; +}; + +struct vif_device { + struct net_device *dev; + 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; + __be32 local; + __be32 remote; + int link; +}; + +struct mr_table { + struct list_head list; + possible_net_t net; + u32 id; + struct sock *mroute_sk; + struct timer_list ipmr_expire_timer; + struct list_head mfc_unres_queue; + struct list_head mfc_cache_array[64]; + struct vif_device vif_table[32]; + int maxvif; + atomic_t cache_resolve_queue_len; + bool mroute_do_assert; + bool mroute_do_pim; + int mroute_reg_vif_num; +}; + +struct ms_hyperv_info { + u32 features; + u32 misc_features; + u32 hints; +}; + +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; + time_t q_stime; + time_t q_rtime; + time_t q_ctime; + long unsigned int q_cbytes; + long unsigned int q_qnum; + long unsigned int q_qbytes; + pid_t q_lspid; + pid_t q_lrpid; + struct list_head q_messages; + struct list_head q_receivers; + struct list_head q_senders; +}; + +struct msg_receiver { + struct list_head r_list; + struct task_struct___2 *r_tsk; + int r_mode; + long int r_msgtype; + long int r_maxsize; + struct msg_msg * volatile r_msg; +}; + +struct msg_sender { + struct list_head list; + struct task_struct___2 *tsk; +}; + +struct msgbuf { + __kernel_long_t mtype; + char mtext[1]; +}; + +struct msghdr { + void *msg_name; + int msg_namelen; + struct iov_iter msg_iter; + void *msg_control; + __kernel_size_t msg_controllen; + unsigned int msg_flags; + struct kiocb *msg_iocb; +}; + +struct msginfo { + int msgpool; + int msgmap; + int msgmax; + int msgmnb; + int msgmni; + int msgssz; + int msgtql; + short unsigned int msgseg; +}; + +struct msi_controller { + struct module *owner; + struct device *dev; + struct device_node *of_node; + struct list_head list; + int (*setup_irq)(struct msi_controller *, struct pci_dev *, struct msi_desc *); + int (*setup_irqs)(struct msi_controller *, struct pci_dev *, int, int); + void (*teardown_irq)(struct msi_controller *, unsigned int); +}; + +struct platform_msi_priv_data; + +struct platform_msi_desc { + struct platform_msi_priv_data *msi_priv_data; + u16 msi_index; +}; + +struct msi_desc { + struct list_head list; + unsigned int irq; + unsigned int nvec_used; + struct device *dev; + struct msi_msg msg; + union { + struct { + u32 masked; + struct { + __u8 is_msix: 1; + __u8 multiple: 3; + __u8 multi_cap: 3; + __u8 maskbit: 1; + __u8 is_64: 1; + __u16 entry_nr; + unsigned int default_irq; + } msi_attrib; + union { + u8 mask_pos; + void *mask_base; + }; + }; + struct platform_msi_desc platform; + struct fsl_mc_msi_desc fsl_mc; + }; +}; + +struct msi_domain_ops; + +struct msi_domain_info { + u32 flags; + 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_check)(struct irq_domain *, struct msi_domain_info *, struct device *); + int (*msi_prepare)(struct irq_domain *, struct device *, int, msi_alloc_info_t *); + void (*msi_finish)(msi_alloc_info_t *, int); + void (*set_desc)(msi_alloc_info_t *, struct msi_desc *); + int (*handle_error)(struct irq_domain *, struct msi_desc *, int); +}; + +struct msix_entry { + u32 vector; + u16 entry; +}; + +struct msqid64_ds { + struct ipc64_perm msg_perm; + __kernel_time_t msg_stime; + __kernel_time_t msg_rtime; + __kernel_time_t msg_ctime; + __kernel_ulong_t msg_cbytes; + __kernel_ulong_t msg_qnum; + __kernel_ulong_t msg_qbytes; + __kernel_pid_t msg_lspid; + __kernel_pid_t msg_lrpid; + __kernel_ulong_t __unused4; + __kernel_ulong_t __unused5; +}; + +struct msg; + +struct msqid_ds { + struct ipc_perm msg_perm; + struct msg *msg_first; + struct msg *msg_last; + __kernel_time_t msg_stime; + __kernel_time_t msg_rtime; + __kernel_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 msr { + union { + struct { + u32 l; + u32 h; + }; + u64 q; + }; +}; + +struct vmx_msr_entry { + u32 index; + u32 reserved; + u64 value; +}; + +struct msr_autoload { + unsigned int nr; + long: 64; + struct vmx_msr_entry guest[8]; + struct vmx_msr_entry host[8]; +}; + +struct msr_data { + bool host_initiated; + u32 index; + u64 data; +}; + +struct msr_info { + u32 msr_no; + struct msr reg; + struct msr *msrs; + int err; +}; + +struct msr_range { + unsigned int min; + unsigned int max; +}; + +struct msr_regs_info { + u32 *regs; + int err; +}; + +struct mtget { + long int mt_type; + long int mt_resid; + long int mt_dsreg; + long int mt_gstat; + long int mt_erreg; + __kernel_daddr_t mt_fileno; + __kernel_daddr_t mt_blkno; +}; + +struct mtget32 { + compat_long_t mt_type; + compat_long_t mt_resid; + compat_long_t mt_dsreg; + compat_long_t mt_gstat; + compat_long_t mt_erreg; + compat_daddr_t mt_fileno; + compat_daddr_t mt_blkno; +}; + +struct mtpos { + long int mt_blkno; +}; + +struct mtpos32 { + compat_long_t mt_blkno; +}; + +struct mtrr_gentry { + __u64 base; + __u32 size; + __u32 regnum; + __u32 type; + __u32 _pad; +}; + +struct mtrr_gentry32 { + compat_ulong_t regnum; + compat_uint_t base; + compat_uint_t size; + compat_uint_t type; +}; + +struct mtrr_iter { + struct kvm_mtrr *mtrr_state; + u64 start; + u64 end; + int mem_type; + bool mtrr_disabled; + bool partial_map; + union { + struct { + int index; + int seg; + }; + struct { + struct kvm_mtrr_range *range; + u64 start_max; + }; + }; + bool fixed; +}; + +struct mtrr_ops { + u32 vendor; + u32 use_intel_if; + void (*set)(unsigned int, long unsigned int, long unsigned int, mtrr_type); + void (*set_all)(void); + void (*get)(unsigned int, long unsigned int *, long unsigned int *, mtrr_type *); + int (*get_free_region)(long unsigned int, long unsigned int, int); + int (*validate_add_page)(long unsigned int, long unsigned int, unsigned int); + int (*have_wrcomb)(void); +}; + +struct mtrr_sentry { + __u64 base; + __u32 size; + __u32 type; +}; + +struct mtrr_sentry32 { + compat_ulong_t base; + compat_uint_t size; + compat_uint_t type; +}; + +struct mtrr_var_range { + __u32 base_lo; + __u32 base_hi; + __u32 mask_lo; + __u32 mask_hi; +}; + +struct mtrr_state_type { + struct mtrr_var_range var_ranges[256]; + mtrr_type fixed_ranges[88]; + unsigned char enabled; + unsigned char have_fixed; + mtrr_type def_type; +}; + +struct mtrr_value { + mtrr_type ltype; + long unsigned int lbase; + long unsigned int lsize; +}; + +struct snd_pcm_plugin; + +struct snd_pcm_plugin_channel; + +typedef void (*mulaw_f)(struct snd_pcm_plugin *, const struct snd_pcm_plugin_channel *, struct snd_pcm_plugin_channel *, snd_pcm_uframes_t); + +struct mulaw_priv { + mulaw_f func; + int cvt_endian; + unsigned int native_ofs; + unsigned int copy_ofs; + unsigned int native_bytes; + unsigned int copy_bytes; + u16 flip; +}; + +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 mutex_waiter { + struct list_head list; + struct task_struct *task; +}; + +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; + 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; + char read_buf[4096]; + long unsigned int read_flags[64]; + unsigned char echo_buf[4096]; + size_t read_tail; + size_t line_start; + unsigned int column; + unsigned int canon_column; + size_t echo_tail; + struct mutex___2 atomic_read_lock; + struct mutex___2 output_lock; +}; + +struct saved { + struct path___2 link; + struct delayed_call done; + const char *name; + unsigned int seq; +}; + +struct nameidata { + struct path___2 path; + struct qstr last; + struct path___2 root; + struct inode *inode; + unsigned int flags; + unsigned int seq; + unsigned int m_seq; + int last_type; + unsigned int depth; + int total_link_count; + struct saved *stack; + struct saved internal[2]; + struct filename *name; + struct nameidata *saved; + struct inode *link_inode; + unsigned int root_seq; + int dfd; +}; + +struct page_frag_cache { + void *va; + __u16 offset; + __u16 size; + unsigned int pagecnt_bias; + bool pfmemalloc; +}; + +struct napi_alloc_cache { + struct page_frag_cache page; + size_t skb_count; + void *skb_cache[64]; +}; + +struct napi_gro_cb { + void *frag0; + unsigned int frag0_len; + int data_offset; + u16 flush; + u16 flush_id; + u16 count; + u16 gro_remcsum_start; + long unsigned int age; + u16 proto; + 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 is_atomic: 1; + __wsum csum; + struct sk_buff *last; +}; + +struct napi_struct { + struct list_head poll_list; + long unsigned int state; + int weight; + unsigned int gro_count; + int (*poll)(struct napi_struct *, int); + spinlock_t poll_lock; + int poll_owner; + struct net_device *dev; + struct sk_buff *gro_list; + struct sk_buff *skb; + struct hrtimer timer; + struct list_head dev_list; + struct hlist_node napi_hash_node; + unsigned int napi_id; +}; + +struct napi_struct___2 { + struct list_head poll_list; + long unsigned int state; + int weight; + unsigned int gro_count; + int (*poll)(struct napi_struct___2 *, int); + spinlock_t poll_lock; + int poll_owner; + struct net_device___2 *dev; + struct sk_buff___2 *gro_list; + struct sk_buff___2 *skb; + struct hrtimer timer; + struct list_head dev_list; + struct hlist_node napi_hash_node; + unsigned int napi_id; +}; + +struct ncp_mount_data { + int version; + unsigned int ncp_fd; + __kernel_uid_t mounted_uid; + __kernel_pid_t wdog_pid; + unsigned char mounted_vol[17]; + unsigned int time_out; + unsigned int retry_count; + unsigned int flags; + __kernel_uid_t uid; + __kernel_gid_t gid; + __kernel_mode_t file_mode; + __kernel_mode_t dir_mode; +}; + +struct ncp_mount_data_v4 { + int version; + long unsigned int flags; + long unsigned int mounted_uid; + long int wdog_pid; + unsigned int ncp_fd; + unsigned int time_out; + unsigned int retry_count; + long unsigned int uid; + long unsigned int gid; + long unsigned int file_mode; + long unsigned int dir_mode; +}; + +struct nda_cacheinfo { + __u32 ndm_confirmed; + __u32 ndm_used; + __u32 ndm_updated; + __u32 ndm_refcnt; +}; + +struct ndmsg { + __u8 ndm_family; + __u8 ndm_pad1; + __u16 ndm_pad2; + __s32 ndm_ifindex; + __u16 ndm_state; + __u8 ndm_flags; + __u8 ndm_type; +}; + +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 neigh_hash_table { + struct neighbour **hash_buckets; + 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; + struct list_head list; + int (*neigh_setup)(struct neighbour *); + void (*neigh_cleanup)(struct neighbour *); + struct neigh_table *tbl; + void *sysctl_table; + int dead; + atomic_t refcnt; + struct callback_head callback_head; + int reachable_time; + int data[13]; + 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; + int entry_size; + 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 *); + 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 timer_list proxy_timer; + struct sk_buff_head proxy_queue; + atomic_t entries; + 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 neighbour *next; + struct neigh_table *tbl; + struct neigh_parms *parms; + long unsigned int confirmed; + long unsigned int updated; + rwlock_t lock; + atomic_t refcnt; + struct sk_buff_head arp_queue; + unsigned int arp_queue_len_bytes; + struct timer_list timer; + long unsigned int used; + atomic_t probes; + __u8 flags; + __u8 nud_state; + __u8 type; + __u8 dead; + seqlock_t ha_lock; + unsigned char ha[32]; + struct hh_cache hh; + int (*output)(struct neighbour *, struct sk_buff *); + const struct neigh_ops *ops; + struct callback_head rcu; + struct net_device *dev; + u8 primary_key[0]; +}; + +struct neighbour_cb { + long unsigned int sched_next; + unsigned int flags; +}; + +struct nested_call_node { + struct list_head llink; + void *cookie; + void *ctx; +}; + +struct nested_calls { + struct list_head tasks_call_list; + spinlock_t lock; +}; + +struct vmcb; + +struct nested_state { + struct vmcb *hsave; + u64 hsave_msr; + u64 vm_cr_msr; + u64 vmcb; + u32 *msrpm; + u64 vmcb_msrpm; + u64 vmcb_iopm; + bool exit_required; + u32 intercept_cr; + u32 intercept_dr; + u32 intercept_exceptions; + u64 intercept; + u64 nested_cr3; +}; + +struct vmcs12; + +struct pi_desc; + +struct nested_vmx { + bool vmxon; + gpa_t vmxon_ptr; + gpa_t current_vmptr; + struct page___2 *current_vmcs12_page; + struct vmcs12 *current_vmcs12; + struct vmcs *current_shadow_vmcs; + bool sync_shadow_vmcs; + struct list_head vmcs02_pool; + int vmcs02_num; + u64 vmcs01_tsc_offset; + bool nested_run_pending; + struct page___2 *apic_access_page; + struct page___2 *virtual_apic_page; + struct page___2 *pi_desc_page; + struct pi_desc *pi_desc; + bool pi_pending; + u16 posted_intr_nv; + u64 msr_ia32_feature_control; + struct hrtimer preemption_timer; + bool preemption_timer_expired; + u64 vmcs01_debugctl; + u16 vpid02; + u16 last_vpid; + u32 nested_vmx_procbased_ctls_low; + u32 nested_vmx_procbased_ctls_high; + u32 nested_vmx_true_procbased_ctls_low; + u32 nested_vmx_secondary_ctls_low; + u32 nested_vmx_secondary_ctls_high; + u32 nested_vmx_pinbased_ctls_low; + u32 nested_vmx_pinbased_ctls_high; + u32 nested_vmx_exit_ctls_low; + u32 nested_vmx_exit_ctls_high; + u32 nested_vmx_true_exit_ctls_low; + u32 nested_vmx_entry_ctls_low; + u32 nested_vmx_entry_ctls_high; + u32 nested_vmx_true_entry_ctls_low; + u32 nested_vmx_misc_low; + u32 nested_vmx_misc_high; + u32 nested_vmx_ept_caps; + u32 nested_vmx_vpid_caps; +}; + +struct prot_inuse; + +struct netns_core { + struct ctl_table_header *sysctl_hdr; + int sysctl_somaxconn; + struct prot_inuse *inuse; +}; + +struct tcp_mib; + +struct udp_mib; + +struct netns_mib { + struct tcp_mib *tcp_statistics; + struct ipstats_mib *ip_statistics; + struct linux_mib *net_statistics; + struct udp_mib *udp_statistics; + struct udp_mib *udplite_statistics; + struct icmp_mib *icmp_statistics; + struct icmpmsg_mib *icmpmsg_statistics; +}; + +struct netns_packet { + struct mutex sklist_lock; + struct hlist_head sklist; +}; + +struct netns_unix { + int sysctl_max_dgram_qlen; + struct ctl_table_header *ctl; +}; + +struct netns_frags { + struct percpu_counter mem; + int timeout; + int high_thresh; + int low_thresh; + int max_dist; + long: 64; +}; + +struct ping_group_range { + seqlock_t lock; + kgid_t range[2]; +}; + +struct netns_ipv4 { + 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 fib_rules_ops *rules_ops; + bool fib_has_custom_rules; + struct fib_table *fib_local; + struct fib_table *fib_main; + struct fib_table *fib_default; + struct hlist_head *fib_table_hash; + bool fib_offload_disabled; + struct sock *fibnl; + struct sock **icmp_sk; + struct sock *mc_autojoin_sk; + struct inet_peer_base *peers; + struct sock **tcp_sk; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + struct netns_frags frags; + int sysctl_icmp_echo_ignore_all; + int sysctl_icmp_echo_ignore_broadcasts; + int sysctl_icmp_ignore_bogus_error_responses; + int sysctl_icmp_ratelimit; + int sysctl_icmp_ratemask; + int sysctl_icmp_errors_use_inbound_ifaddr; + struct local_ports ip_local_ports; + int sysctl_tcp_ecn; + int sysctl_tcp_ecn_fallback; + int sysctl_ip_default_ttl; + int sysctl_ip_no_pmtu_disc; + int sysctl_ip_fwd_use_pmtu; + int sysctl_ip_nonlocal_bind; + int sysctl_ip_dynaddr; + int sysctl_ip_early_demux; + int sysctl_fwmark_reflect; + int sysctl_tcp_fwmark_accept; + int sysctl_tcp_mtu_probing; + int sysctl_tcp_base_mss; + int sysctl_tcp_probe_threshold; + u32 sysctl_tcp_probe_interval; + int sysctl_tcp_keepalive_time; + int sysctl_tcp_keepalive_probes; + int sysctl_tcp_keepalive_intvl; + int sysctl_tcp_syn_retries; + int sysctl_tcp_synack_retries; + int sysctl_tcp_syncookies; + int sysctl_tcp_reordering; + int sysctl_tcp_retries1; + int sysctl_tcp_retries2; + int sysctl_tcp_orphan_retries; + int sysctl_tcp_fin_timeout; + unsigned int sysctl_tcp_notsent_lowat; + int sysctl_igmp_max_memberships; + int sysctl_igmp_max_msf; + int sysctl_igmp_llm_reports; + int sysctl_igmp_qrv; + struct ping_group_range ping_group_range; + atomic_t dev_addr_genid; + long unsigned int *sysctl_local_reserved_ports; + struct mr_table *mrt; + int sysctl_fib_multipath_use_neigh; + atomic_t rt_genid; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; +}; + +struct net_generic; + +struct net { + atomic_t passive; + atomic_t count; + spinlock_t rules_mod_lock; + atomic64_t cookie_gen; + struct list_head list; + struct list_head cleanup_list; + struct list_head exit_list; + struct user_namespace *user_ns; + spinlock_t nsid_lock; + struct idr netns_ids; + struct ns_common ns; + 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 list_head dev_base_head; + struct hlist_head *dev_name_head; + struct hlist_head *dev_index_head; + unsigned int dev_base_seq; + int ifindex; + unsigned int dev_unreg_count; + struct list_head rules_ops; + struct net_device *loopback_dev; + struct netns_core core; + struct netns_mib mib; + struct netns_packet packet; + struct netns_unix unx; + long: 64; + long: 64; + long: 64; + struct netns_ipv4 ipv4; + struct net_generic *gen; + struct sock *diag_nlsk; + atomic_t fnhe_genid; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; +}; + +struct netns_core___2 { + struct ctl_table_header___2 *sysctl_hdr; + int sysctl_somaxconn; + struct prot_inuse *inuse; +}; + +struct netns_packet___2 { + struct mutex___2 sklist_lock; + struct hlist_head sklist; +}; + +struct netns_unix___2 { + int sysctl_max_dgram_qlen; + struct ctl_table_header___2 *ctl; +}; + +struct netns_ipv4___2 { + struct ctl_table_header___2 *forw_hdr; + struct ctl_table_header___2 *frags_hdr; + struct ctl_table_header___2 *ipv4_hdr; + struct ctl_table_header___2 *route_hdr; + struct ctl_table_header___2 *xfrm4_hdr; + struct ipv4_devconf *devconf_all; + struct ipv4_devconf *devconf_dflt; + struct fib_rules_ops *rules_ops; + bool fib_has_custom_rules; + struct fib_table *fib_local; + struct fib_table *fib_main; + struct fib_table *fib_default; + struct hlist_head *fib_table_hash; + bool fib_offload_disabled; + struct sock *fibnl; + struct sock **icmp_sk; + struct sock *mc_autojoin_sk; + struct inet_peer_base *peers; + struct sock **tcp_sk; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + struct netns_frags frags; + int sysctl_icmp_echo_ignore_all; + int sysctl_icmp_echo_ignore_broadcasts; + int sysctl_icmp_ignore_bogus_error_responses; + int sysctl_icmp_ratelimit; + int sysctl_icmp_ratemask; + int sysctl_icmp_errors_use_inbound_ifaddr; + struct local_ports ip_local_ports; + int sysctl_tcp_ecn; + int sysctl_tcp_ecn_fallback; + int sysctl_ip_default_ttl; + int sysctl_ip_no_pmtu_disc; + int sysctl_ip_fwd_use_pmtu; + int sysctl_ip_nonlocal_bind; + int sysctl_ip_dynaddr; + int sysctl_ip_early_demux; + int sysctl_fwmark_reflect; + int sysctl_tcp_fwmark_accept; + int sysctl_tcp_mtu_probing; + int sysctl_tcp_base_mss; + int sysctl_tcp_probe_threshold; + u32 sysctl_tcp_probe_interval; + int sysctl_tcp_keepalive_time; + int sysctl_tcp_keepalive_probes; + int sysctl_tcp_keepalive_intvl; + int sysctl_tcp_syn_retries; + int sysctl_tcp_synack_retries; + int sysctl_tcp_syncookies; + int sysctl_tcp_reordering; + int sysctl_tcp_retries1; + int sysctl_tcp_retries2; + int sysctl_tcp_orphan_retries; + int sysctl_tcp_fin_timeout; + unsigned int sysctl_tcp_notsent_lowat; + int sysctl_igmp_max_memberships; + int sysctl_igmp_max_msf; + int sysctl_igmp_llm_reports; + int sysctl_igmp_qrv; + struct ping_group_range ping_group_range; + atomic_t dev_addr_genid; + long unsigned int *sysctl_local_reserved_ports; + struct mr_table *mrt; + int sysctl_fib_multipath_use_neigh; + atomic_t rt_genid; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; +}; + +struct net___2 { + atomic_t passive; + atomic_t count; + spinlock_t rules_mod_lock; + atomic64_t cookie_gen; + struct list_head list; + struct list_head cleanup_list; + struct list_head exit_list; + struct user_namespace *user_ns; + spinlock_t nsid_lock; + struct idr netns_ids; + struct ns_common ns; + struct proc_dir_entry *proc_net; + struct proc_dir_entry *proc_net_stat; + struct ctl_table_set___2 sysctls; + struct sock *rtnl; + struct sock *genl_sock; + struct list_head dev_base_head; + struct hlist_head *dev_name_head; + struct hlist_head *dev_index_head; + unsigned int dev_base_seq; + int ifindex; + unsigned int dev_unreg_count; + struct list_head rules_ops; + struct net_device___2 *loopback_dev; + struct netns_core___2 core; + struct netns_mib mib; + struct netns_packet___2 packet; + struct netns_unix___2 unx; + long: 64; + long: 64; + long: 64; + struct netns_ipv4___2 ipv4; + struct net_generic *gen; + struct sock *diag_nlsk; + atomic_t fnhe_genid; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; +}; + +struct net_device_stats { + long unsigned int rx_packets; + long unsigned int tx_packets; + long unsigned int rx_bytes; + long unsigned int tx_bytes; + long unsigned int rx_errors; + long unsigned int tx_errors; + long unsigned int rx_dropped; + long unsigned int tx_dropped; + long unsigned int multicast; + long unsigned int collisions; + long unsigned int rx_length_errors; + long unsigned int rx_over_errors; + long unsigned int rx_crc_errors; + long unsigned int rx_frame_errors; + long unsigned int rx_fifo_errors; + long unsigned int rx_missed_errors; + long unsigned int tx_aborted_errors; + long unsigned int tx_carrier_errors; + long unsigned int tx_fifo_errors; + long unsigned int tx_heartbeat_errors; + long unsigned int tx_window_errors; + long unsigned int rx_compressed; + long unsigned int tx_compressed; +}; + +struct netdev_hw_addr_list { + struct list_head list; + int count; +}; + +struct dn_dev; + +struct wireless_dev; + +struct wpan_dev; + +typedef rx_handler_result_t rx_handler_func_t(struct sk_buff **); + +struct pcpu_dstats; + +struct pcpu_vstats; + +struct garp_port; + +struct mrp_port; + +struct netdev_tc_txq { + u16 count; + u16 offset; +}; + +struct net_device_ops; + +struct netdev_rx_queue; + +struct xps_dev_maps; + +struct netpoll_info; + +struct pcpu_lstats; + +struct pcpu_sw_netstats; + +struct rtnl_link_ops; + +struct phy_device; + +struct net_device { + char name[16]; + struct hlist_node name_hlist; + char *ifalias; + long unsigned int mem_end; + long unsigned int mem_start; + long unsigned int base_addr; + int irq; + atomic_t carrier_changes; + long unsigned int state; + 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 list_head ptype_specific; + struct { + struct list_head upper; + struct list_head lower; + } adj_list; + struct { + struct list_head upper; + struct list_head lower; + } all_adj_list; + netdev_features_t features; + 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; + netdev_features_t gso_partial_features; + int ifindex; + int group; + struct net_device_stats stats; + atomic_long_t rx_dropped; + atomic_long_t tx_dropped; + atomic_long_t rx_nohandler; + const struct net_device_ops *netdev_ops; + const struct ethtool_ops *ethtool_ops; + const struct header_ops *header_ops; + unsigned int flags; + unsigned int priv_flags; + short unsigned int gflags; + short unsigned int padded; + unsigned char operstate; + unsigned char link_mode; + unsigned char if_port; + unsigned char dma; + unsigned int mtu; + short unsigned int type; + short unsigned int hard_header_len; + short unsigned int needed_headroom; + short unsigned int needed_tailroom; + unsigned char perm_addr[32]; + unsigned char addr_assign_type; + unsigned char addr_len; + short unsigned int neigh_priv_len; + short unsigned int dev_id; + short unsigned int dev_port; + spinlock_t addr_list_lock; + unsigned char name_assign_type; + bool uc_promisc; + 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; + void *atalk_ptr; + struct in_device *ip_ptr; + struct dn_dev *dn_ptr; + struct inet6_dev *ip6_ptr; + void *ax25_ptr; + struct wireless_dev *ieee80211_ptr; + struct wpan_dev *ieee802154_ptr; + long unsigned int last_rx; + unsigned char *dev_addr; + struct netdev_rx_queue *_rx; + unsigned int num_rx_queues; + unsigned int real_num_rx_queues; + long unsigned int gro_flush_timeout; + rx_handler_func_t *rx_handler; + void *rx_handler_data; + struct tcf_proto *ingress_cl_list; + struct netdev_queue *ingress_queue; + unsigned char broadcast[32]; + struct cpu_rmap *rx_cpu_rmap; + struct hlist_node index_hlist; + long: 64; + struct netdev_queue *_tx; + unsigned int num_tx_queues; + unsigned int real_num_tx_queues; + struct Qdisc *qdisc; + long unsigned int tx_queue_len; + spinlock_t tx_global_lock; + int watchdog_timeo; + struct xps_dev_maps *xps_maps; + struct tcf_proto *egress_cl_list; + struct timer_list watchdog_timer; + int *pcpu_refcnt; + struct list_head todo_list; + struct list_head link_watch_list; + enum { + NETREG_UNINITIALIZED = 0, + NETREG_REGISTERED = 1, + NETREG_UNREGISTERING = 2, + NETREG_UNREGISTERED = 3, + NETREG_RELEASED = 4, + NETREG_DUMMY = 5, + } reg_state: 8; + bool dismantle; + enum { + RTNL_LINK_INITIALIZED = 0, + RTNL_LINK_INITIALIZING = 1, + } rtnl_link_state: 16; + void (*destructor)(struct net_device *); + struct netpoll_info *npinfo; + possible_net_t nd_net; + union { + void *ml_priv; + struct pcpu_lstats *lstats; + struct pcpu_sw_netstats *tstats; + struct pcpu_dstats *dstats; + struct pcpu_vstats *vstats; + }; + struct garp_port *garp_port; + struct mrp_port *mrp_port; + 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; + unsigned int gso_max_size; + u16 gso_max_segs; + u8 num_tc; + struct netdev_tc_txq tc_to_txq[16]; + u8 prio_tc_map[16]; + struct phy_device *phydev; + struct lock_class_key *qdisc_tx_busylock; + bool proto_down; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; +}; + +typedef rx_handler_result_t rx_handler_func_t___2(struct sk_buff___2 **); + +struct net_device_ops___2; + +struct netdev_rx_queue___2; + +struct rtnl_link_ops___2; + +struct phy_device___2; + +struct net_device___2 { + char name[16]; + struct hlist_node name_hlist; + char *ifalias; + long unsigned int mem_end; + long unsigned int mem_start; + long unsigned int base_addr; + int irq; + atomic_t carrier_changes; + long unsigned int state; + 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 list_head ptype_specific; + struct { + struct list_head upper; + struct list_head lower; + } adj_list; + struct { + struct list_head upper; + struct list_head lower; + } all_adj_list; + netdev_features_t features; + 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; + netdev_features_t gso_partial_features; + int ifindex; + int group; + struct net_device_stats stats; + atomic_long_t rx_dropped; + atomic_long_t tx_dropped; + atomic_long_t rx_nohandler; + const struct net_device_ops___2 *netdev_ops; + const struct ethtool_ops___2 *ethtool_ops; + const struct header_ops___2 *header_ops; + unsigned int flags; + unsigned int priv_flags; + short unsigned int gflags; + short unsigned int padded; + unsigned char operstate; + unsigned char link_mode; + unsigned char if_port; + unsigned char dma; + unsigned int mtu; + short unsigned int type; + short unsigned int hard_header_len; + short unsigned int needed_headroom; + short unsigned int needed_tailroom; + unsigned char perm_addr[32]; + unsigned char addr_assign_type; + unsigned char addr_len; + short unsigned int neigh_priv_len; + short unsigned int dev_id; + short unsigned int dev_port; + spinlock_t addr_list_lock; + unsigned char name_assign_type; + bool uc_promisc; + struct netdev_hw_addr_list uc; + struct netdev_hw_addr_list mc; + struct netdev_hw_addr_list dev_addrs; + struct kset___2 *queues_kset; + unsigned int promiscuity; + unsigned int allmulti; + void *atalk_ptr; + struct in_device *ip_ptr; + struct dn_dev *dn_ptr; + struct inet6_dev *ip6_ptr; + void *ax25_ptr; + struct wireless_dev *ieee80211_ptr; + struct wpan_dev *ieee802154_ptr; + long unsigned int last_rx; + unsigned char *dev_addr; + struct netdev_rx_queue___2 *_rx; + unsigned int num_rx_queues; + unsigned int real_num_rx_queues; + long unsigned int gro_flush_timeout; + rx_handler_func_t___2 *rx_handler; + void *rx_handler_data; + struct tcf_proto___2 *ingress_cl_list; + struct netdev_queue___2 *ingress_queue; + unsigned char broadcast[32]; + struct cpu_rmap *rx_cpu_rmap; + struct hlist_node index_hlist; + long: 64; + struct netdev_queue___2 *_tx; + unsigned int num_tx_queues; + unsigned int real_num_tx_queues; + struct Qdisc___2 *qdisc; + long unsigned int tx_queue_len; + spinlock_t tx_global_lock; + int watchdog_timeo; + struct xps_dev_maps *xps_maps; + struct tcf_proto___2 *egress_cl_list; + struct timer_list watchdog_timer; + int *pcpu_refcnt; + struct list_head todo_list; + struct list_head link_watch_list; + enum { + NETREG_UNINITIALIZED___2 = 0, + NETREG_REGISTERED___2 = 1, + NETREG_UNREGISTERING___2 = 2, + NETREG_UNREGISTERED___2 = 3, + NETREG_RELEASED___2 = 4, + NETREG_DUMMY___2 = 5, + } reg_state: 8; + bool dismantle; + enum { + RTNL_LINK_INITIALIZED___2 = 0, + RTNL_LINK_INITIALIZING___2 = 1, + } rtnl_link_state: 16; + void (*destructor)(struct net_device___2 *); + struct netpoll_info *npinfo; + possible_net_t___2 nd_net; + union { + void *ml_priv; + struct pcpu_lstats *lstats; + struct pcpu_sw_netstats *tstats; + struct pcpu_dstats *dstats; + struct pcpu_vstats *vstats; + }; + struct garp_port *garp_port; + struct mrp_port *mrp_port; + struct device___2 dev; + const struct attribute_group___2 *sysfs_groups[4]; + const struct attribute_group___2 *sysfs_rx_queue_group; + const struct rtnl_link_ops___2 *rtnl_link_ops; + unsigned int gso_max_size; + u16 gso_max_segs; + u8 num_tc; + struct netdev_tc_txq tc_to_txq[16]; + u8 prio_tc_map[16]; + struct phy_device___2 *phydev; + struct lock_class_key *qdisc_tx_busylock; + bool proto_down; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; +}; + +typedef u16 (*select_queue_fallback_t)(struct net_device *, struct sk_buff *); + +struct rtnl_link_stats64; + +struct tc_to_netdev; + +struct netdev_phys_item_id; + +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 *, void *, select_queue_fallback_t); + 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_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 *); + struct rtnl_link_stats64 * (*ndo_get_stats64)(struct net_device *, struct rtnl_link_stats64 *); + 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 *, struct netpoll_info *); + void (*ndo_netpoll_cleanup)(struct net_device *); + int (*ndo_busy_poll)(struct napi_struct *); + int (*ndo_set_vf_mac)(struct net_device *, int, u8 *); + int (*ndo_set_vf_vlan)(struct net_device *, int, u16, u8); + 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_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 *, u32, __be16, struct tc_to_netdev *); + int (*ndo_rx_flow_steer)(struct net_device *, const struct sk_buff *, u16, u32); + int (*ndo_add_slave)(struct net_device *, struct net_device *); + int (*ndo_del_slave)(struct net_device *, struct net_device *); + 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 neighbour *); + void (*ndo_neigh_destroy)(struct neighbour *); + int (*ndo_fdb_add)(struct ndmsg *, struct nlattr **, struct net_device *, const unsigned char *, u16, u16); + int (*ndo_fdb_del)(struct ndmsg *, struct nlattr **, struct net_device *, const unsigned char *, u16); + int (*ndo_fdb_dump)(struct sk_buff *, struct netlink_callback *, struct net_device *, struct net_device *, int); + int (*ndo_bridge_setlink)(struct net_device *, struct nlmsghdr *, u16); + 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_phys_port_name)(struct net_device *, char *, size_t); + void (*ndo_add_vxlan_port)(struct net_device *, sa_family_t, __be16); + void (*ndo_del_vxlan_port)(struct net_device *, sa_family_t, __be16); + void (*ndo_add_geneve_port)(struct net_device *, sa_family_t, __be16); + void (*ndo_del_geneve_port)(struct net_device *, sa_family_t, __be16); + void * (*ndo_dfwd_add_station)(struct net_device *, struct net_device *); + void (*ndo_dfwd_del_station)(struct net_device *, void *); + netdev_tx_t (*ndo_dfwd_start_xmit)(struct sk_buff *, struct net_device *, void *); + int (*ndo_get_lock_subclass)(struct net_device *); + int (*ndo_set_tx_maxrate)(struct net_device *, int, u32); + int (*ndo_get_iflink)(const struct net_device *); + int (*ndo_change_proto_down)(struct net_device *, bool); + int (*ndo_fill_metadata_dst)(struct net_device *, struct sk_buff *); + void (*ndo_set_rx_headroom)(struct net_device *, int); +}; + +typedef u16 (*select_queue_fallback_t___2)(struct net_device___2 *, struct sk_buff___2 *); + +struct netlink_callback___2; + +struct net_device_ops___2 { + int (*ndo_init)(struct net_device___2 *); + void (*ndo_uninit)(struct net_device___2 *); + int (*ndo_open)(struct net_device___2 *); + int (*ndo_stop)(struct net_device___2 *); + netdev_tx_t (*ndo_start_xmit)(struct sk_buff___2 *, struct net_device___2 *); + netdev_features_t (*ndo_features_check)(struct sk_buff___2 *, struct net_device___2 *, netdev_features_t); + u16 (*ndo_select_queue)(struct net_device___2 *, struct sk_buff___2 *, void *, select_queue_fallback_t___2); + void (*ndo_change_rx_flags)(struct net_device___2 *, int); + void (*ndo_set_rx_mode)(struct net_device___2 *); + int (*ndo_set_mac_address)(struct net_device___2 *, void *); + int (*ndo_validate_addr)(struct net_device___2 *); + int (*ndo_do_ioctl)(struct net_device___2 *, struct ifreq *, int); + int (*ndo_set_config)(struct net_device___2 *, struct ifmap *); + int (*ndo_change_mtu)(struct net_device___2 *, int); + int (*ndo_neigh_setup)(struct net_device___2 *, struct neigh_parms *); + void (*ndo_tx_timeout)(struct net_device___2 *); + struct rtnl_link_stats64 * (*ndo_get_stats64)(struct net_device___2 *, struct rtnl_link_stats64 *); + struct net_device_stats * (*ndo_get_stats)(struct net_device___2 *); + int (*ndo_vlan_rx_add_vid)(struct net_device___2 *, __be16, u16); + int (*ndo_vlan_rx_kill_vid)(struct net_device___2 *, __be16, u16); + void (*ndo_poll_controller)(struct net_device___2 *); + int (*ndo_netpoll_setup)(struct net_device___2 *, struct netpoll_info *); + void (*ndo_netpoll_cleanup)(struct net_device___2 *); + int (*ndo_busy_poll)(struct napi_struct___2 *); + int (*ndo_set_vf_mac)(struct net_device___2 *, int, u8 *); + int (*ndo_set_vf_vlan)(struct net_device___2 *, int, u16, u8); + int (*ndo_set_vf_rate)(struct net_device___2 *, int, int, int); + int (*ndo_set_vf_spoofchk)(struct net_device___2 *, int, bool); + int (*ndo_set_vf_trust)(struct net_device___2 *, int, bool); + int (*ndo_get_vf_config)(struct net_device___2 *, int, struct ifla_vf_info *); + int (*ndo_set_vf_link_state)(struct net_device___2 *, int, int); + int (*ndo_get_vf_stats)(struct net_device___2 *, int, struct ifla_vf_stats *); + int (*ndo_set_vf_port)(struct net_device___2 *, int, struct nlattr **); + int (*ndo_get_vf_port)(struct net_device___2 *, int, struct sk_buff___2 *); + int (*ndo_set_vf_guid)(struct net_device___2 *, int, u64, int); + int (*ndo_set_vf_rss_query_en)(struct net_device___2 *, int, bool); + int (*ndo_setup_tc)(struct net_device___2 *, u32, __be16, struct tc_to_netdev *); + int (*ndo_rx_flow_steer)(struct net_device___2 *, const struct sk_buff___2 *, u16, u32); + int (*ndo_add_slave)(struct net_device___2 *, struct net_device___2 *); + int (*ndo_del_slave)(struct net_device___2 *, struct net_device___2 *); + netdev_features_t (*ndo_fix_features)(struct net_device___2 *, netdev_features_t); + int (*ndo_set_features)(struct net_device___2 *, netdev_features_t); + int (*ndo_neigh_construct)(struct neighbour *); + void (*ndo_neigh_destroy)(struct neighbour *); + int (*ndo_fdb_add)(struct ndmsg *, struct nlattr **, struct net_device___2 *, const unsigned char *, u16, u16); + int (*ndo_fdb_del)(struct ndmsg *, struct nlattr **, struct net_device___2 *, const unsigned char *, u16); + int (*ndo_fdb_dump)(struct sk_buff___2 *, struct netlink_callback___2 *, struct net_device___2 *, struct net_device___2 *, int); + int (*ndo_bridge_setlink)(struct net_device___2 *, struct nlmsghdr *, u16); + int (*ndo_bridge_getlink)(struct sk_buff___2 *, u32, u32, struct net_device___2 *, u32, int); + int (*ndo_bridge_dellink)(struct net_device___2 *, struct nlmsghdr *, u16); + int (*ndo_change_carrier)(struct net_device___2 *, bool); + int (*ndo_get_phys_port_id)(struct net_device___2 *, struct netdev_phys_item_id *); + int (*ndo_get_phys_port_name)(struct net_device___2 *, char *, size_t); + void (*ndo_add_vxlan_port)(struct net_device___2 *, sa_family_t, __be16); + void (*ndo_del_vxlan_port)(struct net_device___2 *, sa_family_t, __be16); + void (*ndo_add_geneve_port)(struct net_device___2 *, sa_family_t, __be16); + void (*ndo_del_geneve_port)(struct net_device___2 *, sa_family_t, __be16); + void * (*ndo_dfwd_add_station)(struct net_device___2 *, struct net_device___2 *); + void (*ndo_dfwd_del_station)(struct net_device___2 *, void *); + netdev_tx_t (*ndo_dfwd_start_xmit)(struct sk_buff___2 *, struct net_device___2 *, void *); + int (*ndo_get_lock_subclass)(struct net_device___2 *); + int (*ndo_set_tx_maxrate)(struct net_device___2 *, int, u32); + int (*ndo_get_iflink)(const struct net_device___2 *); + int (*ndo_change_proto_down)(struct net_device___2 *, bool); + int (*ndo_fill_metadata_dst)(struct net_device___2 *, struct sk_buff___2 *); + void (*ndo_set_rx_headroom)(struct net_device___2 *, int); +}; + +struct net_generic { + unsigned int len; + struct callback_head rcu; + void *ptr[0]; +}; + +struct offload_callbacks { + struct sk_buff * (*gso_segment)(struct sk_buff *, netdev_features_t); + struct sk_buff ** (*gro_receive)(struct sk_buff **, struct sk_buff *); + int (*gro_complete)(struct sk_buff *, int); +}; + +struct net_offload { + struct offload_callbacks callbacks; + unsigned int flags; +}; + +struct net_proto_family { + int family; + int (*create)(struct net *, struct socket *, int, int); + struct module *owner; +}; + +struct net_protocol { + void (*early_demux)(struct sk_buff *); + int (*handler)(struct sk_buff *); + void (*err_handler)(struct sk_buff *, u32); + unsigned int no_policy: 1; + unsigned int netns_ok: 1; + unsigned int icmp_strict_tag_validation: 1; +}; + +struct netconfmsg { + __u8 ncm_family; +}; + +struct netpoll { + struct net_device *dev; + 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 work_struct cleanup_work; +}; + +struct netconsole_target { + struct list_head list; + bool enabled; + bool extended; + struct netpoll np; +}; + +struct netdev_adjacent { + struct net_device *dev; + bool master; + u16 ref_nr; + void *private; + struct list_head list; + struct callback_head rcu; +}; + +struct netdev_bonding_info { + ifslave slave; + ifbond master; +}; + +struct netdev_boot_setup { + char name[16]; + struct ifmap map; +}; + +struct netdev_hw_addr { + struct list_head list; + unsigned char addr[32]; + unsigned char type; + bool global_use; + int sync_cnt; + int refcount; + int synced; + struct callback_head callback_head; +}; + +struct netdev_notifier_info { + struct net_device *dev; +}; + +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_phys_item_id { + unsigned char id[32]; + unsigned char id_len; +}; + +struct netdev_queue { + struct net_device *dev; + struct Qdisc *qdisc; + struct Qdisc *qdisc_sleeping; + struct kobject kobj; + int numa_node; + long unsigned int tx_maxrate; + long unsigned int trans_timeout; + long: 64; + long: 64; + spinlock_t _xmit_lock; + int xmit_lock_owner; + long unsigned int trans_start; + long unsigned int state; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + struct dql dql; +}; + +struct netdev_queue___2 { + struct net_device___2 *dev; + struct Qdisc___2 *qdisc; + struct Qdisc___2 *qdisc_sleeping; + struct kobject___2 kobj; + int numa_node; + long unsigned int tx_maxrate; + long unsigned int trans_timeout; + long: 64; + long: 64; + spinlock_t _xmit_lock; + int xmit_lock_owner; + long unsigned int trans_start; + long unsigned int state; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + struct dql dql; +}; + +struct netdev_queue_attribute { + struct attribute attr; + ssize_t (*show)(struct netdev_queue *, struct netdev_queue_attribute *, char *); + ssize_t (*store)(struct netdev_queue *, struct netdev_queue_attribute *, const char *, size_t); +}; + +struct rps_map; + +struct rps_dev_flow_table; + +struct netdev_rx_queue { + struct rps_map *rps_map; + struct rps_dev_flow_table *rps_flow_table; + struct kobject kobj; + struct net_device *dev; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; +}; + +struct netdev_rx_queue___2 { + struct rps_map *rps_map; + struct rps_dev_flow_table *rps_flow_table; + struct kobject___2 kobj; + struct net_device___2 *dev; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; +}; + +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 (*start)(struct netlink_callback *); + int (*dump)(struct sk_buff *, struct netlink_callback *); + int (*done)(struct netlink_callback *); + void *data; + struct module *module; + u16 family; + u16 min_dump_alloc; + unsigned int prev_seq; + unsigned int seq; + long int args[6]; +}; + +struct netlink_callback___2 { + struct sk_buff___2 *skb; + const struct nlmsghdr *nlh; + int (*start)(struct netlink_callback___2 *); + int (*dump)(struct sk_buff___2 *, struct netlink_callback___2 *); + int (*done)(struct netlink_callback___2 *); + void *data; + struct module___2 *module; + u16 family; + u16 min_dump_alloc; + unsigned int prev_seq; + unsigned int seq; + 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 *); + void *data; + struct module *module; + u16 min_dump_alloc; +}; + +struct netlink_kernel_cfg { + unsigned int groups; + unsigned int flags; + void (*input)(struct sk_buff *); + struct mutex *cb_mutex; + int (*bind)(struct net *, int); + void (*unbind)(struct net *, int); + bool (*compare)(struct net *, struct sock *); +}; + +struct netlink_notify { + struct net *net; + u32 portid; + int protocol; +}; + +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 rhash_head { + struct rhash_head *next; +}; + +struct netlink_sock { + struct sock sk; + u32 portid; + u32 dst_portid; + u32 dst_group; + u32 flags; + 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; + struct netlink_callback cb; + struct mutex *cb_mutex; + struct mutex cb_def_mutex; + void (*netlink_rcv)(struct sk_buff *); + int (*netlink_bind)(struct net *, int); + void (*netlink_unbind)(struct net *, int); + struct module *module; + struct rhash_head node; + struct callback_head rcu; +}; + +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 { + size_t nelem_hint; + size_t key_len; + size_t key_offset; + size_t head_offset; + unsigned int insecure_max_entries; + unsigned int max_size; + unsigned int min_size; + u32 nulls_base; + bool insecure_elasticity; + bool automatic_shrinking; + size_t locks_mul; + rht_hashfn_t hashfn; + rht_obj_hashfn_t obj_hashfn; + rht_obj_cmpfn_t obj_cmpfn; +}; + +struct rhashtable { + struct bucket_table *tbl; + atomic_t nelems; + unsigned int key_len; + unsigned int elasticity; + struct rhashtable_params p; + struct work_struct run_work; + struct mutex___2 mutex; + spinlock_t lock; +}; + +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); + bool (*compare)(struct net *, struct sock *); + int registered; +}; + +struct netlink_tap { + struct net_device *dev; + struct module *module; + struct list_head list; +}; + +struct netpoll_info { + atomic_t refcnt; + struct semaphore dev_lock; + struct sk_buff_head txq; + struct delayed_work tx_work; + struct netpoll *netpoll; + struct callback_head rcu; +}; + +struct new_utsname { + char sysname[65]; + char nodename[65]; + char release[65]; + char version[65]; + char machine[65]; + char domainname[65]; +}; + +struct nfs_string { + unsigned int len; + const char *data; +}; + +struct nfs4_mount_data { + int version; + int flags; + int rsize; + int wsize; + int timeo; + int retrans; + int acregmin; + int acregmax; + int acdirmin; + int acdirmax; + struct nfs_string client_addr; + struct nfs_string mnt_path; + struct nfs_string hostname; + unsigned int host_addrlen; + struct sockaddr *host_addr; + int proto; + int auth_flavourlen; + int *auth_flavours; +}; + +struct nid_path { + int depth; + hda_nid_t path[10]; + unsigned char idx[10]; + unsigned char multi[10]; + unsigned int ctls[3]; + bool active: 1; + bool pin_enabled: 1; + bool pin_fixed: 1; + bool stream_enabled: 1; +}; + +struct nl_pktinfo { + __u32 group; +}; + +struct rhashtable_walker; + +struct rhashtable_iter { + struct rhashtable *ht; + struct rhash_head *p; + struct rhashtable_walker *walker; + unsigned int slot; + unsigned int skip; +}; + +struct nl_seq_iter { + struct seq_net_private p; + struct rhashtable_iter hti; + int link; +}; + +struct nla_policy { + u16 type; + u16 len; +}; + +struct nlattr { + __u16 nla_len; + __u16 nla_type; +}; + +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___2 *owner; + struct nls_table *next; +}; + +struct nmi_desc { + spinlock_t lock; + struct list_head head; +}; + +struct nmi_seq_buf { + atomic_t len; + struct irq_work work; + unsigned char buffer[8164]; +}; + +struct nmi_stats { + unsigned int normal; + unsigned int unknown; + unsigned int external; + unsigned int swallow; +}; + +typedef int (*nmi_handler_t)(unsigned int, struct pt_regs *); + +struct nmiaction { + struct list_head list; + nmi_handler_t handler; + u64 max_duration; + struct irq_work irq_work; + long unsigned int flags; + const char *name; +}; + +struct node { + struct device dev; + struct work_struct node_work; +}; + +struct node_attr { + struct device_attribute attr; + enum node_states state; +}; + +struct node_hstate { + struct kobject *hugepages_kobj; + struct kobject *hstate_kobjs[2]; +}; + +struct nodemask_scratch { + nodemask_t mask1; + nodemask_t mask2; +}; + +struct noop_data { + struct list_head queue; +}; + +struct nosave_region { + struct list_head list; + long unsigned int start_pfn; + long unsigned int end_pfn; +}; + +struct ns2501_configuration { + uint8_t sync; + uint8_t conf; + uint8_t syncb; + uint8_t dither; + uint8_t pll_a; + uint16_t pll_b; + uint16_t hstart; + uint16_t hstop; + uint16_t vstart; + uint16_t vstop; + uint16_t vsync; + uint16_t vtotal; + uint16_t hpos; + uint16_t vpos; + uint16_t voffs; + uint16_t hscale; + uint16_t vscale; +}; + +struct ns2501_priv { + bool quiet; + const struct ns2501_configuration *conf; +}; + +struct ns2501_reg { + uint8_t offset; + uint8_t value; +}; + +struct uts_namespace; + +struct nsproxy { + atomic_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 cgroup_namespace *cgroup_ns; +}; + +struct pid_namespace___2; + +struct nsproxy___2 { + atomic_t count; + struct uts_namespace *uts_ns; + struct ipc_namespace *ipc_ns; + struct mnt_namespace *mnt_ns; + struct pid_namespace___2 *pid_ns_for_children; + struct net___2 *net_ns; + struct cgroup_namespace___2 *cgroup_ns; +}; + +struct numa_maps { + long unsigned int pages; + long unsigned int anon; + long unsigned int active; + long unsigned int writeback; + long unsigned int mapcount_max; + long unsigned int dirty; + long unsigned int swapcache; + long unsigned int node[64]; +}; + +struct proc_maps_private { + struct inode *inode; + struct task_struct *task; + struct mm_struct *mm; + struct vm_area_struct___2 *tail_vma; + struct mempolicy *task_mempolicy; +}; + +struct numa_maps_private { + struct proc_maps_private proc_maps; + struct numa_maps md; +}; + +struct numa_memblk { + u64 start; + u64 end; + int nid; +}; + +struct numa_meminfo { + int nr_blks; + struct numa_memblk blk[128]; +}; + +struct nvs_page { + long unsigned int phys_start; + unsigned int size; + void *kaddr; + void *data; + bool unmap; + struct list_head node; +}; + +struct nvs_region { + __u64 phys_start; + __u64 size; + struct list_head node; +}; + +struct obs_kernel_param { + const char *str; + int (*setup_func)(char *); + int early; +}; + +struct of_device_id { + char name[32]; + char type[32]; + char compatible[128]; + const void *data; +}; + +struct of_phandle_args { + struct device_node *np; + int args_count; + uint32_t args[16]; +}; + +struct ohci { + void *registers; +}; + +struct old_linux_dirent { + long unsigned int d_ino; + long unsigned int d_offset; + short unsigned int d_namlen; + char d_name[1]; +}; + +struct old_serial_port { + unsigned int uart; + unsigned int baud_base; + unsigned int port; + unsigned int irq; + upf_t flags; + unsigned char hub6; + unsigned char io_type; + unsigned char *iomem_base; + short unsigned int iomem_reg_shift; + long unsigned int irqflags; +}; + +struct old_utsname { + char sysname[65]; + char nodename[65]; + char release[65]; + char version[65]; + char machine[65]; +}; + +struct oldold_utsname { + char sysname[9]; + char nodename[9]; + char release[9]; + char version[9]; + char machine[9]; +}; + +struct static_key; + +struct once_work { + struct work_struct work; + struct static_key *key; +}; + +struct oom_control { + struct zonelist *zonelist; + nodemask_t *nodemask; + const gfp_t gfp_mask; + const int order; +}; + +struct open_flags { + int open_flag; + umode_t mode; + int acc_mode; + int intent; + int lookup_flags; +}; + +struct opregion_acpi { + u32 drdy; + u32 csts; + u32 cevt; + u8 rsvd1[20]; + u32 didl[8]; + u32 cpdl[8]; + u32 cadl[8]; + u32 nadl[8]; + u32 aslp; + u32 tidx; + u32 chpd; + u32 clid; + u32 cdck; + u32 sxsw; + u32 evts; + u32 cnot; + u32 nrdy; + u32 did2[7]; + u32 cpd2[7]; + u8 rsvd2[4]; +}; + +struct opregion_asle { + u32 ardy; + u32 aslc; + u32 tche; + u32 alsi; + u32 bclp; + u32 pfit; + u32 cblv; + u16 bclm[20]; + u32 cpfm; + u32 epfm; + u8 plut[74]; + u32 pfmb; + u32 cddv; + u32 pcft; + u32 srot; + u32 iuer; + u64 fdss; + u32 fdsp; + u32 stat; + u64 rvda; + u32 rvds; + u8 rsvd[58]; +} __attribute__((packed)); + +struct opregion_header { + u8 signature[16]; + u32 size; + u32 opregion_ver; + u8 bios_ver[32]; + u8 vbios_ver[16]; + u8 driver_ver[16]; + u32 mboxes; + u32 driver_model; + u32 pcon; + u8 dver[32]; + u8 rsvd[124]; +}; + +struct opregion_swsci { + u32 scic; + u32 parm; + u32 dslp; + u8 rsvd[244]; +}; + +struct opstack_op { + int op; + struct list_head list; +}; + +struct optimistic_spin_node { + struct optimistic_spin_node *next; + struct optimistic_spin_node *prev; + int locked; + int cpu; +}; + +struct orig_ist { + long unsigned int ist[7]; +}; + +struct ovl_cache_entry { + unsigned int len; + unsigned int type; + u64 ino; + struct list_head l_node; + struct rb_node node; + struct ovl_cache_entry *next_maybe_whiteout; + bool is_whiteout; + char name[0]; +}; + +struct ovl_config { + char *lowerdir; + char *upperdir; + char *workdir; + bool default_permissions; +}; + +struct ovl_dir_cache { + long int refcount; + u64 version; + struct list_head entries; +}; + +struct ovl_dir_file { + bool is_real; + bool is_upper; + struct ovl_dir_cache *cache; + struct list_head *cursor; + struct file *realfile; + struct file *upperfile; +}; + +struct ovl_entry { + struct dentry *__upperdentry; + struct ovl_dir_cache *cache; + union { + struct { + u64 version; + bool opaque; + }; + struct callback_head rcu; + }; + unsigned int numlower; + struct path lowerstack[0]; +}; + +struct ovl_fs { + struct vfsmount *upper_mnt; + unsigned int numlower; + struct vfsmount **lower_mnt; + struct dentry *workdir; + long int lower_namelen; + struct ovl_config config; + const struct cred *creator_cred; +}; + +struct ovl_readdir_data { + struct dir_context ctx; + struct dentry *dentry; + bool is_lowest; + struct rb_root root; + struct list_head *list; + struct list_head middle; + struct ovl_cache_entry *first_maybe_whiteout; + int count; + int err; + bool d_type_supported; +}; + +struct p4_event_alias { + u64 original; + u64 alternative; +}; + +struct p4_event_bind { + unsigned int opcode; + unsigned int escr_msr[2]; + unsigned int escr_emask; + unsigned int shared; + char cntr[6]; +}; + +struct p4_pebs_bind { + unsigned int metric_pebs; + unsigned int metric_vert; +}; + +struct p9_trans_module; + +struct p9_idpool; + +struct p9_req_t; + +struct p9_client { + spinlock_t lock; + unsigned int msize; + unsigned char proto_version; + struct p9_trans_module *trans_mod; + enum p9_trans_status status; + void *trans; + struct p9_idpool *fidpool; + struct list_head fidlist; + struct p9_idpool *tagpool; + struct p9_req_t *reqs[255]; + int max_tag; + char name[65]; +}; + +struct p9_fcall { + u32 size; + u8 id; + u16 tag; + size_t offset; + size_t capacity; + u8 *sdata; +}; + +struct p9_conn; + +struct p9_poll_wait { + struct p9_conn *conn; + wait_queue_t wait; + wait_queue_head_t *wait_addr; +}; + +struct p9_conn { + struct list_head mux_list; + struct p9_client *client; + int err; + struct list_head req_list; + struct list_head unsent_req_list; + struct p9_req_t *req; + char tmp_buf[7]; + struct p9_fcall rc; + int wpos; + int wsize; + char *wbuf; + struct list_head poll_pending_link; + struct p9_poll_wait poll_wait[2]; + poll_table pt; + struct work_struct rq; + struct work_struct wq; + long unsigned int wsched; +}; + +struct p9_qid { + u8 type; + u32 version; + u64 path; +}; + +struct p9_dirent { + struct p9_qid qid; + u64 d_off; + unsigned char d_type; + char d_name[256]; +}; + +struct p9_fd_opts { + int rfd; + int wfd; + u16 port; + int privport; +}; + +struct p9_fid { + struct p9_client *clnt; + u32 fid; + int mode; + struct p9_qid qid; + u32 iounit; + kuid_t uid; + void *rdir; + struct list_head flist; + struct hlist_node dlist; +}; + +struct p9_flock { + u8 type; + u32 flags; + u64 start; + u64 length; + u32 proc_id; + char *client_id; +}; + +struct p9_getlock { + u8 type; + u64 start; + u64 length; + u32 proc_id; + char *client_id; +}; + +struct p9_iattr_dotl { + u32 valid; + u32 mode; + kuid_t uid; + kgid_t gid; + u64 size; + u64 atime_sec; + u64 atime_nsec; + u64 mtime_sec; + u64 mtime_nsec; +}; + +struct p9_idpool { + spinlock_t lock; + struct idr pool; +}; + +struct p9_rdir { + int head; + int tail; + uint8_t buf[0]; +}; + +struct p9_req_t { + int status; + int t_err; + wait_queue_head_t *wq; + struct p9_fcall *tc; + struct p9_fcall *rc; + void *aux; + struct list_head req_list; +}; + +struct p9_rstatfs { + u32 type; + u32 bsize; + u64 blocks; + u64 bfree; + u64 bavail; + u64 files; + u64 ffree; + u64 fsid; + u32 namelen; +}; + +struct p9_stat_dotl { + u64 st_result_mask; + struct p9_qid qid; + u32 st_mode; + kuid_t st_uid; + kgid_t st_gid; + u64 st_nlink; + u64 st_rdev; + u64 st_size; + u64 st_blksize; + u64 st_blocks; + u64 st_atime_sec; + u64 st_atime_nsec; + u64 st_mtime_sec; + u64 st_mtime_nsec; + u64 st_ctime_sec; + u64 st_ctime_nsec; + u64 st_btime_sec; + u64 st_btime_nsec; + u64 st_gen; + u64 st_data_version; +}; + +struct p9_trans_fd { + struct file___2 *rd; + struct file___2 *wr; + struct p9_conn conn; +}; + +struct p9_trans_module { + struct list_head list; + char *name; + int maxsize; + int def; + struct module___2 *owner; + int (*create)(struct p9_client *, const char *, char *); + void (*close)(struct p9_client *); + int (*request)(struct p9_client *, struct p9_req_t *); + int (*cancel)(struct p9_client *, struct p9_req_t *); + int (*cancelled)(struct p9_client *, struct p9_req_t *); + int (*zc_request)(struct p9_client *, struct p9_req_t *, struct iov_iter *, struct iov_iter *, int, int, int); +}; + +struct p9_wstat { + u16 size; + u16 type; + u32 dev; + struct p9_qid qid; + u32 mode; + u32 atime; + u32 mtime; + u64 length; + char *name; + char *uid; + char *gid; + char *muid; + char *extension; + kuid_t n_uid; + kgid_t n_gid; + kuid_t n_muid; +}; + +struct pacct_struct { + int ac_flag; + long int ac_exitcode; + long unsigned int ac_mem; + cputime_t ac_utime; + cputime_t ac_stime; + long unsigned int ac_minflt; + long unsigned int ac_majflt; +}; + +struct packet_type { + __be16 type; + struct net_device *dev; + int (*func)(struct sk_buff *, struct net_device *, struct packet_type *, struct net_device *); + bool (*id_match)(struct packet_type *, struct sock *); + void *af_packet_priv; + struct list_head list; +}; + +struct packet_fanout { + possible_net_t net; + unsigned int num_members; + u16 id; + u8 type; + u8 flags; + union { + atomic_t rr_cur; + struct bpf_prog *bpf_prog; + }; + struct list_head list; + struct sock *arr[256]; + spinlock_t lock; + atomic_t sk_ref; + long: 64; + long: 64; + struct packet_type prot_hook; + 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 packet_offload { + __be16 type; + u16 priority; + struct offload_callbacks callbacks; + struct list_head list; +}; + +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; + atomic_t blk_fill_in_prog; + 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; + struct tpacket_kbdq_core prb_bdqc; +}; + +struct packet_rollover { + int sock; + struct callback_head rcu; + atomic_long_t num; + atomic_long_t num_huge; + atomic_long_t num_failed; + 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; + unsigned int running: 1; + unsigned int auxdata: 1; + unsigned int origdev: 1; + unsigned int has_vnet_hdr: 1; + int pressure; + int ifindex; + __be16 num; + struct packet_rollover *rollover; + struct packet_mclist *mclist; + atomic_t mapped; + enum tpacket_versions tp_version; + unsigned int tp_hdrlen; + unsigned int tp_reserve; + unsigned int tp_loss: 1; + unsigned int tp_tx_has_off: 1; + unsigned int tp_tstamp; + struct net_device *cached_dev; + int (*xmit)(struct sk_buff *); + long: 64; + struct packet_type prot_hook; + long: 64; +}; + +struct page___2 { + long unsigned int flags; + union { + struct address_space *mapping; + void *s_mem; + atomic_t compound_mapcount; + }; + struct { + union { + long unsigned int index; + void *freelist; + }; + union { + long unsigned int counters; + struct { + union { + atomic_t _mapcount; + struct { + unsigned int inuse: 16; + unsigned int objects: 15; + unsigned int frozen: 1; + }; + int units; + }; + atomic_t _refcount; + }; + unsigned int active; + }; + }; + union { + struct list_head lru; + struct dev_pagemap *pgmap; + struct { + struct page___2 *next; + int pages; + int pobjects; + }; + struct callback_head callback_head; + struct { + long unsigned int compound_head; + unsigned int compound_dtor; + unsigned int compound_order; + }; + }; + union { + long unsigned int private; + spinlock_t ptl; + struct kmem_cache *slab_cache; + }; + long: 64; +}; + +struct page { + long unsigned int flags; + union { + struct address_space___2 *mapping; + void *s_mem; + atomic_t compound_mapcount; + }; + struct { + union { + long unsigned int index; + void *freelist; + }; + union { + long unsigned int counters; + struct { + union { + atomic_t _mapcount; + struct { + unsigned int inuse: 16; + unsigned int objects: 15; + unsigned int frozen: 1; + }; + int units; + }; + atomic_t _refcount; + }; + unsigned int active; + }; + }; + union { + struct list_head lru; + struct dev_pagemap *pgmap; + struct { + struct page *next; + int pages; + int pobjects; + }; + struct callback_head callback_head; + struct { + long unsigned int compound_head; + unsigned int compound_dtor; + unsigned int compound_order; + }; + }; + union { + long unsigned int private; + spinlock_t ptl; + struct kmem_cache *slab_cache; + }; + long: 64; +}; + +typedef struct page___2 *pgtable_t; + +typedef struct page *pgtable_t___2; + +struct page_ext_operations { + bool (*need)(void); + void (*init)(void); +}; + +struct page_frag___2 { + struct page *page; + __u32 offset; + __u32 size; +}; + +struct page_list { + struct page_list *next; + struct page___2 *page; +}; + +struct page_referenced_arg { + int mapcount; + int referenced; + long unsigned int vm_flags; + struct mem_cgroup *memcg; +}; + +struct page_to_node { + long unsigned int addr; + struct page___2 *page; + int node; + int status; +}; + +struct pagemapread { + int pos; + int len; + pagemap_entry_t *buffer; + bool show_pfn; +}; + +struct pagerange_state { + long unsigned int cur_pfn; + int ram; + int not_ram; +}; + +struct pages_devres { + long unsigned int addr; + unsigned int order; +}; + +struct pagevec { + long unsigned int nr; + long unsigned int cold; + struct page___2 *pages[14]; +}; + +struct paravirt_callee_save { + void *func; +}; + +struct paravirt_patch_site { + u8 *instr; + u8 instrtype; + u8 len; + u16 clobbers; +}; + +struct pv_init_ops { + unsigned int (*patch)(u8, u16, void *, long unsigned int, unsigned int); +}; + +struct pv_time_ops { + long long unsigned int (*sched_clock)(void); + long long unsigned int (*steal_clock)(int); +}; + +struct thread_struct; + +struct tss_struct; + +struct pv_cpu_ops { + long unsigned int (*get_debugreg)(int); + void (*set_debugreg)(int, long unsigned int); + void (*clts)(void); + long unsigned int (*read_cr0)(void); + void (*write_cr0)(long unsigned int); + long unsigned int (*read_cr4_safe)(void); + long unsigned int (*read_cr4)(void); + void (*write_cr4)(long unsigned int); + long unsigned int (*read_cr8)(void); + void (*write_cr8)(long unsigned int); + void (*load_tr_desc)(void); + void (*load_gdt)(const struct desc_ptr *); + void (*load_idt)(const struct desc_ptr *); + void (*store_idt)(struct desc_ptr *); + void (*set_ldt)(const void *, unsigned int); + long unsigned int (*store_tr)(void); + void (*load_tls)(struct thread_struct *, unsigned int); + void (*load_gs_index)(unsigned int); + void (*write_ldt_entry)(struct desc_struct *, int, const void *); + void (*write_gdt_entry)(struct desc_struct *, int, const void *, int); + void (*write_idt_entry)(gate_desc *, int, const gate_desc *); + void (*alloc_ldt)(struct desc_struct *, unsigned int); + void (*free_ldt)(struct desc_struct *, unsigned int); + void (*load_sp0)(struct tss_struct *, struct thread_struct *); + void (*set_iopl_mask)(unsigned int); + void (*wbinvd)(void); + void (*io_delay)(void); + void (*cpuid)(unsigned int *, unsigned int *, unsigned int *, unsigned int *); + u64 (*read_msr)(unsigned int); + void (*write_msr)(unsigned int, unsigned int, unsigned int); + u64 (*read_msr_safe)(unsigned int, int *); + int (*write_msr_safe)(unsigned int, unsigned int, unsigned int); + u64 (*read_pmc)(int); + void (*usergs_sysret64)(void); + void (*iret)(void); + void (*swapgs)(void); + void (*start_context_switch)(struct task_struct *); + void (*end_context_switch)(struct task_struct *); +}; + +struct pv_irq_ops { + struct paravirt_callee_save save_fl; + struct paravirt_callee_save restore_fl; + struct paravirt_callee_save irq_disable; + struct paravirt_callee_save irq_enable; + void (*safe_halt)(void); + void (*halt)(void); + void (*adjust_exception_frame)(void); +}; + +struct pv_lazy_ops { + void (*enter)(void); + void (*leave)(void); + void (*flush)(void); +}; + +struct pv_mmu_ops { + long unsigned int (*read_cr2)(void); + void (*write_cr2)(long unsigned int); + long unsigned int (*read_cr3)(void); + void (*write_cr3)(long unsigned int); + void (*activate_mm)(struct mm_struct *, struct mm_struct *); + void (*dup_mmap)(struct mm_struct *, struct mm_struct *); + void (*exit_mmap)(struct mm_struct *); + void (*flush_tlb_user)(void); + void (*flush_tlb_kernel)(void); + void (*flush_tlb_single)(long unsigned int); + void (*flush_tlb_others)(const struct cpumask *, struct mm_struct *, long unsigned int, long unsigned int); + int (*pgd_alloc)(struct mm_struct *); + void (*pgd_free)(struct mm_struct *, pgd_t *); + void (*alloc_pte)(struct mm_struct *, long unsigned int); + void (*alloc_pmd)(struct mm_struct *, long unsigned int); + void (*alloc_pud)(struct mm_struct *, long unsigned int); + void (*release_pte)(long unsigned int); + void (*release_pmd)(long unsigned int); + void (*release_pud)(long unsigned int); + void (*set_pte)(pte_t *, pte_t); + void (*set_pte_at)(struct mm_struct *, long unsigned int, pte_t *, pte_t); + void (*set_pmd)(pmd_t *, pmd_t); + void (*set_pmd_at)(struct mm_struct *, long unsigned int, pmd_t *, pmd_t); + void (*pte_update)(struct mm_struct *, long unsigned int, pte_t *); + pte_t (*ptep_modify_prot_start)(struct mm_struct *, long unsigned int, pte_t *); + void (*ptep_modify_prot_commit)(struct mm_struct *, long unsigned int, pte_t *, pte_t); + struct paravirt_callee_save pte_val; + struct paravirt_callee_save make_pte; + struct paravirt_callee_save pgd_val; + struct paravirt_callee_save make_pgd; + void (*set_pud)(pud_t *, pud_t); + struct paravirt_callee_save pmd_val; + struct paravirt_callee_save make_pmd; + struct paravirt_callee_save pud_val; + struct paravirt_callee_save make_pud; + void (*set_pgd)(pgd_t *, pgd_t); + struct pv_lazy_ops lazy_mode; + void (*set_fixmap)(unsigned int, phys_addr_t, pgprot_t); +}; + +struct pv_lock_ops { + void (*queued_spin_lock_slowpath)(struct qspinlock *, u32); + struct paravirt_callee_save queued_spin_unlock; + void (*wait)(u8 *, u8); + void (*kick)(int); +}; + +struct paravirt_patch_template { + struct pv_init_ops pv_init_ops; + struct pv_time_ops pv_time_ops; + struct pv_cpu_ops pv_cpu_ops; + struct pv_irq_ops pv_irq_ops; + struct pv_mmu_ops pv_mmu_ops; + struct pv_lock_ops pv_lock_ops; +}; + +struct partition_meta_info { + char uuid[37]; + u8 volname[64]; +}; + +struct parsed_partitions { + struct block_device *bdev; + 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_page { + unsigned int offset; + unsigned int len; + long unsigned int private; +}; + +struct partition { + unsigned char boot_ind; + unsigned char head; + unsigned char sector; + unsigned char cyl; + unsigned char sys_ind; + unsigned char end_head; + unsigned char end_sector; + unsigned char end_cyl; + __le32 start_sect; + __le32 nr_sects; +}; + +struct pbe { + void *address; + void *orig_address; + struct pbe *next; +}; + +struct pccard_io_map { + u_char map; + u_char flags; + u_short speed; + phys_addr_t start; + phys_addr_t stop; +}; + +typedef struct pccard_io_map pccard_io_map; + +struct pccard_mem_map { + u_char map; + u_char flags; + u_short speed; + phys_addr_t static_start; + u_int card_start; + struct resource *res; +}; + +typedef struct pccard_mem_map pccard_mem_map; + +struct pcmcia_socket; + +struct socket_state_t; + +typedef struct socket_state_t socket_state_t; + +struct pccard_operations { + int (*init)(struct pcmcia_socket *); + int (*suspend)(struct pcmcia_socket *); + int (*get_status)(struct pcmcia_socket *, u_int *); + int (*set_socket)(struct pcmcia_socket *, socket_state_t *); + int (*set_io_map)(struct pcmcia_socket *, struct pccard_io_map *); + int (*set_mem_map)(struct pcmcia_socket *, struct pccard_mem_map *); +}; + +struct pccard_resource_ops { + int (*validate_mem)(struct pcmcia_socket *); + int (*find_io)(struct pcmcia_socket *, unsigned int, unsigned int *, unsigned int, unsigned int, struct resource **); + struct resource * (*find_mem)(long unsigned int, long unsigned int, long unsigned int, int, struct pcmcia_socket *); + int (*init)(struct pcmcia_socket *); + void (*exit)(struct pcmcia_socket *); +}; + +struct pci2phy_map { + struct list_head list; + int segment; + int pbus_to_physid[256]; +}; + +struct pci_bits { + unsigned int reg; + unsigned int width; + long unsigned int mask; + long unsigned int val; +}; + +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; + struct msi_controller *msi; + void *sysdata; + struct proc_dir_entry *procdir; + unsigned char number; + unsigned char primary; + unsigned char max_bus_speed; + unsigned char cur_bus_speed; + char name[48]; + short unsigned int bridge_ctl; + pci_bus_flags_t bus_flags; + struct device *bridge; + struct device dev; + struct bin_attribute___2 *legacy_io; + struct bin_attribute___2 *legacy_mem; + unsigned int is_added: 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; + unsigned int flags; +}; + +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_check_idx_range { + int start; + int end; +}; + +struct pcie_link_state; + +struct pci_vpd; + +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; + 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_interrupt: 1; + unsigned int pme_poll: 1; + unsigned int d1_support: 1; + unsigned int d2_support: 1; + unsigned int no_d1d2: 1; + unsigned int no_d3cold: 1; + unsigned int d3cold_allowed: 1; + unsigned int mmio_always_on: 1; + unsigned int wakeup_prepared: 1; + unsigned int runtime_d3cold: 1; + unsigned int ignore_hotplug: 1; + unsigned int d3_delay; + unsigned int d3cold_delay; + struct pcie_link_state *link_state; + pci_channel_state_t error_state; + struct device dev; + int cfg_size; + unsigned int irq; + struct resource resource[11]; + bool match_driver; + unsigned int transparent: 1; + unsigned int multifunction: 1; + unsigned int is_added: 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 is_managed: 1; + unsigned int needs_freset: 1; + unsigned int state_saved: 1; + unsigned int is_physfn: 1; + unsigned int is_virtfn: 1; + unsigned int reset_fn: 1; + unsigned int is_hotplug_bridge: 1; + unsigned int __aer_firmware_first_valid: 1; + unsigned int __aer_firmware_first: 1; + unsigned int broken_intx_masking: 1; + unsigned int io_window_1k: 1; + unsigned int irq_managed: 1; + unsigned int has_secondary_link: 1; + unsigned int non_compliant_bars: 1; + pci_dev_flags_t dev_flags; + atomic_t enable_cnt; + u32 saved_config_space[16]; + struct hlist_head saved_cap_space; + struct bin_attribute___2 *rom_attr; + int rom_attr_enabled; + struct bin_attribute___2 *res_attr[11]; + struct bin_attribute___2 *res_attr_wc[11]; + const struct attribute_group **msi_irq_groups; + struct pci_vpd *vpd; + union { + struct pci_sriov *sriov; + struct pci_dev *physfn; + }; + u16 ats_cap; + u8 ats_stu; + atomic_t ats_ref_cnt; + phys_addr_t rom; + size_t romlen; + char *driver_override; +}; + +struct pci_dev_acs_enabled { + u16 vendor; + u16 device; + int (*acs_enabled)(struct pci_dev *, u16); +}; + +struct pci_dev_enable_acs { + u16 vendor; + u16 device; + int (*enable_acs)(struct pci_dev *); +}; + +struct pci_dev_reset_methods { + u16 vendor; + u16 device; + int (*reset)(struct pci_dev *, int); +}; + +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; +}; + +struct pci_devres { + unsigned int enabled: 1; + unsigned int pinned: 1; + unsigned int orig_intx: 1; + unsigned int restore_intx: 1; + u32 region_mask; +}; + +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 { + struct list_head node; + 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 (*suspend_late)(struct pci_dev *, pm_message_t); + int (*resume_early)(struct pci_dev *); + int (*resume)(struct pci_dev *); + void (*shutdown)(struct pci_dev *); + int (*sriov_configure)(struct pci_dev *, int); + const struct pci_error_handlers *err_handler; + struct device_driver driver; + struct pci_dynids dynids; +}; + +struct pci_dynid { + struct list_head node; + struct pci_device_id id; +}; + +struct pci_error_handlers { + pci_ers_result_t (*error_detected)(struct pci_dev *, enum pci_channel_state); + pci_ers_result_t (*mmio_enabled)(struct pci_dev *); + pci_ers_result_t (*link_reset)(struct pci_dev *); + pci_ers_result_t (*slot_reset)(struct pci_dev *); + void (*reset_notify)(struct pci_dev *, bool); + void (*resume)(struct pci_dev *); +}; + +struct pci_extra_dev { + struct pci_dev *dev[3]; +}; + +struct pci_filp_private { + enum pci_mmap_state mmap_state; + int write_combine; +}; + +struct pci_fixup { + u16 vendor; + u16 device; + u32 class; + unsigned int class_shift; + void (*hook)(struct pci_dev *); +}; + +struct pci_host_bridge { + struct device___2 dev; + struct pci_bus *bus; + struct list_head windows; + void (*release_fn)(struct pci_host_bridge *); + void *release_data; + unsigned int ignore_reset_delay: 1; + resource_size_t (*align_resource)(struct pci_dev *, const struct resource *, resource_size_t, resource_size_t, resource_size_t); +}; + +struct pci_hostbridge_probe { + u32 bus; + u32 slot; + u32 vendor; + u32 device; +}; + +struct pci_mmcfg_hostbridge_probe { + u32 bus; + u32 devfn; + u32 vendor; + u32 device; + const char * (*probe)(void); +}; + +struct pci_mmcfg_region { + struct list_head list; + struct resource res; + u64 address; + char *virt; + u16 segment; + u8 start_bus; + u8 end_bus; + char name[30]; +}; + +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_osc_bit_struct { + u32 bit; + char *desc; +}; + +struct pci_platform_pm_ops { + bool (*is_manageable)(struct pci_dev *); + int (*set_state)(struct pci_dev *, pci_power_t); + pci_power_t (*choose_state)(struct pci_dev *); + int (*sleep_wake)(struct pci_dev *, bool); + int (*run_wake)(struct pci_dev *, bool); + bool (*need_resume)(struct pci_dev *); +}; + +struct pci_pme_device { + struct list_head list; + struct pci_dev *dev; +}; + +struct pci_raw_ops { + int (*read)(unsigned int, unsigned int, unsigned int, int, int, u32 *); + int (*write)(unsigned int, unsigned int, unsigned int, int, int, u32); +}; + +struct pci_sysdata { + int domain; + int node; + struct acpi_device *companion; + void *iommu; + void *fwnode; +}; + +struct pci_root_info { + struct acpi_pci_root_info common; + struct pci_sysdata sd; + bool mcfg_added; + u8 start_bus; + u8 end_bus; +}; + +struct pci_root_info___2 { + struct list_head list; + char name[12]; + struct list_head resources; + struct resource busn; + int node; + int link; +}; + +struct pci_root_res { + struct list_head list; + struct resource res; +}; + +struct pci_saved_state { + u32 config_space[16]; + struct pci_cap_saved_data cap[0]; +}; + +struct serial_private; + +struct pciserial_board; + +struct pci_serial_quirk { + u32 vendor; + u32 device; + u32 subvendor; + u32 subdevice; + int (*probe)(struct pci_dev *); + int (*init)(struct pci_dev *); + int (*setup)(struct serial_private *, const struct pciserial_board *, struct uart_8250_port *, int); + void (*exit)(struct pci_dev *); +}; + +struct setup_data { + __u64 next; + __u32 type; + __u32 len; + __u8 data[0]; +}; + +struct pci_setup_rom { + struct setup_data data; + uint16_t vendor; + uint16_t devid; + uint64_t pcilen; + long unsigned int segment; + long unsigned int bus; + long unsigned int device; + long unsigned int function; + uint8_t romdata[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; + u32 pgsz; + u8 link; + u8 max_VF_buses; + u16 driver_max_VFs; + struct pci_dev *dev; + struct pci_dev *self; + struct mutex___2 lock; + resource_size_t barsz[6]; +}; + +struct pci_vpd_ops; + +struct pci_vpd { + const struct pci_vpd_ops *ops; + struct bin_attribute *attr; + struct mutex___2 lock; + unsigned int len; + u16 flag; + u8 cap; + u8 busy: 1; + u8 valid: 1; +}; + +struct pci_vpd_ops { + ssize_t (*read)(struct pci_dev *, loff_t, size_t, void *); + ssize_t (*write)(struct pci_dev *, loff_t, size_t, const void *); + int (*set_size)(struct pci_dev *, size_t); +}; + +struct pcibios_fwaddrmap { + struct list_head list; + struct pci_dev *dev; + resource_size_t fw_addr[11]; +}; + +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 pcie_link_state *root; + struct pcie_link_state *parent; + struct list_head sibling; + struct list_head children; + struct list_head link; + u32 aspm_support: 3; + u32 aspm_enabled: 3; + u32 aspm_capable: 3; + u32 aspm_default: 3; + u32 aspm_disable: 3; + u32 clkpm_capable: 1; + u32 clkpm_enabled: 1; + u32 clkpm_default: 1; + struct aspm_latency latency_up; + struct aspm_latency latency_dw; + struct aspm_latency acceptable[8]; +}; + +struct pcie_pme_service_data { + spinlock_t lock; + struct pcie_device *srv; + struct work_struct work; + enum pme_suspend_level suspend_level; +}; + +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)(struct pcie_device *); + const struct pci_error_handlers *err_handler; + pci_ers_result_t (*reset_link)(struct pci_dev *); + int port_type; + u32 service; + struct device_driver driver; +}; + +struct pcim_iomap_devres { + void *table[6]; +}; + +struct pciserial_board { + unsigned int flags; + unsigned int num_ports; + unsigned int base_baud; + unsigned int uart_offset; + unsigned int reg_shift; + unsigned int first_offset; +}; + +struct pcm_format_data { + unsigned char width; + unsigned char phys; + signed char le; + signed char signd; + unsigned char silence[8]; +}; + +struct pcmcia_callback { + struct module *owner; + int (*add)(struct pcmcia_socket *); + int (*remove)(struct pcmcia_socket *); + void (*requery)(struct pcmcia_socket *); + int (*validate)(struct pcmcia_socket *, unsigned int *); + int (*suspend)(struct pcmcia_socket *); + int (*early_resume)(struct pcmcia_socket *); + int (*resume)(struct pcmcia_socket *); +}; + +struct pcmcia_device; + +struct pcmcia_cfg_mem { + struct pcmcia_device *p_dev; + int (*conf_check)(struct pcmcia_device *, void *); + void *priv_data; + cisparse_t parse; + cistpl_cftable_entry_t dflt; +}; + +struct pcmcia_device { + struct pcmcia_socket *socket; + char *devname; + u8 device_no; + u8 func; + struct config_t *function_config; + struct list_head socket_device_list; + unsigned int irq; + struct resource *resource[6]; + resource_size_t card_addr; + unsigned int vpp; + unsigned int config_flags; + unsigned int config_base; + unsigned int config_index; + unsigned int config_regs; + unsigned int io_lines; + u16 suspended: 1; + u16 _irq: 1; + u16 _io: 1; + u16 _win: 4; + u16 _locked: 1; + u16 allow_func_id_match: 1; + u16 has_manf_id: 1; + u16 has_card_id: 1; + u16 has_func_id: 1; + u16 reserved: 4; + u8 func_id; + u16 manf_id; + u16 card_id; + char *prod_id[4]; + u64 dma_mask; + struct device dev; + void *priv; + unsigned int open; +}; + +struct pcmcia_device_id { + __u16 match_flags; + __u16 manf_id; + __u16 card_id; + __u8 func_id; + __u8 function; + __u8 device_no; + __u32 prod_id_hash[4]; + const char *prod_id[4]; + kernel_ulong_t driver_info; + char *cisfile; +}; + +struct pcmcia_dynids { + struct mutex lock; + struct list_head list; +}; + +struct pcmcia_driver { + const char *name; + int (*probe)(struct pcmcia_device *); + void (*remove)(struct pcmcia_device *); + int (*suspend)(struct pcmcia_device *); + int (*resume)(struct pcmcia_device *); + struct module *owner; + const struct pcmcia_device_id *id_table; + struct device_driver drv; + struct pcmcia_dynids dynids; +}; + +struct pcmcia_dynid { + struct list_head node; + struct pcmcia_device_id id; +}; + +struct pcmcia_loop_get { + size_t len; + cisdata_t **buf; +}; + +struct tuple_t; + +typedef struct tuple_t tuple_t; + +struct pcmcia_loop_mem { + struct pcmcia_device *p_dev; + void *priv_data; + int (*loop_tuple)(struct pcmcia_device *, tuple_t *, void *); +}; + +struct socket_state_t { + u_int flags; + u_int csc_mask; + u_char Vcc; + u_char Vpp; + u_char io_irq; +}; + +struct pcmcia_socket { + struct module *owner; + socket_state_t socket; + u_int state; + u_int suspended_state; + u_short functions; + u_short lock_count; + pccard_mem_map cis_mem; + void *cis_virt; + io_window_t io[2]; + pccard_mem_map win[4]; + struct list_head cis_cache; + size_t fake_cis_len; + u8 *fake_cis; + struct list_head socket_list; + struct completion socket_released; + unsigned int sock; + u_int features; + u_int irq_mask; + u_int map_size; + u_int io_offset; + u_int pci_irq; + struct pci_dev *cb_dev; + u8 resource_setup_done; + struct pccard_operations *ops; + struct pccard_resource_ops *resource_ops; + void *resource_data; + void (*zoom_video)(struct pcmcia_socket *, int); + int (*power_hook)(struct pcmcia_socket *, int); + void (*tune_bridge)(struct pcmcia_socket *, struct pci_bus *); + struct task_struct *thread; + struct completion thread_done; + unsigned int thread_events; + unsigned int sysfs_events; + struct mutex skt_mutex; + struct mutex ops_mutex; + spinlock_t thread_lock; + struct pcmcia_callback *callback; + struct list_head devices_list; + u8 device_count; + u8 pcmcia_pfc; + atomic_t present; + unsigned int pcmcia_irq; + struct device dev; + void *driver_data; + int resume_status; +}; + +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_chunk { + struct list_head list; + int free_size; + int contig_hint; + void *base_addr; + int map_used; + int map_alloc; + int *map; + struct list_head map_extend_list; + void *data; + int first_free; + bool immutable; + int nr_populated; + long unsigned int populated[0]; +}; + +struct pcpu_freelist_head { + struct pcpu_freelist_node *first; + raw_spinlock_t lock; +}; + +struct pcpu_lstats { + u64 packets; + u64 bytes; + struct u64_stats_sync syncp; +}; + +struct pcpu_sw_netstats { + u64 rx_packets; + u64 rx_bytes; + u64 tx_packets; + u64 tx_bytes; + struct u64_stats_sync syncp; +}; + +struct pde_opener { + struct file___2 *file; + struct list_head lh; + int closing; + struct completion *c; +}; + +struct pdev_archdata {}; + +struct pebs_record_core { + u64 flags; + u64 ip; + u64 ax; + u64 bx; + u64 cx; + u64 dx; + u64 si; + u64 di; + u64 bp; + u64 sp; + u64 r8; + u64 r9; + u64 r10; + u64 r11; + u64 r12; + u64 r13; + u64 r14; + u64 r15; +}; + +struct pebs_record_nhm { + u64 flags; + u64 ip; + u64 ax; + u64 bx; + u64 cx; + u64 dx; + u64 si; + u64 di; + u64 bp; + u64 sp; + u64 r8; + u64 r9; + u64 r10; + u64 r11; + u64 r12; + u64 r13; + u64 r14; + u64 r15; + u64 status; + u64 dla; + u64 dse; + u64 lat; +}; + +struct pebs_record_skl { + u64 flags; + u64 ip; + u64 ax; + u64 bx; + u64 cx; + u64 dx; + u64 si; + u64 di; + u64 bp; + u64 sp; + u64 r8; + u64 r9; + u64 r10; + u64 r11; + u64 r12; + u64 r13; + u64 r14; + u64 r15; + u64 status; + u64 dla; + u64 dse; + u64 lat; + u64 real_ip; + u64 tsx_tuning; + u64 tsc; +}; + +struct per_cpu_pages { + int count; + int high; + int batch; + struct list_head lists[3]; +}; + +struct per_cpu_pageset { + struct per_cpu_pages pcp; + s8 expire; + s8 stat_threshold; + s8 vm_stat_diff[39]; +}; + +struct swap_cluster_info { + unsigned int data: 24; + unsigned int flags: 8; +}; + +struct percpu_cluster { + struct swap_cluster_info index; + unsigned int next; +}; + +struct percpu_ida_cpu; + +struct percpu_ida { + unsigned int nr_tags; + unsigned int percpu_max_size; + unsigned int percpu_batch_size; + struct percpu_ida_cpu *tag_cpu; + cpumask_t cpus_have_tags; + long: 64; + long: 64; + long: 64; + long: 64; + struct { + spinlock_t lock; + unsigned int cpu_last_stolen; + wait_queue_head_t wait; + unsigned int nr_free; + unsigned int *freelist; + long: 64; + long: 64; + }; +}; + +struct percpu_ida_cpu { + spinlock_t lock; + unsigned int nr_free; + unsigned int freelist[0]; +}; + +struct rcu_sync { + int gp_state; + int gp_count; + wait_queue_head_t gp_wait; + int cb_state; + struct callback_head cb_head; + enum rcu_sync_type gp_type; +}; + +struct percpu_rw_semaphore { + struct rcu_sync rss; + unsigned int *fast_read_ctr; + struct rw_semaphore rw_sem; + atomic_t slow_read_ctr; + wait_queue_head_t write_waitq; +}; + +struct percpu_rw_semaphore___2 { + struct rcu_sync rss; + unsigned int *fast_read_ctr; + struct rw_semaphore___2 rw_sem; + atomic_t slow_read_ctr; + wait_queue_head_t write_waitq; +}; + +struct perf_addr_filter { + struct list_head entry; + struct inode *inode; + long unsigned int offset; + long unsigned int size; + unsigned int range: 1; + unsigned int filter: 1; +}; + +struct perf_addr_filter___2 { + struct list_head entry; + struct inode___2 *inode; + long unsigned int offset; + long unsigned int size; + unsigned int range: 1; + unsigned int filter: 1; +}; + +struct perf_addr_filters_head { + struct list_head list; + raw_spinlock_t lock; +}; + +struct perf_amd_iommu { + struct pmu pmu; + u8 max_banks; + u8 max_counters; + u64 cntr_assign_mask; + raw_spinlock_t lock; + const struct attribute_group *attr_groups[4]; +}; + +struct perf_event_header { + __u32 type; + __u16 misc; + __u16 size; +}; + +struct perf_aux_event { + struct perf_event_header header; + u32 pid; + u32 tid; +}; + +struct perf_aux_event___2 { + struct perf_event_header header; + u64 offset; + u64 size; + u64 flags; +}; + +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; +}; + +union perf_capabilities { + struct { + u64 lbr_format: 6; + u64 pebs_trap: 1; + u64 pebs_arch_reg: 1; + u64 pebs_format: 4; + u64 smm_freeze: 1; + u64 full_width_write: 1; + }; + u64 capabilities; +}; + +struct perf_comm_event { + struct task_struct___2 *task; + char *comm; + int comm_size; + struct { + struct perf_event_header header; + u32 pid; + u32 tid; + } event_id; +}; + +struct perf_event_context___2 { + struct pmu *pmu; + raw_spinlock_t lock; + struct mutex mutex; + struct list_head active_ctx_list; + struct list_head pinned_groups; + struct list_head flexible_groups; + struct list_head event_list; + int nr_events; + int nr_active; + int is_active; + int nr_stat; + int nr_freq; + int rotate_disable; + atomic_t refcount; + struct task_struct *task; + u64 time; + u64 timestamp; + struct perf_event_context___2 *parent_ctx; + u64 parent_gen; + u64 generation; + int pin_count; + int nr_cgroups; + void *task_ctx_data; + struct callback_head callback_head; +}; + +struct perf_cgroup; + +struct perf_cpu_context___2 { + struct perf_event_context___2 ctx; + struct perf_event_context___2 *task_ctx; + int active_oncpu; + int exclusive; + raw_spinlock_t hrtimer_lock; + struct hrtimer hrtimer; + ktime_t hrtimer_interval; + unsigned int hrtimer_active; + struct pmu *unique_pmu; + struct perf_cgroup *cgrp; +}; + +struct pmu___2; + +struct perf_event_context { + struct pmu___2 *pmu; + raw_spinlock_t lock; + struct mutex___2 mutex; + struct list_head active_ctx_list; + struct list_head pinned_groups; + struct list_head flexible_groups; + struct list_head event_list; + int nr_events; + int nr_active; + int is_active; + int nr_stat; + int nr_freq; + int rotate_disable; + atomic_t refcount; + struct task_struct___2 *task; + u64 time; + u64 timestamp; + struct perf_event_context *parent_ctx; + u64 parent_gen; + u64 generation; + int pin_count; + int nr_cgroups; + void *task_ctx_data; + struct callback_head callback_head; +}; + +struct perf_cpu_context { + struct perf_event_context ctx; + struct perf_event_context *task_ctx; + int active_oncpu; + int exclusive; + raw_spinlock_t hrtimer_lock; + struct hrtimer hrtimer; + ktime_t hrtimer_interval; + unsigned int hrtimer_active; + struct pmu___2 *unique_pmu; + struct perf_cgroup *cgrp; +}; + +struct perf_pmu_events_attr; + +struct perf_cstate_msr { + u64 msr; + struct perf_pmu_events_attr *attr; +}; + +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 __reserved_1: 36; + union { + __u32 wakeup_events; + __u32 wakeup_watermark; + }; + __u32 bp_type; + union { + __u64 bp_addr; + __u64 config1; + }; + union { + __u64 bp_len; + __u64 config2; + }; + __u64 branch_sample_type; + __u64 sample_regs_user; + __u32 sample_stack_user; + __s32 clockid; + __u64 sample_regs_intr; + __u32 aux_watermark; + __u32 __reserved_2; +}; + +struct perf_sample_data; + +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 group_entry; + struct list_head sibling_list; + struct list_head migrate_entry; + struct hlist_node hlist_entry; + struct list_head active_entry; + int nr_siblings; + int group_flags; + struct perf_event *group_leader; + struct pmu *pmu; + void *pmu_private; + enum perf_event_active_state state; + unsigned int attach_state; + local64_t count; + atomic64_t child_count; + u64 total_time_enabled; + u64 total_time_running; + u64 tstamp_enabled; + u64 tstamp_running; + u64 tstamp_stopped; + u64 shadow_ctx_time; + struct perf_event_attr attr; + u16 header_size; + u16 id_header_size; + u16 read_size; + struct hw_perf_event hw; + struct perf_event_context___2 *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 ring_buffer *rb; + struct list_head rb_entry; + long unsigned int rcu_batches; + int rcu_pending; + wait_queue_head_t waitq; + struct fasync_struct *fasync; + int pending_wakeup; + int pending_kill; + int pending_disable; + struct irq_work pending; + atomic_t event_limit; + struct perf_addr_filters_head addr_filters; + long unsigned int *addr_filters_offs; + long unsigned int addr_filters_gen; + void (*destroy)(struct perf_event *); + struct callback_head callback_head; + struct pid_namespace *ns; + u64 id; + u64 (*clock)(void); + perf_overflow_handler_t overflow_handler; + void *overflow_handler_context; + struct trace_event_call *tp_event; + struct event_filter *filter; + struct ftrace_ops ftrace_ops; +}; + +typedef void (*perf_overflow_handler_t___2)(struct perf_event___2 *, struct perf_sample_data *, struct pt_regs *); + +struct ring_buffer___2; + +struct perf_event___2 { + struct list_head event_entry; + struct list_head group_entry; + struct list_head sibling_list; + struct list_head migrate_entry; + struct hlist_node hlist_entry; + struct list_head active_entry; + int nr_siblings; + int group_flags; + struct perf_event___2 *group_leader; + struct pmu___2 *pmu; + void *pmu_private; + enum perf_event_active_state state; + unsigned int attach_state; + local64_t count; + atomic64_t child_count; + u64 total_time_enabled; + u64 total_time_running; + u64 tstamp_enabled; + u64 tstamp_running; + u64 tstamp_stopped; + u64 shadow_ctx_time; + struct perf_event_attr attr; + u16 header_size; + u16 id_header_size; + u16 read_size; + struct hw_perf_event___2 hw; + struct perf_event_context *ctx; + atomic_long_t refcount; + atomic64_t child_total_time_enabled; + atomic64_t child_total_time_running; + struct mutex___2 child_mutex; + struct list_head child_list; + struct perf_event___2 *parent; + int oncpu; + int cpu; + struct list_head owner_entry; + struct task_struct___2 *owner; + struct mutex___2 mmap_mutex; + atomic_t mmap_count; + struct ring_buffer___2 *rb; + struct list_head rb_entry; + long unsigned int rcu_batches; + int rcu_pending; + wait_queue_head_t waitq; + struct fasync_struct___2 *fasync; + int pending_wakeup; + int pending_kill; + int pending_disable; + struct irq_work pending; + atomic_t event_limit; + struct perf_addr_filters_head addr_filters; + long unsigned int *addr_filters_offs; + long unsigned int addr_filters_gen; + void (*destroy)(struct perf_event___2 *); + struct callback_head callback_head; + struct pid_namespace___2 *ns; + u64 id; + u64 (*clock)(void); + perf_overflow_handler_t___2 overflow_handler; + void *overflow_handler_context; + struct trace_event_call___2 *tp_event; + struct event_filter *filter; + struct ftrace_ops___2 ftrace_ops; +}; + +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_____res: 59; + }; + }; + __u16 pmc_width; + __u16 time_shift; + __u32 time_mult; + __u64 time_offset; + __u64 time_zero; + __u32 size; + __u8 __reserved[948]; + __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_guest_info_callbacks { + int (*is_in_guest)(void); + int (*is_user_mode)(void); + long unsigned int (*get_guest_ip)(void); +}; + +struct perf_ibs { + struct pmu pmu; + unsigned int msr; + u64 config_mask; + u64 cnt_mask; + u64 enable_mask; + u64 valid_mask; + u64 max_period; + long unsigned int offset_mask[1]; + int offset_max; + struct cpu_perf_ibs *pcpu; + struct attribute **format_attrs; + struct attribute_group format_group; + const struct attribute_group *attr_groups[2]; + u64 (*get_count)(u64); +}; + +struct perf_ibs_data { + u32 size; + union { + u32 data[0]; + u32 caps; + }; + u64 regs[8]; +}; + +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_rsvd: 31; + }; +}; + +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; + struct { + struct perf_event_header header; + u32 pid; + u32 tid; + u64 start; + u64 len; + u64 pgoff; + } event_id; +}; + +struct perf_msr { + u64 msr; + struct perf_pmu_events_attr *attr; + bool (*test)(int); +}; + +struct perf_output_handle___2 { + struct perf_event___2 *event; + struct ring_buffer___2 *rb; + long unsigned int wakeup; + long unsigned int size; + union { + void *addr; + long unsigned int head; + }; + int page; +}; + +struct perf_pmu_events_attr { + struct device_attribute attr; + u64 id; + const char *event_str; +}; + +struct perf_pmu_events_attr___2 { + struct device_attribute___2 attr; + u64 id; + const char *event_str; +}; + +struct perf_raw_record { + u32 size; + void *data; +}; + +struct perf_read_data { + struct perf_event___2 *event; + bool group; + int ret; +}; + +struct perf_read_event { + struct perf_event_header header; + u32 pid; + u32 tid; +}; + +struct perf_regs { + __u64 abi; + struct pt_regs *regs; +}; + +struct perf_sample_data { + u64 addr; + struct perf_raw_record *raw; + struct perf_branch_stack *br_stack; + u64 period; + u64 weight; + u64 txn; + union perf_mem_data_src data_src; + u64 type; + u64 ip; + struct { + u32 pid; + u32 tid; + } tid_entry; + u64 time; + u64 id; + u64 stream_id; + struct { + u32 cpu; + u32 reserved; + } cpu_entry; + struct perf_callchain_entry *callchain; + struct perf_regs regs_user; + struct pt_regs regs_user_copy; + struct perf_regs regs_intr; + u64 stack_user_size; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; +}; + +struct sched_state { + int weight; + int event; + int counter; + int unassigned; + int nr_gp; + long unsigned int used[1]; +}; + +struct perf_sched { + int max_weight; + int max_events; + int max_gp; + int saved_states; + struct event_constraint **constraints; + struct sched_state state; + struct sched_state saved[2]; +}; + +struct perf_switch_event { + struct task_struct___2 *task; + struct task_struct___2 *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___2 *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 pernet_operations { + struct list_head list; + int (*init)(struct net *); + void (*exit)(struct net *); + void (*exit_batch)(struct list_head *); + int *id; + size_t size; +}; + +struct pfifo_fast_priv { + u32 bitmap; + struct sk_buff_head q[3]; +}; + +struct zone_padding { + char x[0]; +}; + +struct pglist_data; + +struct zone___2 { + long unsigned int watermark[3]; + long unsigned int nr_reserved_highatomic; + long int lowmem_reserve[4]; + int node; + unsigned int inactive_ratio; + struct pglist_data *zone_pgdat; + struct per_cpu_pageset *pageset; + long unsigned int totalreserve_pages; + long unsigned int min_unmapped_pages; + long unsigned int min_slab_pages; + long unsigned int zone_start_pfn; + long unsigned int managed_pages; + long unsigned int spanned_pages; + long unsigned int present_pages; + const char *name; + long unsigned int nr_isolate_pageblock; + seqlock_t span_seqlock; + wait_queue_head_t *wait_table; + long unsigned int wait_table_hash_nr_entries; + long unsigned int wait_table_bits; + struct zone_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; + struct zone_padding _pad2_; + spinlock_t lru_lock; + struct lruvec lruvec; + long unsigned int percpu_drift_mark; + long unsigned int compact_cached_free_pfn; + long unsigned int compact_cached_migrate_pfn[2]; + unsigned int compact_considered; + unsigned int compact_defer_shift; + int compact_order_failed; + bool compact_blockskip_flush; + bool contiguous; + long: 64; + long: 64; + struct zone_padding _pad3_; + atomic_long_t vm_stat[39]; + long: 64; +}; + +struct zoneref___2 { + struct zone___2 *zone; + int zone_idx; +}; + +struct zonelist___2 { + struct zoneref___2 _zonerefs[257]; +}; + +struct pglist_data { + struct zone___2 node_zones[4]; + struct zonelist___2 node_zonelists[2]; + int nr_zones; + spinlock_t node_size_lock; + 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; + struct task_struct *kswapd; + int kswapd_max_order; + enum zone_type classzone_idx; + int kcompactd_max_order; + enum zone_type kcompactd_classzone_idx; + wait_queue_head_t kcompactd_wait; + struct task_struct *kcompactd; + long: 64; + long: 64; +}; + +typedef struct pglist_data pg_data_t; + +struct pglist_data___2; + +struct zone { + long unsigned int watermark[3]; + long unsigned int nr_reserved_highatomic; + long int lowmem_reserve[4]; + int node; + unsigned int inactive_ratio; + struct pglist_data___2 *zone_pgdat; + struct per_cpu_pageset *pageset; + long unsigned int totalreserve_pages; + long unsigned int min_unmapped_pages; + long unsigned int min_slab_pages; + long unsigned int zone_start_pfn; + long unsigned int managed_pages; + long unsigned int spanned_pages; + long unsigned int present_pages; + const char *name; + long unsigned int nr_isolate_pageblock; + seqlock_t span_seqlock; + wait_queue_head_t *wait_table; + long unsigned int wait_table_hash_nr_entries; + long unsigned int wait_table_bits; + struct zone_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; + struct zone_padding _pad2_; + spinlock_t lru_lock; + struct lruvec lruvec; + long unsigned int percpu_drift_mark; + long unsigned int compact_cached_free_pfn; + long unsigned int compact_cached_migrate_pfn[2]; + unsigned int compact_considered; + unsigned int compact_defer_shift; + int compact_order_failed; + bool compact_blockskip_flush; + bool contiguous; + long: 64; + long: 64; + struct zone_padding _pad3_; + atomic_long_t vm_stat[39]; + long: 64; +}; + +struct zoneref { + struct zone *zone; + int zone_idx; +}; + +struct zonelist { + struct zoneref _zonerefs[257]; +}; + +struct pglist_data___2 { + struct zone node_zones[4]; + struct zonelist node_zonelists[2]; + int nr_zones; + spinlock_t node_size_lock; + 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; + struct task_struct___2 *kswapd; + int kswapd_max_order; + enum zone_type classzone_idx; + int kcompactd_max_order; + enum zone_type kcompactd_classzone_idx; + wait_queue_head_t kcompactd_wait; + struct task_struct___2 *kcompactd; + long: 64; + long: 64; +}; + +typedef struct pglist_data___2 pg_data_t___2; + +struct pgv { + char *buffer; +}; + +struct phy_attrs { + u32 bus_width; +}; + +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 phy_c45_device_ids { + u32 devices_in_package; + u32 device_ids[8]; +}; + +struct phy_driver; + +struct phy_device { + struct mdio_device mdio; + struct phy_driver *drv; + u32 phy_id; + struct phy_c45_device_ids c45_ids; + bool is_c45; + bool is_internal; + bool is_pseudo_fixed_link; + bool has_fixups; + bool suspended; + enum phy_state state; + u32 dev_flags; + phy_interface_t interface; + int speed; + int duplex; + int pause; + int asym_pause; + int link; + u32 interrupts; + u32 supported; + u32 advertising; + u32 lp_advertising; + int autoneg; + int link_timeout; + int irq; + void *priv; + struct work_struct phy_queue; + struct delayed_work state_queue; + atomic_t irq_disable; + struct mutex lock; + struct net_device *attached_dev; + u8 mdix; + void (*adjust_link)(struct net_device *); +}; + +struct phy_driver___2; + +struct phy_device___2 { + struct mdio_device___2 mdio; + struct phy_driver___2 *drv; + u32 phy_id; + struct phy_c45_device_ids c45_ids; + bool is_c45; + bool is_internal; + bool is_pseudo_fixed_link; + bool has_fixups; + bool suspended; + enum phy_state state; + u32 dev_flags; + phy_interface_t interface; + int speed; + int duplex; + int pause; + int asym_pause; + int link; + u32 interrupts; + u32 supported; + u32 advertising; + u32 lp_advertising; + int autoneg; + int link_timeout; + int irq; + void *priv; + struct work_struct phy_queue; + struct delayed_work state_queue; + atomic_t irq_disable; + struct mutex___2 lock; + struct net_device___2 *attached_dev; + u8 mdix; + void (*adjust_link)(struct net_device___2 *); +}; + +struct phy_driver { + struct mdio_driver_common mdiodrv; + u32 phy_id; + char *name; + unsigned int phy_id_mask; + u32 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 (*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 (*ack_interrupt)(struct phy_device *); + int (*config_intr)(struct phy_device *); + int (*did_interrupt)(struct phy_device *); + void (*remove)(struct phy_device *); + int (*match_phy_device)(struct phy_device *); + int (*ts_info)(struct phy_device *, struct ethtool_ts_info *); + int (*hwtstamp)(struct phy_device *, struct ifreq *); + bool (*rxtstamp)(struct phy_device *, struct sk_buff *, int); + void (*txtstamp)(struct phy_device *, struct sk_buff *, int); + 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_indirect)(struct phy_device *, int, int, int); + void (*write_mmd_indirect)(struct phy_device *, int, int, int, u32); + int (*module_info)(struct phy_device *, struct ethtool_modinfo *); + int (*module_eeprom)(struct phy_device *, struct ethtool_eeprom *, u8 *); + int (*get_sset_count)(struct phy_device *); + void (*get_strings)(struct phy_device *, u8 *); + void (*get_stats)(struct phy_device *, struct ethtool_stats *, u64 *); +}; + +struct phy_driver___2 { + struct mdio_driver_common___2 mdiodrv; + u32 phy_id; + char *name; + unsigned int phy_id_mask; + u32 features; + u32 flags; + const void *driver_data; + int (*soft_reset)(struct phy_device___2 *); + int (*config_init)(struct phy_device___2 *); + int (*probe)(struct phy_device___2 *); + int (*suspend)(struct phy_device___2 *); + int (*resume)(struct phy_device___2 *); + int (*config_aneg)(struct phy_device___2 *); + int (*aneg_done)(struct phy_device___2 *); + int (*read_status)(struct phy_device___2 *); + int (*ack_interrupt)(struct phy_device___2 *); + int (*config_intr)(struct phy_device___2 *); + int (*did_interrupt)(struct phy_device___2 *); + void (*remove)(struct phy_device___2 *); + int (*match_phy_device)(struct phy_device___2 *); + int (*ts_info)(struct phy_device___2 *, struct ethtool_ts_info *); + int (*hwtstamp)(struct phy_device___2 *, struct ifreq *); + bool (*rxtstamp)(struct phy_device___2 *, struct sk_buff___2 *, int); + void (*txtstamp)(struct phy_device___2 *, struct sk_buff___2 *, int); + int (*set_wol)(struct phy_device___2 *, struct ethtool_wolinfo *); + void (*get_wol)(struct phy_device___2 *, struct ethtool_wolinfo *); + void (*link_change_notify)(struct phy_device___2 *); + int (*read_mmd_indirect)(struct phy_device___2 *, int, int, int); + void (*write_mmd_indirect)(struct phy_device___2 *, int, int, int, u32); + int (*module_info)(struct phy_device___2 *, struct ethtool_modinfo *); + int (*module_eeprom)(struct phy_device___2 *, struct ethtool_eeprom *, u8 *); + int (*get_sset_count)(struct phy_device___2 *); + void (*get_strings)(struct phy_device___2 *, u8 *); + void (*get_stats)(struct phy_device___2 *, struct ethtool_stats *, u64 *); +}; + +struct phy_fixup { + struct list_head list; + char bus_id[20]; + u32 phy_uid; + u32 phy_uid_mask; + int (*run)(struct phy_device *); +}; + +struct phy_ops { + int (*init)(struct phy *); + int (*exit)(struct phy *); + int (*power_on)(struct phy *); + int (*power_off)(struct phy *); + struct module *owner; +}; + +struct phy_setting { + int speed; + int duplex; + u32 setting; +}; + +struct physid_mask { + long unsigned int mask[512]; +}; + +struct pi_desc { + u32 pir[8]; + union { + struct { + u16 on: 1; + u16 sn: 1; + u16 rsvd_1: 14; + u8 nv; + u8 rsvd_2; + u32 ndst; + }; + u64 control; + }; + u32 rsvd[6]; +}; + +struct upid { + int nr; + struct pid_namespace *ns; + struct hlist_node pid_chain; +}; + +struct pid___2 { + atomic_t count; + unsigned int level; + struct hlist_head tasks[3]; + struct callback_head rcu; + struct upid numbers[1]; +}; + +struct upid___2 { + int nr; + struct pid_namespace___2 *ns; + struct hlist_node pid_chain; +}; + +struct pid { + atomic_t count; + unsigned int level; + struct hlist_head tasks[3]; + struct callback_head rcu; + struct upid___2 numbers[1]; +}; + +struct pid_cache { + int nr_ids; + char name[16]; + struct kmem_cache *cachep; + struct list_head list; +}; + +union proc_op { + int (*proc_get_link)(struct dentry___2 *, struct path___2 *); + int (*proc_show)(struct seq_file *, struct pid_namespace *, struct pid___2 *, struct task_struct *); +}; + +struct pid_entry { + const char *name; + int len; + umode_t mode; + const struct inode_operations *iop; + const struct file_operations *fop; + union proc_op op; +}; + +struct pid_link { + struct hlist_node node; + struct pid___2 *pid; +}; + +struct pid_link___2 { + struct hlist_node node; + struct pid *pid; +}; + +struct pidmap { + atomic_t nr_free; + void *page; +}; + +struct pid_namespace { + struct kref kref; + struct pidmap pidmap[128]; + struct callback_head rcu; + int last_pid; + unsigned int nr_hashed; + struct task_struct *child_reaper; + struct kmem_cache *pid_cachep; + unsigned int level; + struct pid_namespace *parent; + struct vfsmount *proc_mnt; + struct dentry___2 *proc_self; + struct dentry___2 *proc_thread_self; + struct fs_pin *bacct; + struct user_namespace *user_ns; + struct work_struct proc_work; + kgid_t pid_gid; + int hide_pid; + int reboot; + struct ns_common ns; +}; + +struct pid_namespace___2 { + struct kref kref; + struct pidmap pidmap[128]; + struct callback_head rcu; + int last_pid; + unsigned int nr_hashed; + struct task_struct___2 *child_reaper; + struct kmem_cache *pid_cachep; + unsigned int level; + struct pid_namespace___2 *parent; + struct vfsmount *proc_mnt; + struct dentry *proc_self; + struct dentry *proc_thread_self; + struct fs_pin *bacct; + struct user_namespace *user_ns; + struct work_struct proc_work; + kgid_t pid_gid; + int hide_pid; + int reboot; + struct ns_common ns; +}; + +struct piix_host_priv { + const int *map; + u32 saved_iocfg; + void *sidpr; +}; + +struct piix_map_db { + const u32 mask; + const u16 port_enable; + const int map[0]; +}; + +struct pimreghdr { + __u8 type; + __u8 reserved; + __be16 csum; + __be32 flags; +}; + +struct pin_cookie {}; + +struct ping_iter_state { + struct seq_net_private p; + int bucket; + sa_family_t family; +}; + +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 ping_seq_afinfo { + char *name; + sa_family_t family; + const struct file_operations___2 *seq_fops; + const struct seq_operations seq_ops; +}; + +struct ping_table { + struct hlist_nulls_head hash[64]; + rwlock_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 pipe_buf_operations { + int can_merge; + int (*confirm)(struct pipe_inode_info___2 *, struct pipe_buffer *); + void (*release)(struct pipe_inode_info___2 *, struct pipe_buffer *); + int (*steal)(struct pipe_inode_info___2 *, struct pipe_buffer *); + void (*get)(struct pipe_inode_info___2 *, struct pipe_buffer *); +}; + +struct pipe_buffer___2; + +struct pipe_buf_operations___2 { + int can_merge; + int (*confirm)(struct pipe_inode_info *, struct pipe_buffer___2 *); + void (*release)(struct pipe_inode_info *, struct pipe_buffer___2 *); + int (*steal)(struct pipe_inode_info *, struct pipe_buffer___2 *); + void (*get)(struct pipe_inode_info *, struct pipe_buffer___2 *); +}; + +struct pipe_buffer { + struct page___2 *page; + unsigned int offset; + unsigned int len; + const struct pipe_buf_operations *ops; + unsigned int flags; + long unsigned int private; +}; + +struct pipe_buffer___2 { + struct page *page; + unsigned int offset; + unsigned int len; + const struct pipe_buf_operations___2 *ops; + unsigned int flags; + long unsigned int private; +}; + +struct pipe_crc_info { + const char *name; + struct drm_device *dev; + enum pipe pipe; +}; + +struct pipe_inode_info___2 { + struct mutex mutex; + wait_queue_head_t wait; + unsigned int nrbufs; + unsigned int curbuf; + unsigned int buffers; + unsigned int readers; + unsigned int writers; + unsigned int files; + unsigned int waiting_writers; + unsigned int r_counter; + unsigned int w_counter; + struct page___2 *tmp_page; + struct fasync_struct *fasync_readers; + struct fasync_struct *fasync_writers; + struct pipe_buffer *bufs; + struct user_struct *user; +}; + +struct pipe_inode_info { + struct mutex___2 mutex; + wait_queue_head_t wait; + unsigned int nrbufs; + unsigned int curbuf; + unsigned int buffers; + unsigned int readers; + unsigned int writers; + unsigned int files; + unsigned int waiting_writers; + unsigned int r_counter; + unsigned int w_counter; + struct page *tmp_page; + struct fasync_struct___2 *fasync_readers; + struct fasync_struct___2 *fasync_writers; + struct pipe_buffer___2 *bufs; + struct user_struct___2 *user; +}; + +struct pkru_state { + u32 pkru; + u32 pad; +}; + +struct plat_serial8250_port { + long unsigned int iobase; + void *membase; + resource_size_t mapbase; + unsigned int irq; + long unsigned int irqflags; + unsigned int uartclk; + void *private_data; + unsigned char regshift; + unsigned char iotype; + unsigned char hub6; + upf_t flags; + unsigned int type; + unsigned int (*serial_in)(struct uart_port *, int); + void (*serial_out)(struct uart_port *, int, int); + void (*set_termios)(struct uart_port *, struct ktermios *, 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 mfd_cell; + +struct platform_device_id; + +struct platform_device { + const char *name; + int id; + bool id_auto; + struct device dev; + u32 num_resources; + struct resource *resource; + const struct platform_device_id *id_entry; + char *driver_override; + struct mfd_cell *mfd_cell; + struct pdev_archdata archdata; +}; + +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; + const char *name; + int id; + const struct resource *res; + unsigned int num_res; + const void *data; + size_t size_data; + u64 dma_mask; + struct property_entry *properties; +}; + +struct platform_driver { + int (*probe)(struct platform_device *); + int (*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; +}; + +struct platform_freeze_ops { + int (*begin)(void); + int (*prepare)(void); + void (*restore)(void); + void (*end)(void); +}; + +struct platform_hibernation_ops { + int (*begin)(void); + void (*end)(void); + int (*pre_snapshot)(void); + void (*finish)(void); + int (*prepare)(void); + int (*enter)(void); + void (*leave)(void); + int (*pre_restore)(void); + void (*restore_cleanup)(void); + void (*recover)(void); +}; + +typedef void (*irq_write_msi_msg_t)(struct msi_desc *, struct msi_msg *); + +struct platform_msi_priv_data { + struct device *dev; + void *host_data; + msi_alloc_info_t arg; + irq_write_msi_msg_t write_msg; + int devid; +}; + +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 pm_qos_object { + struct pm_qos_constraints *constraints; + struct miscdevice pm_qos_power_miscdev; + char *name; +}; + +struct pm_subsys_data { + spinlock_t lock; + unsigned int refcount; +}; + +struct pm_vt_switch { + struct list_head head; + struct device *dev; + bool required; +}; + +struct pmc_bit_map { + const char *name; + u32 bit_mask; +}; + +struct pmc_reg_map; + +struct pmc_dev { + u32 base_addr; + void *regmap; + const struct pmc_reg_map *map; + struct dentry___2 *dbgfs_dir; + bool init; +}; + +struct pmc_reg_map { + const struct pmc_bit_map *d3_sts_0; + const struct pmc_bit_map *d3_sts_1; + const struct pmc_bit_map *func_dis; + const struct pmc_bit_map *func_dis_2; + const struct pmc_bit_map *pss; +}; + +struct pmu___2 { + struct list_head entry; + struct module___2 *module; + struct device___2 *dev; + const struct attribute_group___2 **attr_groups; + const char *name; + int type; + int capabilities; + int *pmu_disable_count; + struct perf_cpu_context *pmu_cpu_context; + atomic_t exclusive_cnt; + int task_ctx_nr; + int hrtimer_interval_ms; + unsigned int nr_addr_filters; + void (*pmu_enable)(struct pmu___2 *); + void (*pmu_disable)(struct pmu___2 *); + int (*event_init)(struct perf_event___2 *); + void (*event_mapped)(struct perf_event___2 *); + void (*event_unmapped)(struct perf_event___2 *); + int (*add)(struct perf_event___2 *, int); + void (*del)(struct perf_event___2 *, int); + void (*start)(struct perf_event___2 *, int); + void (*stop)(struct perf_event___2 *, int); + void (*read)(struct perf_event___2 *); + void (*start_txn)(struct pmu___2 *, unsigned int); + int (*commit_txn)(struct pmu___2 *); + void (*cancel_txn)(struct pmu___2 *); + int (*event_idx)(struct perf_event___2 *); + void (*sched_task)(struct perf_event_context *, bool); + size_t task_ctx_size; + u64 (*count)(struct perf_event___2 *); + void * (*setup_aux)(int, void **, int, bool); + void (*free_aux)(void *); + int (*addr_filters_validate)(struct list_head *); + void (*addr_filters_sync)(struct perf_event___2 *); + int (*filter_match)(struct perf_event___2 *); +}; + +struct pneigh_entry { + struct pneigh_entry *next; + possible_net_t net; + struct net_device *dev; + u8 flags; + u8 key[0]; +}; + +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_driver { + 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_dma { + unsigned char map; + unsigned char flags; +}; + +struct pnp_fixup { + char id[7]; + void (*quirk_function)(struct pnp_dev *); +}; + +struct pnp_id { + char id[8]; + struct pnp_id *next; +}; + +struct pnp_info_buffer { + char *buffer; + char *curr; + long unsigned int size; + long unsigned int len; + int stop; + int error; +}; + +typedef struct pnp_info_buffer pnp_info_buffer_t; + +struct pnp_irq { + pnp_irq_mask_t map; + unsigned char flags; +}; + +struct pnp_mem { + resource_size_t min; + resource_size_t max; + resource_size_t align; + resource_size_t size; + unsigned char flags; +}; + +struct pnp_port { + resource_size_t min; + resource_size_t max; + resource_size_t align; + resource_size_t size; + unsigned char flags; +}; + +struct pnp_option { + struct list_head list; + unsigned int flags; + long unsigned int type; + union { + struct pnp_port port; + struct pnp_irq irq; + struct pnp_dma dma; + struct pnp_mem mem; + } u; +}; + +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 pnp_resource { + struct list_head list; + struct resource res; +}; + +struct pollfd { + int fd; + short int events; + short int revents; +}; + +struct poll_list { + struct poll_list *next; + int len; + struct pollfd entries[0]; +}; + +struct poll_table_entry { + struct file___2 *filp; + long unsigned int key; + wait_queue_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]; +}; + +typedef void (*poll_queue_proc___2)(struct file *, wait_queue_head_t *, struct poll_table_struct___2 *); + +struct poll_table_struct___2 { + poll_queue_proc___2 _qproc; + long unsigned int _key; +}; + +typedef struct poll_table_struct___2 poll_table___2; + +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[15]; + int nr_active; + int max_active; + struct list_head delayed_works; + struct list_head pwqs_node; + struct list_head mayday_node; + struct work_struct unbound_release_work; + struct callback_head rcu; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; +}; + +struct poolinfo { + int poolbitshift; + int poolwords; + int poolbytes; + int poolbits; + int poolfracbits; + int tap1; + int tap2; + int tap3; + int tap4; + int tap5; +}; + +struct port_stats { + long unsigned int bytes_sent; + long unsigned int bytes_received; + long unsigned int bytes_discarded; +}; + +struct ports_device; + +struct port_buffer; + +struct virtqueue; + +struct port___2 { + struct list_head list; + struct ports_device *portdev; + struct port_buffer *inbuf; + spinlock_t inbuf_lock; + spinlock_t outvq_lock; + struct virtqueue *in_vq; + struct virtqueue *out_vq; + struct dentry *debugfs_file; + struct port_stats stats; + struct console___2 cons; + struct cdev *cdev; + struct device *dev; + struct kref kref; + wait_queue_head_t waitqueue; + char *name; + struct fasync_struct___2 *async_queue; + u32 id; + bool outvq_full; + bool host_connected; + bool guest_connected; +}; + +struct port_buffer { + char *buf; + size_t size; + size_t len; + size_t offset; + dma_addr_t dma; + struct device *dev; + struct list_head list; + unsigned int sgpages; + struct scatterlist sg[0]; +}; + +struct virtio_console_config { + __u16 cols; + __u16 rows; + __u32 max_nr_ports; + __u32 emerg_wr; +}; + +struct ports_device { + struct list_head list; + struct work_struct control_work; + struct work_struct config_work; + struct list_head ports; + spinlock_t ports_lock; + spinlock_t c_ivq_lock; + spinlock_t c_ovq_lock; + struct virtio_console_config config; + struct virtio_device *vdev; + struct virtqueue *c_ivq; + struct virtqueue *c_ovq; + struct virtqueue **in_vqs; + struct virtqueue **out_vqs; + int chr_major; +}; + +struct ports_driver_data { + struct class *class; + struct dentry *debugfs_dir; + struct list_head portdevs; + unsigned int next_vtermno; + struct list_head consoles; +}; + +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 { + union { + atomic_t a_refcount; + struct callback_head a_rcu; + }; + unsigned int a_count; + struct posix_acl_entry a_entries[0]; +}; + +struct posix_clock; + +struct posix_clock_operations { + struct module *owner; + int (*clock_adjtime)(struct posix_clock *, struct timex *); + int (*clock_gettime)(struct posix_clock *, struct timespec *); + int (*clock_getres)(struct posix_clock *, struct timespec *); + int (*clock_settime)(struct posix_clock *, const struct timespec *); + int (*timer_create)(struct posix_clock *, struct k_itimer *); + int (*timer_delete)(struct posix_clock *, struct k_itimer *); + void (*timer_gettime)(struct posix_clock *, struct k_itimer *, struct itimerspec *); + int (*timer_settime)(struct posix_clock *, struct k_itimer *, int, struct itimerspec *, struct itimerspec *); + int (*fasync)(struct posix_clock *, int, struct file___2 *, int); + long int (*ioctl)(struct posix_clock *, unsigned int, long unsigned int); + int (*mmap)(struct posix_clock *, struct vm_area_struct___2 *); + int (*open)(struct posix_clock *, fmode_t); + uint (*poll)(struct posix_clock *, struct file___2 *, poll_table *); + int (*release)(struct posix_clock *); + ssize_t (*read)(struct posix_clock *, uint, char *, size_t); +}; + +struct posix_clock { + struct posix_clock_operations ops; + struct cdev cdev; + struct kref kref; + struct rw_semaphore rwsem; + bool zombie; + void (*release)(struct posix_clock *); +}; + +struct posix_clock_desc { + struct file___2 *fp; + struct posix_clock *clk; +}; + +struct posix_msg_tree_node { + struct rb_node rb_node; + struct list_head msg_list; + int priority; +}; + +struct postfix_elt { + int op; + char *operand; + struct list_head list; +}; + +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___2 dev; + struct work_struct changed_work; + struct delayed_work deferred_register_work; + spinlock_t changed_lock; + bool changed; + atomic_t use_cnt; + struct thermal_zone_device *tzd; + struct thermal_cooling_device *tcd; + struct led_trigger *charging_full_trig; + char *charging_full_trig_name; + struct led_trigger *charging_trig; + char *charging_trig_name; + struct led_trigger *full_trig; + char *full_trig_name; + struct led_trigger *online_trig; + char *online_trig_name; + struct led_trigger *charging_blink_full_solid_trig; + char *charging_blink_full_solid_trig_name; +}; + +struct power_supply_config { + struct device_node *of_node; + void *drv_data; + char **supplied_to; + size_t num_supplicants; +}; + +union power_supply_propval { + int intval; + const char *strval; +}; + +struct ppp_idle { + __kernel_time_t xmit_idle; + __kernel_time_t recv_idle; +}; + +struct ppp_idle32 { + compat_time_t xmit_idle; + compat_time_t recv_idle; +}; + +struct ppp_option_data { + __u8 *ptr; + __u32 length; + int transmit; +}; + +struct ppp_option_data32 { + compat_caddr_t ptr; + u32 length; + compat_int_t transmit; +}; + +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 cdev cdev; + struct device *dev; + struct fasync_struct *async_queue; + spinlock_t lock; +}; + +struct pps_event_time { + struct timespec 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 pr_clear { + __u64 key; + __u32 flags; + __u32 __pad; +}; + +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); +}; + +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 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 pred_stack { + struct filter_pred **preds; + int index; +}; + +struct preempt_ops { + void (*sched_in)(struct preempt_notifier *, int); + void (*sched_out)(struct preempt_notifier *, struct task_struct *); +}; + +struct prev_cputime { + cputime_t utime; + cputime_t stime; + raw_spinlock_t lock; +}; + +struct print_entry { + struct trace_entry ent; + long unsigned int ip; + char buf[0]; +}; + +struct printf_spec { + unsigned int type: 8; + int field_width: 24; + unsigned int flags: 8; + unsigned int base: 8; + int precision: 16; +}; + +struct printk_log { + u64 ts_nsec; + u16 len; + u16 text_len; + u16 dict_len; + u8 facility; + u8 flags: 5; + u8 level: 3; +}; + +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_param fetch; + struct fetch_param fetch_size; + unsigned int offset; + const char *name; + const char *comm; + const struct fetch_type *type; +}; + +struct proc_dir_entry { + unsigned int low_ino; + umode_t mode; + nlink_t nlink; + kuid_t uid; + kgid_t gid; + loff_t size; + const struct inode_operations___2 *proc_iops; + const struct file_operations *proc_fops; + struct proc_dir_entry *parent; + struct rb_root subdir; + struct rb_node subdir_node; + void *data; + atomic_t count; + atomic_t in_use; + struct completion *pde_unload_completion; + struct list_head pde_openers; + spinlock_t pde_unload_lock; + u8 namelen; + char name[0]; +}; + +struct sid_proc_event { + __kernel_pid_t process_pid; + __kernel_pid_t process_tgid; +}; + +struct ptrace_proc_event { + __kernel_pid_t process_pid; + __kernel_pid_t process_tgid; + __kernel_pid_t tracer_pid; + __kernel_pid_t tracer_tgid; +}; + +struct proc_event { + enum what what; + __u32 cpu; + __u64 timestamp_ns; + union { + struct { + __u32 err; + } ack; + struct fork_proc_event fork; + struct exec_proc_event exec; + struct id_proc_event id; + struct sid_proc_event sid; + struct ptrace_proc_event ptrace; + struct comm_proc_event comm; + struct coredump_proc_event coredump; + struct exit_proc_event exit; + } event_data; +}; + +struct proc_fs_info { + int flag; + const char *str; +}; + +struct proc_inode { + struct pid___2 *pid; + int fd; + union proc_op op; + struct proc_dir_entry *pde; + struct ctl_table_header___2 *sysctl; + struct ctl_table *sysctl_entry; + const struct proc_ns_operations *ns_ops; + struct inode vfs_inode; +}; + +struct proc_mounts { + struct mnt_namespace *ns; + struct path___2 root; + int (*show)(struct seq_file *, struct vfsmount *); + void *cached_mount; + u64 cached_event; + loff_t cached_index; +}; + +struct proc_ns_operations { + const char *name; + int type; + struct ns_common * (*get)(struct task_struct *); + void (*put)(struct ns_common *); + int (*install)(struct nsproxy *, struct ns_common *); +}; + +struct profile_hit { + u32 pc; + u32 hits; +}; + +struct property { + char *name; + int length; + void *value; + struct property *next; + long unsigned int _flags; + unsigned int unique_id; + struct bin_attribute___2 attr; +}; + +struct property___2 { + char *name; + int length; + void *value; + struct property___2 *next; + long unsigned int _flags; + unsigned int unique_id; + struct bin_attribute attr; +}; + +struct property_entry { + const char *name; + size_t length; + bool is_array; + bool is_string; + union { + union { + void *raw_data; + u8 *u8_data; + u16 *u16_data; + u32 *u32_data; + u64 *u64_data; + const char **str; + } pointer; + union { + long long unsigned int raw_data; + u8 u8_data; + u16 u16_data; + u32 u32_data; + u64 u64_data; + const char *str; + } value; + }; +}; + +struct property_set { + struct fwnode_handle fwnode; + struct property_entry *properties; +}; + +struct prot_inuse { + int val[64]; +}; + +struct timewait_sock_ops; + +struct udp_table; + +struct raw_hashinfo; + +struct proto { + void (*close)(struct sock *, long int); + int (*connect)(struct sock *, struct sockaddr *, int); + int (*disconnect)(struct sock *, int); + struct sock * (*accept)(struct sock *, int, int *); + int (*ioctl)(struct sock *, int, long unsigned int); + int (*init)(struct sock *); + void (*destroy)(struct sock *); + void (*shutdown)(struct sock *, int); + int (*setsockopt)(struct sock *, int, int, char *, unsigned int); + int (*getsockopt)(struct sock *, int, int, char *, int *); + int (*compat_setsockopt)(struct sock *, int, int, char *, unsigned int); + int (*compat_getsockopt)(struct sock *, int, int, char *, 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, int *); + int (*sendpage)(struct sock *, struct page___2 *, int, size_t, int); + int (*bind)(struct sock *, struct sockaddr *, int); + int (*backlog_rcv)(struct sock *, struct sk_buff *); + 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 (*clear_sk)(struct sock *, int); + unsigned int inuse_idx; + bool (*stream_memory_free)(const struct sock *); + void (*enter_memory_pressure)(struct sock *); + atomic_long_t *memory_allocated; + struct percpu_counter *sockets_allocated; + int *memory_pressure; + long int *sysctl_mem; + int *sysctl_wmem; + int *sysctl_rmem; + int max_header; + bool no_autobind; + struct kmem_cache *slab; + unsigned int obj_size; + int slab_flags; + struct percpu_counter *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; + } h; + struct module *owner; + char name[32]; + struct list_head node; + int (*diag_destroy)(struct sock *, int); +}; + +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 *, int); + int (*getname)(struct socket *, struct sockaddr *, int *, int); + unsigned int (*poll)(struct file___2 *, 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 (*listen)(struct socket *, int); + int (*shutdown)(struct socket *, int); + int (*setsockopt)(struct socket *, int, int, char *, unsigned int); + int (*getsockopt)(struct socket *, int, int, char *, int *); + int (*compat_setsockopt)(struct socket *, int, int, char *, unsigned int); + int (*compat_getsockopt)(struct socket *, int, int, char *, int *); + int (*sendmsg)(struct socket *, struct msghdr *, size_t); + int (*recvmsg)(struct socket *, struct msghdr *, size_t, int); + int (*mmap)(struct file___2 *, struct socket *, struct vm_area_struct___2 *); + ssize_t (*sendpage)(struct socket *, struct page___2 *, int, size_t, int); + ssize_t (*splice_read)(struct socket *, loff_t *, struct pipe_inode_info___2 *, size_t, unsigned int); + int (*set_peek_off)(struct sock *, int); +}; + +struct prt_quirk { + const struct dmi_system_id *system; + unsigned int segment; + unsigned int bus; + unsigned int device; + unsigned char pin; + const char *source; + const char *actual_source; +}; + +struct ps2pp_info { + u8 model; + u8 kind; + u16 features; +}; + +struct psched_ratecfg { + u64 rate_bytes_ps; + u32 mult; + u16 overhead; + u8 linklayer; + u8 shift; +}; + +struct psmouse { + void *private; + struct input_dev *dev; + struct ps2dev ps2dev; + struct delayed_work resync_work; + char *vendor; + char *name; + unsigned char packet[8]; + unsigned char badbyte; + unsigned char pktcnt; + unsigned char pktsize; + unsigned char type; + bool ignore_parity; + bool acks_disable_command; + unsigned int model; + long unsigned int last; + long unsigned int out_of_sync_cnt; + long unsigned int num_resyncs; + enum psmouse_state state; + char devname[64]; + char phys[32]; + unsigned int rate; + unsigned int resolution; + unsigned int resetafter; + unsigned int resync_time; + bool smartscroll; + psmouse_ret_t (*protocol_handler)(struct psmouse *); + void (*set_rate)(struct psmouse *, unsigned int); + void (*set_resolution)(struct psmouse *, unsigned int); + void (*set_scale)(struct psmouse *, enum psmouse_scale); + int (*reconnect)(struct psmouse *); + void (*disconnect)(struct psmouse *); + void (*cleanup)(struct psmouse *); + int (*poll)(struct psmouse *); + void (*pt_activate)(struct psmouse *); + void (*pt_deactivate)(struct psmouse *); +}; + +struct psmouse_attribute { + struct device_attribute dattr; + void *data; + ssize_t (*show)(struct psmouse *, void *, char *); + ssize_t (*set)(struct psmouse *, void *, const char *, size_t); + bool protect; +}; + +struct psmouse_protocol { + enum psmouse_type type; + bool maxproto; + bool ignore_parity; + bool try_passthru; + const char *name; + const char *alias; + int (*detect)(struct psmouse *, bool); + int (*init)(struct psmouse *); +}; + +struct pt_filter { + long unsigned int msr_a; + long unsigned int msr_b; + long unsigned int config; +}; + +struct pt_filters { + struct pt_filter filter[4]; + unsigned int nr_filters; +}; + +struct pt { + struct perf_output_handle handle; + struct pt_filters filters; + int handle_nmi; + int vmx_on; +}; + +struct pt_address_range { + long unsigned int msr_a; + long unsigned int msr_b; + unsigned int reg_off; +}; + +struct topa; + +struct topa_entry; + +struct pt_buffer { + int cpu; + struct list_head tables; + struct topa *first; + struct topa *last; + struct topa *cur; + unsigned int cur_idx; + size_t output_off; + long unsigned int nr_pages; + local_t data_size; + local_t lost; + local64_t head; + bool snapshot; + long unsigned int stop_pos; + long unsigned int intr_pos; + void **data_pages; + struct topa_entry *topa_index[0]; +}; + +struct pt_cap_desc { + const char *name; + u32 leaf; + u8 reg; + u32 mask; +}; + +struct pt_pmu { + struct pmu pmu; + u32 caps[8]; + bool vmx; + long unsigned int max_nonturbo_ratio; + unsigned int tsc_art_num; + unsigned int tsc_art_den; +}; + +typedef struct pt_regs *pto_T_____22; + +struct pt_regs_offset { + const char *name; + int offset; +}; + +struct pte_list_desc { + u64 *sptes[3]; + struct pte_list_desc *more; +}; + +struct ptp_clock_time { + __s64 sec; + __u32 nsec; + __u32 reserved; +}; + +struct ptp_extts_event { + struct ptp_clock_time t; + unsigned int index; + unsigned int flags; + unsigned int rsv[2]; +}; + +struct timestamp_event_queue { + struct ptp_extts_event buf[128]; + int head; + int tail; + spinlock_t lock; +}; + +struct ptp_clock_info; + +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 timestamp_event_queue tsevq; + struct mutex tsevq_mux; + 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; +}; + +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 rsv[13]; +}; + +struct ptp_clock_event { + int type; + int index; + union { + u64 timestamp; + struct pps_event_time pps_times; + }; +}; + +struct ptp_pin_desc; + +struct system_device_crosststamp; + +struct ptp_clock_request; + +struct ptp_clock_info { + struct module *owner; + char name[16]; + 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 (*adjfreq)(struct ptp_clock_info *, s32); + int (*adjtime)(struct ptp_clock_info *, s64); + int (*gettime64)(struct ptp_clock_info *, struct timespec *); + int (*getcrosststamp)(struct ptp_clock_info *, struct system_device_crosststamp *); + int (*settime64)(struct ptp_clock_info *, const struct timespec *); + 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); +}; + +struct ptp_extts_request { + unsigned int index; + unsigned int flags; + unsigned int rsv[2]; +}; + +struct ptp_perout_request { + struct ptp_clock_time start; + struct ptp_clock_time period; + unsigned int index; + unsigned int flags; + 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_pin_desc { + char name[64]; + unsigned int index; + unsigned int func; + unsigned int chan; + unsigned int rsv[5]; +}; + +struct ptp_sys_offset { + unsigned int n_samples; + unsigned int rsv[3]; + struct ptp_clock_time ts[51]; +}; + +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 ptrace_peeksiginfo_args { + __u64 off; + __u32 flags; + __s32 nr; +}; + +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 put_image_params { + int format; + short int dst_x; + short int dst_y; + short int dst_w; + short int dst_h; + short int src_w; + short int src_scan_h; + short int src_scan_w; + short int src_h; + short int stride_Y; + short int stride_UV; + int offset_Y; + int offset_U; + int offset_V; +}; + +struct pv_info { + unsigned int kernel_rpl; + int shared_kernel_pmd; + u16 extra_user_64bit_cs; + const char *name; +}; + +struct pvclock_gtod_data { + seqcount_t seq; + struct { + int vclock_mode; + cycle_t cycle_last; + cycle_t mask; + u32 mult; + u32 shift; + } clock; + u64 boot_ns; + u64 nsec_base; +}; + +struct pvclock_vsyscall_time_info { + struct pvclock_vcpu_time_info pvti; + long: 64; + long: 64; + long: 64; + long: 64; +}; + +struct pvclock_wall_clock { + u32 version; + u32 sec; + u32 nsec; +}; + +struct pwm_args { + unsigned int period; + enum pwm_polarity polarity; +}; + +struct pwm_ops; + +struct pwm_chip { + struct device *dev; + struct list_head list; + const struct pwm_ops *ops; + int base; + unsigned int npwm; + struct pwm_device *pwms; + struct pwm_device * (*of_xlate)(struct pwm_chip *, const struct of_phandle_args *); + unsigned int of_pwm_n_cells; + bool can_sleep; +}; + +struct pwm_state { + unsigned int period; + unsigned int duty_cycle; + enum pwm_polarity polarity; + bool enabled; +}; + +struct pwm_device { + const char *label; + long unsigned int flags; + unsigned int hwpwm; + unsigned int pwm; + struct pwm_chip *chip; + void *chip_data; + struct pwm_args args; + struct pwm_state state; +}; + +struct pwm_ops { + int (*request)(struct pwm_chip *, struct pwm_device *); + void (*free)(struct pwm_chip *, struct pwm_device *); + int (*config)(struct pwm_chip *, struct pwm_device *, int, int); + int (*set_polarity)(struct pwm_chip *, struct pwm_device *, enum pwm_polarity); + int (*enable)(struct pwm_chip *, struct pwm_device *); + void (*disable)(struct pwm_chip *, struct pwm_device *); + int (*apply)(struct pwm_chip *, struct pwm_device *, struct pwm_state *); + void (*get_state)(struct pwm_chip *, struct pwm_device *, struct pwm_state *); + void (*dbg_show)(struct pwm_chip *, struct seq_file *); + struct module *owner; +}; + +struct qi_desc; + +struct q_inval { + raw_spinlock_t q_lock; + struct qi_desc *desc; + int *desc_status; + int free_head; + int free_tail; + int free_cnt; +}; + +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 { + u64 last_expires; + struct hrtimer timer; + struct Qdisc *qdisc; +}; + +struct qi_desc { + u64 low; + u64 high; +}; + +struct qt_disk_dqdbheader { + __le32 dqdh_next_free; + __le32 dqdh_prev_free; + __le16 dqdh_entries; + __le16 dqdh_pad1; + __le32 dqdh_pad2; +}; + +struct qtree_fmt_operations { + void (*mem2disk_dqblk)(void *, struct dquot *); + void (*disk2mem_dqblk)(struct dquot *, void *); + int (*is_id)(void *, struct dquot *); +}; + +struct qtree_mem_dqinfo { + struct super_block *dqi_sb; + int dqi_type; + unsigned int dqi_blocks; + unsigned int dqi_free_blk; + unsigned int dqi_free_entry; + unsigned int dqi_blocksize_bits; + unsigned int dqi_entry_size; + unsigned int dqi_usable_bs; + unsigned int dqi_qtree_depth; + const struct qtree_fmt_operations *dqi_ops; +}; + +struct quatech_feature { + u16 devid; + bool amcc; +}; + +struct queue_limits { + long unsigned int bounce_pfn; + 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_segment_size; + unsigned int physical_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_write_same_sectors; + unsigned int discard_granularity; + unsigned int discard_alignment; + short unsigned int logical_block_size; + short unsigned int max_segments; + short unsigned int max_integrity_segments; + unsigned char misaligned; + unsigned char discard_misaligned; + unsigned char cluster; + unsigned char discard_zeroes_data; + unsigned char raid_partial_stripes_expensive; +}; + +struct queue_pages { + struct list_head *pagelist; + long unsigned int flags; + nodemask_t *nmask; + struct vm_area_struct *prev; +}; + +struct queue_sysfs_entry { + struct attribute attr; + ssize_t (*show)(struct request_queue *, char *); + ssize_t (*store)(struct request_queue *, const char *, size_t); +}; + +struct quirk_table { + const char *name; + int (*func)(struct snd_ac97 *); +}; + +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_ops___2 { + int (*check_quota_file)(struct super_block___2 *, int); + int (*read_file_info)(struct super_block___2 *, int); + int (*write_file_info)(struct super_block___2 *, int); + int (*free_file_info)(struct super_block___2 *, int); + int (*read_dqblk)(struct dquot___2 *); + int (*commit_dqblk)(struct dquot___2 *); + int (*release_dqblk)(struct dquot___2 *); + int (*get_next_id)(struct super_block___2 *, 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_format_type___2 { + int qf_fmt_id; + const struct quota_format_ops___2 *qf_ops; + struct module___2 *qf_owner; + struct quota_format_type___2 *qf_next; +}; + +struct quota_info { + unsigned int flags; + struct mutex dqio_mutex; + struct mutex dqonoff_mutex; + struct inode *files[3]; + struct mem_dqinfo info[3]; + const struct quota_format_ops *ops[3]; +}; + +struct quota_info___2 { + unsigned int flags; + struct mutex___2 dqio_mutex; + struct mutex___2 dqonoff_mutex; + struct inode___2 *files[3]; + struct mem_dqinfo___2 info[3]; + const struct quota_format_ops___2 *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, 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 quotactl_ops___2 { + int (*quota_on)(struct super_block___2 *, int, int, struct path___2 *); + int (*quota_off)(struct super_block___2 *, int); + int (*quota_enable)(struct super_block___2 *, unsigned int); + int (*quota_disable)(struct super_block___2 *, unsigned int); + int (*quota_sync)(struct super_block___2 *, int); + int (*set_info)(struct super_block___2 *, int, struct qc_info *); + int (*get_dqblk)(struct super_block___2 *, struct kqid, struct qc_dqblk *); + int (*get_nextdqblk)(struct super_block___2 *, struct kqid *, struct qc_dqblk *); + int (*set_dqblk)(struct super_block___2 *, struct kqid, struct qc_dqblk *); + int (*get_state)(struct super_block___2 *, struct qc_state *); + int (*rm_xquota)(struct super_block___2 *, unsigned int); +}; + +struct radix_tree_iter { + long unsigned int index; + long unsigned int next_index; + long unsigned int tags; +}; + +struct radix_tree_node { + unsigned char shift; + unsigned char offset; + unsigned int count; + union { + struct { + struct radix_tree_node *parent; + void *private_data; + }; + struct callback_head callback_head; + }; + struct list_head private_list; + void *slots[64]; + long unsigned int tags[3]; +}; + +struct radix_tree_preload { + unsigned int nr; + struct radix_tree_node *nodes; +}; + +struct ramfs_mount_opts { + umode_t mode; +}; + +struct ramfs_fs_info { + struct ramfs_mount_opts mount_opts; +}; + +struct rand_data { + __u64 data; + __u64 old_data; + __u64 prev_time; + __u64 last_delta; + __s64 last_delta2; + unsigned int stuck: 1; + unsigned int osr; + unsigned int stir: 1; + unsigned int disable_unbias: 1; + unsigned char *mem; + unsigned int memlocation; + unsigned int memblocks; + unsigned int memblocksize; + unsigned int memaccessloops; +}; + +struct range { + u64 start; + u64 end; +}; + +struct rapl_pmu { + raw_spinlock_t lock; + int n_active; + int cpu; + struct list_head active_list; + struct pmu *pmu; + ktime_t timer_interval; + struct hrtimer hrtimer; +}; + +struct rapl_pmus { + struct pmu pmu; + unsigned int maxpkg; + struct rapl_pmu *pmus[0]; +}; + +struct rate_channel { + short int last_S1; + short int last_S2; +}; + +typedef void (*rate_f)(struct snd_pcm_plugin *, const struct snd_pcm_plugin_channel *, struct snd_pcm_plugin_channel *, int, int); + +struct rate_priv { + unsigned int pitch; + unsigned int pos; + rate_f func; + snd_pcm_sframes_t old_src_frames; + snd_pcm_sframes_t old_dst_frames; + struct rate_channel channels[0]; +}; + +struct ratelimit_state { + raw_spinlock_t lock; + int interval; + int burst; + int printed; + int missed; + long unsigned int begin; +}; + +struct raw_frag_vec { + struct msghdr *msg; + union { + struct icmphdr icmph; + char c[1]; + } hdr; + int hlen; +}; + +struct raw_hashinfo { + rwlock_t lock; + struct hlist_head ht[256]; +}; + +struct raw_iter_state { + struct seq_net_private p; + int bucket; + struct raw_hashinfo *h; +}; + +struct raw_notifier_head { + struct notifier_block *head; +}; + +struct raw_sock { + struct inet_sock inet; + struct icmp_filter filter; + u32 ipmr_table; +}; + +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; + 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; + bool waiters_pending; + bool full_waiters_pending; + bool wakeup_full; +}; + +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 rchan_callbacks; + +struct rchan_buf; + +struct rchan { + u32 version; + size_t subbuf_size; + size_t n_subbufs; + size_t alloc_size; + struct rchan_callbacks *cb; + struct kref kref; + void *private_data; + size_t last_toobig; + struct rchan_buf *buf[64]; + int is_global; + struct list_head list; + struct dentry___2 *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 timer_list timer; + struct dentry___2 *dentry; + struct kref kref; + struct page___2 **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; + long: 64; + long: 64; +}; + +struct rchan_callbacks { + int (*subbuf_start)(struct rchan_buf *, void *, void *, size_t); + void (*buf_mapped)(struct rchan_buf *, struct file___2 *); + void (*buf_unmapped)(struct rchan_buf *, struct file___2 *); + struct dentry___2 * (*create_buf_file)(const char *, struct dentry___2 *, umode_t, struct rchan_buf *, int *); + int (*remove_buf_file)(struct dentry___2 *); +}; + +struct rchan_percpu_buf_dispatcher { + struct rchan_buf *buf; + struct dentry___2 *dentry; +}; + +union rcu_noqs { + struct { + u8 norm; + u8 exp; + } b; + u16 s; +}; + +struct rcu_node; + +struct rcu_dynticks; + +struct rcu_state; + +struct rcu_data { + long unsigned int completed; + long unsigned int gpnum; + long unsigned int rcu_qs_ctr_snap; + union rcu_noqs cpu_no_qs; + bool core_needs_qs; + bool beenonline; + bool gpwrap; + struct rcu_node *mynode; + long unsigned int grpmask; + long unsigned int ticks_this_gp; + struct callback_head *nxtlist; + struct callback_head **nxttail[4]; + long unsigned int nxtcompleted[4]; + long int qlen_lazy; + long int qlen; + long int qlen_last_fqs_check; + long unsigned int n_cbs_invoked; + long unsigned int n_nocbs_invoked; + long unsigned int n_cbs_orphaned; + long unsigned int n_cbs_adopted; + long unsigned int n_force_qs_snap; + long int blimit; + struct rcu_dynticks *dynticks; + int dynticks_snap; + long unsigned int dynticks_fqs; + long unsigned int offline_fqs; + long unsigned int cond_resched_completed; + long unsigned int n_rcu_pending; + long unsigned int n_rp_core_needs_qs; + long unsigned int n_rp_report_qs; + long unsigned int n_rp_cb_ready; + long unsigned int n_rp_cpu_needs_gp; + long unsigned int n_rp_gp_completed; + long unsigned int n_rp_gp_started; + long unsigned int n_rp_nocb_defer_wakeup; + long unsigned int n_rp_need_nothing; + struct callback_head barrier_head; + atomic_long_t exp_workdone1; + atomic_long_t exp_workdone2; + atomic_long_t exp_workdone3; + unsigned int softirq_snap; + int cpu; + struct rcu_state *rsp; +}; + +struct rcu_dynticks { + long long int dynticks_nesting; + int dynticks_nmi_nesting; + atomic_t dynticks; +}; + +struct rcu_node { + raw_spinlock_t lock; + long unsigned int gpnum; + long unsigned int completed; + long unsigned int qsmask; + long unsigned int qsmaskinit; + long unsigned int qsmaskinitnext; + long unsigned int expmask; + long unsigned int expmaskinit; + long unsigned int expmaskinitnext; + 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 task_struct *boost_kthread_task; + unsigned int boost_kthread_status; + long unsigned int n_tasks_boosted; + long unsigned int n_exp_boosts; + long unsigned int n_normal_boosts; + long unsigned int n_balk_blkd_tasks; + long unsigned int n_balk_exp_gp_tasks; + long unsigned int n_balk_boost_tasks; + long unsigned int n_balk_notblocked; + long unsigned int n_balk_notyet; + long unsigned int n_balk_nos; + int need_future_gp[2]; + 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]; + long: 64; + long: 64; +}; + +union rcu_special { + struct { + u8 blocked; + u8 need_qs; + u8 exp_need_qs; + u8 pad; + } b; + u32 s; +}; + +typedef void (*rcu_callback_t)(struct callback_head *); + +typedef void (*call_rcu_func_t)(struct callback_head *, rcu_callback_t); + +struct rcu_state { + struct rcu_node node[1]; + struct rcu_node *level[2]; + u8 flavor_mask; + struct rcu_data *rda; + call_rcu_func_t call; + int ncpus; + long: 64; + long: 64; + u8 boost; + long unsigned int gpnum; + long unsigned int completed; + struct task_struct *gp_kthread; + struct swait_queue_head gp_wq; + short int gp_flags; + short int gp_state; + long: 0; + raw_spinlock_t orphan_lock; + struct callback_head *orphan_nxtlist; + struct callback_head **orphan_nxttail; + struct callback_head *orphan_donelist; + struct callback_head **orphan_donetail; + long int qlen_lazy; + long int qlen; + struct mutex barrier_mutex; + atomic_t barrier_cpu_count; + struct completion barrier_completion; + long unsigned int barrier_sequence; + struct mutex exp_mutex; + struct mutex exp_wake_mutex; + long unsigned int expedited_sequence; + atomic_long_t expedited_normal; + atomic_t expedited_need_qs; + struct swait_queue_head expedited_wq; + int ncpus_snap; + long unsigned int jiffies_force_qs; + long unsigned int jiffies_kick_kthreads; + long unsigned int n_force_qs; + long unsigned int n_force_qs_lh; + long unsigned int n_force_qs_ngp; + long unsigned int gp_start; + long unsigned int gp_activity; + long unsigned int jiffies_stall; + long unsigned int jiffies_resched; + long unsigned int n_force_qs_gpstart; + long unsigned int gp_max; + const char *name; + char abbr; + struct list_head flavors; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; +}; + +struct rcu_synchronize { + struct callback_head head; + struct completion completion; +}; + +struct rdev_sysfs_entry { + struct attribute attr; + ssize_t (*show)(struct md_rdev *, char *); + ssize_t (*store)(struct md_rdev *, const char *, size_t); +}; + +struct read_write_emulator_ops { + int (*read_write_prepare)(struct kvm_vcpu *, void *, int); + int (*read_write_emulate)(struct kvm_vcpu *, gpa_t, void *, int); + int (*read_write_mmio)(struct kvm_vcpu *, gpa_t, int, void *); + int (*read_write_exit_mmio)(struct kvm_vcpu *, gpa_t, void *, int); + bool write; +}; + +struct readdir_callback { + struct dir_context ctx; + struct old_linux_dirent *dirent; + int result; +}; + +struct readyevents_arg { + struct eventpoll *ep; + bool locked; +}; + +struct real_mode_header { + u32 text_start; + u32 ro_end; + u32 trampoline_start; + u32 trampoline_status; + u32 trampoline_header; + u32 trampoline_pgd; + u32 wakeup_start; + u32 wakeup_header; + u32 machine_real_restart_asm; + u32 machine_real_restart_seg; +}; + +struct receive_queue { + struct virtqueue *vq; + struct napi_struct napi; + struct page___2 *pages; + struct ewma_pkt_len mrg_avg_pkt_len; + struct page_frag alloc_frag; + struct scatterlist sg[19]; + char name[40]; +}; + +struct reclaim_state { + long unsigned int reclaimed_slab; +}; + +struct redirect_info { + u32 ifindex; + u32 flags; +}; + +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_sequence { + unsigned int reg; + unsigned int def; + unsigned int delay_us; +}; + +struct reg_state { + enum bpf_reg_type type; + union { + s64 imm; + struct { + u32 id; + u16 off; + u16 range; + }; + struct bpf_map *map_ptr; + }; +}; + +struct regcache_lzo_ctx { + void *wmem; + void *dst; + const void *src; + size_t src_len; + size_t dst_len; + size_t decompressed_size; + long unsigned int *sync_bmp; + int sync_bmp_nbits; +}; + +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 int *cache_present; + unsigned int base_reg; + unsigned int blklen; + struct rb_node node; +}; + +struct region_devres { + struct resource *parent; + resource_size_t start; + resource_size_t n; +}; + +struct register_whitelist { + i915_reg_t offset_ldw; + i915_reg_t offset_udw; + uint32_t size; + uint32_t gen_bitmask; +}; + +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; + 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 regmap_bus; + +struct regmap_access_table; + +struct regmap { + union { + struct mutex mutex; + struct { + spinlock_t spinlock; + long unsigned int spinlock_flags; + }; + }; + regmap_lock lock; + regmap_unlock unlock; + void *lock_arg; + gfp_t alloc_flags; + 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; + struct dentry___2 *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 (*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); + 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; + 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); + bool defer_caching; + u8 read_flag_mask; + u8 write_flag_mask; + int reg_shift; + int reg_stride; + int reg_stride_order; + 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 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_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 void (*regmap_hw_free_context)(void *); + +typedef struct regmap_async * (*regmap_hw_async_alloc)(void); + +struct regmap_bus { + bool fast_io; + 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_update_bits reg_update_bits; + regmap_hw_read read; + regmap_hw_reg_read reg_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 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); + regmap_lock lock; + regmap_unlock unlock; + void *lock_arg; + int (*reg_read)(void *, unsigned int, unsigned int *); + int (*reg_write)(void *, unsigned int, unsigned int); + bool fast_io; + unsigned int max_register; + 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 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; + u8 read_flag_mask; + u8 write_flag_mask; + bool use_single_rw; + bool can_multi_write; + 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; + const char *name; + 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_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; +}; + +typedef int (*remote_function_f)(void *); + +struct remote_function_call { + struct task_struct___2 *p; + remote_function_f func; + void *info; + int ret; +}; + +struct remote_output { + struct ring_buffer___2 *rb; + int err; +}; + +struct render_state { + const struct intel_renderstate_rodata *rodata; + struct drm_i915_gem_object *obj; + u64 ggtt_offset; + int gen; + u32 aux_batch_size; + u32 aux_batch_offset; +}; + +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 void rq_end_io_fn(struct request *, int); + +struct request { + struct list_head queuelist; + union { + struct call_single_data csd; + long unsigned int fifo_time; + }; + struct request_queue *q; + struct blk_mq_ctx *mq_ctx; + u64 cmd_flags; + unsigned int cmd_type; + long unsigned int atomic_flags; + int cpu; + unsigned int __data_len; + sector_t __sector; + struct bio *bio; + struct bio *biotail; + union { + struct hlist_node hash; + struct list_head ipi_list; + }; + union { + struct rb_node rb_node; + void *completion_data; + }; + union { + struct { + struct io_cq *icq; + void *priv[2]; + } elv; + struct { + unsigned int seq; + struct list_head list; + rq_end_io_fn *saved_end_io; + } flush; + }; + struct gendisk *rq_disk; + struct hd_struct *part; + long unsigned int start_time; + short unsigned int nr_phys_segments; + short unsigned int ioprio; + void *special; + int tag; + int errors; + unsigned char __cmd[16]; + unsigned char *cmd; + short unsigned int cmd_len; + unsigned int extra_len; + unsigned int sense_len; + unsigned int resid_len; + void *sense; + long unsigned int deadline; + struct list_head timeout_list; + unsigned int timeout; + int retries; + rq_end_io_fn *end_io; + void *end_io_data; + struct request *next_rq; +}; + +struct request_boost { + struct work_struct work; + struct drm_i915_gem_request *req; +}; + +struct request_key_auth { + struct key___2 *target_key; + struct key___2 *dest_keyring; + const struct cred___2 *cred; + void *callout_info; + size_t callout_len; + pid_t pid; +}; + +struct request_list { + struct request_queue *q; + int count[2]; + int starved[2]; + mempool_t *rq_pool; + wait_queue_head_t wait[2]; + unsigned int flags; +}; + +typedef void request_fn_proc(struct request_queue *); + +typedef blk_qc_t make_request_fn(struct request_queue *, struct bio *); + +typedef int prep_rq_fn(struct request_queue *, struct request *); + +typedef void unprep_rq_fn(struct request_queue *, struct request *); + +typedef enum blk_eh_timer_return rq_timed_out_fn(struct request *); + +typedef int dma_drain_needed_fn(struct request *); + +typedef int lld_busy_fn(struct request_queue *); + +struct bsg_job; + +typedef int bsg_job_fn(struct bsg_job *); + +struct request_queue { + struct list_head queue_head; + struct request *last_merge; + struct elevator_queue *elevator; + int nr_rqs[2]; + int nr_rqs_elvpriv; + struct request_list root_rl; + request_fn_proc *request_fn; + make_request_fn *make_request_fn; + prep_rq_fn *prep_rq_fn; + unprep_rq_fn *unprep_rq_fn; + softirq_done_fn *softirq_done_fn; + rq_timed_out_fn *rq_timed_out_fn; + dma_drain_needed_fn *dma_drain_needed; + lld_busy_fn *lld_busy_fn; + struct blk_mq_ops *mq_ops; + unsigned int *mq_map; + struct blk_mq_ctx *queue_ctx; + unsigned int nr_queues; + struct blk_mq_hw_ctx **queue_hw_ctx; + unsigned int nr_hw_queues; + sector_t end_sector; + struct request *boundary_rq; + struct delayed_work delay_work; + struct backing_dev_info backing_dev_info; + void *queuedata; + long unsigned int queue_flags; + int id; + gfp_t bounce_gfp; + spinlock_t __queue_lock; + spinlock_t *queue_lock; + struct kobject kobj; + struct kobject mq_kobj; + struct device *dev; + int rpm_status; + unsigned int nr_pending; + long unsigned int nr_requests; + unsigned int nr_congestion_on; + unsigned int nr_congestion_off; + unsigned int nr_batching; + unsigned int dma_drain_size; + void *dma_drain_buffer; + unsigned int dma_pad_mask; + unsigned int dma_alignment; + struct blk_queue_tag *queue_tags; + struct list_head tag_busy_list; + unsigned int nr_sorted; + unsigned int in_flight[2]; + unsigned int request_fn_active; + unsigned int rq_timeout; + struct timer_list timeout; + struct work_struct timeout_work; + struct list_head timeout_list; + struct list_head icq_list; + struct queue_limits limits; + unsigned int sg_timeout; + unsigned int sg_reserved_size; + int node; + struct blk_trace *blk_trace; + struct blk_flush_queue *fq; + struct list_head requeue_list; + spinlock_t requeue_lock; + struct work_struct requeue_work; + struct mutex sysfs_lock; + int bypass_depth; + atomic_t mq_freeze_depth; + bsg_job_fn *bsg_job_fn; + int bsg_job_size; + struct bsg_class_device bsg_dev; + struct callback_head callback_head; + wait_queue_head_t mq_freeze_wq; + struct percpu_ref q_usage_counter; + struct list_head all_q_node; + struct blk_mq_tag_set *tag_set; + struct list_head tag_set_list; + struct bio_set *bio_split; + bool mq_sysfs_init_done; +}; + +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_ops { + int family; + 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 *); + void (*destructor)(struct request_sock *); + void (*syn_ack_timeout)(const struct request_sock *); +}; + +struct res_proc_context { + struct list_head *list; + int (*preproc)(struct acpi_resource *, void *); + void *preproc_data; + int count; + int error; +}; + +struct reservation_object_list { + struct callback_head rcu; + u32 shared_count; + u32 shared_max; + struct fence *shared[0]; +}; + +struct resource_constraint { + resource_size_t min; + resource_size_t max; + resource_size_t align; + resource_size_t (*alignf)(void *, const struct resource *, resource_size_t, resource_size_t); + void *alignf_data; +}; + +struct resource_entry { + struct list_head node; + struct resource *res; + resource_size_t offset; + struct resource __res; +}; + +struct resource_win { + struct resource res; + resource_size_t offset; +}; + +struct restart_block { + 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; + struct timespec *rmtp; + struct compat_timespec *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 restore_data_record { + long unsigned int jump_address; + long unsigned int cr3; + long unsigned int magic; +}; + +struct resume_swap_area { + __kernel_loff_t offset; + __u32 dev; +} __attribute__((packed)); + +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 rfkill_ops { + void (*poll)(struct rfkill *, void *); + void (*query)(struct rfkill *, void *); + int (*set_block)(void *, bool); +}; + +struct rgb { + u8 r; + u8 g; + u8 b; +}; + +struct rhashtable_compare_arg { + struct rhashtable *ht; + const void *key; +}; + +struct rhashtable_walker { + struct list_head list; + struct bucket_table *tbl; +}; + +struct ring_buffer_per_cpu; + +struct ring_buffer { + unsigned int flags; + int cpus; + atomic_t record_disabled; + atomic_t resize_disabled; + cpumask_var_t cpumask; + struct lock_class_key *reader_lock_key; + struct mutex mutex; + struct ring_buffer_per_cpu **buffers; + struct notifier_block cpu_notify; + u64 (*clock)(void); + struct rb_irq_work irq_work; +}; + +struct ring_buffer___2 { + atomic_t refcount; + struct callback_head callback_head; + int nr_pages; + int overwrite; + int paused; + atomic_t poll; + local_t head; + local_t 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___2 *mmap_user; + local_t aux_head; + local_t aux_nest; + local_t 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 *); + atomic_t aux_refcount; + void **aux_pages; + void *aux_priv; + struct perf_event_mmap_page *user_page; + void *data_pages[0]; +}; + +struct ring_buffer_event { + u32 type_len: 5; + u32 time_delta: 27; + u32 array[0]; +}; + +struct ring_buffer_iter { + struct ring_buffer_per_cpu *cpu_buffer; + long unsigned int head; + struct buffer_page *head_page; + struct buffer_page *cache_reader_page; + long unsigned int cache_read; + u64 read_stamp; +}; + +struct ring_buffer_per_cpu { + int cpu; + atomic_t record_disabled; + struct ring_buffer *buffer; + raw_spinlock_t reader_lock; + arch_spinlock_t lock; + struct lock_class_key lock_key; + long unsigned int nr_pages; + unsigned int current_context; + struct list_head *pages; + 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; + local_t entries_bytes; + local_t entries; + local_t overrun; + local_t commit_overrun; + local_t dropped_events; + local_t committing; + local_t commits; + long unsigned int read; + long unsigned int read_bytes; + u64 write_stamp; + u64 read_stamp; + 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 rio_detail { + u8 node_id; + u32 BBAR; + u8 type; + u8 owner_id; + u8 port0node; + u8 port0port; + u8 port1node; + u8 port1port; + u8 first_slot; + u8 status; + u8 WP_index; + u8 chassis_num; +} __attribute__((packed)); + +struct rio_table_hdr { + u8 version; + u8 num_scal_dev; + u8 num_rio_dev; +}; + +struct rlimit { + __kernel_ulong_t rlim_cur; + __kernel_ulong_t rlim_max; +}; + +struct rlimit64 { + __u64 rlim_cur; + __u64 rlim_max; +}; + +struct rmap_iterator { + struct pte_list_desc *desc; + int pos; +}; + +struct rmap_private { + enum ttu_flags flags; + int lazyfreed; +}; + +struct rmap_walk_control { + void *arg; + int (*rmap_one)(struct page___2 *, struct vm_area_struct *, long unsigned int, void *); + int (*done)(struct page___2 *); + struct anon_vma * (*anon_lock)(struct page___2 *); + bool (*invalid_vma)(struct vm_area_struct *, void *); +}; + +struct rmid_read { + u32 rmid; + u32 evt_type; + atomic64_t value; +}; + +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 rock_ridge { + char signature[2]; + unsigned char len; + unsigned char version; + union { + struct SU_SP_s SP; + struct SU_CE_s CE; + struct SU_ER_s ER; + struct RR_RR_s RR; + struct RR_PX_s PX; + struct RR_PN_s PN; + struct RR_SL_s SL; + struct RR_NM_s NM; + struct RR_CL_s CL; + struct RR_PL_s PL; + struct RR_TF_s TF; + struct RR_ZF_s ZF; + } u; +}; + +struct rock_state { + void *buffer; + unsigned char *chr; + int len; + int cont_size; + int cont_extent; + int cont_offset; + int cont_loops; + struct inode___2 *inode; +}; + +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 overload; + cpumask_var_t dlo_mask; + atomic_t dlo_count; + struct dl_bw dl_bw; + struct cpudl cpudl; + cpumask_var_t rto_mask; + struct cpupri cpupri; +}; + +struct root_entry { + u64 lo; + u64 hi; +}; + +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 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; + long unsigned int rt_nr_migratory; + long unsigned int rt_nr_total; + int overloaded; + struct plist_head pushable_tasks; + int push_flags; + int push_cpu; + struct irq_work push_work; + raw_spinlock_t push_lock; + int rt_queued; + int rt_throttled; + u64 rt_time; + u64 rt_runtime; + raw_spinlock_t rt_runtime_lock; +}; + +struct sched_info { + long unsigned int pcount; + long long unsigned int 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 cpu_load[5]; + long unsigned int last_load_update_tick; + u64 nohz_stamp; + long unsigned int nohz_flags; + struct load_weight load; + long unsigned int nr_load_updates; + u64 nr_switches; + struct cfs_rq cfs; + struct rt_rq rt; + struct dl_rq dl; + struct list_head leaf_cfs_rq_list; + long unsigned int nr_uninterruptible; + struct task_struct *curr; + struct task_struct *idle; + struct task_struct *stop; + long unsigned int next_balance; + struct mm_struct *prev_mm; + unsigned int clock_skip_update; + u64 clock; + u64 clock_task; + atomic_t nr_iowait; + struct root_domain *rd; + struct sched_domain *sd; + long unsigned int cpu_capacity; + long unsigned int cpu_capacity_orig; + struct callback_head *balance_callback; + unsigned char idle_balance; + int active_balance; + int push_cpu; + struct cpu_stop_work active_balance_work; + int cpu; + int online; + struct list_head cfs_tasks; + u64 rt_avg; + u64 age_stamp; + 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; + int hrtick_csd_pending; + struct call_single_data hrtick_csd; + struct hrtimer hrtick_timer; + 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 llist_head wake_list; + struct cpuidle_state *idle_state; +}; + +struct rq_flags { + long unsigned int flags; + struct pin_cookie cookie; +}; + +struct rq_map_data { + struct page **pages; + int page_order; + int nr_entries; + long unsigned int offset; + int null_mapped; + int from_user; +}; + +struct rt6key { + struct in6_addr addr; + int plen; +}; + +struct uncached_list; + +struct rt6_info { + struct dst_entry dst; + struct fib6_table *rt6i_table; + struct fib6_node *rt6i_node; + struct in6_addr rt6i_gateway; + struct list_head rt6i_siblings; + unsigned int rt6i_nsiblings; + atomic_t rt6i_ref; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + struct rt6key rt6i_dst; + u32 rt6i_flags; + struct rt6key rt6i_src; + struct rt6key rt6i_prefsrc; + struct list_head rt6i_uncached; + struct uncached_list *rt6i_uncached_list; + struct inet6_dev *rt6i_idev; + struct rt6_info **rt6i_pcpu; + u32 rt6i_metric; + u32 rt6i_pmtu; + short unsigned int rt6i_nfheader_len; + u8 rt6i_protocol; + long: 64; +}; + +struct rt_bandwidth { + raw_spinlock_t rt_runtime_lock; + ktime_t rt_period; + u64 rt_runtime; + struct hrtimer rt_period_timer; + unsigned int rt_period_active; +}; + +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_mutex_waiter { + struct rb_node tree_entry; + struct rb_node pi_tree_entry; + struct task_struct *task; + struct rt_mutex *lock; + int prio; +}; + +typedef struct rt_rq *rt_rq_iter_t; + +struct sigaltstack { + void *ss_sp; + int ss_flags; + size_t ss_size; +}; + +typedef struct sigaltstack stack_t; + +struct sigcontext_64 { + __u64 r8; + __u64 r9; + __u64 r10; + __u64 r11; + __u64 r12; + __u64 r13; + __u64 r14; + __u64 r15; + __u64 di; + __u64 si; + __u64 bp; + __u64 bx; + __u64 dx; + __u64 ax; + __u64 cx; + __u64 sp; + __u64 ip; + __u64 flags; + __u16 cs; + __u16 gs; + __u16 fs; + __u16 ss; + __u64 err; + __u64 trapno; + __u64 oldmask; + __u64 cr2; + __u64 fpstate; + __u64 reserved1[8]; +}; + +struct ucontext { + long unsigned int uc_flags; + struct ucontext *uc_link; + stack_t uc_stack; + struct sigcontext_64 uc_mcontext; + sigset_t uc_sigmask; +}; + +struct rt_sigframe { + char *pretcode; + struct ucontext uc; + struct siginfo info; +}; + +struct sigcontext_32 { + __u16 gs; + __u16 __gsh; + __u16 fs; + __u16 __fsh; + __u16 es; + __u16 __esh; + __u16 ds; + __u16 __dsh; + __u32 di; + __u32 si; + __u32 bp; + __u32 sp; + __u32 bx; + __u32 dx; + __u32 cx; + __u32 ax; + __u32 trapno; + __u32 err; + __u32 ip; + __u16 cs; + __u16 __csh; + __u32 flags; + __u32 sp_at_signal; + __u16 ss; + __u16 __ssh; + __u32 fpstate; + __u32 oldmask; + __u32 cr2; +}; + +struct ucontext_ia32 { + unsigned int uc_flags; + unsigned int uc_link; + compat_stack_t uc_stack; + struct sigcontext_32 uc_mcontext; + compat_sigset_t uc_sigmask; +}; + +struct rt_sigframe_ia32 { + u32 pretcode; + int sig; + u32 pinfo; + u32 puc; + compat_siginfo_t info; + struct ucontext_ia32 uc; + char retcode[8]; +}; + +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 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; + __be32 rt_gateway; + u32 rt_pmtu; + u32 rt_table_id; + struct list_head rt_uncached; + struct uncached_list *rt_uncached_list; +}; + +struct rtc_time; + +struct rtc_wkalrm; + +struct rtc_class_ops { + int (*open)(struct device *); + void (*release)(struct device *); + 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 (*set_mmss64)(struct device *, time64_t); + int (*set_mmss)(struct device *, long unsigned int); + int (*read_callback)(struct device *, int); + int (*alarm_irq_enable)(struct device *, unsigned int); + int (*read_offset)(struct device *, long int *); + int (*set_offset)(struct device *, long int); +}; + +struct rtc_task { + void (*func)(void *); + void *private_data; +}; + +struct rtc_timer { + struct rtc_task task; + struct timerqueue_node node; + ktime_t period; + int enabled; +}; + +struct rtc_device { + struct device dev; + struct module *owner; + int id; + char name[20]; + 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; + struct rtc_task *irq_task; + spinlock_t irq_task_lock; + 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; + int uie_unsupported; +}; + +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 rtentry32 { + 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; + u32 rt_dev; + u32 rt_mtu; + u32 rt_window; + short unsigned int rt_irtt; +}; + +struct rtgenmsg { + unsigned char rtgen_family; +}; + +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; + 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 *); + int (*set_link_af)(struct net_device *, const struct nlattr *); +}; + +typedef int (*rtnl_doit_func)(struct sk_buff *, struct nlmsghdr *); + +typedef int (*rtnl_dumpit_func)(struct sk_buff *, struct netlink_callback *); + +typedef u16 (*rtnl_calcit_func)(struct sk_buff *, struct nlmsghdr *); + +struct rtnl_link { + rtnl_doit_func doit; + rtnl_dumpit_func dumpit; + rtnl_calcit_func calcit; +}; + +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; + const char *kind; + size_t priv_size; + void (*setup)(struct net_device *); + int maxtype; + const struct nla_policy *policy; + int (*validate)(struct nlattr **, struct nlattr **); + int (*newlink)(struct net *, struct net_device *, struct nlattr **, struct nlattr **); + int (*changelink)(struct net_device *, struct nlattr **, struct nlattr **); + 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); + int slave_maxtype; + const struct nla_policy *slave_policy; + int (*slave_validate)(struct nlattr **, struct nlattr **); + int (*slave_changelink)(struct net_device *, struct net_device *, struct nlattr **, struct nlattr **); + 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 (*fill_linkxstats)(struct sk_buff *, const struct net_device *, int *); +}; + +struct rtnl_link_ops___2 { + struct list_head list; + const char *kind; + size_t priv_size; + void (*setup)(struct net_device___2 *); + int maxtype; + const struct nla_policy *policy; + int (*validate)(struct nlattr **, struct nlattr **); + int (*newlink)(struct net___2 *, struct net_device___2 *, struct nlattr **, struct nlattr **); + int (*changelink)(struct net_device___2 *, struct nlattr **, struct nlattr **); + void (*dellink)(struct net_device___2 *, struct list_head *); + size_t (*get_size)(const struct net_device___2 *); + int (*fill_info)(struct sk_buff___2 *, const struct net_device___2 *); + size_t (*get_xstats_size)(const struct net_device___2 *); + int (*fill_xstats)(struct sk_buff___2 *, const struct net_device___2 *); + unsigned int (*get_num_tx_queues)(void); + unsigned int (*get_num_rx_queues)(void); + int slave_maxtype; + const struct nla_policy *slave_policy; + int (*slave_validate)(struct nlattr **, struct nlattr **); + int (*slave_changelink)(struct net_device___2 *, struct net_device___2 *, struct nlattr **, struct nlattr **); + size_t (*get_slave_size)(const struct net_device___2 *, const struct net_device___2 *); + int (*fill_slave_info)(struct sk_buff___2 *, const struct net_device___2 *, const struct net_device___2 *); + struct net___2 * (*get_link_net)(const struct net_device___2 *); + size_t (*get_linkxstats_size)(const struct net_device___2 *); + int (*fill_linkxstats)(struct sk_buff___2 *, const struct net_device___2 *, 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; +}; + +struct rtnl_net_dump_cb { + struct net *net; + struct sk_buff *skb; + struct netlink_callback *cb; + int idx; + int s_idx; +}; + +struct rtree_node { + struct list_head list; + long unsigned int *data; +}; + +struct rtt_meas { + u32 rtt; + u32 ts; +}; + +struct rusage { + struct timeval ru_utime; + struct 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; +}; + +struct rwsem_waiter { + struct list_head list; + struct task_struct *task; + enum rwsem_waiter_type type; +}; + +struct rx_queue_attribute { + struct attribute attr; + ssize_t (*show)(struct netdev_rx_queue *, struct rx_queue_attribute *, char *); + ssize_t (*store)(struct netdev_rx_queue *, struct rx_queue_attribute *, const char *, size_t); +}; + +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 sample { + u64 total_bytes; + u64 prev_msr; +}; + +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; +}; + +struct saved_msr; + +struct saved_msrs { + unsigned int num; + struct saved_msr *array; +}; + +struct saved_context { + struct pt_regs regs; + u16 ds; + u16 es; + u16 fs; + u16 gs; + u16 ss; + long unsigned int gs_base; + long unsigned int gs_kernel_base; + long unsigned int fs_base; + long unsigned int cr0; + long unsigned int cr2; + long unsigned int cr3; + long unsigned int cr4; + long unsigned int cr8; + u64 misc_enable; + bool misc_enable_saved; + struct saved_msrs saved_msrs; + long unsigned int efer; + u16 gdt_pad; + struct desc_ptr gdt_desc; + u16 idt_pad; + u16 idt_limit; + long unsigned int idt_base; + u16 ldt; + u16 tss; + long unsigned int tr; + long unsigned int safety; + long unsigned int return_address; +} __attribute__((packed)); + +struct saved_msr { + bool valid; + struct msr_info info; +}; + +struct sb_writers { + int frozen; + wait_queue_head_t wait_unfrozen; + struct percpu_rw_semaphore rw_sem[3]; +}; + +struct sb_writers___2 { + int frozen; + wait_queue_head_t wait_unfrozen; + struct percpu_rw_semaphore___2 rw_sem[3]; +}; + +struct scal_detail { + u8 node_id; + u32 CBAR; + u8 port0node; + u8 port0port; + u8 port1node; + u8 port1port; + u8 port2node; + u8 port2port; + u8 chassis_num; +} __attribute__((packed)); + +struct scan_area { + u64 addr; + u64 size; +}; + +struct scan_control { + long unsigned int nr_to_reclaim; + gfp_t gfp_mask; + int order; + nodemask_t *nodemask; + struct mem_cgroup *target_mem_cgroup; + int priority; + unsigned int may_writepage: 1; + unsigned int may_unmap: 1; + unsigned int may_swap: 1; + unsigned int may_thrash: 1; + unsigned int hibernation_mode: 1; + unsigned int compaction_ready: 1; + long unsigned int nr_scanned; + long unsigned int nr_reclaimed; +}; + +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; +}; + +struct sched_class { + const struct sched_class *next; + void (*enqueue_task)(struct rq *, struct task_struct *, int); + void (*dequeue_task)(struct rq *, struct task_struct *, int); + void (*yield_task)(struct rq *); + bool (*yield_to_task)(struct rq *, struct task_struct *, bool); + void (*check_preempt_curr)(struct rq *, struct task_struct *, int); + struct task_struct * (*pick_next_task)(struct rq *, struct task_struct *, struct pin_cookie); + void (*put_prev_task)(struct rq *, struct task_struct *); + int (*select_task_rq)(struct task_struct *, int, int, int); + void (*migrate_task_rq)(struct task_struct *); + void (*task_woken)(struct rq *, struct task_struct *); + void (*set_cpus_allowed)(struct task_struct *, const struct cpumask *); + void (*rq_online)(struct rq *); + void (*rq_offline)(struct rq *); + void (*set_curr_task)(struct rq *); + void (*task_tick)(struct rq *, struct task_struct *, int); + void (*task_fork)(struct task_struct *); + void (*task_dead)(struct task_struct *); + void (*switched_from)(struct rq *, struct task_struct *); + void (*switched_to)(struct rq *, struct task_struct *); + 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_move_group)(struct task_struct *); +}; + +struct sched_clock_data { + u64 tick_raw; + u64 tick_gtod; + u64 clock; +}; + +struct sched_dl_entity { + struct rb_node rb_node; + u64 dl_runtime; + u64 dl_deadline; + u64 dl_period; + u64 dl_bw; + s64 runtime; + u64 deadline; + unsigned int flags; + int dl_throttled; + int dl_boosted; + int dl_yielded; + struct hrtimer dl_timer; +}; + +struct sched_group; + +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 busy_idx; + unsigned int idle_idx; + unsigned int newidle_idx; + unsigned int wake_idx; + unsigned int forkexec_idx; + unsigned int smt_gain; + 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 next_decay_max_lb_cost; + unsigned int lb_count[3]; + unsigned int lb_failed[3]; + unsigned int lb_balanced[3]; + unsigned int lb_imbalance[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; + }; + unsigned int span_weight; + long unsigned int span[0]; +}; + +struct sched_domain_attr { + int relax_domain_level; +}; + +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_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_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; + u64 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; +}; + +struct sched_entity { + struct load_weight load; + struct rb_node run_node; + struct list_head group_node; + unsigned int on_rq; + u64 exec_start; + u64 sum_exec_runtime; + u64 vruntime; + u64 prev_sum_exec_runtime; + u64 nr_migrations; + struct sched_statistics statistics; + int depth; + struct sched_entity *parent; + struct cfs_rq *cfs_rq; + struct cfs_rq *my_q; + long: 64; + long: 64; + long: 64; + long: 64; + struct sched_avg avg; + long: 64; + long: 64; + long: 64; +}; + +struct sched_group { + struct sched_group *next; + atomic_t ref; + unsigned int group_weight; + struct sched_group_capacity *sgc; + long unsigned int cpumask[0]; +}; + +struct sched_group_capacity { + atomic_t ref; + unsigned int capacity; + long unsigned int next_update; + int imbalance; + atomic_t nr_busy_cpus; + 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___2 *pid; + struct scm_fp_list *fp; + struct scm_creds creds; +}; + +struct scm_fp_list { + short int count; + short int max; + struct user_struct *user; + struct file___2 *fp[253]; +}; + +struct scm_timestamping { + struct timespec ts[3]; +}; + +struct sg_table { + struct scatterlist *sgl; + unsigned int nents; + unsigned int orig_nents; +}; + +struct scsi_data_buffer { + struct sg_table table; + unsigned int length; + int resid; +}; + +struct scsi_pointer { + char *ptr; + int this_residual; + struct scatterlist *buffer; + int buffers_residual; + dma_addr_t dma_handle; + volatile int Status; + volatile int Message; + volatile int have_data_in; + volatile int sent_command; + volatile int phase; +}; + +struct scsi_cmnd { + struct scsi_device *device; + struct list_head list; + struct list_head eh_entry; + struct delayed_work abort_work; + int eh_eflags; + long unsigned int serial_number; + long unsigned int jiffies_at_alloc; + int retries; + int allowed; + unsigned char prot_op; + unsigned char prot_type; + unsigned char prot_flags; + short unsigned int cmd_len; + enum dma_data_direction sc_data_direction; + unsigned char *cmnd; + struct scsi_data_buffer sdb; + struct scsi_data_buffer *prot_sdb; + unsigned int underflow; + unsigned int transfersize; + struct request *request; + unsigned char *sense_buffer; + void (*scsi_done)(struct scsi_cmnd *); + struct scsi_pointer SCp; + unsigned char *host_scribble; + int result; + int flags; + unsigned char tag; +}; + +struct scsi_dev_info_list { + struct list_head dev_info_list; + char vendor[8]; + char model[16]; + unsigned int 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_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; + atomic_t device_busy; + atomic_t device_blocked; + spinlock_t list_lock; + struct list_head cmd_list; + struct list_head starved_entry; + struct scsi_cmnd *current_cmnd; + 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; + 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; + int vpd_pg83_len; + unsigned char *vpd_pg83; + int vpd_pg80_len; + unsigned char *vpd_pg80; + unsigned char current_tag; + struct scsi_target *sdev_target; + unsigned int sdev_bflags; + unsigned int eh_timeout; + 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 no_report_opcodes: 1; + unsigned int no_write_same: 1; + unsigned int use_16_for_rw: 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 manage_start_stop: 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 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 synchronous_alua: 1; + 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; + struct device sdev_gendev; + struct device sdev_dev; + struct execute_work ew; + struct work_struct requeue_work; + struct scsi_device_handler *handler; + void *handler_data; + unsigned char access_state; + enum scsi_device_state sdev_state; + long unsigned int sdev_data[0]; +}; + +typedef void (*activate_complete)(void *, int); + +struct scsi_sense_hdr; + +struct scsi_device_handler { + struct list_head list; + struct module *module; + const char *name; + int (*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 *); + int (*prep_fn)(struct scsi_device *, struct request *); + int (*set_params)(struct scsi_device *, const char *); + void (*rescan)(struct scsi_device *); +}; + +struct scsi_driver; + +struct scsi_disk { + struct scsi_driver *driver; + struct scsi_device *device; + struct device dev; + struct gendisk *disk; + atomic_t openers; + sector_t capacity; + u32 max_xfer_blocks; + u32 opt_xfer_blocks; + u32 max_ws_blocks; + u32 max_unmap_blocks; + u32 unmap_granularity; + u32 unmap_alignment; + u32 index; + unsigned int physical_block_size; + unsigned int max_medium_access_timeouts; + unsigned int medium_access_timed_out; + u8 media_present; + u8 write_prot; + u8 protection_type; + u8 provisioning_mode; + 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; +}; + +struct scsi_driver { + struct device_driver gendrv; + void (*rescan)(struct device *); + int (*init_command)(struct scsi_cmnd *); + void (*uninit_command)(struct scsi_cmnd *); + int (*done)(struct scsi_cmnd *); + int (*eh_action)(struct scsi_cmnd *, int); +}; + +struct scsi_eh_save { + int result; + enum dma_data_direction data_direction; + unsigned int underflow; + unsigned char cmd_len; + unsigned char prot_op; + unsigned char *cmnd; + struct scsi_data_buffer sdb; + struct request *next_rq; + unsigned char eh_cmnd[16]; + struct scatterlist sense_sgl; +}; + +struct scsi_event { + enum scsi_device_event evt_type; + struct list_head node; +}; + +struct scsi_host_cmd_pool { + struct kmem_cache *cmd_slab; + struct kmem_cache *sense_slab; + unsigned int users; + char *cmd_name; + char *sense_name; + unsigned int slab_flags; + gfp_t gfp_mask; +}; + +struct scsi_host_template { + struct module *module; + const char *name; + int (*detect)(struct scsi_host_template *); + int (*release)(struct Scsi_Host *); + const char * (*info)(struct Scsi_Host *); + int (*ioctl)(struct scsi_device *, int, void *); + int (*compat_ioctl)(struct scsi_device *, int, void *); + int (*queuecommand)(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 (*slave_alloc)(struct scsi_device *); + int (*slave_configure)(struct scsi_device *); + void (*slave_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); + 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 blk_eh_timer_return (*eh_timed_out)(struct scsi_cmnd *); + int (*host_reset)(struct Scsi_Host *, int); + const char *proc_name; + struct proc_dir_entry *proc_dir; + int can_queue; + int this_id; + short unsigned int sg_tablesize; + short unsigned int sg_prot_tablesize; + unsigned int max_sectors; + long unsigned int dma_boundary; + short int cmd_per_lun; + unsigned char present; + int tag_alloc_policy; + unsigned int track_queue_depth: 1; + unsigned int supported_mode: 2; + unsigned int unchecked_isa_dma: 1; + unsigned int use_clustering: 1; + unsigned int emulated: 1; + unsigned int skip_settle_delay: 1; + unsigned int no_write_same: 1; + unsigned int no_async_abort: 1; + unsigned int max_host_blocked; + struct device_attribute **shost_attrs; + struct device_attribute **sdev_attrs; + struct list_head legacy_hosts; + u64 vendor_id; + unsigned int cmd_size; + struct scsi_host_cmd_pool *cmd_pool; + bool disable_blk_mq; +}; + +struct scsi_idlun { + __u32 dev_id; + __u32 host_unique_id; +}; + +struct scsi_ioctl_command { + unsigned int inlen; + unsigned int outlen; + unsigned char data[0]; +}; + +typedef struct scsi_ioctl_command Scsi_Ioctl_Command; + +struct scsi_log_buf { + char buffer[4096]; + long unsigned int map; +}; + +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_sense_hdr { + u8 response_code; + u8 sense_key; + u8 asc; + u8 ascq; + u8 byte4; + u8 byte5; + u8 byte6; + u8 additional_length; +}; + +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 scsi_varlen_cdb_hdr { + __u8 opcode; + __u8 control; + __u8 misc[5]; + __u8 additional_cdb_length; + __be16 service_action; +}; + +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 sum_weighted_load; + long unsigned int load_per_task; + long unsigned int group_capacity; + long unsigned int group_util; + unsigned int sum_nr_running; + unsigned int idle_cpus; + unsigned int group_weight; + enum group_type group_type; + int group_no_capacity; +}; + +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; + struct sg_lb_stats busiest_stat; + struct sg_lb_stats local_stat; +}; + +struct shash_desc { + struct crypto_shash *tfm; + u32 flags; + void *__ctx[0]; +}; + +struct sdesc { + struct shash_desc shash; + char ctx[0]; +}; + +struct xfrm_state; + +struct sec_path { + atomic_t refcnt; + int len; + struct xfrm_state *xvec[6]; +}; + +struct seccomp_filter; + +struct seccomp { + int mode; + struct seccomp_filter *filter; +}; + +struct seccomp_data { + int nr; + __u32 arch; + __u64 instruction_pointer; + __u64 args[6]; +}; + +struct seccomp_filter { + atomic_t usage; + struct seccomp_filter *prev; + struct bpf_prog *prog; +}; + +struct sem { + int semval; + int sempid; + spinlock_t lock; + struct list_head pending_alter; + struct list_head pending_const; + time_t sem_otime; + long: 64; +}; + +struct sem_array { + struct kern_ipc_perm sem_perm; + time_t sem_ctime; + struct sem *sem_base; + struct list_head pending_alter; + struct list_head pending_const; + struct list_head list_id; + int sem_nsems; + int complex_count; +}; + +struct sem_undo; + +struct sembuf; + +struct sem_queue { + struct list_head list; + struct task_struct___2 *sleeper; + struct sem_undo *undo; + int pid; + int status; + struct sembuf *sops; + struct sembuf *blocking; + int nsops; + int alter; +}; + +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; +}; + +struct sem_undo_list { + atomic_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; + __kernel_time_t sem_otime; + __kernel_ulong_t __unused1; + __kernel_time_t sem_ctime; + __kernel_ulong_t __unused2; + __kernel_ulong_t sem_nsems; + __kernel_ulong_t __unused3; + __kernel_ulong_t __unused4; +}; + +struct semid_ds { + struct ipc_perm sem_perm; + __kernel_time_t sem_otime; + __kernel_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_queue { + struct virtqueue *vq; + struct scatterlist sg[19]; + char name[40]; +}; + +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; + u64 version; + struct mutex lock; + const struct seq_operations *op; + int poll_event; + const struct file___2 *file; + void *private; +}; + +struct seq_operations___2; + +struct seq_file___2 { + char *buf; + size_t size; + size_t from; + size_t count; + size_t pad_until; + loff_t index; + loff_t read_pos; + u64 version; + struct mutex___2 lock; + const struct seq_operations___2 *op; + int poll_event; + const struct file *file; + void *private; +}; + +struct snd_seq_client; + +struct seq_ioctl_table { + unsigned int cmd; + int (*func)(struct snd_seq_client *, void *); +}; + +struct seq_operations___2 { + void * (*start)(struct seq_file___2 *, loff_t *); + void (*stop)(struct seq_file___2 *, void *); + void * (*next)(struct seq_file___2 *, void *, loff_t *); + int (*show)(struct seq_file___2 *, void *); +}; + +struct seq_oss_chinfo { + int note; + int vel; +}; + +struct snd_seq_addr { + unsigned char client; + unsigned char port; +}; + +struct snd_seq_oss_arg { + int app_index; + int file_mode; + int seq_mode; + struct snd_seq_addr addr; + void *private_data; + int event_passing; +}; + +struct seq_oss_synth_sysex; + +struct seq_oss_synthinfo { + struct snd_seq_oss_arg arg; + struct seq_oss_chinfo *ch; + struct seq_oss_synth_sysex *sysex; + int nr_voices; + int opened; + int is_midi; + int midi_mapped; +}; + +struct seq_oss_writeq; + +struct seq_oss_readq; + +struct seq_oss_timer; + +struct seq_oss_devinfo { + int index; + int cseq; + int port; + int queue; + struct snd_seq_addr addr; + int seq_mode; + int file_mode; + int max_mididev; + int max_synthdev; + struct seq_oss_synthinfo synths[16]; + int synth_opened; + struct seq_oss_writeq *writeq; + struct seq_oss_readq *readq; + struct seq_oss_timer *timer; +}; + +struct seq_oss_midi { + int seq_device; + int client; + int port; + unsigned int flags; + int opened; + unsigned char name[30]; + struct snd_midi_event *coder; + struct seq_oss_devinfo *devinfo; + snd_use_lock_t use_lock; +}; + +struct seq_oss_readq { + union evrec *q; + int qlen; + int maxlen; + int head; + int tail; + long unsigned int pre_event_timeout; + long unsigned int input_time; + wait_queue_head_t midi_sleep; + spinlock_t lock; +}; + +struct snd_seq_oss_callback { + struct module *owner; + int (*open)(struct snd_seq_oss_arg *, void *); + int (*close)(struct snd_seq_oss_arg *); + int (*ioctl)(struct snd_seq_oss_arg *, unsigned int, long unsigned int); + int (*load_patch)(struct snd_seq_oss_arg *, int, const char *, int, int); + int (*reset)(struct snd_seq_oss_arg *); + int (*raw_event)(struct snd_seq_oss_arg *, unsigned char *); +}; + +struct seq_oss_synth { + int seq_device; + int synth_type; + int synth_subtype; + int nr_voices; + char name[30]; + struct snd_seq_oss_callback oper; + int opened; + void *private_data; + snd_use_lock_t use_lock; +}; + +struct seq_oss_synth_sysex { + int len; + int skip; + unsigned char buf[128]; +}; + +struct seq_oss_timer { + struct seq_oss_devinfo *dp; + reltime_t cur_tick; + int realtime; + int running; + int tempo; + int ppq; + int oss_tempo; + int oss_timebase; +}; + +struct seq_oss_writeq { + struct seq_oss_devinfo *dp; + int maxlen; + abstime_t sync_time; + int sync_event_put; + wait_queue_head_t sync_sleep; + spinlock_t sync_lock; +}; + +struct seqiv_ctx { + spinlock_t lock; + u8 salt[0]; +}; + +struct seqno_fence { + struct fence base; + const struct fence_ops *ops; + struct dma_buf *sync_buf; + uint32_t seqno_ofs; + enum seqno_fence_condition condition; +}; + +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_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_private { + struct pci_dev *dev; + unsigned int nr; + struct pci_serial_quirk *quirk; + int line[0]; +}; + +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[1]; + 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[1]; +}; + +struct serio_device_id { + __u8 type; + __u8 extra; + __u8 id; + __u8 proto; +}; + +struct serio_driver; + +struct serio { + void *port_data; + char name[32]; + char phys[32]; + char firmware_id[128]; + bool manual_bind; + struct serio_device_id id; + spinlock_t lock; + int (*write)(struct serio *, unsigned char); + int (*open)(struct serio *); + void (*close)(struct serio *); + int (*start)(struct serio *); + void (*stop)(struct serio *); + struct serio *parent; + struct list_head child_node; + struct list_head children; + unsigned int depth; + struct serio_driver *drv; + struct mutex drv_mutex; + struct device dev; + struct list_head node; +}; + +struct serio_driver { + const char *description; + const struct serio_device_id *id_table; + bool manual_bind; + void (*write_wakeup)(struct serio *); + irqreturn_t (*interrupt)(struct serio *, unsigned char, unsigned int); + int (*connect)(struct serio *, struct serio_driver *); + int (*reconnect)(struct serio *); + void (*disconnect)(struct serio *); + void (*cleanup)(struct serio *); + struct device_driver driver; +}; + +struct serio_event { + enum serio_event_type type; + void *object; + struct module *owner; + struct list_head node; +}; + +struct serport { + struct tty_struct *tty; + wait_queue_head_t wait; + struct serio *serio; + struct serio_device_id id; + spinlock_t lock; + long unsigned int flags; +}; + +struct set_mtrr_data { + long unsigned int smp_base; + long unsigned int smp_size; + unsigned int smp_reg; + mtrr_type smp_type; +}; + +struct setup_data_node { + u64 paddr; + u32 type; + u32 len; +}; + +struct severity { + u64 mask; + u64 result; + unsigned char sev; + unsigned char mcgmask; + unsigned char mcgres; + unsigned char ser; + unsigned char context; + unsigned char excp; + unsigned char covered; + char *msg; +}; + +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; + struct gendisk *disk; + struct cdev *cdev; + struct kref d_ref; +}; + +typedef struct sg_device Sg_device; + +struct sg_scatter_hold { + short unsigned int k_use_sg; + unsigned int sglist_len; + unsigned int bufflen; + struct page___2 **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 sg_request *nextrp; + 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; + int timeout; + int timeout_user; + Sg_scatter_hold reserve; + unsigned int save_scat_len; + Sg_request *headrp; + struct fasync_struct *async_qp; + Sg_request req_arr[16]; + char low_dma; + char force_packid; + char cmd_q; + unsigned char next_cmd_len; + char keep_orphan; + char mmap_called; + 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_hdr32 { + 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; +}; + +typedef struct sg_io_hdr32 sg_io_hdr32_t; + +struct sg_iovec { + void *iov_base; + size_t iov_len; +}; + +typedef struct sg_iovec sg_iovec_t; + +struct sg_iovec32 { + compat_uint_t iov_base; + compat_uint_t iov_len; +}; + +typedef struct sg_iovec32 sg_iovec32_t; + +struct sg_list { + unsigned int n; + unsigned int size; + size_t len; + struct scatterlist *sg; +}; + +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 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_proc_leaf { + const char *name; + const struct file_operations___2 *fops; +}; + +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 sgi_volume { + s8 name[8]; + __be32 block_num; + __be32 num_bytes; +}; + +struct sgi_partition { + __be32 num_blocks; + __be32 first_block; + __be32 type; +}; + +struct sgi_disklabel { + __be32 magic_mushroom; + __be16 root_part_num; + __be16 swap_part_num; + s8 boot_file[16]; + u8 _unused0[48]; + struct sgi_volume volume[15]; + struct sgi_partition partitions[16]; + __be32 csum; + __be32 _unused1; +}; + +struct sha1_state { + u32 state[5]; + u64 count; + u8 buffer[64]; +}; + +struct sha256_state { + u32 state[8]; + u64 count; + u8 buf[64]; +}; + +struct shared_msr_entry { + unsigned int index; + u64 data; + u64 mask; +}; + +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); + unsigned int descsize; + long: 0; + unsigned int digestsize; + unsigned int statesize; + struct crypto_alg base; +}; + +struct shash_instance { + struct shash_alg alg; +}; + +struct shm_file_data { + int id; + struct ipc_namespace *ns; + struct file *file; + const struct vm_operations_struct___2 *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; + struct shared_policy policy; + struct list_head swaplist; + struct simple_xattrs xattrs; + struct inode vfs_inode; +}; + +struct shmem_sb_info { + long unsigned int max_blocks; + struct percpu_counter used_blocks; + long unsigned int max_inodes; + long unsigned int free_inodes; + spinlock_t stat_lock; + kuid_t uid; + kgid_t gid; + umode_t mode; + struct mempolicy *mpol; +}; + +struct shmid64_ds { + struct ipc64_perm shm_perm; + size_t shm_segsz; + __kernel_time_t shm_atime; + __kernel_time_t shm_dtime; + __kernel_time_t shm_ctime; + __kernel_pid_t shm_cpid; + __kernel_pid_t shm_lpid; + __kernel_ulong_t shm_nattch; + __kernel_ulong_t __unused4; + __kernel_ulong_t __unused5; +}; + +struct shmid_ds { + struct ipc_perm shm_perm; + int shm_segsz; + __kernel_time_t shm_atime; + __kernel_time_t shm_dtime; + __kernel_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; + time_t shm_atim; + time_t shm_dtim; + time_t shm_ctim; + pid_t shm_cprid; + pid_t shm_lprid; + struct user_struct *mlock_user; + struct task_struct *shm_creator; + struct list_head shm_clist; +}; + +struct shminfo { + int shmmax; + int shmmin; + int shmmni; + int shmseg; + int shmall; +}; + +struct shminfo64 { + __kernel_ulong_t shmmax; + __kernel_ulong_t shmmin; + __kernel_ulong_t shmmni; + __kernel_ulong_t shmseg; + __kernel_ulong_t shmall; + __kernel_ulong_t __unused1; + __kernel_ulong_t __unused2; + __kernel_ulong_t __unused3; + __kernel_ulong_t __unused4; +}; + +struct shortname_table { + unsigned int id; + const char *s; +}; + +struct shrink_control { + gfp_t gfp_mask; + long unsigned int nr_to_scan; + int nid; + struct mem_cgroup *memcg; +}; + +struct shrinker_lock_uninterruptible { + bool was_interruptible; + bool unlock; +}; + +typedef struct sigevent sigevent_t; + +struct sigframe_ia32 { + u32 pretcode; + int sig; + struct sigcontext_32 sc; + struct _fpstate_32 fpstate_unused; + unsigned int extramask[1]; + char retcode[8]; +}; + +struct sighand_struct { + atomic_t count; + struct k_sigaction action[64]; + spinlock_t siglock; + wait_queue_head_t signalfd_wqh; +}; + +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; + bool running; + bool checking_timer; +}; + +struct task_cputime { + cputime_t utime; + cputime_t stime; + long long unsigned int sum_exec_runtime; +}; + +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 signal_struct { + atomic_t sigcnt; + atomic_t live; + int nr_threads; + atomic_t oom_victims; + struct list_head thread_head; + wait_queue_head_t wait_chldexit; + struct task_struct *curr_target; + struct sigpending shared_pending; + int group_exit_code; + int notify_count; + struct task_struct *group_exit_task; + int group_stop_count; + unsigned int flags; + unsigned int is_child_subreaper: 1; + unsigned int has_child_subreaper: 1; + int posix_timer_id; + struct list_head posix_timers; + struct hrtimer real_timer; + struct pid___2 *leader_pid; + ktime_t it_real_incr; + struct cpu_itimer it[2]; + struct thread_group_cputimer cputimer; + struct task_cputime cputime_expires; + struct list_head cpu_timers[3]; + struct pid___2 *tty_old_pgrp; + int leader; + struct tty_struct *tty; + struct autogroup *autogroup; + seqlock_t stats_lock; + cputime_t utime; + cputime_t stime; + cputime_t cutime; + cputime_t cstime; + cputime_t gtime; + cputime_t 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; + bool oom_flag_origin; + short int oom_score_adj; + short int oom_score_adj_min; + struct mutex cred_guard_mutex; +}; + +struct signal_struct___2 { + atomic_t sigcnt; + atomic_t live; + int nr_threads; + atomic_t oom_victims; + struct list_head thread_head; + wait_queue_head_t wait_chldexit; + struct task_struct___2 *curr_target; + struct sigpending shared_pending; + int group_exit_code; + int notify_count; + struct task_struct___2 *group_exit_task; + int group_stop_count; + unsigned int flags; + unsigned int is_child_subreaper: 1; + unsigned int has_child_subreaper: 1; + int posix_timer_id; + struct list_head posix_timers; + struct hrtimer real_timer; + struct pid *leader_pid; + ktime_t it_real_incr; + struct cpu_itimer it[2]; + struct thread_group_cputimer cputimer; + struct task_cputime cputime_expires; + struct list_head cpu_timers[3]; + struct pid *tty_old_pgrp; + int leader; + struct tty_struct *tty; + struct autogroup *autogroup; + seqlock_t stats_lock; + cputime_t utime; + cputime_t stime; + cputime_t cutime; + cputime_t cstime; + cputime_t gtime; + cputime_t 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; + bool oom_flag_origin; + short int oom_score_adj; + short int oom_score_adj_min; + struct mutex___2 cred_guard_mutex; +}; + +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; + __u8 __pad[46]; +}; + +struct sigqueue { + struct list_head list; + int flags; + siginfo_t info; + struct user_struct *user; +}; + +struct sil164_priv { + bool quiet; +}; + +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_transaction_argresp { + ssize_t size; + char data[0]; +}; + +struct simple_xattr { + struct list_head list; + char *name; + size_t size; + char value[0]; +}; + +struct simplefb_platform_data { + u32 width; + u32 height; + u32 stride; + const char *format; +}; + +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_vif_req { + vifi_t vifi; + long unsigned int icount; + long unsigned int ocount; + long unsigned int ibytes; + long unsigned int obytes; +}; + +typedef struct sk_buff *pto_T_____23; + +struct skb_mstamp { + union { + u64 v64; + struct { + u32 stamp_us; + u32 stamp_jiffies; + }; + }; +}; + +struct sk_buff { + union { + struct { + struct sk_buff *next; + struct sk_buff *prev; + union { + ktime_t tstamp; + struct skb_mstamp skb_mstamp; + }; + }; + struct rb_node rbnode; + }; + struct sock *sk; + struct net_device *dev; + char cb[48]; + long unsigned int _skb_refdst; + void (*destructor)(struct sk_buff *); + unsigned int len; + unsigned int data_len; + __u16 mac_len; + __u16 hdr_len; + __u16 queue_mapping; + __u8 cloned: 1; + __u8 nohdr: 1; + __u8 fclone: 2; + __u8 peeked: 1; + __u8 head_frag: 1; + __u8 xmit_more: 1; + __u32 headers_start[0]; + __u8 __pkt_type_offset[0]; + __u8 pkt_type: 3; + __u8 pfmemalloc: 1; + __u8 ignore_df: 1; + __u8 nfctinfo: 3; + __u8 nf_trace: 1; + __u8 ip_summed: 2; + __u8 ooo_okay: 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 csum_complete_sw: 1; + __u8 csum_level: 2; + __u8 csum_bad: 1; + __u8 ipvs_property: 1; + __u8 inner_protocol_type: 1; + __u8 remcsum_offload: 1; + __u16 tc_index; + __u16 tc_verd; + union { + __wsum csum; + struct { + __u16 csum_start; + __u16 csum_offset; + }; + }; + __u32 priority; + int skb_iif; + __u32 hash; + __be16 vlan_proto; + __u16 vlan_tci; + union { + unsigned int napi_id; + unsigned int sender_cpu; + }; + union { + __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; + __u32 headers_end[0]; + sk_buff_data_t tail; + sk_buff_data_t end; + unsigned char *head; + unsigned char *data; + unsigned int truesize; + atomic_t users; +}; + +struct sk_buff___2 { + union { + struct { + struct sk_buff___2 *next; + struct sk_buff___2 *prev; + union { + ktime_t tstamp; + struct skb_mstamp skb_mstamp; + }; + }; + struct rb_node rbnode; + }; + struct sock *sk; + struct net_device___2 *dev; + char cb[48]; + long unsigned int _skb_refdst; + void (*destructor)(struct sk_buff___2 *); + unsigned int len; + unsigned int data_len; + __u16 mac_len; + __u16 hdr_len; + __u16 queue_mapping; + __u8 cloned: 1; + __u8 nohdr: 1; + __u8 fclone: 2; + __u8 peeked: 1; + __u8 head_frag: 1; + __u8 xmit_more: 1; + __u32 headers_start[0]; + __u8 __pkt_type_offset[0]; + __u8 pkt_type: 3; + __u8 pfmemalloc: 1; + __u8 ignore_df: 1; + __u8 nfctinfo: 3; + __u8 nf_trace: 1; + __u8 ip_summed: 2; + __u8 ooo_okay: 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 csum_complete_sw: 1; + __u8 csum_level: 2; + __u8 csum_bad: 1; + __u8 ipvs_property: 1; + __u8 inner_protocol_type: 1; + __u8 remcsum_offload: 1; + __u16 tc_index; + __u16 tc_verd; + union { + __wsum csum; + struct { + __u16 csum_start; + __u16 csum_offset; + }; + }; + __u32 priority; + int skb_iif; + __u32 hash; + __be16 vlan_proto; + __u16 vlan_tci; + union { + unsigned int napi_id; + unsigned int sender_cpu; + }; + union { + __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; + __u32 headers_end[0]; + sk_buff_data_t tail; + sk_buff_data_t end; + unsigned char *head; + unsigned char *data; + unsigned int truesize; + atomic_t users; +}; + +struct sk_buff_fclones { + struct sk_buff skb1; + struct sk_buff skb2; + atomic_t fclone_ref; +}; + +struct sk_filter { + atomic_t refcnt; + struct callback_head rcu; + struct bpf_prog *prog; +}; + +struct skb_checksum_ops { + __wsum (*update)(const void *, int, __wsum); + __wsum (*combine)(__wsum, __wsum, int, int); +}; + +struct skb_csum_offl_spec { + __u16 ipv4_okay: 1; + __u16 ipv6_okay: 1; + __u16 encap_okay: 1; + __u16 ip_options_okay: 1; + __u16 ext_hdrs_okay: 1; + __u16 tcp_okay: 1; + __u16 udp_okay: 1; + __u16 sctp_okay: 1; + __u16 vlan_okay: 1; + __u16 no_encapped_ipv6: 1; + __u16 no_not_encapped: 1; +}; + +struct skb_frag_struct { + struct { + struct page___2 *p; + } page; + __u32 page_offset; + __u32 size; +}; + +typedef struct skb_frag_struct skb_frag_t; + +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; +}; + +struct skb_shared_hwtstamps { + ktime_t hwtstamp; +}; + +struct skb_shared_info { + unsigned char nr_frags; + __u8 tx_flags; + short unsigned int gso_size; + short unsigned int gso_segs; + short unsigned int gso_type; + struct sk_buff *frag_list; + struct skb_shared_hwtstamps hwtstamps; + u32 tskey; + __be32 ip6_frag_id; + atomic_t dataref; + void *destructor_arg; + skb_frag_t frags[17]; +}; + +struct skcipher_givcrypt_request { + u64 seq; + u8 *giv; + struct ablkcipher_request creq; +}; + +struct skcipher_request { + unsigned int cryptlen; + u8 *iv; + struct scatterlist *src; + struct scatterlist *dst; + struct crypto_async_request base; + void *__ctx[0]; +}; + +struct skl_cdclk_entry { + unsigned int freq; + unsigned int vco; +}; + +struct skl_dpll_regs { + i915_reg_t ctl; + i915_reg_t cfgcr1; + i915_reg_t cfgcr2; +}; + +struct skl_wrpll_context { + uint64_t min_deviation; + uint64_t central_freq; + uint64_t dco_freq; + unsigned int p; +}; + +struct skl_wrpll_params { + uint32_t dco_fraction; + uint32_t dco_integer; + uint32_t qdiv_ratio; + uint32_t qdiv_mode; + uint32_t kdiv; + uint32_t pdiv; + uint32_t central_freq; +}; + +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 snd_mixer_oss_assign_table; + +struct slot { + unsigned int signature; + unsigned int present; + unsigned int channels; + unsigned int numid[11]; + unsigned int capture_item; + struct snd_mixer_oss_assign_table *assigned; + unsigned int allocated: 1; +}; + +struct slot_rmap_walk_iterator { + struct kvm_memory_slot *slot; + gfn_t start_gfn; + gfn_t end_gfn; + int start_level; + int end_level; + gfn_t gfn; + struct kvm_rmap_head *rmap; + int level; + struct kvm_rmap_head *end_rmap; +}; + +struct smp_alt_module { + struct module *mod; + char *name; + const s32 *locks; + const s32 *locks_end; + u8 *text; + u8 *text_end; + struct list_head next; +}; + +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); + cpumask_var_t cpumask; + bool selfparking; + const char *thread_comm; +}; + +struct smp_ops { + void (*smp_prepare_boot_cpu)(void); + void (*smp_prepare_cpus)(unsigned int); + void (*smp_cpus_done)(unsigned int); + void (*stop_other_cpus)(int); + void (*smp_send_reschedule)(int); + int (*cpu_up)(unsigned int, struct task_struct *); + int (*cpu_disable)(void); + void (*cpu_die)(unsigned int); + void (*play_dead)(void); + void (*send_call_func_ipi)(const struct cpumask *); + void (*send_call_func_single_ipi)(int); +}; + +struct smpboot_thread_data { + unsigned int cpu; + unsigned int status; + struct smp_hotplug_thread *ht; +}; + +struct snapshot_handle { + unsigned int cur; + void *buffer; + int sync_read; +}; + +struct snapshot_data { + struct snapshot_handle handle; + int swap; + int mode; + bool frozen; + bool ready; + bool platform_support; + bool free_bitmaps; +}; + +struct snd_ac97_gpio_priv; + +struct snd_ac97_build_ops; + +struct snd_info_entry; + +struct snd_ac97_res_table; + +struct snd_pcm_chmap; + +struct snd_ac97 { + const struct snd_ac97_build_ops *build_ops; + void *private_data; + void (*private_free)(struct snd_ac97 *); + struct snd_ac97_bus *bus; + struct pci_dev *pci; + struct snd_info_entry *proc; + struct snd_info_entry *proc_regs; + short unsigned int subsystem_vendor; + short unsigned int subsystem_device; + struct mutex reg_mutex; + struct mutex page_mutex; + short unsigned int num; + short unsigned int addr; + unsigned int id; + short unsigned int caps; + short unsigned int ext_id; + short unsigned int ext_mid; + const struct snd_ac97_res_table *res_table; + unsigned int scaps; + unsigned int flags; + unsigned int rates[6]; + unsigned int spdif_status; + short unsigned int regs[128]; + long unsigned int reg_accessed[2]; + union { + struct { + short unsigned int unchained[3]; + short unsigned int chained[3]; + short unsigned int id[3]; + short unsigned int pcmreg[3]; + short unsigned int codec_cfg[3]; + unsigned char swap_mic_linein; + unsigned char lo_as_master; + } ad18xx; + unsigned int dev_flags; + } spec; + unsigned char indep_surround; + unsigned char channel_mode; + struct device dev; + struct snd_ac97_gpio_priv *gpio_priv; + struct snd_pcm_chmap *chmaps[2]; +}; + +struct snd_ac97_build_ops { + int (*build_3d)(struct snd_ac97 *); + int (*build_specific)(struct snd_ac97 *); + int (*build_spdif)(struct snd_ac97 *); + int (*build_post_spdif)(struct snd_ac97 *); + void (*suspend)(struct snd_ac97 *); + void (*resume)(struct snd_ac97 *); + void (*update_jacks)(struct snd_ac97 *); +}; + +struct snd_ac97_bus_ops; + +struct snd_ac97_bus { + struct snd_ac97_bus_ops *ops; + void *private_data; + void (*private_free)(struct snd_ac97_bus *); + struct snd_card *card; + short unsigned int num; + short unsigned int no_vra: 1; + short unsigned int dra: 1; + short unsigned int isdin: 1; + unsigned int clock; + spinlock_t bus_lock; + short unsigned int used_slots[8]; + short unsigned int pcms_count; + struct ac97_pcm *pcms; + struct snd_ac97 *codec[4]; + struct snd_info_entry *proc; +}; + +struct snd_ac97_bus_ops { + void (*reset)(struct snd_ac97 *); + void (*warm_reset)(struct snd_ac97 *); + void (*write)(struct snd_ac97 *, short unsigned int, short unsigned int); + short unsigned int (*read)(struct snd_ac97 *, short unsigned int); + void (*wait)(struct snd_ac97 *); + void (*init)(struct snd_ac97 *); +}; + +struct snd_ac97_res_table { + short unsigned int reg; + short unsigned int bits; +}; + +struct snd_ac97_template { + void *private_data; + void (*private_free)(struct snd_ac97 *); + struct pci_dev *pci; + short unsigned int num; + short unsigned int addr; + unsigned int scaps; + const struct snd_ac97_res_table *res_table; +}; + +struct snd_aes_iec958 { + unsigned char status[24]; + unsigned char subcode[147]; + unsigned char pad; + unsigned char dig_subframe[4]; +}; + +struct snd_shutdown_f_ops; + +struct snd_mixer_oss; + +struct snd_card { + int number; + char id[16]; + char driver[16]; + char shortname[32]; + char longname[80]; + char irq_descr[32]; + char mixername[80]; + char components[128]; + struct module *module; + void *private_data; + void (*private_free)(struct snd_card *); + struct list_head devices; + struct device ctl_dev; + unsigned int last_numid; + struct rw_semaphore controls_rwsem; + rwlock_t ctl_files_rwlock; + int controls_count; + int user_ctl_count; + struct list_head controls; + struct list_head ctl_files; + struct mutex user_ctl_lock; + struct snd_info_entry *proc_root; + struct snd_info_entry *proc_id; + struct proc_dir_entry *proc_root_link; + struct list_head files_list; + struct snd_shutdown_f_ops *s_f_ops; + spinlock_t files_lock; + int shutdown; + struct completion *release_completion; + struct device *dev; + struct device card_dev; + const struct attribute_group *dev_groups[4]; + bool registered; + unsigned int power_state; + struct mutex power_lock; + wait_queue_head_t power_sleep; + struct snd_mixer_oss *mixer_oss; + int mixer_oss_change_count; +}; + +struct snd_ctl_card_info { + int card; + int pad; + unsigned char id[16]; + unsigned char driver[16]; + unsigned char name[32]; + unsigned char longname[80]; + unsigned char reserved_[16]; + unsigned char mixername[80]; + unsigned char components[128]; +}; + +struct snd_ctl_elem_info { + struct snd_ctl_elem_id id; + snd_ctl_elem_type_t type; + unsigned int access; + unsigned int count; + __kernel_pid_t owner; + union { + struct { + long int min; + long int max; + long int step; + } integer; + struct { + long long int min; + long long int max; + long long int step; + } integer64; + struct { + unsigned int items; + unsigned int item; + char name[64]; + __u64 names_ptr; + unsigned int names_length; + } enumerated; + unsigned char reserved[128]; + } value; + union { + short unsigned int d[4]; + short unsigned int *d_ptr; + } dimen; + unsigned char reserved[56]; +}; + +struct snd_ctl_elem_info32 { + struct snd_ctl_elem_id id; + s32 type; + u32 access; + u32 count; + s32 owner; + union { + struct { + s32 min; + s32 max; + s32 step; + } integer; + struct { + u64 min; + u64 max; + u64 step; + } integer64; + struct { + u32 items; + u32 item; + char name[64]; + u64 names_ptr; + u32 names_length; + } enumerated; + unsigned char reserved[128]; + } value; + unsigned char reserved[64]; +}; + +struct snd_ctl_elem_list { + unsigned int offset; + unsigned int space; + unsigned int used; + unsigned int count; + struct snd_ctl_elem_id *pids; + unsigned char reserved[50]; +}; + +struct snd_ctl_elem_list32 { + u32 offset; + u32 space; + u32 used; + u32 count; + u32 pids; + unsigned char reserved[50]; +}; + +struct snd_ctl_elem_value { + struct snd_ctl_elem_id id; + unsigned int indirect: 1; + union { + union { + long int value[128]; + long int *value_ptr; + } integer; + union { + long long int value[64]; + long long int *value_ptr; + } integer64; + union { + unsigned int item[128]; + unsigned int *item_ptr; + } enumerated; + union { + unsigned char data[512]; + unsigned char *data_ptr; + } bytes; + struct snd_aes_iec958 iec958; + } value; + struct timespec tstamp; + unsigned char reserved[112]; +}; + +struct snd_ctl_elem_value32 { + struct snd_ctl_elem_id id; + unsigned int indirect; + union { + s32 integer[128]; + unsigned char data[512]; + } value; + unsigned char reserved[128]; +}; + +struct snd_ctl_event { + int type; + union { + struct { + unsigned int mask; + struct snd_ctl_elem_id id; + } elem; + unsigned char data8[60]; + } data; +}; + +struct snd_ctl_file { + struct list_head list; + struct snd_card *card; + struct pid___2 *pid; + int preferred_subdevice[2]; + wait_queue_head_t change_sleep; + spinlock_t read_lock; + struct fasync_struct *fasync; + int subscribed; + struct list_head events; +}; + +struct snd_ctl_tlv { + unsigned int numid; + unsigned int length; + unsigned int tlv[0]; +}; + +struct snd_device_ops; + +struct snd_device { + struct list_head list; + struct snd_card *card; + enum snd_device_state state; + enum snd_device_type type; + void *device_data; + struct snd_device_ops *ops; +}; + +struct snd_device_ops { + int (*dev_free)(struct snd_device *); + int (*dev_register)(struct snd_device *); + int (*dev_disconnect)(struct snd_device *); +}; + +struct snd_hda_pin_quirk { + unsigned int codec; + short unsigned int subvendor; + const struct hda_pintbl *pins; + int value; +}; + +struct snd_timer; + +struct snd_hrtimer { + struct snd_timer *timer; + struct hrtimer hrt; + bool in_callback; +}; + +struct snd_hwdep_dsp_status; + +struct snd_hwdep_dsp_image; + +struct snd_hwdep_ops { + long long int (*llseek)(struct snd_hwdep *, struct file___2 *, long long int, int); + long int (*read)(struct snd_hwdep *, char *, long int, loff_t *); + long int (*write)(struct snd_hwdep *, const char *, long int, loff_t *); + int (*open)(struct snd_hwdep *, struct file___2 *); + int (*release)(struct snd_hwdep *, struct file___2 *); + unsigned int (*poll)(struct snd_hwdep *, struct file___2 *, poll_table *); + int (*ioctl)(struct snd_hwdep *, struct file___2 *, unsigned int, long unsigned int); + int (*ioctl_compat)(struct snd_hwdep *, struct file___2 *, unsigned int, long unsigned int); + int (*mmap)(struct snd_hwdep *, struct file___2 *, struct vm_area_struct___2 *); + int (*dsp_status)(struct snd_hwdep *, struct snd_hwdep_dsp_status *); + int (*dsp_load)(struct snd_hwdep *, struct snd_hwdep_dsp_image *); +}; + +struct snd_hwdep { + struct snd_card *card; + struct list_head list; + int device; + char id[32]; + char name[80]; + int iface; + int oss_type; + int ossreg; + struct snd_hwdep_ops ops; + wait_queue_head_t open_wait; + void *private_data; + void (*private_free)(struct snd_hwdep *); + struct device dev; + struct mutex open_mutex; + int used; + unsigned int dsp_loaded; + unsigned int exclusive: 1; +}; + +struct snd_hwdep_dsp_image { + unsigned int index; + unsigned char name[64]; + unsigned char *image; + size_t length; + long unsigned int driver_data; +}; + +struct snd_hwdep_dsp_image32 { + u32 index; + unsigned char name[64]; + u32 image; + u32 length; + u32 driver_data; +}; + +struct snd_hwdep_dsp_status { + unsigned int version; + unsigned char id[32]; + unsigned int num_dsps; + unsigned int dsp_loaded; + unsigned int chip_ready; + unsigned char reserved[16]; +}; + +struct snd_hwdep_info { + unsigned int device; + int card; + unsigned char id[64]; + unsigned char name[80]; + int iface; + unsigned char reserved[64]; +}; + +struct snd_info_buffer { + char *buffer; + unsigned int curr; + unsigned int size; + unsigned int len; + int stop; + int error; +}; + +struct snd_info_entry_text { + void (*read)(struct snd_info_entry *, struct snd_info_buffer *); + void (*write)(struct snd_info_entry *, struct snd_info_buffer *); +}; + +struct snd_info_entry_ops; + +struct snd_info_entry { + const char *name; + umode_t mode; + long int size; + short unsigned int content; + union { + struct snd_info_entry_text text; + struct snd_info_entry_ops *ops; + } c; + struct snd_info_entry *parent; + struct snd_card *card; + struct module *module; + void *private_data; + void (*private_free)(struct snd_info_entry *); + struct proc_dir_entry *p; + struct mutex access; + struct list_head children; + struct list_head list; +}; + +struct snd_info_entry_ops { + int (*open)(struct snd_info_entry *, short unsigned int, void **); + int (*release)(struct snd_info_entry *, short unsigned int, void *); + ssize_t (*read)(struct snd_info_entry *, void *, struct file___2 *, char *, size_t, loff_t); + ssize_t (*write)(struct snd_info_entry *, void *, struct file___2 *, const char *, size_t, loff_t); + loff_t (*llseek)(struct snd_info_entry *, void *, struct file___2 *, loff_t, int); + unsigned int (*poll)(struct snd_info_entry *, void *, struct file___2 *, poll_table *); + int (*ioctl)(struct snd_info_entry *, void *, struct file___2 *, unsigned int, long unsigned int); + int (*mmap)(struct snd_info_entry *, void *, struct inode *, struct file___2 *, struct vm_area_struct___2 *); +}; + +struct snd_info_private_data { + struct snd_info_buffer *rbuffer; + struct snd_info_buffer *wbuffer; + struct snd_info_entry *entry; + void *file_private_data; +}; + +struct snd_interval { + unsigned int min; + unsigned int max; + unsigned int openmin: 1; + unsigned int openmax: 1; + unsigned int integer: 1; + unsigned int empty: 1; +}; + +struct snd_jack { + struct list_head kctl_list; + struct snd_card *card; + const char *id; + struct input_dev *input_dev; + int registered; + int type; + char name[100]; + unsigned int key[6]; + void *private_data; + void (*private_free)(struct snd_jack *); +}; + +struct snd_jack_kctl { + struct snd_kcontrol *kctl; + struct list_head list; + unsigned int mask_bits; +}; + +struct snd_kcontrol_new { + snd_ctl_elem_iface_t iface; + unsigned int device; + unsigned int subdevice; + const unsigned char *name; + unsigned int index; + unsigned int access; + unsigned int count; + snd_kcontrol_info_t *info; + snd_kcontrol_get_t *get; + snd_kcontrol_put_t *put; + union { + snd_kcontrol_tlv_rw_t *c; + const unsigned int *p; + } tlv; + long unsigned int private_value; +}; + +struct snd_kctl_event { + struct list_head list; + struct snd_ctl_elem_id id; + unsigned int mask; +}; + +typedef int (*snd_kctl_ioctl_func_t)(struct snd_card *, struct snd_ctl_file *, unsigned int, long unsigned int); + +struct snd_kctl_ioctl { + struct list_head list; + snd_kctl_ioctl_func_t fioctl; +}; + +struct snd_mask { + __u32 bits[8]; +}; + +struct snd_midi_event { + int qlen; + int read; + int type; + unsigned char lastcmd; + unsigned char nostat; + int bufsize; + unsigned char *buf; + spinlock_t lock; +}; + +struct snd_minor { + int type; + int card; + int device; + const struct file_operations___2 *f_ops; + void *private_data; + struct device *dev; + struct snd_card *card_ptr; +}; + +struct snd_mixer_oss_file; + +struct snd_mixer_oss_slot { + int number; + unsigned int stereo: 1; + int (*get_volume)(struct snd_mixer_oss_file *, struct snd_mixer_oss_slot *, int *, int *); + int (*put_volume)(struct snd_mixer_oss_file *, struct snd_mixer_oss_slot *, int, int); + int (*get_recsrc)(struct snd_mixer_oss_file *, struct snd_mixer_oss_slot *, int *); + int (*put_recsrc)(struct snd_mixer_oss_file *, struct snd_mixer_oss_slot *, int); + long unsigned int private_value; + void *private_data; + void (*private_free)(struct snd_mixer_oss_slot *); + int volume[2]; +}; + +struct snd_mixer_oss { + struct snd_card *card; + char id[16]; + char name[32]; + struct snd_mixer_oss_slot slots[32]; + unsigned int mask_recsrc; + int (*get_recsrc)(struct snd_mixer_oss_file *, unsigned int *); + int (*put_recsrc)(struct snd_mixer_oss_file *, unsigned int); + void *private_data_recsrc; + void (*private_free_recsrc)(struct snd_mixer_oss *); + struct mutex reg_mutex; + struct snd_info_entry *proc_entry; + int oss_dev_alloc; + int oss_recsrc; +}; + +struct snd_mixer_oss_assign_table { + int oss_id; + const char *name; + int index; +}; + +struct snd_mixer_oss_file { + struct snd_card *card; + struct snd_mixer_oss *mixer; +}; + +struct snd_monitor_file { + struct file___2 *file; + const struct file_operations___2 *disconnected_f_op; + struct list_head shutdown_list; + struct list_head list; +}; + +struct snd_pci_quirk { + short unsigned int subvendor; + short unsigned int subdevice; + short unsigned int subdevice_mask; + int value; +}; + +struct snd_pcm_oss_setup; + +struct snd_pcm_oss_stream { + struct snd_pcm_oss_setup *setup_list; + struct mutex setup_mutex; + struct snd_info_entry *proc_entry; +}; + +struct snd_pcm_str { + int stream; + struct snd_pcm *pcm; + unsigned int substream_count; + unsigned int substream_opened; + struct snd_pcm_substream *substream; + struct snd_pcm_oss_stream oss; + struct snd_info_entry *proc_root; + struct snd_info_entry *proc_info_entry; + struct snd_kcontrol *chmap_kctl; + struct device dev; +}; + +struct snd_pcm_oss { + int reg; + unsigned int reg_mask; +}; + +struct snd_pcm { + struct snd_card *card; + struct list_head list; + int device; + unsigned int info_flags; + short unsigned int dev_class; + short unsigned int dev_subclass; + char id[64]; + char name[80]; + struct snd_pcm_str streams[2]; + struct mutex open_mutex; + wait_queue_head_t open_wait; + void *private_data; + void (*private_free)(struct snd_pcm *); + bool internal; + bool nonatomic; + struct snd_pcm_oss oss; +}; + +struct snd_pcm_audio_tstamp_config { + u32 type_requested: 4; + u32 report_delay: 1; +}; + +struct snd_pcm_audio_tstamp_report { + u32 valid: 1; + u32 actual_type: 4; + u32 accuracy_report: 1; + u32 accuracy; +}; + +struct snd_pcm_channel_area { + void *addr; + unsigned int first; + unsigned int step; +}; + +struct snd_pcm_channel_info { + unsigned int channel; + __kernel_off_t offset; + unsigned int first; + unsigned int step; +}; + +struct snd_pcm_channel_info32 { + u32 channel; + u32 offset; + u32 first; + u32 step; +}; + +struct snd_pcm_chmap { + struct snd_pcm *pcm; + int stream; + struct snd_kcontrol *kctl; + const struct snd_pcm_chmap_elem *chmap; + unsigned int max_channels; + unsigned int channel_mask; + void *private_data; +}; + +struct snd_pcm_chmap_elem { + unsigned char channels; + unsigned char map[15]; +}; + +struct snd_pcm_file { + struct snd_pcm_substream *substream; + int no_compat_mmap; +}; + +struct snd_pcm_group { + spinlock_t lock; + struct mutex mutex; + struct list_head substreams; + int count; +}; + +struct snd_pcm_hardware { + unsigned int info; + u64 formats; + unsigned int rates; + unsigned int rate_min; + unsigned int rate_max; + unsigned int channels_min; + unsigned int channels_max; + size_t buffer_bytes_max; + size_t period_bytes_min; + size_t period_bytes_max; + unsigned int periods_min; + unsigned int periods_max; + size_t fifo_size; +}; + +struct snd_pcm_hw_constraint_list { + const unsigned int *list; + unsigned int count; + unsigned int mask; +}; + +struct snd_pcm_hw_constraint_ranges { + unsigned int count; + const struct snd_interval *ranges; + unsigned int mask; +}; + +struct snd_ratden; + +struct snd_pcm_hw_constraint_ratdens { + int nrats; + const struct snd_ratden *rats; +}; + +struct snd_ratnum; + +struct snd_pcm_hw_constraint_ratnums { + int nrats; + const struct snd_ratnum *rats; +}; + +struct snd_pcm_hw_rule; + +struct snd_pcm_hw_constraints { + struct snd_mask masks[3]; + struct snd_interval intervals[12]; + unsigned int rules_num; + unsigned int rules_all; + struct snd_pcm_hw_rule *rules; +}; + +struct snd_pcm_hw_params { + unsigned int flags; + struct snd_mask masks[3]; + struct snd_mask mres[5]; + struct snd_interval intervals[12]; + struct snd_interval ires[9]; + unsigned int rmask; + unsigned int cmask; + unsigned int info; + unsigned int msbits; + unsigned int rate_num; + unsigned int rate_den; + snd_pcm_uframes_t fifo_size; + unsigned char reserved[64]; +}; + +struct snd_pcm_hw_params32 { + u32 flags; + struct snd_mask masks[3]; + struct snd_mask mres[5]; + struct snd_interval intervals[12]; + struct snd_interval ires[9]; + u32 rmask; + u32 cmask; + u32 info; + u32 msbits; + u32 rate_num; + u32 rate_den; + u32 fifo_size; + unsigned char reserved[64]; +}; + +struct snd_pcm_hw_params_old { + unsigned int flags; + unsigned int masks[3]; + struct snd_interval intervals[12]; + unsigned int rmask; + unsigned int cmask; + unsigned int info; + unsigned int msbits; + unsigned int rate_num; + unsigned int rate_den; + snd_pcm_uframes_t fifo_size; + unsigned char reserved[64]; +}; + +typedef int (*snd_pcm_hw_rule_func_t)(struct snd_pcm_hw_params *, struct snd_pcm_hw_rule *); + +struct snd_pcm_hw_rule { + unsigned int cond; + int var; + int deps[4]; + snd_pcm_hw_rule_func_t func; + void *private; +}; + +union snd_pcm_sync_id { + unsigned char id[16]; + short unsigned int id16[8]; + unsigned int id32[4]; +}; + +struct snd_pcm_info { + unsigned int device; + unsigned int subdevice; + int stream; + int card; + unsigned char id[64]; + unsigned char name[80]; + unsigned char subname[32]; + int dev_class; + int dev_subclass; + unsigned int subdevices_count; + unsigned int subdevices_avail; + union snd_pcm_sync_id sync; + unsigned char reserved[64]; +}; + +struct snd_pcm_mmap_control { + snd_pcm_uframes_t appl_ptr; + snd_pcm_uframes_t avail_min; +}; + +struct snd_pcm_mmap_control32 { + u32 appl_ptr; + u32 avail_min; +}; + +struct snd_pcm_mmap_status { + snd_pcm_state_t state; + int pad1; + snd_pcm_uframes_t hw_ptr; + struct timespec tstamp; + snd_pcm_state_t suspended_state; + struct timespec audio_tstamp; +}; + +struct snd_pcm_mmap_status32 { + s32 state; + s32 pad1; + u32 hw_ptr; + struct compat_timespec tstamp; + s32 suspended_state; + struct compat_timespec audio_tstamp; +}; + +struct snd_pcm_notify { + int (*n_register)(struct snd_pcm *); + int (*n_disconnect)(struct snd_pcm *); + int (*n_unregister)(struct snd_pcm *); + struct list_head list; +}; + +struct snd_pcm_ops { + int (*open)(struct snd_pcm_substream *); + int (*close)(struct snd_pcm_substream *); + int (*ioctl)(struct snd_pcm_substream *, unsigned int, void *); + int (*hw_params)(struct snd_pcm_substream *, struct snd_pcm_hw_params *); + int (*hw_free)(struct snd_pcm_substream *); + int (*prepare)(struct snd_pcm_substream *); + int (*trigger)(struct snd_pcm_substream *, int); + snd_pcm_uframes_t (*pointer)(struct snd_pcm_substream *); + int (*get_time_info)(struct snd_pcm_substream *, struct timespec *, struct timespec *, struct snd_pcm_audio_tstamp_config *, struct snd_pcm_audio_tstamp_report *); + int (*copy)(struct snd_pcm_substream *, int, snd_pcm_uframes_t, void *, snd_pcm_uframes_t); + int (*silence)(struct snd_pcm_substream *, int, snd_pcm_uframes_t, snd_pcm_uframes_t); + struct page___2 * (*page)(struct snd_pcm_substream *, long unsigned int); + int (*mmap)(struct snd_pcm_substream *, struct vm_area_struct___2 *); + int (*ack)(struct snd_pcm_substream *); +}; + +struct snd_pcm_oss_file { + struct snd_pcm_substream *streams[2]; +}; + +struct snd_pcm_oss_runtime { + unsigned int params: 1; + unsigned int prepare: 1; + unsigned int trigger: 1; + unsigned int sync_trigger: 1; + int rate; + int format; + unsigned int channels; + unsigned int fragshift; + unsigned int maxfrags; + unsigned int subdivision; + size_t period_bytes; + size_t period_frames; + size_t period_ptr; + unsigned int periods; + size_t buffer_bytes; + size_t bytes; + size_t mmap_bytes; + char *buffer; + size_t buffer_used; + struct mutex params_lock; + struct snd_pcm_plugin *plugin_first; + struct snd_pcm_plugin *plugin_last; + unsigned int prev_hw_ptr_period; +}; + +struct snd_pcm_oss_setup { + char *task_name; + unsigned int disable: 1; + unsigned int direct: 1; + unsigned int block: 1; + unsigned int nonblock: 1; + unsigned int partialfrag: 1; + unsigned int nosilence: 1; + unsigned int buggyptr: 1; + unsigned int periods; + unsigned int period_size; + struct snd_pcm_oss_setup *next; +}; + +struct snd_pcm_oss_substream { + unsigned int oss: 1; + struct snd_pcm_oss_setup setup; +}; + +struct snd_pcm_plugin_format { + snd_pcm_format_t format; + unsigned int rate; + unsigned int channels; +}; + +struct snd_pcm_plugin { + const char *name; + int stream; + struct snd_pcm_plugin_format src_format; + struct snd_pcm_plugin_format dst_format; + int src_width; + int dst_width; + snd_pcm_access_t access; + snd_pcm_sframes_t (*src_frames)(struct snd_pcm_plugin *, snd_pcm_uframes_t); + snd_pcm_sframes_t (*dst_frames)(struct snd_pcm_plugin *, snd_pcm_uframes_t); + snd_pcm_sframes_t (*client_channels)(struct snd_pcm_plugin *, snd_pcm_uframes_t, struct snd_pcm_plugin_channel **); + snd_pcm_sframes_t (*transfer)(struct snd_pcm_plugin *, const struct snd_pcm_plugin_channel *, struct snd_pcm_plugin_channel *, snd_pcm_uframes_t); + int (*action)(struct snd_pcm_plugin *, enum snd_pcm_plugin_action, long unsigned int); + struct snd_pcm_plugin *prev; + struct snd_pcm_plugin *next; + struct snd_pcm_substream *plug; + void *private_data; + void (*private_free)(struct snd_pcm_plugin *); + char *buf; + snd_pcm_uframes_t buf_frames; + struct snd_pcm_plugin_channel *buf_channels; + char extra_data[0]; +}; + +struct snd_pcm_plugin_channel { + void *aptr; + struct snd_pcm_channel_area area; + snd_pcm_uframes_t frames; + unsigned int enabled: 1; + unsigned int wanted: 1; +}; + +struct snd_pcm_runtime { + struct snd_pcm_substream *trigger_master; + struct timespec trigger_tstamp; + bool trigger_tstamp_latched; + int overrange; + snd_pcm_uframes_t avail_max; + snd_pcm_uframes_t hw_ptr_base; + snd_pcm_uframes_t hw_ptr_interrupt; + long unsigned int hw_ptr_jiffies; + long unsigned int hw_ptr_buffer_jiffies; + snd_pcm_sframes_t delay; + u64 hw_ptr_wrap; + snd_pcm_access_t access; + snd_pcm_format_t format; + snd_pcm_subformat_t subformat; + unsigned int rate; + unsigned int channels; + snd_pcm_uframes_t period_size; + unsigned int periods; + snd_pcm_uframes_t buffer_size; + snd_pcm_uframes_t min_align; + size_t byte_align; + unsigned int frame_bits; + unsigned int sample_bits; + unsigned int info; + unsigned int rate_num; + unsigned int rate_den; + unsigned int no_period_wakeup: 1; + int tstamp_mode; + unsigned int period_step; + snd_pcm_uframes_t start_threshold; + snd_pcm_uframes_t stop_threshold; + snd_pcm_uframes_t silence_threshold; + snd_pcm_uframes_t silence_size; + snd_pcm_uframes_t boundary; + snd_pcm_uframes_t silence_start; + snd_pcm_uframes_t silence_filled; + union snd_pcm_sync_id sync; + struct snd_pcm_mmap_status *status; + struct snd_pcm_mmap_control *control; + snd_pcm_uframes_t twake; + wait_queue_head_t sleep; + wait_queue_head_t tsleep; + struct fasync_struct *fasync; + void *private_data; + void (*private_free)(struct snd_pcm_runtime *); + struct snd_pcm_hardware hw; + struct snd_pcm_hw_constraints hw_constraints; + unsigned int timer_resolution; + int tstamp_type; + unsigned char *dma_area; + dma_addr_t dma_addr; + size_t dma_bytes; + struct snd_dma_buffer *dma_buffer_p; + struct snd_pcm_audio_tstamp_config audio_tstamp_config; + struct snd_pcm_audio_tstamp_report audio_tstamp_report; + struct timespec driver_tstamp; + struct snd_pcm_oss_runtime oss; +}; + +struct snd_pcm_status { + snd_pcm_state_t state; + struct timespec trigger_tstamp; + struct timespec tstamp; + snd_pcm_uframes_t appl_ptr; + snd_pcm_uframes_t hw_ptr; + snd_pcm_sframes_t delay; + snd_pcm_uframes_t avail; + snd_pcm_uframes_t avail_max; + snd_pcm_uframes_t overrange; + snd_pcm_state_t suspended_state; + __u32 audio_tstamp_data; + struct timespec audio_tstamp; + struct timespec driver_tstamp; + __u32 audio_tstamp_accuracy; + unsigned char reserved[20]; +}; + +struct snd_pcm_status32 { + s32 state; + struct compat_timespec trigger_tstamp; + struct compat_timespec tstamp; + u32 appl_ptr; + u32 hw_ptr; + s32 delay; + u32 avail; + u32 avail_max; + u32 overrange; + s32 suspended_state; + u32 audio_tstamp_data; + struct compat_timespec audio_tstamp; + struct compat_timespec driver_tstamp; + u32 audio_tstamp_accuracy; + unsigned char reserved[36]; +}; + +struct snd_pcm_substream { + struct snd_pcm *pcm; + struct snd_pcm_str *pstr; + void *private_data; + int number; + char name[32]; + int stream; + struct pm_qos_request latency_pm_qos_req; + size_t buffer_bytes_max; + struct snd_dma_buffer dma_buffer; + size_t dma_max; + const struct snd_pcm_ops *ops; + struct snd_pcm_runtime *runtime; + struct snd_timer *timer; + unsigned int timer_running: 1; + struct snd_pcm_substream *next; + struct list_head link_list; + struct snd_pcm_group self_group; + struct snd_pcm_group *group; + void *file; + int ref_count; + atomic_t mmap_count; + unsigned int f_flags; + void (*pcm_release)(struct snd_pcm_substream *); + struct pid___2 *pid; + struct snd_pcm_oss_substream oss; + struct snd_info_entry *proc_root; + struct snd_info_entry *proc_info_entry; + struct snd_info_entry *proc_hw_params_entry; + struct snd_info_entry *proc_sw_params_entry; + struct snd_info_entry *proc_status_entry; + struct snd_info_entry *proc_prealloc_entry; + struct snd_info_entry *proc_prealloc_max_entry; + unsigned int hw_opened: 1; +}; + +struct snd_pcm_sw_params { + int tstamp_mode; + unsigned int period_step; + unsigned int sleep_min; + snd_pcm_uframes_t avail_min; + snd_pcm_uframes_t xfer_align; + snd_pcm_uframes_t start_threshold; + snd_pcm_uframes_t stop_threshold; + snd_pcm_uframes_t silence_threshold; + snd_pcm_uframes_t silence_size; + snd_pcm_uframes_t boundary; + unsigned int proto; + unsigned int tstamp_type; + unsigned char reserved[56]; +}; + +struct snd_pcm_sw_params32 { + s32 tstamp_mode; + u32 period_step; + u32 sleep_min; + u32 avail_min; + u32 xfer_align; + u32 start_threshold; + u32 stop_threshold; + u32 silence_threshold; + u32 silence_size; + u32 boundary; + u32 proto; + u32 tstamp_type; + unsigned char reserved[56]; +}; + +struct snd_pcm_sync_ptr { + unsigned int flags; + union { + struct snd_pcm_mmap_status status; + unsigned char reserved[64]; + } s; + union { + struct snd_pcm_mmap_control control; + unsigned char reserved[64]; + } c; +}; + +struct snd_pcm_sync_ptr32 { + u32 flags; + union { + struct snd_pcm_mmap_status32 status; + unsigned char reserved[64]; + } s; + union { + struct snd_pcm_mmap_control32 control; + unsigned char reserved[64]; + } c; +}; + +struct snd_ratden { + unsigned int num_min; + unsigned int num_max; + unsigned int num_step; + unsigned int den; +}; + +struct snd_ratnum { + unsigned int num; + unsigned int den_min; + unsigned int den_max; + unsigned int den_step; +}; + +struct snd_seq_fifo; + +struct snd_seq_user_client { + struct file___2 *file; + struct pid___2 *owner; + struct snd_seq_fifo *fifo; + int fifo_pool_size; +}; + +struct snd_seq_kernel_client { + struct snd_card *card; +}; + +struct snd_seq_pool; + +struct snd_seq_client { + snd_seq_client_type_t type; + unsigned int accept_input: 1; + unsigned int accept_output: 1; + char name[64]; + int number; + unsigned int filter; + long unsigned int event_filter[4]; + snd_use_lock_t use_lock; + int event_lost; + int num_ports; + struct list_head ports_list_head; + rwlock_t ports_lock; + struct mutex ports_mutex; + int convert32; + struct snd_seq_pool *pool; + union { + struct snd_seq_user_client user; + struct snd_seq_kernel_client kernel; + } data; +}; + +struct snd_seq_client_info { + int client; + snd_seq_client_type_t type; + char name[64]; + unsigned int filter; + unsigned char multicast_filter[8]; + unsigned char event_filter[32]; + int num_ports; + int event_lost; + int card; + int pid; + char reserved[56]; +}; + +struct snd_seq_client_pool { + int client; + int output_pool; + int input_pool; + int output_room; + int output_free; + int input_free; + char reserved[64]; +}; + +struct snd_seq_port_subscribe; + +struct snd_seq_port_subs_info { + struct list_head list_head; + unsigned int count; + unsigned int exclusive: 1; + struct rw_semaphore list_mutex; + rwlock_t list_lock; + int (*open)(void *, struct snd_seq_port_subscribe *); + int (*close)(void *, struct snd_seq_port_subscribe *); +}; + +struct snd_seq_client_port { + struct snd_seq_addr addr; + struct module *owner; + char name[64]; + struct list_head list; + snd_use_lock_t use_lock; + struct snd_seq_port_subs_info c_src; + struct snd_seq_port_subs_info c_dest; + int (*event_input)(struct snd_seq_event *, int, void *, int, int); + void (*private_free)(void *); + void *private_data; + unsigned int closing: 1; + unsigned int timestamping: 1; + unsigned int time_real: 1; + int time_queue; + unsigned int capability; + unsigned int type; + int midi_channels; + int midi_voices; + int synth_voices; +}; + +struct snd_seq_connect { + struct snd_seq_addr sender; + struct snd_seq_addr dest; +}; + +struct snd_seq_device { + struct snd_card *card; + int device; + const char *id; + char name[80]; + int argsize; + void *driver_data; + void *private_data; + void (*private_free)(struct snd_seq_device *); + struct device dev; +}; + +struct snd_seq_driver { + struct device_driver driver; + char *id; + int argsize; +}; + +struct snd_seq_dummy_port { + int client; + int port; + int duplex; + int connect; +}; + +struct snd_seq_ev_ctrl { + unsigned char channel; + unsigned char unused1; + unsigned char unused2; + unsigned char unused3; + unsigned int param; + int value; +}; + +struct snd_seq_ev_ext { + unsigned int len; + void *ptr; +} __attribute__((packed)); + +struct snd_seq_ev_note { + unsigned char channel; + unsigned char note; + unsigned char velocity; + unsigned char off_velocity; + unsigned int duration; +}; + +struct snd_seq_real_time { + unsigned int tv_sec; + unsigned int tv_nsec; +}; + +union snd_seq_timestamp { + snd_seq_tick_time_t tick; + struct snd_seq_real_time time; +}; + +struct snd_seq_queue_skew { + unsigned int value; + unsigned int base; +}; + +struct snd_seq_ev_queue_control { + unsigned char queue; + unsigned char pad[3]; + union { + int value; + union snd_seq_timestamp time; + unsigned int position; + struct snd_seq_queue_skew skew; + unsigned int d32[2]; + unsigned char d8[8]; + } param; +}; + +struct snd_seq_ev_quote { + struct snd_seq_addr origin; + short unsigned int value; + struct snd_seq_event *event; +} __attribute__((packed)); + +struct snd_seq_ev_raw32 { + unsigned int d[3]; +}; + +struct snd_seq_ev_raw8 { + unsigned char d[12]; +}; + +struct snd_seq_result { + int event; + int result; +}; + +struct snd_seq_event { + snd_seq_event_type_t type; + unsigned char flags; + char tag; + unsigned char queue; + union snd_seq_timestamp time; + struct snd_seq_addr source; + struct snd_seq_addr dest; + union { + struct snd_seq_ev_note note; + struct snd_seq_ev_ctrl control; + struct snd_seq_ev_raw8 raw8; + struct snd_seq_ev_raw32 raw32; + struct snd_seq_ev_ext ext; + struct snd_seq_ev_queue_control queue; + union snd_seq_timestamp time; + struct snd_seq_addr addr; + struct snd_seq_connect connect; + struct snd_seq_result result; + struct snd_seq_ev_quote quote; + } data; +}; + +struct snd_seq_event_cell { + struct snd_seq_event event; + struct snd_seq_pool *pool; + struct snd_seq_event_cell *next; +}; + +struct snd_seq_fifo { + struct snd_seq_pool *pool; + struct snd_seq_event_cell *head; + struct snd_seq_event_cell *tail; + int cells; + spinlock_t lock; + snd_use_lock_t use_lock; + wait_queue_head_t input_sleep; + atomic_t overflow; +}; + +struct snd_seq_oss_reg { + int type; + int subtype; + int nvoices; + struct snd_seq_oss_callback oper; + void *private_data; +}; + +struct snd_seq_pool { + struct snd_seq_event_cell *ptr; + struct snd_seq_event_cell *free; + int total_elements; + atomic_t counter; + int size; + int room; + int closing; + int max_used; + int event_alloc_nopool; + int event_alloc_failures; + int event_alloc_success; + wait_queue_head_t output_sleep; + spinlock_t lock; +}; + +struct snd_seq_port_callback { + struct module *owner; + void *private_data; + int (*subscribe)(void *, struct snd_seq_port_subscribe *); + int (*unsubscribe)(void *, struct snd_seq_port_subscribe *); + int (*use)(void *, struct snd_seq_port_subscribe *); + int (*unuse)(void *, struct snd_seq_port_subscribe *); + int (*event_input)(struct snd_seq_event *, int, void *, int, int); + void (*private_free)(void *); +}; + +struct snd_seq_port_info { + struct snd_seq_addr addr; + char name[64]; + unsigned int capability; + unsigned int type; + int midi_channels; + int midi_voices; + int synth_voices; + int read_use; + int write_use; + void *kernel; + unsigned int flags; + unsigned char time_queue; + char reserved[59]; +}; + +struct snd_seq_port_info32 { + struct snd_seq_addr addr; + char name[64]; + u32 capability; + u32 type; + s32 midi_channels; + s32 midi_voices; + s32 synth_voices; + s32 read_use; + s32 write_use; + u32 kernel; + u32 flags; + unsigned char time_queue; + char reserved[59]; +}; + +struct snd_seq_port_subscribe { + struct snd_seq_addr sender; + struct snd_seq_addr dest; + unsigned int voices; + unsigned int flags; + unsigned char queue; + unsigned char pad[3]; + char reserved[64]; +}; + +struct snd_seq_prioq { + struct snd_seq_event_cell *head; + struct snd_seq_event_cell *tail; + int cells; + spinlock_t lock; +}; + +struct snd_seq_query_subs { + struct snd_seq_addr root; + int type; + int index; + int num_subs; + struct snd_seq_addr addr; + unsigned char queue; + unsigned int flags; + char reserved[64]; +}; + +struct snd_seq_timer; + +struct snd_seq_queue { + int queue; + char name[64]; + struct snd_seq_prioq *tickq; + struct snd_seq_prioq *timeq; + struct snd_seq_timer *timer; + int owner; + unsigned int locked: 1; + unsigned int klocked: 1; + unsigned int check_again: 1; + unsigned int check_blocked: 1; + unsigned int flags; + unsigned int info_flags; + spinlock_t owner_lock; + spinlock_t check_lock; + long unsigned int clients_bitmap[3]; + unsigned int clients; + struct mutex timer_mutex; + snd_use_lock_t use_lock; +}; + +struct snd_seq_queue_client { + int queue; + int client; + int used; + char reserved[64]; +}; + +struct snd_seq_queue_info { + int queue; + int owner; + unsigned int locked: 1; + char name[64]; + unsigned int flags; + char reserved[60]; +}; + +struct snd_seq_queue_status { + int queue; + int events; + snd_seq_tick_time_t tick; + struct snd_seq_real_time time; + int running; + int flags; + char reserved[64]; +}; + +struct snd_seq_queue_tempo { + int queue; + unsigned int tempo; + int ppq; + unsigned int skew_value; + unsigned int skew_base; + char reserved[24]; +}; + +struct snd_timer_id { + int dev_class; + int dev_sclass; + int card; + int device; + int subdevice; +}; + +struct snd_seq_queue_timer { + int queue; + int type; + union { + struct { + struct snd_timer_id id; + unsigned int resolution; + } alsa; + } u; + char reserved[64]; +}; + +typedef struct snd_seq_real_time snd_seq_real_time_t; + +struct snd_seq_remove_events { + unsigned int remove_mode; + union snd_seq_timestamp time; + unsigned char queue; + struct snd_seq_addr dest; + unsigned char channel; + int type; + char tag; + int reserved[10]; +}; + +struct snd_seq_running_info { + unsigned char client; + unsigned char big_endian; + unsigned char cpu_mode; + unsigned char pad; + unsigned char reserved[12]; +}; + +struct snd_seq_subscribers { + struct snd_seq_port_subscribe info; + struct list_head src_list; + struct list_head dest_list; + atomic_t ref_count; +}; + +struct snd_seq_system_info { + int queues; + int clients; + int ports; + int channels; + int cur_clients; + int cur_queues; + char reserved[24]; +}; + +struct snd_seq_timer_tick { + snd_seq_tick_time_t cur_tick; + long unsigned int resolution; + long unsigned int fraction; +}; + +struct snd_timer_instance; + +struct snd_seq_timer { + unsigned int running: 1; + unsigned int initialized: 1; + unsigned int tempo; + int ppq; + snd_seq_real_time_t cur_time; + struct snd_seq_timer_tick tick; + int tick_updated; + int type; + struct snd_timer_id alsa_id; + struct snd_timer_instance *timeri; + unsigned int ticks; + long unsigned int preferred_resolution; + unsigned int skew; + unsigned int skew_base; + struct timeval last_update; + spinlock_t lock; +}; + +struct snd_seq_usage { + int cur; + int peak; +}; + +struct snd_sg_page; + +struct snd_sg_buf { + int size; + int pages; + int tblsize; + struct snd_sg_page *table; + struct page___2 **page_table; + struct device *dev; +}; + +struct snd_sg_page { + void *buf; + dma_addr_t addr; +}; + +struct snd_timer_hardware { + unsigned int flags; + long unsigned int resolution; + long unsigned int resolution_min; + long unsigned int resolution_max; + long unsigned int ticks; + int (*open)(struct snd_timer *); + int (*close)(struct snd_timer *); + long unsigned int (*c_resolution)(struct snd_timer *); + int (*start)(struct snd_timer *); + int (*stop)(struct snd_timer *); + int (*set_period)(struct snd_timer *, long unsigned int, long unsigned int); + int (*precise_resolution)(struct snd_timer *, long unsigned int *, long unsigned int *); +}; + +struct snd_timer { + int tmr_class; + struct snd_card *card; + struct module *module; + int tmr_device; + int tmr_subdevice; + char id[64]; + char name[80]; + unsigned int flags; + int running; + long unsigned int sticks; + void *private_data; + void (*private_free)(struct snd_timer *); + struct snd_timer_hardware hw; + spinlock_t lock; + struct list_head device_list; + struct list_head open_list_head; + struct list_head active_list_head; + struct list_head ack_list_head; + struct list_head sack_list_head; + struct tasklet_struct task_queue; +}; + +struct snd_timer_ginfo { + struct snd_timer_id tid; + unsigned int flags; + int card; + unsigned char id[64]; + unsigned char name[80]; + long unsigned int reserved0; + long unsigned int resolution; + long unsigned int resolution_min; + long unsigned int resolution_max; + unsigned int clients; + unsigned char reserved[32]; +}; + +struct snd_timer_gparams { + struct snd_timer_id tid; + long unsigned int period_num; + long unsigned int period_den; + unsigned char reserved[32]; +}; + +struct snd_timer_gparams32 { + struct snd_timer_id tid; + u32 period_num; + u32 period_den; + unsigned char reserved[32]; +}; + +struct snd_timer_gstatus { + struct snd_timer_id tid; + long unsigned int resolution; + long unsigned int resolution_num; + long unsigned int resolution_den; + unsigned char reserved[32]; +}; + +struct snd_timer_info { + unsigned int flags; + int card; + unsigned char id[64]; + unsigned char name[80]; + long unsigned int reserved0; + long unsigned int resolution; + unsigned char reserved[64]; +}; + +struct snd_timer_info32 { + u32 flags; + s32 card; + unsigned char id[64]; + unsigned char name[80]; + u32 reserved0; + u32 resolution; + unsigned char reserved[64]; +}; + +struct snd_timer_instance { + struct snd_timer *timer; + char *owner; + unsigned int flags; + void *private_data; + void (*private_free)(struct snd_timer_instance *); + void (*callback)(struct snd_timer_instance *, long unsigned int, long unsigned int); + void (*ccallback)(struct snd_timer_instance *, int, struct timespec *, long unsigned int); + void (*disconnect)(struct snd_timer_instance *); + void *callback_data; + long unsigned int ticks; + long unsigned int cticks; + long unsigned int pticks; + long unsigned int resolution; + long unsigned int lost; + int slave_class; + unsigned int slave_id; + struct list_head open_list; + struct list_head active_list; + struct list_head ack_list; + struct list_head slave_list_head; + struct list_head slave_active_head; + struct snd_timer_instance *master; +}; + +struct snd_timer_params { + unsigned int flags; + unsigned int ticks; + unsigned int queue_size; + unsigned int reserved0; + unsigned int filter; + unsigned char reserved[60]; +}; + +struct snd_timer_read { + unsigned int resolution; + unsigned int ticks; +}; + +struct snd_timer_select { + struct snd_timer_id id; + unsigned char reserved[32]; +}; + +struct snd_timer_status { + struct timespec tstamp; + unsigned int resolution; + unsigned int lost; + unsigned int overrun; + unsigned int queue; + unsigned char reserved[64]; +}; + +struct snd_timer_status32 { + struct compat_timespec tstamp; + u32 resolution; + u32 lost; + u32 overrun; + u32 queue; + unsigned char reserved[64]; +}; + +struct snd_timer_system_private { + struct timer_list tlist; + long unsigned int last_expires; + long unsigned int last_jiffies; + long unsigned int correction; +}; + +struct snd_timer_tread { + int event; + struct timespec tstamp; + unsigned int val; +}; + +struct snd_timer_user { + struct snd_timer_instance *timeri; + int tread; + long unsigned int ticks; + long unsigned int overrun; + int qhead; + int qtail; + int qused; + int queue_size; + bool disconnected; + struct snd_timer_read *queue; + struct snd_timer_tread *tqueue; + spinlock_t qlock; + long unsigned int last_resolution; + unsigned int filter; + struct timespec tstamp; + wait_queue_head_t qchange_sleep; + struct fasync_struct *fasync; + struct mutex ioctl_lock; +}; + +struct snd_xferi { + snd_pcm_sframes_t result; + void *buf; + snd_pcm_uframes_t frames; +}; + +struct snd_xferi32 { + s32 result; + u32 buf; + u32 frames; +}; + +struct snd_xfern { + snd_pcm_sframes_t result; + void **bufs; + snd_pcm_uframes_t frames; +}; + +struct snd_xfern32 { + s32 result; + u32 bufs; + u32 frames; +}; + +struct snmp_mib { + const char *name; + int entry; +}; + +struct sock_diag_handler { + __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_req { + __u8 sdiag_family; + __u8 sdiag_protocol; +}; + +struct sock_extended_err { + __u32 ee_errno; + __u8 ee_origin; + __u8 ee_type; + __u8 ee_code; + __u8 ee_pad; + __u32 ee_info; + __u32 ee_data; +}; + +struct sock_exterr_skb { + union { + struct inet_skb_parm h4; + } header; + struct sock_extended_err ee; + u16 addr_offset; + __be16 port; +}; + +struct sock_fprog { + short unsigned int len; + struct sock_filter *filter; +}; + +struct sock_fprog32 { + short unsigned int len; + compat_caddr_t filter; +}; + +struct sock_fprog_kern { + u16 len; + struct sock_filter *filter; +}; + +struct sock_reuseport { + struct callback_head rcu; + u16 max_socks; + u16 num_socks; + struct bpf_prog *prog; + struct sock *socks[0]; +}; + +struct sock_skb_cb { + u32 dropcount; +}; + +struct sockaddr_in { + __kernel_sa_family_t sin_family; + __be16 sin_port; + struct in_addr sin_addr; + unsigned char __pad[8]; +}; + +struct sockaddr_in6 { + short unsigned int sin6_family; + __be16 sin6_port; + __be32 sin6_flowinfo; + struct in6_addr sin6_addr; + __u32 sin6_scope_id; +}; + +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 socket { + socket_state state; + short int type; + long unsigned int flags; + struct socket_wq *wq; + struct file___2 *file; + struct sock *sk; + const struct proto_ops *ops; +}; + +struct socket_alloc { + struct socket socket; + struct inode vfs_inode; +}; + +struct socket_wq { + wait_queue_head_t wait; + struct fasync_struct *fasync_list; + long unsigned int flags; + struct callback_head rcu; + long: 64; +}; + +struct softirq_action { + void (*action)(struct softirq_action *); +}; + +struct softnet_data { + struct list_head poll_list; + struct sk_buff_head process_queue; + unsigned int processed; + unsigned int time_squeeze; + unsigned int received_rps; + struct softnet_data *rps_ipi_list; + struct sd_flow_limit *flow_limit; + struct Qdisc *output_queue; + struct Qdisc **output_queue_tailp; + struct sk_buff *completion_queue; + long: 64; + long: 64; + long: 64; + long: 64; + unsigned int input_queue_head; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + struct call_single_data csd; + struct softnet_data *rps_ipi_next; + unsigned int cpu; + unsigned int input_queue_tail; + unsigned int dropped; + struct sk_buff_head input_pkt_queue; + struct napi_struct backlog; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; +}; + +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___2 *unit_fops; + struct sound_unit *next; + char name[32]; +}; + +struct sp_node { + struct rb_node nd; + long unsigned int start; + long unsigned int end; + struct mempolicy *policy; +}; + +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 space_resv_32 { + __s16 l_type; + __s16 l_whence; + __s64 l_start; + __s64 l_len; + __s32 l_sysid; + __u32 l_pid; + __s32 l_pad[4]; +} __attribute__((packed)); + +struct speed_down_verdict_arg { + u64 since; + int xfer_ok; + int nr_errors[8]; +}; + +struct spi_function_template { + void (*get_period)(struct scsi_target *); + void (*set_period)(struct scsi_target *, int); + void (*get_offset)(struct scsi_target *); + void (*set_offset)(struct scsi_target *, int); + void (*get_width)(struct scsi_target *); + void (*set_width)(struct scsi_target *, int); + void (*get_iu)(struct scsi_target *); + void (*set_iu)(struct scsi_target *, int); + void (*get_dt)(struct scsi_target *); + void (*set_dt)(struct scsi_target *, int); + void (*get_qas)(struct scsi_target *); + void (*set_qas)(struct scsi_target *, int); + void (*get_wr_flow)(struct scsi_target *); + void (*set_wr_flow)(struct scsi_target *, int); + void (*get_rd_strm)(struct scsi_target *); + void (*set_rd_strm)(struct scsi_target *, int); + void (*get_rti)(struct scsi_target *); + void (*set_rti)(struct scsi_target *, int); + void (*get_pcomp_en)(struct scsi_target *); + void (*set_pcomp_en)(struct scsi_target *, int); + void (*get_hold_mcs)(struct scsi_target *); + void (*set_hold_mcs)(struct scsi_target *, int); + void (*get_signalling)(struct Scsi_Host *); + void (*set_signalling)(struct Scsi_Host *, enum spi_signal_type); + int (*deny_binding)(struct scsi_target *); + long unsigned int show_period: 1; + long unsigned int show_offset: 1; + long unsigned int show_width: 1; + long unsigned int show_iu: 1; + long unsigned int show_dt: 1; + long unsigned int show_qas: 1; + long unsigned int show_wr_flow: 1; + long unsigned int show_rd_strm: 1; + long unsigned int show_rti: 1; + long unsigned int show_pcomp_en: 1; + long unsigned int show_hold_mcs: 1; +}; + +struct spi_host_attrs { + enum spi_signal_type signalling; +}; + +struct spi_internal { + struct scsi_transport_template t; + struct spi_function_template *f; +}; + +struct spi_transport_attrs { + int period; + int min_period; + int offset; + int max_offset; + unsigned int width: 1; + unsigned int max_width: 1; + unsigned int iu: 1; + unsigned int max_iu: 1; + unsigned int dt: 1; + unsigned int qas: 1; + unsigned int max_qas: 1; + unsigned int wr_flow: 1; + unsigned int rd_strm: 1; + unsigned int rti: 1; + unsigned int pcomp_en: 1; + unsigned int hold_mcs: 1; + unsigned int initial_dv: 1; + long unsigned int flags; + unsigned int support_sync: 1; + unsigned int support_wide: 1; + unsigned int support_dt: 1; + unsigned int support_dt_only; + unsigned int support_ius; + unsigned int support_qas; + unsigned int dv_pending: 1; + unsigned int dv_in_progress: 1; + struct mutex dv_mutex; +}; + +struct splice_desc { + size_t total_len; + unsigned int len; + unsigned int flags; + union { + void *userptr; + struct file *file; + void *data; + } u; + loff_t pos; + loff_t *opos; + size_t num_spliced; + bool need_wakeup; +}; + +struct splice_pipe_desc { + struct page___2 **pages; + struct partial_page *partial; + int nr_pages; + unsigned int nr_pages_max; + unsigned int flags; + 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 buffer_head **, int, int, int, struct squashfs_page_actor *); + int id; + char *name; + int supported; +}; + +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___2 vfs_inode; +}; + +struct squashfs_page_actor { + void **page; + int pages; + int length; + int next_page; +}; + +struct squashfs_stream; + +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; + int next_meta_index; + __le64 *id_table; + __le64 *fragment_index; + __le64 *xattr_id_table; + struct mutex___2 meta_index_mutex; + struct meta_index *meta_index; + struct squashfs_stream *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; + int xattr_ids; +}; + +struct squashfs_stream { + void *stream; + struct mutex___2 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 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 srcu_notifier_head { + struct mutex mutex; + struct srcu_struct srcu; + struct notifier_block *head; +}; + +struct srcu_struct_array { + long unsigned int c[2]; + long unsigned int seq[2]; +}; + +struct sseu_dev_status { + unsigned int slice_total; + unsigned int subslice_total; + unsigned int subslice_per_slice; + unsigned int eu_total; + unsigned int eu_per_subslice; +}; + +struct stack_entry { + struct trace_entry ent; + int size; + long unsigned int caller[0]; +}; + +struct stack_frame { + struct stack_frame *next_frame; + long unsigned int return_address; +}; + +struct stack_frame_ia32 { + u32 next_frame; + u32 return_address; +}; + +struct stack_frame_user { + const void *next_fp; + long unsigned int ret_addr; +}; + +struct stack_map_bucket { + struct pcpu_freelist_node fnode; + u32 hash; + u32 nr; + u64 ip[0]; +}; + +struct stack_trace { + unsigned int nr_entries; + unsigned int max_entries; + long unsigned int *entries; + int skip; +}; + +struct thread_info; + +struct stacktrace_ops; + +typedef long unsigned int (*walk_stack_t)(struct thread_info *, long unsigned int *, long unsigned int, const struct stacktrace_ops *, void *, long unsigned int *, int *); + +struct stacktrace_ops { + int (*address)(void *, long unsigned int, int); + int (*stack)(void *, char *); + walk_stack_t walk_stack; +}; + +struct stat { + __kernel_ulong_t st_dev; + __kernel_ulong_t st_ino; + __kernel_ulong_t st_nlink; + unsigned int st_mode; + unsigned int st_uid; + unsigned int st_gid; + unsigned int __pad0; + __kernel_ulong_t st_rdev; + __kernel_long_t st_size; + __kernel_long_t st_blksize; + __kernel_long_t st_blocks; + __kernel_ulong_t st_atime; + __kernel_ulong_t st_atime_nsec; + __kernel_ulong_t st_mtime; + __kernel_ulong_t st_mtime_nsec; + __kernel_ulong_t st_ctime; + __kernel_ulong_t st_ctime_nsec; + __kernel_long_t __unused[3]; +}; + +struct stat64 { + long long unsigned int st_dev; + unsigned char __pad0[4]; + unsigned int __st_ino; + unsigned int st_mode; + unsigned int st_nlink; + unsigned int st_uid; + unsigned int st_gid; + long long unsigned int st_rdev; + unsigned char __pad3[4]; + long long int st_size; + unsigned int st_blksize; + long long int st_blocks; + unsigned int st_atime; + unsigned int st_atime_nsec; + unsigned int st_mtime; + unsigned int st_mtime_nsec; + unsigned int st_ctime; + unsigned int st_ctime_nsec; + long long unsigned int st_ino; +} __attribute__((packed)); + +struct stat_node { + struct rb_node node; + void *stat; +}; + +struct tracer_stat; + +struct stat_session { + struct list_head session_list; + struct tracer_stat *ts; + struct rb_root stat_root; + struct mutex stat_mutex; + struct dentry___2 *file; +}; + +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_key_mod; + +struct static_key { + atomic_t enabled; + struct jump_entry *entries; + struct static_key_mod *next; +}; + +struct static_key_deferred { + struct static_key key; + long unsigned int timeout; + struct delayed_work work; +}; + +struct static_key_false { + struct static_key key; +}; + +struct static_key_mod { + struct static_key_mod *next; + struct jump_entry *entries; + struct module___2 *mod; +}; + +struct static_key_true { + struct static_key key; +}; + +struct status_event_list { + int event; + int qlen; + void (*encode)(struct snd_midi_event *, struct snd_seq_event *); + void (*decode)(struct snd_seq_event *, unsigned char *); +}; + +struct stepping_info { + char stepping; + char substepping; +}; + +struct stereo_mandatory_mode { + int width; + int height; + int vrefresh; + unsigned int flags; +}; + +struct stop_event_data { + struct perf_event___2 *event; + unsigned int restart; +}; + +struct stripe { + struct dm_dev *dev; + sector_t physical_start; + atomic_t error_count; +}; + +struct stripe_c { + uint32_t stripes; + int stripes_shift; + sector_t stripe_width; + uint32_t chunk_size; + int chunk_size_shift; + struct dm_target___2 *ti; + struct work_struct trigger_event; + struct stripe stripe[0]; +}; + +struct submit_bio_ret { + struct completion event; + int error; +}; + +struct subprocess_info { + struct work_struct work; + struct completion *complete; + 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; + 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; + struct bus_type *bus; + struct kset glue_dirs; + struct class *class; +}; + +struct sun_info { + __be16 id; + __be16 flags; +}; + +struct sun_vtoc { + __be32 version; + char volume[8]; + __be16 nparts; + struct sun_info infos[8]; + __be16 padding; + __be32 bootinfo[3]; + __be32 sanity; + __be32 reserved[10]; + __be32 timestamp[8]; +}; + +struct sun_partition { + __be32 start_cylinder; + __be32 num_sectors; +}; + +struct sun_disklabel { + unsigned char info[128]; + struct sun_vtoc vtoc; + __be32 write_reinstruct; + __be32 read_reinstruct; + unsigned char spare[148]; + __be16 rspeed; + __be16 pcylcount; + __be16 sparecyl; + __be16 obs1; + __be16 obs2; + __be16 ilfact; + __be16 ncyl; + __be16 nacyl; + __be16 ntrks; + __be16 nsect; + __be16 obs3; + __be16 obs4; + struct sun_partition partitions[8]; + __be16 magic; + __be16 csum; +}; + +struct fscrypt_operations; + +struct mtd_info; + +struct super_operations; + +struct xattr_handler; + +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___2 *s_root; + struct rw_semaphore s_umount; + int s_count; + atomic_t s_active; + const struct xattr_handler **s_xattr; + const struct fscrypt_operations *s_cop; + struct hlist_bl_head s_anon; + struct list_head s_mounts; + struct block_device *s_bdev; + 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; + char s_id[32]; + u8 s_uuid[16]; + void *s_fs_info; + unsigned int s_max_links; + fmode_t s_mode; + u32 s_time_gran; + struct mutex s_vfs_rename_mutex; + char *s_subtype; + char *s_options; + const struct dentry_operations *s_d_op; + int cleancache_poolid; + struct shrinker s_shrink; + atomic_long_t s_remove_count; + int s_readonly_remount; + struct workqueue_struct *s_dio_done_wq; + struct hlist_head s_pins; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + struct list_lru s_dentry_lru; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + 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; + long: 64; + spinlock_t s_inode_list_lock; + struct list_head s_inodes; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; +}; + +struct super_operations___2; + +struct super_block___2 { + 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___2 *s_type; + const struct super_operations___2 *s_op; + const struct dquot_operations___2 *dq_op; + const struct quotactl_ops___2 *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___2 s_umount; + int s_count; + atomic_t s_active; + const struct xattr_handler **s_xattr; + const struct fscrypt_operations *s_cop; + struct hlist_bl_head s_anon; + struct list_head s_mounts; + struct block_device___2 *s_bdev; + struct backing_dev_info *s_bdi; + struct mtd_info *s_mtd; + struct hlist_node s_instances; + unsigned int s_quota_types; + struct quota_info___2 s_dquot; + struct sb_writers___2 s_writers; + char s_id[32]; + u8 s_uuid[16]; + void *s_fs_info; + unsigned int s_max_links; + fmode_t s_mode; + u32 s_time_gran; + struct mutex___2 s_vfs_rename_mutex; + char *s_subtype; + char *s_options; + const struct dentry_operations___2 *s_d_op; + int cleancache_poolid; + struct shrinker s_shrink; + atomic_long_t s_remove_count; + int s_readonly_remount; + struct workqueue_struct *s_dio_done_wq; + struct hlist_head s_pins; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + struct list_lru s_dentry_lru; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + struct list_lru s_inode_lru; + struct callback_head rcu; + struct work_struct destroy_work; + struct mutex___2 s_sync_lock; + int s_stack_depth; + long: 64; + long: 64; + long: 64; + spinlock_t s_inode_list_lock; + struct list_head s_inodes; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; +}; + +struct super_operations { + struct inode * (*alloc_inode)(struct super_block *); + void (*destroy_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 *); + int (*freeze_fs)(struct super_block *); + int (*thaw_super)(struct super_block *); + int (*unfreeze_fs)(struct super_block *); + int (*statfs)(struct dentry___2 *, struct kstatfs *); + int (*remount_fs)(struct super_block *, int *, char *); + void (*umount_begin)(struct super_block *); + int (*show_options)(struct seq_file *, struct dentry___2 *); + int (*show_devname)(struct seq_file *, struct dentry___2 *); + int (*show_path)(struct seq_file *, struct dentry___2 *); + int (*show_stats)(struct seq_file *, struct dentry___2 *); + 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 *); + int (*bdev_try_to_free_page)(struct super_block *, struct page___2 *, gfp_t); + long int (*nr_cached_objects)(struct super_block *, struct shrink_control *); + long int (*free_cached_objects)(struct super_block *, struct shrink_control *); +}; + +struct super_operations___2 { + struct inode___2 * (*alloc_inode)(struct super_block___2 *); + void (*destroy_inode)(struct inode___2 *); + void (*dirty_inode)(struct inode___2 *, int); + int (*write_inode)(struct inode___2 *, struct writeback_control *); + int (*drop_inode)(struct inode___2 *); + void (*evict_inode)(struct inode___2 *); + void (*put_super)(struct super_block___2 *); + int (*sync_fs)(struct super_block___2 *, int); + int (*freeze_super)(struct super_block___2 *); + int (*freeze_fs)(struct super_block___2 *); + int (*thaw_super)(struct super_block___2 *); + int (*unfreeze_fs)(struct super_block___2 *); + int (*statfs)(struct dentry *, struct kstatfs *); + int (*remount_fs)(struct super_block___2 *, int *, char *); + void (*umount_begin)(struct super_block___2 *); + int (*show_options)(struct seq_file___2 *, struct dentry *); + int (*show_devname)(struct seq_file___2 *, struct dentry *); + int (*show_path)(struct seq_file___2 *, struct dentry *); + int (*show_stats)(struct seq_file___2 *, struct dentry *); + ssize_t (*quota_read)(struct super_block___2 *, int, char *, size_t, loff_t); + ssize_t (*quota_write)(struct super_block___2 *, int, const char *, size_t, loff_t); + struct dquot___2 ** (*get_dquots)(struct inode___2 *); + int (*bdev_try_to_free_page)(struct super_block___2 *, struct page *, gfp_t); + long int (*nr_cached_objects)(struct super_block___2 *, struct shrink_control *); + long int (*free_cached_objects)(struct super_block___2 *, struct shrink_control *); +}; + +struct super_type { + char *name; + struct module *owner; + int (*load_super)(struct md_rdev *, struct md_rdev *, int); + int (*validate_super)(struct mddev *, struct md_rdev *); + void (*sync_super)(struct mddev *, struct md_rdev *); + long long unsigned int (*rdev_size_change)(struct md_rdev *, sector_t); + int (*allow_new_offset)(struct md_rdev *, long long unsigned int); +}; + +struct suspend_stats { + int success; + int fail; + int failed_freeze; + int failed_prepare; + int failed_suspend; + int failed_suspend_late; + int failed_suspend_noirq; + int failed_resume; + int failed_resume_early; + int failed_resume_noirq; + int last_failed_dev; + char failed_devs[80]; + int last_failed_errno; + int errno[2]; + int last_failed_step; + enum suspend_stat_step failed_steps[2]; +}; + +struct svm_cpu_data { + int cpu; + u64 asid_generation; + u32 max_asid; + u32 next_asid; + struct kvm_ldttss_desc *tss_desc; + struct page___2 *save_area; +}; + +struct svm_direct_access_msrs { + u32 index; + bool always; +}; + +struct swait_queue { + struct task_struct *task; + struct list_head task_list; +}; + +struct swap_extent { + struct list_head list; + 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 { + long unsigned int flags; + short int prio; + struct plist_node list; + struct plist_node avail_list; + signed char type; + unsigned int max; + unsigned char *swap_map; + struct swap_cluster_info *cluster_info; + struct swap_cluster_info free_cluster_head; + struct swap_cluster_info free_cluster_tail; + unsigned int lowest_bit; + unsigned int highest_bit; + unsigned int pages; + unsigned int inuse_pages; + unsigned int cluster_next; + unsigned int cluster_nr; + struct percpu_cluster *percpu_cluster; + struct swap_extent *curr_swap_extent; + struct swap_extent first_swap_extent; + struct block_device *bdev; + struct file___2 *swap_file; + unsigned int old_block_size; + spinlock_t lock; + struct work_struct discard_work; + struct swap_cluster_info discard_cluster_head; + struct swap_cluster_info discard_cluster_tail; +}; + +struct swap_map_page; + +struct swap_map_page_list; + +struct swap_map_handle { + struct swap_map_page *cur; + struct swap_map_page_list *maps; + sector_t cur_swap; + sector_t first_sector; + unsigned int k; + long unsigned int reqd_free_pages; + u32 crc32; +}; + +struct swap_map_page { + sector_t entries[511]; + sector_t next_swap; +}; + +struct swap_map_page_list { + struct swap_map_page *map; + struct swap_map_page_list *next; +}; + +struct swevent_hlist { + struct hlist_head heads[256]; + struct callback_head callback_head; +}; + +struct swevent_htable { + struct swevent_hlist *swevent_hlist; + struct mutex___2 hlist_mutex; + int hlist_refcount; + int recursion[4]; +}; + +struct switch_request { + struct file___2 *file; + struct completion wait; +}; + +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 { + struct netdev_phys_item_id ppid; + u8 stp_state; + long unsigned int brport_flags; + u32 ageing_time; + bool vlan_filtering; + } u; +}; + +struct swsusp_extent { + struct rb_node node; + long unsigned int start; + long unsigned int end; +}; + +struct swsusp_header { + char reserved[4060]; + u32 crc32; + sector_t image; + unsigned int flags; + char orig_sig[10]; + char sig[10]; +}; + +struct swsusp_info { + struct new_utsname uts; + u32 version_code; + long unsigned int num_physpages; + int cpus; + long unsigned int image_pages; + long unsigned int pages; + long unsigned int size; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + 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 symbol_cache { + char *symbol; + long int offset; + long unsigned int addr; +}; + +struct symsearch { + const struct kernel_symbol *start; + const struct kernel_symbol *stop; + const long unsigned int *crcs; + enum { + NOT_GPL_ONLY = 0, + GPL_ONLY = 1, + WILL_BE_GPL_ONLY = 2, + } licence; + bool unused; +}; + +struct synaptics_hw_state { + int x; + int y; + int z; + int w; + unsigned int left: 1; + unsigned int right: 1; + unsigned int middle: 1; + unsigned int up: 1; + unsigned int down: 1; + unsigned char ext_buttons; + signed char scroll; +}; + +struct synaptics_data { + long unsigned int model_id; + long unsigned int firmware_id; + long unsigned int board_id; + long unsigned int capabilities; + long unsigned int ext_cap; + long unsigned int ext_cap_0c; + long unsigned int ext_cap_10; + long unsigned int identity; + unsigned int x_res; + unsigned int y_res; + unsigned int x_max; + unsigned int y_max; + unsigned int x_min; + unsigned int y_min; + unsigned char pkt_type; + unsigned char mode; + int scroll; + bool absolute_mode; + bool disable_gesture; + struct serio *pt_port; + unsigned char pt_buttons; + struct synaptics_hw_state agm; + unsigned int agm_count; + long unsigned int press_start; + bool press; + bool report_press; + bool is_forcepad; +}; + +struct sync_io { + long unsigned int error_bits; + struct completion wait; +}; + +struct synth_info { + char name[30]; + int device; + int synth_type; + int synth_subtype; + int perc_mode; + int nr_voices; + int nr_drums; + int instr_bank_size; + unsigned int capabilities; + int dummies[19]; +}; + +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_metadata___2 { + const char *name; + int syscall_nr; + int nb_args; + const char **types; + const char **args; + struct list_head enter_fields; + struct trace_event_call___2 *enter_event; + struct trace_event_call___2 *exit_event; +}; + +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 syscore_ops { + struct list_head node; + int (*suspend)(void); + void (*resume)(void); + void (*shutdown)(void); +}; + +struct sysfs_ops { + ssize_t (*show)(struct kobject *, struct attribute *, char *); + ssize_t (*store)(struct kobject *, struct attribute *, const char *, size_t); +}; + +struct sysfs_ops___2 { + ssize_t (*show)(struct kobject___2 *, struct attribute *, char *); + ssize_t (*store)(struct kobject___2 *, 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 (*handler)(int); + char *help_msg; + char *action_msg; + 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; + 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 { + cycle_t cycles; + struct clocksource *cs; +}; + +struct system_device_crosststamp { + ktime_t device; + ktime_t sys_realtime; + ktime_t sys_monoraw; +}; + +struct system_time_snapshot { + cycle_t cycles; + ktime_t real; + ktime_t raw; + 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 table_device { + struct list_head list; + atomic_t count; + struct dm_dev dm_dev; +}; + +typedef int (*dm_ctr_fn)(struct dm_target___2 *, unsigned int, char **); + +typedef void (*dm_dtr_fn)(struct dm_target___2 *); + +typedef int (*dm_map_fn)(struct dm_target___2 *, struct bio *); + +typedef int (*dm_map_request_fn)(struct dm_target___2 *, struct request *, union map_info *); + +typedef int (*dm_clone_and_map_request_fn)(struct dm_target___2 *, struct request *, union map_info *, struct request **); + +typedef void (*dm_release_clone_request_fn)(struct request *); + +typedef int (*dm_endio_fn)(struct dm_target___2 *, struct bio *, int); + +typedef int (*dm_request_endio_fn)(struct dm_target___2 *, struct request *, int, union map_info *); + +typedef void (*dm_presuspend_fn)(struct dm_target___2 *); + +typedef void (*dm_presuspend_undo_fn)(struct dm_target___2 *); + +typedef void (*dm_postsuspend_fn)(struct dm_target___2 *); + +typedef int (*dm_preresume_fn)(struct dm_target___2 *); + +typedef void (*dm_resume_fn)(struct dm_target___2 *); + +typedef void (*dm_status_fn)(struct dm_target___2 *, status_type_t, unsigned int, char *, unsigned int); + +typedef int (*dm_message_fn)(struct dm_target___2 *, unsigned int, char **); + +typedef int (*dm_prepare_ioctl_fn)(struct dm_target___2 *, struct block_device **, fmode_t *); + +typedef int (*dm_busy_fn)(struct dm_target___2 *); + +typedef int (*iterate_devices_callout_fn)(struct dm_target___2 *, struct dm_dev *, sector_t, sector_t, void *); + +typedef int (*dm_iterate_devices_fn)(struct dm_target___2 *, iterate_devices_callout_fn, void *); + +typedef void (*dm_io_hints_fn)(struct dm_target___2 *, struct queue_limits *); + +struct target_type { + uint64_t features; + const char *name; + struct module *module; + unsigned int version[3]; + dm_ctr_fn ctr; + dm_dtr_fn dtr; + dm_map_fn map; + dm_map_request_fn map_rq; + dm_clone_and_map_request_fn clone_and_map_rq; + dm_release_clone_request_fn release_clone_rq; + dm_endio_fn end_io; + dm_request_endio_fn rq_end_io; + dm_presuspend_fn presuspend; + dm_presuspend_undo_fn presuspend_undo; + dm_postsuspend_fn postsuspend; + dm_preresume_fn preresume; + dm_resume_fn resume; + dm_status_fn status; + dm_message_fn message; + dm_prepare_ioctl_fn prepare_ioctl; + dm_busy_fn busy; + dm_iterate_devices_fn iterate_devices; + dm_io_hints_fn io_hints; + struct list_head list; +}; + +typedef int (*dm_ctr_fn___2)(struct dm_target *, unsigned int, char **); + +typedef void (*dm_dtr_fn___2)(struct dm_target *); + +typedef int (*dm_map_fn___2)(struct dm_target *, struct bio *); + +typedef int (*dm_map_request_fn___2)(struct dm_target *, struct request *, union map_info *); + +typedef int (*dm_clone_and_map_request_fn___2)(struct dm_target *, struct request *, union map_info *, struct request **); + +typedef int (*dm_endio_fn___2)(struct dm_target *, struct bio *, int); + +typedef int (*dm_request_endio_fn___2)(struct dm_target *, struct request *, int, union map_info *); + +typedef void (*dm_presuspend_fn___2)(struct dm_target *); + +typedef void (*dm_presuspend_undo_fn___2)(struct dm_target *); + +typedef void (*dm_postsuspend_fn___2)(struct dm_target *); + +typedef int (*dm_preresume_fn___2)(struct dm_target *); + +typedef void (*dm_resume_fn___2)(struct dm_target *); + +typedef void (*dm_status_fn___2)(struct dm_target *, status_type_t, unsigned int, char *, unsigned int); + +typedef int (*dm_message_fn___2)(struct dm_target *, unsigned int, char **); + +typedef int (*dm_prepare_ioctl_fn___2)(struct dm_target *, struct block_device **, fmode_t *); + +typedef int (*dm_busy_fn___2)(struct dm_target *); + +typedef int (*iterate_devices_callout_fn___2)(struct dm_target *, struct dm_dev *, sector_t, sector_t, void *); + +typedef int (*dm_iterate_devices_fn___2)(struct dm_target *, iterate_devices_callout_fn___2, void *); + +typedef void (*dm_io_hints_fn___2)(struct dm_target *, struct queue_limits *); + +struct target_type___2 { + uint64_t features; + const char *name; + struct module *module; + unsigned int version[3]; + dm_ctr_fn___2 ctr; + dm_dtr_fn___2 dtr; + dm_map_fn___2 map; + dm_map_request_fn___2 map_rq; + dm_clone_and_map_request_fn___2 clone_and_map_rq; + dm_release_clone_request_fn release_clone_rq; + dm_endio_fn___2 end_io; + dm_request_endio_fn___2 rq_end_io; + dm_presuspend_fn___2 presuspend; + dm_presuspend_undo_fn___2 presuspend_undo; + dm_postsuspend_fn___2 postsuspend; + dm_preresume_fn___2 preresume; + dm_resume_fn___2 resume; + dm_status_fn___2 status; + dm_message_fn___2 message; + dm_prepare_ioctl_fn___2 prepare_ioctl; + dm_busy_fn___2 busy; + dm_iterate_devices_fn___2 iterate_devices; + dm_io_hints_fn___2 io_hints; + struct list_head list; +}; + +struct task_delay_info { + spinlock_t lock; + unsigned int flags; + u64 blkio_start; + u64 blkio_delay; + u64 swapin_delay; + u32 blkio_count; + u32 swapin_count; + u64 freepages_start; + u64 freepages_delay; + u32 freepages_count; +}; + +struct task_group { + struct cgroup_subsys_state css; + struct sched_entity **se; + struct cfs_rq **cfs_rq; + long unsigned int shares; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + atomic_long_t load_avg; + 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; +}; + +struct task_rss_stat { + int events; + int count[4]; +}; + +typedef struct task_struct *pto_T_____24; + +struct wake_q_node { + struct wake_q_node *next; +}; + +struct tlbflush_unmap_batch { + struct cpumask cpumask; + bool flush_required; + bool writable; +}; + +struct thread_struct { + struct desc_struct tls_array[3]; + long unsigned int sp0; + long unsigned int sp; + short unsigned int es; + short unsigned int ds; + short unsigned int fsindex; + short unsigned int gsindex; + long unsigned int fsbase; + long unsigned int gsbase; + struct perf_event *ptrace_bps[4]; + long unsigned int debugreg6; + long unsigned int ptrace_dr7; + long unsigned int cr2; + long unsigned int trap_nr; + long unsigned int error_code; + long unsigned int *io_bitmap_ptr; + long unsigned int iopl; + unsigned int io_bitmap_max; + long: 64; + long: 64; + long: 64; + long: 64; + struct fpu fpu; +}; + +struct task_struct { + volatile long int state; + void *stack; + atomic_t usage; + unsigned int flags; + unsigned int ptrace; + struct llist_node wake_entry; + int on_cpu; + unsigned int wakee_flips; + long unsigned int wakee_flip_decay_ts; + struct task_struct *last_wakee; + int wake_cpu; + int on_rq; + int prio; + int static_prio; + int normal_prio; + unsigned int rt_priority; + const struct sched_class *sched_class; + long: 64; + long: 64; + long: 64; + long: 64; + struct sched_entity se; + struct sched_rt_entity rt; + struct task_group *sched_task_group; + struct sched_dl_entity dl; + struct hlist_head preempt_notifiers; + unsigned int btrace_seq; + unsigned int policy; + int nr_cpus_allowed; + cpumask_t cpus_allowed; + int rcu_read_lock_nesting; + union rcu_special rcu_read_unlock_special; + struct list_head rcu_node_entry; + struct rcu_node *rcu_blocked_node; + 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; + u32 vmacache_seqnum; + struct vm_area_struct___2 *vmacache[4]; + struct task_rss_stat rss_stat; + 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_remote_wakeup: 1; + long: 28; + unsigned int in_execve: 1; + unsigned int in_iowait: 1; + long unsigned int atomic_flags; + struct restart_block restart_block; + pid_t pid; + pid_t tgid; + 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_link pids[3]; + struct list_head thread_group; + struct list_head thread_node; + struct completion *vfork_done; + int *set_child_tid; + int *clear_child_tid; + cputime_t utime; + cputime_t stime; + cputime_t utimescaled; + cputime_t stimescaled; + cputime_t gtime; + struct prev_cputime prev_cputime; + long unsigned int nvcsw; + long unsigned int nivcsw; + u64 start_time; + u64 real_start_time; + long unsigned int min_flt; + long unsigned int maj_flt; + struct task_cputime cputime_expires; + struct list_head cpu_timers[3]; + const struct cred *real_cred; + const struct cred *cred; + char comm[16]; + struct nameidata *nameidata; + struct sysv_sem sysvsem; + struct sysv_shm sysvshm; + struct fs_struct *fs; + struct files_struct *files; + 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; + struct seccomp seccomp; + u32 parent_exec_id; + u32 self_exec_id; + spinlock_t alloc_lock; + raw_spinlock_t pi_lock; + struct wake_q_node wake_q; + struct rb_root pi_waiters; + struct rb_node *pi_waiters_leftmost; + struct rt_mutex_waiter *pi_blocked_on; + void *journal_info; + struct bio_list *bio_list; + struct blk_plug *plug; + struct reclaim_state *reclaim_state; + struct backing_dev_info *backing_dev_info; + struct io_context *io_context; + long unsigned int ptrace_message; + siginfo_t *last_siginfo; + struct task_io_accounting ioac; + u64 acct_rss_mem1; + u64 acct_vm_mem1; + cputime_t acct_timexpd; + nodemask_t mems_allowed; + seqcount_t mems_allowed_seq; + int cpuset_mem_spread_rotor; + int cpuset_slab_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 perf_event_context___2 *perf_event_ctxp[2]; + struct mutex perf_event_mutex; + struct list_head perf_event_list; + long unsigned int preempt_disable_ip; + struct mempolicy *mempolicy; + short int il_next; + short int pref_node_fork; + struct tlbflush_unmap_batch tlb_ubc; + struct callback_head rcu; + struct pipe_inode_info___2 *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; + u64 timer_slack_ns; + u64 default_timer_slack_ns; + int curr_ret_stack; + struct ftrace_ret_stack *ret_stack; + long long unsigned int ftrace_timestamp; + atomic_t trace_overrun; + atomic_t tracing_graph_pause; + long unsigned int trace; + long unsigned int trace_recursion; + long unsigned int task_state_change; + int pagefault_disabled; + struct task_struct *oom_reaper_list; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + struct thread_struct thread; +}; + +struct thread_struct___2 { + struct desc_struct tls_array[3]; + long unsigned int sp0; + long unsigned int sp; + short unsigned int es; + short unsigned int ds; + short unsigned int fsindex; + short unsigned int gsindex; + long unsigned int fsbase; + long unsigned int gsbase; + struct perf_event___2 *ptrace_bps[4]; + long unsigned int debugreg6; + long unsigned int ptrace_dr7; + long unsigned int cr2; + long unsigned int trap_nr; + long unsigned int error_code; + long unsigned int *io_bitmap_ptr; + long unsigned int iopl; + unsigned int io_bitmap_max; + long: 64; + long: 64; + long: 64; + long: 64; + struct fpu fpu; +}; + +struct task_struct___2 { + volatile long int state; + void *stack; + atomic_t usage; + unsigned int flags; + unsigned int ptrace; + struct llist_node wake_entry; + int on_cpu; + unsigned int wakee_flips; + long unsigned int wakee_flip_decay_ts; + struct task_struct___2 *last_wakee; + int wake_cpu; + int on_rq; + int prio; + int static_prio; + int normal_prio; + unsigned int rt_priority; + const struct sched_class *sched_class; + long: 64; + long: 64; + long: 64; + long: 64; + struct sched_entity se; + struct sched_rt_entity rt; + struct task_group *sched_task_group; + struct sched_dl_entity dl; + struct hlist_head preempt_notifiers; + unsigned int btrace_seq; + unsigned int policy; + int nr_cpus_allowed; + cpumask_t cpus_allowed; + int rcu_read_lock_nesting; + union rcu_special rcu_read_unlock_special; + struct list_head rcu_node_entry; + struct rcu_node *rcu_blocked_node; + struct sched_info sched_info; + struct list_head tasks; + struct plist_node pushable_tasks; + struct rb_node pushable_dl_tasks; + struct mm_struct___2 *mm; + struct mm_struct___2 *active_mm; + u32 vmacache_seqnum; + struct vm_area_struct *vmacache[4]; + struct task_rss_stat rss_stat; + 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_remote_wakeup: 1; + long: 28; + unsigned int in_execve: 1; + unsigned int in_iowait: 1; + long unsigned int atomic_flags; + struct restart_block restart_block; + pid_t pid; + pid_t tgid; + struct task_struct___2 *real_parent; + struct task_struct___2 *parent; + struct list_head children; + struct list_head sibling; + struct task_struct___2 *group_leader; + struct list_head ptraced; + struct list_head ptrace_entry; + struct pid_link___2 pids[3]; + struct list_head thread_group; + struct list_head thread_node; + struct completion *vfork_done; + int *set_child_tid; + int *clear_child_tid; + cputime_t utime; + cputime_t stime; + cputime_t utimescaled; + cputime_t stimescaled; + cputime_t gtime; + struct prev_cputime prev_cputime; + long unsigned int nvcsw; + long unsigned int nivcsw; + u64 start_time; + u64 real_start_time; + long unsigned int min_flt; + long unsigned int maj_flt; + struct task_cputime cputime_expires; + struct list_head cpu_timers[3]; + const struct cred___2 *real_cred; + const struct cred___2 *cred; + char comm[16]; + struct nameidata *nameidata; + struct sysv_sem sysvsem; + struct sysv_shm sysvshm; + struct fs_struct *fs; + struct files_struct *files; + struct nsproxy___2 *nsproxy; + struct signal_struct___2 *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; + struct seccomp seccomp; + u32 parent_exec_id; + u32 self_exec_id; + spinlock_t alloc_lock; + raw_spinlock_t pi_lock; + struct wake_q_node wake_q; + struct rb_root pi_waiters; + struct rb_node *pi_waiters_leftmost; + struct rt_mutex_waiter *pi_blocked_on; + void *journal_info; + struct bio_list *bio_list; + struct blk_plug *plug; + struct reclaim_state *reclaim_state; + struct backing_dev_info *backing_dev_info; + struct io_context *io_context; + long unsigned int ptrace_message; + siginfo_t *last_siginfo; + struct task_io_accounting ioac; + u64 acct_rss_mem1; + u64 acct_vm_mem1; + cputime_t acct_timexpd; + nodemask_t mems_allowed; + seqcount_t mems_allowed_seq; + int cpuset_mem_spread_rotor; + int cpuset_slab_spread_rotor; + struct css_set___2 *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 perf_event_context *perf_event_ctxp[2]; + struct mutex___2 perf_event_mutex; + struct list_head perf_event_list; + long unsigned int preempt_disable_ip; + struct mempolicy *mempolicy; + short int il_next; + short int pref_node_fork; + struct tlbflush_unmap_batch tlb_ubc; + struct callback_head rcu; + struct pipe_inode_info *splice_pipe; + struct page_frag___2 task_frag; + struct task_delay_info *delays; + int nr_dirtied; + int nr_dirtied_pause; + long unsigned int dirty_paused_when; + u64 timer_slack_ns; + u64 default_timer_slack_ns; + int curr_ret_stack; + struct ftrace_ret_stack *ret_stack; + long long unsigned int ftrace_timestamp; + atomic_t trace_overrun; + atomic_t tracing_graph_pause; + long unsigned int trace; + long unsigned int trace_recursion; + long unsigned int task_state_change; + int pagefault_disabled; + struct task_struct___2 *oom_reaper_list; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + struct thread_struct___2 thread; +}; + +struct tasklet_head { + struct tasklet_struct *head; + struct tasklet_struct **tail; +}; + +struct tasklet_hrtimer { + struct hrtimer timer; + struct tasklet_struct tasklet; + enum hrtimer_restart (*function)(struct hrtimer *); +}; + +typedef struct tasklet_struct **pto_T_____25; + +typedef struct tasklet_struct *pto_T_____26; + +struct taskstats { + __u16 version; + __u32 ac_exitcode; + __u8 ac_flag; + __u8 ac_nice; + __u64 cpu_count; + __u64 cpu_delay_total; + __u64 blkio_count; + __u64 blkio_delay_total; + __u64 swapin_count; + __u64 swapin_delay_total; + __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; +}; + +struct tc_action_ops; + +struct tcf_hashinfo; + +struct tc_action { + void *priv; + const struct tc_action_ops *ops; + __u32 type; + __u32 order; + struct list_head list; + struct tcf_hashinfo *hinfo; +}; + +struct tc_action_net { + struct tcf_hashinfo *hinfo; + const struct tc_action_ops *ops; +}; + +struct tcf_result; + +struct tc_action_ops { + struct list_head head; + char kind[16]; + __u32 type; + 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); + int (*lookup)(struct net *, struct tc_action *, u32); + int (*init)(struct net *, struct nlattr *, struct nlattr *, struct tc_action *, int, int); + int (*walk)(struct net *, struct sk_buff *, struct netlink_callback *, int, struct tc_action *); + void (*stats_update)(struct tc_action *, u64, u32, u64); +}; + +struct fl_flow_key; + +struct tcf_exts; + +struct tc_cls_flower_offload { + enum tc_fl_command command; + long unsigned int cookie; + struct flow_dissector *dissector; + struct fl_flow_key *mask; + struct fl_flow_key *key; + struct tcf_exts *exts; +}; + +struct tc_cls_u32_hnode { + u32 handle; + u32 prio; + unsigned int divisor; +}; + +struct tc_u32_sel; + +struct tc_cls_u32_knode { + struct tcf_exts *exts; + struct tc_u32_sel *sel; + u32 handle; + u32 val; + u32 mask; + u32 link_handle; + u8 fshift; +}; + +struct tc_cls_u32_offload { + enum tc_clsu32_command command; + union { + struct tc_cls_u32_knode knode; + struct tc_cls_u32_hnode hnode; + }; +}; + +struct tc_fifo_qopt { + __u32 limit; +}; + +struct tc_prio_qopt { + int bands; + __u8 priomap[16]; +}; + +struct tc_to_netdev { + unsigned int type; + union { + u8 tc; + struct tc_cls_u32_offload *cls_u32; + struct tc_cls_flower_offload *cls_flower; + }; +}; + +struct tc_u32_key { + __be32 mask; + __be32 val; + int off; + int offmask; +}; + +struct tc_u32_sel { + unsigned char flags; + unsigned char offshift; + unsigned char nkeys; + __be16 offmask; + __u16 off; + short int offoff; + short int hoff; + __be32 hmask; + struct tc_u32_key keys[0]; +}; + +struct tcamsg { + unsigned char tca_family; + unsigned char tca__pad1; + short unsigned int tca__pad2; +}; + +struct tcf_t { + __u64 install; + __u64 lastuse; + __u64 expires; +}; + +struct tcf_common { + struct hlist_node tcfc_head; + u32 tcfc_index; + int tcfc_refcnt; + int tcfc_bindcnt; + u32 tcfc_capab; + int tcfc_action; + struct tcf_t tcfc_tm; + struct gnet_stats_basic_packed tcfc_bstats; + struct gnet_stats_queue tcfc_qstats; + struct gnet_stats_rate_est64 tcfc_rate_est; + spinlock_t tcfc_lock; + struct callback_head tcfc_rcu; + struct gnet_stats_basic_cpu *cpu_bstats; + struct gnet_stats_queue *cpu_qstats; +}; + +struct tcf_walker { + int stop; + int skip; + int count; + int (*fn)(struct tcf_proto *, long unsigned int, struct tcf_walker *); +}; + +struct tcf_dump_args { + struct tcf_walker w; + struct sk_buff *skb; + struct netlink_callback *cb; +}; + +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 { + __u32 type; + struct list_head actions; + int action; + int police; +}; + +struct tcf_hashinfo { + struct hlist_head *htab; + unsigned int hmask; + spinlock_t lock; + u32 index; +}; + +struct tcf_pkt_info { + unsigned char *ptr; + int nexthdr; +}; + +struct tcf_proto_ops; + +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; + u32 classid; + struct Qdisc *q; + void *data; + const struct tcf_proto_ops *ops; + struct callback_head rcu; +}; + +struct tcf_proto_ops___2; + +struct tcf_proto___2 { + struct tcf_proto___2 *next; + void *root; + int (*classify)(struct sk_buff___2 *, const struct tcf_proto___2 *, struct tcf_result *); + __be16 protocol; + u32 prio; + u32 classid; + struct Qdisc___2 *q; + void *data; + const struct tcf_proto_ops___2 *ops; + struct callback_head rcu; +}; + +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 *); + bool (*destroy)(struct tcf_proto *, bool); + long unsigned int (*get)(struct tcf_proto *, u32); + int (*change)(struct net *, struct sk_buff *, struct tcf_proto *, long unsigned int, u32, struct nlattr **, long unsigned int *, bool); + int (*delete)(struct tcf_proto *, long unsigned int); + void (*walk)(struct tcf_proto *, struct tcf_walker *); + int (*dump)(struct net *, struct tcf_proto *, long unsigned int, struct sk_buff *, struct tcmsg *); + struct module *owner; +}; + +struct tcf_proto_ops___2 { + struct list_head head; + char kind[16]; + int (*classify)(struct sk_buff___2 *, const struct tcf_proto___2 *, struct tcf_result *); + int (*init)(struct tcf_proto___2 *); + bool (*destroy)(struct tcf_proto___2 *, bool); + long unsigned int (*get)(struct tcf_proto___2 *, u32); + int (*change)(struct net___2 *, struct sk_buff___2 *, struct tcf_proto___2 *, long unsigned int, u32, struct nlattr **, long unsigned int *, bool); + int (*delete)(struct tcf_proto___2 *, long unsigned int); + void (*walk)(struct tcf_proto___2 *, struct tcf_walker *); + int (*dump)(struct net___2 *, struct tcf_proto___2 *, long unsigned int, struct sk_buff___2 *, struct tcmsg *); + struct module___2 *owner; +}; + +struct tcf_result { + long unsigned int class; + u32 classid; +}; + +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 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_congestion_ops { + struct list_head list; + u32 key; + u32 flags; + void (*init)(struct sock *); + void (*release)(struct sock *); + 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); + u32 (*undo_cwnd)(struct sock *); + void (*pkts_acked)(struct sock *, const struct ack_sample *); + size_t (*get_info)(struct sock *, u32, int *, union tcp_cc_info *); + char name[16]; + struct module *owner; +}; + +struct tcp_fastopen_context { + struct crypto_cipher *tfm; + __u8 key[16]; + struct callback_head rcu; +}; + +struct tcp_fastopen_cookie { + s8 len; + u8 val[16]; + 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 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; + __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; +}; + +struct tcp_iter_state { + struct seq_net_private p; + sa_family_t family; + enum tcp_seq_states state; + struct sock *syn_wait_sk; + int bucket; + int offset; + int sbucket; + int num; + loff_t last_pos; +}; + +union tcp_md5_addr { + struct in_addr a4; +}; + +struct tcp_md5sig_key { + struct hlist_node node; + u8 keylen; + u8 family; + union tcp_md5_addr addr; + u8 key[80]; + struct callback_head rcu; +}; + +struct tcp_metrics_block { + struct tcp_metrics_block *tcpm_next; + possible_net_t tcpm_net; + struct inetpeer_addr tcpm_saddr; + struct inetpeer_addr tcpm_daddr; + long unsigned int tcpm_stamp; + u32 tcpm_ts; + u32 tcpm_ts_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_options_received { + long 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: 4; + u16 snd_wscale: 4; + u16 rcv_wscale: 4; + u8 num_sacks; + u16 user_mss; + u16 mss_clamp; +}; + +struct tcp_out_options { + u16 options; + u16 mss; + u8 ws; + u8 num_sack_blocks; + u8 hash_size; + __u8 *hash_location; + __u32 tsval; + __u32 tsecr; + struct tcp_fastopen_cookie *fastopen_cookie; +}; + +struct tcp_rack { + struct skb_mstamp mstamp; + u8 advanced; + u8 reord; +}; + +struct tcp_repair_opt { + __u32 opt_code; + __u32 opt_val; +}; + +struct tcp_request_sock_ops; + +struct tcp_request_sock { + struct inet_request_sock req; + const struct tcp_request_sock_ops *af_specific; + struct skb_mstamp snt_synack; + bool tfo_listener; + u32 txhash; + u32 rcv_isn; + u32 snt_isn; + u32 last_oow_ack_time; + u32 rcv_nxt; +}; + +struct tcp_request_sock_ops { + u16 mss_clamp; + void (*init_req)(struct request_sock *, const struct sock *, struct sk_buff *); + __u32 (*cookie_init_seq)(const struct sk_buff *, __u16 *); + struct dst_entry * (*route_req)(const struct sock *, struct flowi *, const struct request_sock *, bool *); + __u32 (*init_seq)(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 tcp_sack_block { + u32 start_seq; + u32 end_seq; +}; + +struct tcp_sack_block_wire { + __be32 start_seq; + __be32 end_seq; +}; + +struct tcp_sacktag_state { + int reord; + int fack_count; + struct skb_mstamp first_sackt; + struct skb_mstamp last_sackt; + int flag; +}; + +struct tcp_seq_afinfo { + char *name; + sa_family_t family; + const struct file_operations___2 *seq_fops; + struct seq_operations seq_ops; +}; + +struct tcp_skb_cb { + __u32 seq; + __u32 end_seq; + union { + __u32 tcp_tw_isn; + 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 unused: 6; + __u32 ack_seq; + union { + struct {} tx; + union { + struct inet_skb_parm h4; + } header; + }; +}; + +struct tcp_sock { + struct inet_connection_sock inet_conn; + u16 tcp_header_len; + u16 gso_segs; + __be32 pred_flags; + u64 bytes_received; + u32 segs_in; + u32 data_segs_in; + u32 rcv_nxt; + u32 copied_seq; + u32 rcv_wup; + u32 snd_nxt; + u32 segs_out; + u32 data_segs_out; + u64 bytes_acked; + struct u64_stats_sync syncp; + u32 snd_una; + u32 snd_sml; + u32 rcv_tstamp; + u32 lsndtime; + u32 last_oow_ack_time; + u32 tsoffset; + struct list_head tsq_node; + long unsigned int tsq_flags; + struct { + struct sk_buff_head prequeue; + struct task_struct *task; + struct msghdr *msg; + int memory; + int len; + } ucopy; + u32 snd_wl1; + u32 snd_wnd; + u32 max_window; + u32 mss_cache; + u32 window_clamp; + u32 rcv_ssthresh; + struct tcp_rack rack; + u16 advmss; + u8 unused; + u8 nonagle: 4; + u8 thin_lto: 1; + u8 thin_dupack: 1; + u8 repair: 1; + u8 frto: 1; + u8 repair_queue; + u8 do_early_retrans: 1; + u8 syn_data: 1; + u8 syn_fastopen: 1; + u8 syn_fastopen_exp: 1; + u8 syn_data_acked: 1; + u8 save_syn: 1; + u8 is_cwnd_limited: 1; + u32 tlp_high_seq; + u32 srtt_us; + u32 mdev_us; + u32 mdev_max_us; + u32 rttvar_us; + u32 rtt_seq; + struct rtt_meas rtt_min[3]; + u32 packets_out; + u32 retrans_out; + u32 max_packets_out; + u32 max_packets_seq; + u16 urg_data; + u8 ecn_flags; + u8 keepalive_probes; + u32 reordering; + u32 snd_up; + struct tcp_options_received rx_opt; + u32 snd_ssthresh; + u32 snd_cwnd; + u32 snd_cwnd_cnt; + u32 snd_cwnd_clamp; + u32 snd_cwnd_used; + u32 snd_cwnd_stamp; + u32 prior_cwnd; + u32 prr_delivered; + u32 prr_out; + u32 delivered; + u32 rcv_wnd; + u32 write_seq; + u32 notsent_lowat; + u32 pushed_seq; + u32 lost_out; + u32 sacked_out; + u32 fackets_out; + struct sk_buff *lost_skb_hint; + struct sk_buff *retransmit_skb_hint; + struct sk_buff_head out_of_order_queue; + struct tcp_sack_block duplicate_sack[1]; + struct tcp_sack_block selective_acks[4]; + struct tcp_sack_block recv_sack_cache[4]; + struct sk_buff *highest_sack; + int lost_cnt_hint; + u32 retransmit_high; + u32 prior_ssthresh; + u32 high_seq; + u32 retrans_stamp; + u32 undo_marker; + int undo_retrans; + u32 total_retrans; + u32 urg_seq; + unsigned int keepalive_time; + unsigned int keepalive_intvl; + int linger2; + struct { + u32 rtt; + u32 seq; + u32 time; + } rcv_rtt_est; + struct { + int space; + u32 seq; + u32 time; + } rcvq_space; + struct { + u32 probe_seq_start; + u32 probe_seq_end; + } mtu_probe; + u32 mtu_info; + struct tcp_fastopen_request *fastopen_req; + struct request_sock *fastopen_rsk; + u32 *saved_syn; +}; + +struct tcp_splice_state { + struct pipe_inode_info___2 *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; + long int tw_ts_recent_stamp; +}; + +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 tcpm_hash_bucket { + struct tcp_metrics_block *chain; +}; + +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 termiox { + __u16 x_hflag; + __u16 x_cflag; + __u16 x_rflag[5]; + __u16 x_sflag; +}; + +struct tfp410_priv { + bool quiet; +}; + +struct tgid_iter { + unsigned int tgid; + struct task_struct___2 *task; +}; + +struct thermal_attr { + struct device_attribute attr; + char name[20]; +}; + +struct thermal_bind_params { + struct thermal_cooling_device *cdev; + int weight; + int trip_mask; + long unsigned int *binding_limits; + int (*match)(struct thermal_zone_device *, struct thermal_cooling_device *); +}; + +struct thermal_cooling_device_ops; + +struct thermal_cooling_device { + int id; + char type[20]; + struct device device; + struct device_node *np; + void *devdata; + const struct thermal_cooling_device_ops *ops; + bool updated; + struct mutex___2 lock; + struct list_head thermal_instances; + struct list_head node; +}; + +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 *, struct thermal_zone_device *, u32 *); + int (*state2power)(struct thermal_cooling_device *, struct thermal_zone_device *, long unsigned int, u32 *); + int (*power2state)(struct thermal_cooling_device *, struct thermal_zone_device *, u32, long unsigned int *); +}; + +struct thermal_genl_event { + u32 orig; + enum events event; +}; + +struct thermal_governor { + char name[20]; + int (*bind_to_tz)(struct thermal_zone_device *); + void (*unbind_from_tz)(struct thermal_zone_device *); + int (*throttle)(struct thermal_zone_device *, int); + 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_zone_device *tz; + struct thermal_cooling_device *cdev; + int 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 tz_node; + struct list_head cdev_node; + unsigned int weight; +}; + +struct thermal_state { + struct _thermal_state core_throttle; + struct _thermal_state core_power_limit; + struct _thermal_state package_throttle; + struct _thermal_state package_power_limit; + struct _thermal_state core_thresh0; + struct _thermal_state core_thresh1; + struct _thermal_state pkg_thresh0; + struct _thermal_state pkg_thresh1; +}; + +struct thermal_zone_device_ops; + +struct thermal_zone_params; + +struct thermal_zone_device { + int id; + char type[20]; + struct device device; + struct thermal_attr *trip_temp_attrs; + struct thermal_attr *trip_type_attrs; + struct thermal_attr *trip_hyst_attrs; + void *devdata; + int trips; + long unsigned int trips_disabled; + int passive_delay; + int polling_delay; + int temperature; + int last_temperature; + int emul_temperature; + int passive; + unsigned int forced_passive; + atomic_t need_update; + struct thermal_zone_device_ops *ops; + struct thermal_zone_params *tzp; + struct thermal_governor *governor; + void *governor_data; + struct list_head thermal_instances; + struct idr idr; + struct mutex___2 lock; + struct list_head node; + struct delayed_work poll_queue; +}; + +struct thermal_zone_device_ops { + int (*bind)(struct thermal_zone_device *, struct thermal_cooling_device *); + int (*unbind)(struct thermal_zone_device *, struct thermal_cooling_device *); + int (*get_temp)(struct thermal_zone_device *, int *); + int (*get_mode)(struct thermal_zone_device *, enum thermal_device_mode *); + int (*set_mode)(struct thermal_zone_device *, enum thermal_device_mode); + int (*get_trip_type)(struct thermal_zone_device *, int, enum thermal_trip_type *); + int (*get_trip_temp)(struct thermal_zone_device *, int, int *); + int (*set_trip_temp)(struct thermal_zone_device *, int, int); + int (*get_trip_hyst)(struct thermal_zone_device *, int, int *); + int (*set_trip_hyst)(struct thermal_zone_device *, int, 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 *, int, enum thermal_trend *); + int (*notify)(struct thermal_zone_device *, int, enum thermal_trip_type); +}; + +struct thermal_zone_params { + char governor_name[20]; + bool no_hwmon; + int num_tbps; + struct thermal_bind_params *tbp; + u32 sustainable_power; + s32 k_po; + s32 k_pu; + s32 k_i; + s32 k_d; + s32 integral_cutoff; + int slope; + int offset; +}; + +struct thread_info { + struct task_struct *task; + __u32 flags; + __u32 status; + __u32 cpu; + mm_segment_t addr_limit; + unsigned int sig_on_uaccess_error: 1; + unsigned int uaccess_err: 1; +}; + +struct thread_info___2 { + struct task_struct___2 *task; + __u32 flags; + __u32 status; + __u32 cpu; + mm_segment_t addr_limit; + unsigned int sig_on_uaccess_error: 1; + unsigned int uaccess_err: 1; +}; + +union thread_union { + struct thread_info thread_info; + long unsigned int stack[2048]; +}; + +struct threshold_block; + +struct thresh_restart { + struct threshold_block *b; + int reset; + int set_lvt_off; + int lvt_off; + u16 old_limit; +}; + +struct threshold_attr { + struct attribute attr; + ssize_t (*show)(struct threshold_block *, char *); + ssize_t (*store)(struct threshold_block *, const char *, size_t); +}; + +struct threshold_bank { + struct kobject *kobj; + struct threshold_block *blocks; + atomic_t cpus; +}; + +struct threshold_block { + unsigned int block; + unsigned int bank; + unsigned int cpu; + u32 address; + u16 interrupt_enable; + bool interrupt_capable; + u16 threshold_limit; + struct kobject kobj; + struct list_head miscj; +}; + +struct throttling_tstate { + unsigned int cpu; + int target_state; +}; + +struct tick_device { + struct clock_event_device *evtdev; + enum tick_device_mode mode; +}; + +struct tick_sched { + struct hrtimer sched_timer; + long unsigned int check_clocks; + enum tick_nohz_mode nohz_mode; + ktime_t last_tick; + int inidle; + int tick_stopped; + long unsigned int idle_jiffies; + long unsigned int idle_calls; + long unsigned int idle_sleeps; + int idle_active; + ktime_t idle_entrytime; + ktime_t idle_waketime; + ktime_t idle_exittime; + ktime_t idle_sleeptime; + ktime_t iowait_sleeptime; + ktime_t sleep_length; + long unsigned int last_jiffies; + u64 next_timer; + ktime_t idle_expires; + int do_timer_last; + atomic_t tick_dep_mask; +}; + +struct timedia_struct { + int num; + const short unsigned int *ids; +}; + +struct tk_read_base { + struct clocksource *clock; + cycle_t (*read)(struct clocksource *); + cycle_t mask; + cycle_t cycle_last; + u32 mult; + u32 shift; + u64 xtime_nsec; + ktime_t base; +}; + +struct timekeeper { + struct tk_read_base tkr_mono; + struct tk_read_base tkr_raw; + u64 xtime_sec; + long unsigned int ktime_sec; + struct timespec wall_to_monotonic; + ktime_t offs_real; + ktime_t offs_boot; + ktime_t offs_tai; + s32 tai_offset; + unsigned int clock_was_set_seq; + u8 cs_was_changed_seq; + ktime_t next_leap_ktime; + struct timespec raw_time; + cycle_t cycle_interval; + u64 xtime_interval; + s64 xtime_remainder; + u32 raw_interval; + u64 ntp_tick; + s64 ntp_error; + u32 ntp_error_shift; + u32 ntp_err_mult; +}; + +struct timer_list_iter { + int cpu; + bool second_pass; + u64 now; +}; + +struct timer_rand_state { + cycles_t last_time; + long int last_delta; + long int last_delta2; + unsigned int dont_count_entropy: 1; +}; + +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; + bool might_cancel; +}; + +struct timewait_sock_ops { + struct kmem_cache *twsk_slab; + char *twsk_slab_name; + unsigned int twsk_obj_size; + int (*twsk_unique)(struct sock *, struct sock *, void *); + void (*twsk_destructor)(struct sock *); +}; + +struct timex { + unsigned int modes; + __kernel_long_t offset; + __kernel_long_t freq; + __kernel_long_t maxerror; + __kernel_long_t esterror; + int status; + __kernel_long_t constant; + __kernel_long_t precision; + __kernel_long_t tolerance; + struct timeval time; + __kernel_long_t tick; + __kernel_long_t ppsfreq; + __kernel_long_t jitter; + int shift; + __kernel_long_t stabil; + __kernel_long_t jitcnt; + __kernel_long_t calcnt; + __kernel_long_t errcnt; + __kernel_long_t stbcnt; + int tai; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; +}; + +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 tk_fast { + seqcount_t seq; + struct tk_read_base base[2]; +}; + +struct tlb_state { + struct mm_struct *active_mm; + int state; + long unsigned int cr4; +}; + +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 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 tnt { + u8 bit; + char true; + char false; +}; + +struct topa_entry { + u64 end: 1; + u64 rsvd0: 1; + u64 intr: 1; + u64 rsvd1: 1; + u64 stop: 1; + u64 rsvd2: 1; + u64 size: 4; + u64 rsvd3: 2; + u64 base: 36; + u64 rsvd4: 16; +}; + +struct topa { + struct topa_entry table[506]; + struct list_head list; + u64 phys; + u64 offset; + size_t size; + int last; +}; + +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 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 trace_array_cpu; + +struct trace_buffer { + struct trace_array *tr; + struct ring_buffer *buffer; + struct trace_array_cpu *data; + cycle_t time_start; + int cpu; +}; + +struct trace_pid_list; + +struct trace_options; + +struct trace_array { + struct list_head list; + char *name; + struct trace_buffer trace_buffer; + struct trace_pid_list *filtered_pids; + arch_spinlock_t max_lock; + int buffer_disabled; + int sys_refcount_enter; + int sys_refcount_exit; + struct trace_event_file *enter_syscall_files[329]; + struct trace_event_file *exit_syscall_files[329]; + int stop_count; + int clock_id; + int nr_topts; + struct tracer *current_trace; + unsigned int trace_flags; + unsigned char trace_flags_index[32]; + unsigned int flags; + raw_spinlock_t start_lock; + struct dentry___2 *dir; + struct dentry___2 *options; + struct dentry___2 *percpu_dir; + struct dentry___2 *event_dir; + struct trace_options *topts; + struct list_head systems; + struct list_head events; + cpumask_var_t tracing_cpumask; + int ref; + struct ftrace_ops *ops; + int function_enabled; +}; + +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; + cycle_t preempt_timestamp; + pid_t pid; + kuid_t uid; + char comm[16]; + bool ignore_pid; +}; + +struct trace_bprintk_fmt { + struct list_head list; + const char *fmt; +}; + +struct trace_branch { + struct trace_entry ent; + unsigned int line; + char func[31]; + char file[21]; + char correct; +}; + +struct trace_buffer_struct { + char buffer[1024]; +}; + +struct trace_enum_map { + const char *system; + const char *enum_string; + long unsigned int enum_value; +}; + +struct trace_event_functions; + +struct trace_event { + struct hlist_node node; + struct list_head list; + int type; + struct trace_event_functions *funcs; +}; + +struct trace_event_functions___2; + +struct trace_event___2 { + struct hlist_node node; + struct list_head list; + int type; + struct trace_event_functions___2 *funcs; +}; + +struct trace_event_buffer { + struct ring_buffer *buffer; + struct ring_buffer_event *event; + struct trace_event_file *trace_file; + void *entry; + long unsigned int flags; + int pc; +}; + +struct trace_event_class; + +struct trace_event_call { + struct list_head list; + struct trace_event_class *class; + union { + char *name; + struct tracepoint *tp; + }; + struct trace_event event; + char *print_fmt; + struct event_filter *filter; + void *mod; + void *data; + int flags; + int perf_refcount; + struct hlist_head *perf_events; + struct bpf_prog *prog; + int (*perf_perm)(struct trace_event_call *, struct perf_event *); +}; + +struct trace_event_class___2; + +struct trace_event_call___2 { + struct list_head list; + struct trace_event_class___2 *class; + union { + char *name; + struct tracepoint *tp; + }; + struct trace_event___2 event; + char *print_fmt; + struct event_filter *filter; + void *mod; + void *data; + int flags; + int perf_refcount; + struct hlist_head *perf_events; + struct bpf_prog___2 *prog; + int (*perf_perm)(struct trace_event_call___2 *, struct perf_event___2 *); +}; + +struct trace_event_class { + const char *system; + void *probe; + void *perf_probe; + int (*reg)(struct trace_event_call *, enum trace_reg, void *); + int (*define_fields)(struct trace_event_call *); + struct list_head * (*get_fields)(struct trace_event_call *); + struct list_head fields; + int (*raw_init)(struct trace_event_call *); +}; + +struct trace_event_class___2 { + const char *system; + void *probe; + void *perf_probe; + int (*reg)(struct trace_event_call___2 *, enum trace_reg, void *); + int (*define_fields)(struct trace_event_call___2 *); + struct list_head * (*get_fields)(struct trace_event_call___2 *); + struct list_head fields; + int (*raw_init)(struct trace_event_call___2 *); +}; + +struct trace_event_data_offsets_9p_client_req {}; + +struct trace_event_data_offsets_9p_client_res {}; + +struct trace_event_data_offsets_9p_protocol_dump {}; + +struct trace_event_data_offsets_add_device_randomness {}; + +struct trace_event_data_offsets_add_disk_randomness {}; + +struct trace_event_data_offsets_add_input_randomness {}; + +struct trace_event_data_offsets_aer_event { + u32 dev_name; +}; + +struct trace_event_data_offsets_ata_eh_link_autopsy {}; + +struct trace_event_data_offsets_ata_eh_link_autopsy_qc {}; + +struct trace_event_data_offsets_ata_qc_complete_template {}; + +struct trace_event_data_offsets_ata_qc_issue {}; + +struct trace_event_data_offsets_azx_get_position {}; + +struct trace_event_data_offsets_azx_pcm {}; + +struct trace_event_data_offsets_azx_pcm_trigger {}; + +struct trace_event_data_offsets_balance_dirty_pages {}; + +struct trace_event_data_offsets_bdi_dirty_ratelimit {}; + +struct trace_event_data_offsets_block_bio_bounce {}; + +struct trace_event_data_offsets_block_bio_complete {}; + +struct trace_event_data_offsets_block_bio_merge {}; + +struct trace_event_data_offsets_block_bio_queue {}; + +struct trace_event_data_offsets_block_bio_remap {}; + +struct trace_event_data_offsets_block_buffer {}; + +struct trace_event_data_offsets_block_get_rq {}; + +struct trace_event_data_offsets_block_plug {}; + +struct trace_event_data_offsets_block_rq { + u32 cmd; +}; + +struct trace_event_data_offsets_block_rq_complete { + u32 cmd; +}; + +struct trace_event_data_offsets_block_rq_remap {}; + +struct trace_event_data_offsets_block_rq_with_error { + u32 cmd; +}; + +struct trace_event_data_offsets_block_split {}; + +struct trace_event_data_offsets_block_unplug {}; + +struct trace_event_data_offsets_cdev_update { + u32 type; +}; + +struct trace_event_data_offsets_check_mmio_spte {}; + +struct trace_event_data_offsets_clock { + u32 name; +}; + +struct trace_event_data_offsets_console { + u32 msg; +}; + +struct trace_event_data_offsets_consume_skb {}; + +struct trace_event_data_offsets_cpu {}; + +struct trace_event_data_offsets_cpuhp_enter {}; + +struct trace_event_data_offsets_cpuhp_exit {}; + +struct trace_event_data_offsets_credit_entropy_bits {}; + +struct trace_event_data_offsets_debit_entropy {}; + +struct trace_event_data_offsets_dev_pm_qos_request { + u32 name; +}; + +struct trace_event_data_offsets_device_pm_callback_end { + u32 device; + u32 driver; +}; + +struct trace_event_data_offsets_device_pm_callback_start { + u32 device; + u32 driver; + u32 parent; + u32 pm_ops; +}; + +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_emulate_vsyscall {}; + +struct trace_event_data_offsets_fast_page_fault {}; + +struct trace_event_data_offsets_fence { + u32 driver; + u32 timeline; +}; + +struct trace_event_data_offsets_fence_annotate_wait_on { + u32 driver; + u32 timeline; + u32 waiting_driver; + u32 waiting_timeline; +}; + +struct trace_event_data_offsets_fib_table_lookup {}; + +struct trace_event_data_offsets_fib_table_lookup_nh { + u32 name; +}; + +struct trace_event_data_offsets_fib_validate_source { + u32 name; +}; + +struct trace_event_data_offsets_filelock_lease {}; + +struct trace_event_data_offsets_filelock_lock {}; + +struct trace_event_data_offsets_generic_add_lease {}; + +struct trace_event_data_offsets_global_dirty_state {}; + +struct trace_event_data_offsets_handle_mmio_page_fault {}; + +struct trace_event_data_offsets_hda_get_response { + u32 msg; +}; + +struct trace_event_data_offsets_hda_pm {}; + +struct trace_event_data_offsets_hda_send_cmd { + u32 msg; +}; + +struct trace_event_data_offsets_hda_unsol_event { + u32 msg; +}; + +struct trace_event_data_offsets_hdac_stream {}; + +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_i2c_read {}; + +struct trace_event_data_offsets_i2c_reply { + u32 buf; +}; + +struct trace_event_data_offsets_i2c_result {}; + +struct trace_event_data_offsets_i2c_write { + u32 buf; +}; + +struct trace_event_data_offsets_i915_context {}; + +struct trace_event_data_offsets_i915_flip_complete {}; + +struct trace_event_data_offsets_i915_flip_request {}; + +struct trace_event_data_offsets_i915_gem_evict {}; + +struct trace_event_data_offsets_i915_gem_evict_everything {}; + +struct trace_event_data_offsets_i915_gem_evict_vm {}; + +struct trace_event_data_offsets_i915_gem_object {}; + +struct trace_event_data_offsets_i915_gem_object_change_domain {}; + +struct trace_event_data_offsets_i915_gem_object_create {}; + +struct trace_event_data_offsets_i915_gem_object_fault {}; + +struct trace_event_data_offsets_i915_gem_object_pread {}; + +struct trace_event_data_offsets_i915_gem_object_pwrite {}; + +struct trace_event_data_offsets_i915_gem_request {}; + +struct trace_event_data_offsets_i915_gem_request_notify {}; + +struct trace_event_data_offsets_i915_gem_request_wait_begin {}; + +struct trace_event_data_offsets_i915_gem_ring_dispatch {}; + +struct trace_event_data_offsets_i915_gem_ring_flush {}; + +struct trace_event_data_offsets_i915_gem_ring_sync_to {}; + +struct trace_event_data_offsets_i915_gem_shrink {}; + +struct trace_event_data_offsets_i915_page_table_entry_update { + u32 cur_ptes; +}; + +struct trace_event_data_offsets_i915_pipe_update_end {}; + +struct trace_event_data_offsets_i915_pipe_update_start {}; + +struct trace_event_data_offsets_i915_pipe_update_vblank_evaded {}; + +struct trace_event_data_offsets_i915_ppgtt {}; + +struct trace_event_data_offsets_i915_px_entry {}; + +struct trace_event_data_offsets_i915_reg_rw {}; + +struct trace_event_data_offsets_i915_va_alloc {}; + +struct trace_event_data_offsets_i915_vma_bind {}; + +struct trace_event_data_offsets_i915_vma_unbind {}; + +struct trace_event_data_offsets_intel_gpu_freq_change {}; + +struct trace_event_data_offsets_iommu_device_event { + u32 device; +}; + +struct trace_event_data_offsets_iommu_error { + u32 device; + u32 driver; +}; + +struct trace_event_data_offsets_iommu_group_event { + u32 device; +}; + +struct trace_event_data_offsets_irq_handler_entry { + u32 name; +}; + +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_kcompactd_wake_template {}; + +struct trace_event_data_offsets_kfree_skb {}; + +struct trace_event_data_offsets_kmem_alloc {}; + +struct trace_event_data_offsets_kmem_alloc_node {}; + +struct trace_event_data_offsets_kmem_free {}; + +struct trace_event_data_offsets_kvm_ack_irq {}; + +struct trace_event_data_offsets_kvm_age_page {}; + +struct trace_event_data_offsets_kvm_apic {}; + +struct trace_event_data_offsets_kvm_apic_accept_irq {}; + +struct trace_event_data_offsets_kvm_apic_ipi {}; + +struct trace_event_data_offsets_kvm_async_get_page_class {}; + +struct trace_event_data_offsets_kvm_async_pf_completed {}; + +struct trace_event_data_offsets_kvm_async_pf_nopresent_ready {}; + +struct trace_event_data_offsets_kvm_avic_incomplete_ipi {}; + +struct trace_event_data_offsets_kvm_avic_unaccelerated_access {}; + +struct trace_event_data_offsets_kvm_cpuid {}; + +struct trace_event_data_offsets_kvm_cr {}; + +struct trace_event_data_offsets_kvm_emulate_insn {}; + +struct trace_event_data_offsets_kvm_enter_smm {}; + +struct trace_event_data_offsets_kvm_entry {}; + +struct trace_event_data_offsets_kvm_eoi {}; + +struct trace_event_data_offsets_kvm_exit {}; + +struct trace_event_data_offsets_kvm_fast_mmio {}; + +struct trace_event_data_offsets_kvm_fpu {}; + +struct trace_event_data_offsets_kvm_halt_poll_ns {}; + +struct trace_event_data_offsets_kvm_hv_hypercall {}; + +struct trace_event_data_offsets_kvm_hv_notify_acked_sint {}; + +struct trace_event_data_offsets_kvm_hv_stimer_callback {}; + +struct trace_event_data_offsets_kvm_hv_stimer_cleanup {}; + +struct trace_event_data_offsets_kvm_hv_stimer_expiration {}; + +struct trace_event_data_offsets_kvm_hv_stimer_set_config {}; + +struct trace_event_data_offsets_kvm_hv_stimer_set_count {}; + +struct trace_event_data_offsets_kvm_hv_stimer_start_one_shot {}; + +struct trace_event_data_offsets_kvm_hv_stimer_start_periodic {}; + +struct trace_event_data_offsets_kvm_hv_synic_send_eoi {}; + +struct trace_event_data_offsets_kvm_hv_synic_set_irq {}; + +struct trace_event_data_offsets_kvm_hv_synic_set_msr {}; + +struct trace_event_data_offsets_kvm_hypercall {}; + +struct trace_event_data_offsets_kvm_inj_exception {}; + +struct trace_event_data_offsets_kvm_inj_virq {}; + +struct trace_event_data_offsets_kvm_invlpga {}; + +struct trace_event_data_offsets_kvm_ioapic_delayed_eoi_inj {}; + +struct trace_event_data_offsets_kvm_ioapic_set_irq {}; + +struct trace_event_data_offsets_kvm_mmio {}; + +struct trace_event_data_offsets_kvm_mmu_get_page {}; + +struct trace_event_data_offsets_kvm_mmu_invalidate_zap_all_pages {}; + +struct trace_event_data_offsets_kvm_mmu_page_class {}; + +struct trace_event_data_offsets_kvm_mmu_pagetable_walk {}; + +struct trace_event_data_offsets_kvm_mmu_paging_element {}; + +struct trace_event_data_offsets_kvm_mmu_set_bit_class {}; + +struct trace_event_data_offsets_kvm_mmu_walker_error {}; + +struct trace_event_data_offsets_kvm_msi_set_irq {}; + +struct trace_event_data_offsets_kvm_msr {}; + +struct trace_event_data_offsets_kvm_nested_intercepts {}; + +struct trace_event_data_offsets_kvm_nested_intr_vmexit {}; + +struct trace_event_data_offsets_kvm_nested_vmexit {}; + +struct trace_event_data_offsets_kvm_nested_vmexit_inject {}; + +struct trace_event_data_offsets_kvm_nested_vmrun {}; + +struct trace_event_data_offsets_kvm_page_fault {}; + +struct trace_event_data_offsets_kvm_pi_irte_update {}; + +struct trace_event_data_offsets_kvm_pic_set_irq {}; + +struct trace_event_data_offsets_kvm_pio {}; + +struct trace_event_data_offsets_kvm_ple_window {}; + +struct trace_event_data_offsets_kvm_pml_full {}; + +struct trace_event_data_offsets_kvm_pv_eoi {}; + +struct trace_event_data_offsets_kvm_pvclock_update {}; + +struct trace_event_data_offsets_kvm_set_irq {}; + +struct trace_event_data_offsets_kvm_skinit {}; + +struct trace_event_data_offsets_kvm_track_tsc {}; + +struct trace_event_data_offsets_kvm_update_master_clock {}; + +struct trace_event_data_offsets_kvm_userspace_exit {}; + +struct trace_event_data_offsets_kvm_vcpu_wakeup {}; + +struct trace_event_data_offsets_kvm_wait_lapic_expire {}; + +struct trace_event_data_offsets_kvm_write_tsc_offset {}; + +struct trace_event_data_offsets_locks_get_lock_context {}; + +struct trace_event_data_offsets_map {}; + +struct trace_event_data_offsets_mark_mmio_spte {}; + +struct trace_event_data_offsets_mc_event { + u32 msg; + u32 label; + u32 driver_detail; +}; + +struct trace_event_data_offsets_mce_record {}; + +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_op_page_cache {}; + +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_numa_migrate_ratelimit {}; + +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_template {}; + +struct trace_event_data_offsets_mm_vmscan_lru_shrink_inactive {}; + +struct trace_event_data_offsets_mm_vmscan_wakeup_kswapd {}; + +struct trace_event_data_offsets_mm_vmscan_writepage {}; + +struct trace_event_data_offsets_module_free { + u32 name; +}; + +struct trace_event_data_offsets_module_load { + u32 name; +}; + +struct trace_event_data_offsets_module_refcnt { + u32 name; +}; + +struct trace_event_data_offsets_module_request { + u32 name; +}; + +struct trace_event_data_offsets_msr_trace_class {}; + +struct trace_event_data_offsets_napi_poll { + u32 dev_name; +}; + +struct trace_event_data_offsets_net_dev_rx_verbose_template { + u32 name; +}; + +struct trace_event_data_offsets_net_dev_start_xmit { + u32 name; +}; + +struct trace_event_data_offsets_net_dev_template { + u32 name; +}; + +struct trace_event_data_offsets_net_dev_xmit { + u32 name; +}; + +struct trace_event_data_offsets_nmi_handler {}; + +struct trace_event_data_offsets_oom_score_adj_update {}; + +struct trace_event_data_offsets_pm_qos_request {}; + +struct trace_event_data_offsets_pm_qos_update {}; + +struct trace_event_data_offsets_pm_qos_update_request_timeout {}; + +struct trace_event_data_offsets_power_domain { + u32 name; +}; + +struct trace_event_data_offsets_powernv_throttle { + u32 reason; +}; + +struct trace_event_data_offsets_pstate_sample {}; + +struct trace_event_data_offsets_push_to_pool {}; + +struct trace_event_data_offsets_random__extract_entropy {}; + +struct trace_event_data_offsets_random__get_random_bytes {}; + +struct trace_event_data_offsets_random__mix_pool_bytes {}; + +struct trace_event_data_offsets_random_read {}; + +struct trace_event_data_offsets_rcu_utilization {}; + +struct trace_event_data_offsets_regcache_drop_region { + u32 name; +}; + +struct trace_event_data_offsets_regcache_sync { + u32 name; + u32 status; + u32 type; +}; + +struct trace_event_data_offsets_regmap_async { + u32 name; +}; + +struct trace_event_data_offsets_regmap_block { + u32 name; +}; + +struct trace_event_data_offsets_regmap_bool { + u32 name; +}; + +struct trace_event_data_offsets_regmap_reg { + u32 name; +}; + +struct trace_event_data_offsets_rpm_internal { + u32 name; +}; + +struct trace_event_data_offsets_rpm_return_int { + u32 name; +}; + +struct trace_event_data_offsets_sched_kthread_stop {}; + +struct trace_event_data_offsets_sched_kthread_stop_ret {}; + +struct trace_event_data_offsets_sched_migrate_task {}; + +struct trace_event_data_offsets_sched_move_task_template {}; + +struct trace_event_data_offsets_sched_pi_setprio {}; + +struct trace_event_data_offsets_sched_process_exec { + u32 filename; +}; + +struct trace_event_data_offsets_sched_process_fork {}; + +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_swap_numa {}; + +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; +}; + +struct trace_event_data_offsets_scsi_dispatch_cmd_error { + u32 cmnd; +}; + +struct trace_event_data_offsets_scsi_dispatch_cmd_start { + u32 cmnd; +}; + +struct trace_event_data_offsets_scsi_eh_wakeup {}; + +struct trace_event_data_offsets_signal_deliver {}; + +struct trace_event_data_offsets_signal_generate {}; + +struct trace_event_data_offsets_skb_copy_datagram_iovec {}; + +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_rcvqueue_full {}; + +struct trace_event_data_offsets_softirq {}; + +struct trace_event_data_offsets_suspend_resume {}; + +struct trace_event_data_offsets_swiotlb_bounced { + u32 dev_name; +}; + +struct trace_event_data_offsets_switch_mm {}; + +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_rename {}; + +struct trace_event_data_offsets_test_pages_isolated {}; + +struct trace_event_data_offsets_thermal_power_cpu_get_power { + u32 cpumask; + u32 load; +}; + +struct trace_event_data_offsets_thermal_power_cpu_limit { + u32 cpumask; +}; + +struct trace_event_data_offsets_thermal_power_devfreq_get_power { + u32 type; +}; + +struct trace_event_data_offsets_thermal_power_devfreq_limit { + u32 type; +}; + +struct trace_event_data_offsets_thermal_temperature { + u32 thermal_zone; +}; + +struct trace_event_data_offsets_thermal_zone_trip { + u32 thermal_zone; +}; + +struct trace_event_data_offsets_tick_stop {}; + +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_udp_fail_queue_rcv_skb {}; + +struct trace_event_data_offsets_unmap {}; + +struct trace_event_data_offsets_urandom_read {}; + +struct trace_event_data_offsets_vcpu_match_mmio {}; + +struct trace_event_data_offsets_wakeup_source { + u32 name; +}; + +struct trace_event_data_offsets_wbc_class {}; + +struct trace_event_data_offsets_workqueue_execute_start {}; + +struct trace_event_data_offsets_workqueue_queue_work {}; + +struct trace_event_data_offsets_workqueue_work {}; + +struct trace_event_data_offsets_writeback_bdi_register {}; + +struct trace_event_data_offsets_writeback_class {}; + +struct trace_event_data_offsets_writeback_congest_waited_template {}; + +struct trace_event_data_offsets_writeback_dirty_inode_template {}; + +struct trace_event_data_offsets_writeback_dirty_page {}; + +struct trace_event_data_offsets_writeback_lazytime_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_x86_exceptions {}; + +struct trace_event_data_offsets_x86_irq_vector {}; + +struct trace_event_data_offsets_xfer_secondary_pool {}; + +struct trace_subsystem_dir; + +struct trace_event_file { + struct list_head list; + struct trace_event_call *event_call; + struct event_filter *filter; + struct dentry___2 *dir; + struct trace_array *tr; + struct trace_subsystem_dir *system; + struct list_head triggers; + long unsigned int flags; + 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_iterator___2; + +typedef enum print_line_t (*trace_print_func___2)(struct trace_iterator___2 *, int, struct trace_event___2 *); + +struct trace_event_functions___2 { + trace_print_func___2 trace; + trace_print_func___2 raw; + trace_print_func___2 hex; + trace_print_func___2 binary; +}; + +struct trace_event_raw_9p_client_req { + struct trace_entry ent; + void *clnt; + __u8 type; + __u32 tag; + char __data[0]; +}; + +struct trace_event_raw_9p_client_res { + struct trace_entry ent; + void *clnt; + __u8 type; + __u32 tag; + __u32 err; + char __data[0]; +}; + +struct trace_event_raw_9p_protocol_dump { + struct trace_entry ent; + void *clnt; + __u8 type; + __u16 tag; + unsigned char line[32]; + char __data[0]; +}; + +struct trace_event_raw_add_device_randomness { + struct trace_entry ent; + int bytes; + long unsigned int IP; + char __data[0]; +}; + +struct trace_event_raw_add_disk_randomness { + struct trace_entry ent; + dev_t dev; + int input_bits; + char __data[0]; +}; + +struct trace_event_raw_add_input_randomness { + struct trace_entry ent; + int input_bits; + char __data[0]; +}; + +struct trace_event_raw_aer_event { + struct trace_entry ent; + u32 __data_loc_dev_name; + u32 status; + u8 severity; + char __data[0]; +}; + +struct trace_event_raw_ata_eh_link_autopsy { + struct trace_entry ent; + unsigned int ata_port; + unsigned int ata_dev; + unsigned int eh_action; + unsigned int eh_err_mask; + char __data[0]; +}; + +struct trace_event_raw_ata_eh_link_autopsy_qc { + struct trace_entry ent; + unsigned int ata_port; + unsigned int ata_dev; + unsigned int tag; + unsigned int qc_flags; + unsigned int eh_err_mask; + char __data[0]; +}; + +struct trace_event_raw_ata_qc_complete_template { + struct trace_entry ent; + unsigned int ata_port; + unsigned int ata_dev; + unsigned int tag; + unsigned char status; + unsigned char dev; + unsigned char lbal; + unsigned char lbam; + unsigned char lbah; + unsigned char nsect; + unsigned char error; + unsigned char hob_lbal; + unsigned char hob_lbam; + unsigned char hob_lbah; + unsigned char hob_nsect; + unsigned char hob_feature; + unsigned char ctl; + long unsigned int flags; + char __data[0]; +}; + +struct trace_event_raw_ata_qc_issue { + struct trace_entry ent; + unsigned int ata_port; + unsigned int ata_dev; + unsigned int tag; + unsigned char cmd; + unsigned char dev; + unsigned char lbal; + unsigned char lbam; + unsigned char lbah; + unsigned char nsect; + unsigned char feature; + unsigned char hob_lbal; + unsigned char hob_lbam; + unsigned char hob_lbah; + unsigned char hob_nsect; + unsigned char hob_feature; + unsigned char ctl; + unsigned char proto; + long unsigned int flags; + char __data[0]; +}; + +struct trace_event_raw_azx_get_position { + struct trace_entry ent; + int card; + int idx; + unsigned int pos; + unsigned int delay; + char __data[0]; +}; + +struct trace_event_raw_azx_pcm { + struct trace_entry ent; + unsigned char stream_tag; + char __data[0]; +}; + +struct trace_event_raw_azx_pcm_trigger { + struct trace_entry ent; + int card; + int idx; + int cmd; + 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; + unsigned int 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; + unsigned int cgroup_ino; + char __data[0]; +}; + +struct trace_event_raw_block_bio_bounce { + 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_merge { + 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_queue { + 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_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_get_rq { + 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_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; + char rwbs[8]; + char comm[16]; + u32 __data_loc_cmd; + char __data[0]; +}; + +struct trace_event_raw_block_rq_complete { + struct trace_entry ent; + dev_t dev; + sector_t sector; + unsigned int nr_sector; + int errors; + 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_with_error { + struct trace_entry ent; + dev_t dev; + sector_t sector; + unsigned int nr_sector; + int errors; + 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_cdev_update { + struct trace_entry ent; + u32 __data_loc_type; + long unsigned int target; + char __data[0]; +}; + +struct trace_event_raw_check_mmio_spte { + struct trace_entry ent; + unsigned int kvm_gen; + unsigned int spte_gen; + u64 spte; + 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_console { + struct trace_entry ent; + u32 __data_loc_msg; + char __data[0]; +}; + +struct trace_event_raw_consume_skb { + struct trace_entry ent; + void *skbaddr; + char __data[0]; +}; + +struct trace_event_raw_cpu { + struct trace_entry ent; + u32 state; + u32 cpu_id; + 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_credit_entropy_bits { + struct trace_entry ent; + const char *pool_name; + int bits; + int entropy_count; + int entropy_total; + long unsigned int IP; + char __data[0]; +}; + +struct trace_event_raw_debit_entropy { + struct trace_entry ent; + const char *pool_name; + int debit_bits; + 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_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_drm_vblank_event { + struct trace_entry ent; + int crtc; + unsigned int seq; + char __data[0]; +}; + +struct trace_event_raw_drm_vblank_event_delivered { + struct trace_entry ent; + pid_t pid; + int crtc; + unsigned int seq; + char __data[0]; +}; + +struct trace_event_raw_drm_vblank_event_queued { + struct trace_entry ent; + pid_t pid; + int crtc; + unsigned int seq; + char __data[0]; +}; + +struct trace_event_raw_emulate_vsyscall { + struct trace_entry ent; + int nr; + char __data[0]; +}; + +struct trace_event_raw_fast_page_fault { + struct trace_entry ent; + int vcpu_id; + gva_t gva; + u32 error_code; + u64 *sptep; + u64 old_spte; + u64 new_spte; + bool retry; + char __data[0]; +}; + +struct trace_event_raw_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_fence_annotate_wait_on { + struct trace_entry ent; + u32 __data_loc_driver; + u32 __data_loc_timeline; + unsigned int context; + unsigned int seqno; + u32 __data_loc_waiting_driver; + u32 __data_loc_waiting_timeline; + unsigned int waiting_context; + unsigned int waiting_seqno; + char __data[0]; +}; + +struct trace_event_raw_fib_table_lookup { + struct trace_entry ent; + u32 tb_id; + int oif; + int iif; + __u8 tos; + __u8 scope; + __u8 flags; + __u8 src[4]; + __u8 dst[4]; + char __data[0]; +}; + +struct trace_event_raw_fib_table_lookup_nh { + struct trace_entry ent; + u32 __data_loc_name; + int oif; + __u8 src[4]; + char __data[0]; +}; + +struct trace_event_raw_fib_validate_source { + struct trace_entry ent; + u32 __data_loc_name; + int oif; + int iif; + __u8 tos; + __u8 src[4]; + __u8 dst[4]; + char __data[0]; +}; + +struct trace_event_raw_filelock_lease { + struct trace_entry ent; + struct file_lock *fl; + long unsigned int i_ino; + dev_t s_dev; + struct file_lock *fl_next; + fl_owner_t fl_owner; + unsigned int fl_flags; + unsigned char fl_type; + long unsigned int fl_break_time; + long unsigned int fl_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 *fl_next; + fl_owner_t fl_owner; + unsigned int fl_pid; + unsigned int fl_flags; + unsigned char fl_type; + loff_t fl_start; + loff_t fl_end; + int ret; + char __data[0]; +}; + +struct trace_event_raw_generic_add_lease { + struct trace_entry ent; + long unsigned int i_ino; + int wcount; + int dcount; + int icount; + dev_t s_dev; + fl_owner_t fl_owner; + unsigned int fl_flags; + unsigned char fl_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 nr_unstable; + 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_handle_mmio_page_fault { + struct trace_entry ent; + u64 addr; + gfn_t gfn; + unsigned int access; + char __data[0]; +}; + +struct trace_event_raw_hda_get_response { + struct trace_entry ent; + u32 __data_loc_msg; + char __data[0]; +}; + +struct trace_event_raw_hda_pm { + struct trace_entry ent; + int dev_index; + char __data[0]; +}; + +struct trace_event_raw_hda_send_cmd { + struct trace_entry ent; + u32 __data_loc_msg; + char __data[0]; +}; + +struct trace_event_raw_hda_unsol_event { + struct trace_entry ent; + u32 __data_loc_msg; + char __data[0]; +}; + +struct trace_event_raw_hdac_stream { + struct trace_entry ent; + unsigned char stream_tag; + 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; + 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_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_i915_context { + struct trace_entry ent; + u32 dev; + struct intel_context *ctx; + struct i915_address_space *vm; + char __data[0]; +}; + +struct trace_event_raw_i915_flip_complete { + struct trace_entry ent; + int plane; + struct drm_i915_gem_object *obj; + char __data[0]; +}; + +struct trace_event_raw_i915_flip_request { + struct trace_entry ent; + int plane; + struct drm_i915_gem_object *obj; + char __data[0]; +}; + +struct trace_event_raw_i915_gem_evict { + struct trace_entry ent; + u32 dev; + u32 size; + u32 align; + unsigned int flags; + char __data[0]; +}; + +struct trace_event_raw_i915_gem_evict_everything { + struct trace_entry ent; + u32 dev; + char __data[0]; +}; + +struct trace_event_raw_i915_gem_evict_vm { + struct trace_entry ent; + u32 dev; + struct i915_address_space *vm; + char __data[0]; +}; + +struct trace_event_raw_i915_gem_object { + struct trace_entry ent; + struct drm_i915_gem_object *obj; + char __data[0]; +}; + +struct trace_event_raw_i915_gem_object_change_domain { + struct trace_entry ent; + struct drm_i915_gem_object *obj; + u32 read_domains; + u32 write_domain; + char __data[0]; +}; + +struct trace_event_raw_i915_gem_object_create { + struct trace_entry ent; + struct drm_i915_gem_object *obj; + u32 size; + char __data[0]; +}; + +struct trace_event_raw_i915_gem_object_fault { + struct trace_entry ent; + struct drm_i915_gem_object *obj; + u32 index; + bool gtt; + bool write; + char __data[0]; +}; + +struct trace_event_raw_i915_gem_object_pread { + struct trace_entry ent; + struct drm_i915_gem_object *obj; + u32 offset; + u32 len; + char __data[0]; +}; + +struct trace_event_raw_i915_gem_object_pwrite { + struct trace_entry ent; + struct drm_i915_gem_object *obj; + u32 offset; + u32 len; + char __data[0]; +}; + +struct trace_event_raw_i915_gem_request { + struct trace_entry ent; + u32 dev; + u32 ring; + u32 seqno; + char __data[0]; +}; + +struct trace_event_raw_i915_gem_request_notify { + struct trace_entry ent; + u32 dev; + u32 ring; + u32 seqno; + char __data[0]; +}; + +struct trace_event_raw_i915_gem_request_wait_begin { + struct trace_entry ent; + u32 dev; + u32 ring; + u32 seqno; + bool blocking; + char __data[0]; +}; + +struct trace_event_raw_i915_gem_ring_dispatch { + struct trace_entry ent; + u32 dev; + u32 ring; + u32 seqno; + u32 flags; + char __data[0]; +}; + +struct trace_event_raw_i915_gem_ring_flush { + struct trace_entry ent; + u32 dev; + u32 ring; + u32 invalidate; + u32 flush; + char __data[0]; +}; + +struct trace_event_raw_i915_gem_ring_sync_to { + struct trace_entry ent; + u32 dev; + u32 sync_from; + u32 sync_to; + u32 seqno; + char __data[0]; +}; + +struct trace_event_raw_i915_gem_shrink { + struct trace_entry ent; + int dev; + long unsigned int target; + unsigned int flags; + char __data[0]; +}; + +struct trace_event_raw_i915_page_table_entry_update { + struct trace_entry ent; + struct i915_address_space *vm; + u32 pde; + u32 first; + u32 last; + u32 __data_loc_cur_ptes; + char __data[0]; +}; + +struct trace_event_raw_i915_pipe_update_end { + struct trace_entry ent; + enum pipe pipe; + u32 frame; + u32 scanline; + char __data[0]; +}; + +struct trace_event_raw_i915_pipe_update_start { + struct trace_entry ent; + enum pipe pipe; + u32 frame; + u32 scanline; + u32 min; + u32 max; + char __data[0]; +}; + +struct trace_event_raw_i915_pipe_update_vblank_evaded { + struct trace_entry ent; + enum pipe pipe; + u32 frame; + u32 scanline; + u32 min; + u32 max; + char __data[0]; +}; + +struct trace_event_raw_i915_ppgtt { + struct trace_entry ent; + struct i915_address_space *vm; + u32 dev; + char __data[0]; +}; + +struct trace_event_raw_i915_px_entry { + struct trace_entry ent; + struct i915_address_space *vm; + u32 px; + u64 start; + u64 end; + char __data[0]; +}; + +struct trace_event_raw_i915_reg_rw { + struct trace_entry ent; + u64 val; + u32 reg; + u16 write; + u16 len; + char __data[0]; +}; + +struct trace_event_raw_i915_va_alloc { + struct trace_entry ent; + struct i915_address_space *vm; + u64 start; + u64 end; + char __data[0]; +}; + +struct trace_event_raw_i915_vma_bind { + struct trace_entry ent; + struct drm_i915_gem_object *obj; + struct i915_address_space *vm; + u64 offset; + u32 size; + unsigned int flags; + char __data[0]; +}; + +struct trace_event_raw_i915_vma_unbind { + struct trace_entry ent; + struct drm_i915_gem_object *obj; + struct i915_address_space *vm; + u64 offset; + u32 size; + char __data[0]; +}; + +struct trace_event_raw_intel_gpu_freq_change { + struct trace_entry ent; + u32 freq; + 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_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; + cputime_t now; + char __data[0]; +}; + +struct trace_event_raw_itimer_state { + struct trace_entry ent; + int which; + cputime_t expires; + long int value_sec; + long int value_usec; + long int interval_sec; + long int interval_usec; + char __data[0]; +}; + +struct trace_event_raw_kcompactd_wake_template { + struct trace_entry ent; + int nid; + int order; + enum zone_type classzone_idx; + char __data[0]; +}; + +struct trace_event_raw_kfree_skb { + struct trace_entry ent; + void *skbaddr; + void *location; + short unsigned int protocol; + char __data[0]; +}; + +struct trace_event_raw_kmem_alloc { + struct trace_entry ent; + long unsigned int call_site; + const void *ptr; + size_t bytes_req; + size_t bytes_alloc; + gfp_t gfp_flags; + char __data[0]; +}; + +struct trace_event_raw_kmem_alloc_node { + struct trace_entry ent; + long unsigned int call_site; + const void *ptr; + size_t bytes_req; + size_t bytes_alloc; + gfp_t gfp_flags; + int node; + char __data[0]; +}; + +struct trace_event_raw_kmem_free { + struct trace_entry ent; + long unsigned int call_site; + const void *ptr; + 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_page { + struct trace_entry ent; + u64 hva; + u64 gfn; + u8 level; + u8 referenced; + char __data[0]; +}; + +struct trace_event_raw_kvm_apic { + struct trace_entry ent; + unsigned int rw; + unsigned int reg; + unsigned int val; + char __data[0]; +}; + +struct trace_event_raw_kvm_apic_accept_irq { + struct trace_entry ent; + __u32 apicid; + __u16 dm; + __u8 tm; + __u8 vec; + char __data[0]; +}; + +struct trace_event_raw_kvm_apic_ipi { + struct trace_entry ent; + __u32 icr_low; + __u32 dest_id; + char __data[0]; +}; + +struct trace_event_raw_kvm_async_get_page_class { + struct trace_entry ent; + __u64 gva; + u64 gfn; + char __data[0]; +}; + +struct trace_event_raw_kvm_async_pf_completed { + struct trace_entry ent; + long unsigned int address; + u64 gva; + char __data[0]; +}; + +struct trace_event_raw_kvm_async_pf_nopresent_ready { + struct trace_entry ent; + __u64 token; + __u64 gva; + char __data[0]; +}; + +struct trace_event_raw_kvm_avic_incomplete_ipi { + struct trace_entry ent; + u32 vcpu; + u32 icrh; + u32 icrl; + u32 id; + u32 index; + char __data[0]; +}; + +struct trace_event_raw_kvm_avic_unaccelerated_access { + struct trace_entry ent; + u32 vcpu; + u32 offset; + bool ft; + bool rw; + u32 vec; + char __data[0]; +}; + +struct trace_event_raw_kvm_cpuid { + struct trace_entry ent; + unsigned int function; + long unsigned int rax; + long unsigned int rbx; + long unsigned int rcx; + long unsigned int rdx; + char __data[0]; +}; + +struct trace_event_raw_kvm_cr { + struct trace_entry ent; + unsigned int rw; + unsigned int cr; + long unsigned int val; + char __data[0]; +}; + +struct trace_event_raw_kvm_emulate_insn { + struct trace_entry ent; + __u64 rip; + __u32 csbase; + __u8 len; + __u8 insn[15]; + __u8 flags; + __u8 failed; + char __data[0]; +}; + +struct trace_event_raw_kvm_enter_smm { + struct trace_entry ent; + unsigned int vcpu_id; + u64 smbase; + bool entering; + char __data[0]; +}; + +struct trace_event_raw_kvm_entry { + struct trace_entry ent; + unsigned int vcpu_id; + char __data[0]; +}; + +struct trace_event_raw_kvm_eoi { + struct trace_entry ent; + __u32 apicid; + int vector; + char __data[0]; +}; + +struct trace_event_raw_kvm_exit { + struct trace_entry ent; + unsigned int exit_reason; + long unsigned int guest_rip; + u32 isa; + u64 info1; + u64 info2; + char __data[0]; +}; + +struct trace_event_raw_kvm_fast_mmio { + struct trace_entry ent; + u64 gpa; + char __data[0]; +}; + +struct trace_event_raw_kvm_fpu { + struct trace_entry ent; + u32 load; + 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_hv_hypercall { + struct trace_entry ent; + __u16 rep_cnt; + __u16 rep_idx; + __u64 ingpa; + __u64 outgpa; + __u16 code; + bool fast; + char __data[0]; +}; + +struct trace_event_raw_kvm_hv_notify_acked_sint { + struct trace_entry ent; + int vcpu_id; + u32 sint; + char __data[0]; +}; + +struct trace_event_raw_kvm_hv_stimer_callback { + struct trace_entry ent; + int vcpu_id; + int timer_index; + char __data[0]; +}; + +struct trace_event_raw_kvm_hv_stimer_cleanup { + struct trace_entry ent; + int vcpu_id; + int timer_index; + char __data[0]; +}; + +struct trace_event_raw_kvm_hv_stimer_expiration { + struct trace_entry ent; + int vcpu_id; + int timer_index; + int msg_send_result; + char __data[0]; +}; + +struct trace_event_raw_kvm_hv_stimer_set_config { + struct trace_entry ent; + int vcpu_id; + int timer_index; + u64 config; + bool host; + char __data[0]; +}; + +struct trace_event_raw_kvm_hv_stimer_set_count { + struct trace_entry ent; + int vcpu_id; + int timer_index; + u64 count; + bool host; + char __data[0]; +}; + +struct trace_event_raw_kvm_hv_stimer_start_one_shot { + struct trace_entry ent; + int vcpu_id; + int timer_index; + u64 time_now; + u64 count; + char __data[0]; +}; + +struct trace_event_raw_kvm_hv_stimer_start_periodic { + struct trace_entry ent; + int vcpu_id; + int timer_index; + u64 time_now; + u64 exp_time; + char __data[0]; +}; + +struct trace_event_raw_kvm_hv_synic_send_eoi { + struct trace_entry ent; + int vcpu_id; + u32 sint; + int vector; + int ret; + char __data[0]; +}; + +struct trace_event_raw_kvm_hv_synic_set_irq { + struct trace_entry ent; + int vcpu_id; + u32 sint; + int vector; + int ret; + char __data[0]; +}; + +struct trace_event_raw_kvm_hv_synic_set_msr { + struct trace_entry ent; + int vcpu_id; + u32 msr; + u64 data; + bool host; + char __data[0]; +}; + +struct trace_event_raw_kvm_hypercall { + struct trace_entry ent; + long unsigned int nr; + long unsigned int a0; + long unsigned int a1; + long unsigned int a2; + long unsigned int a3; + char __data[0]; +}; + +struct trace_event_raw_kvm_inj_exception { + struct trace_entry ent; + u8 exception; + u8 has_error; + u32 error_code; + char __data[0]; +}; + +struct trace_event_raw_kvm_inj_virq { + struct trace_entry ent; + unsigned int irq; + char __data[0]; +}; + +struct trace_event_raw_kvm_invlpga { + struct trace_entry ent; + __u64 rip; + int asid; + __u64 address; + char __data[0]; +}; + +struct trace_event_raw_kvm_ioapic_delayed_eoi_inj { + struct trace_entry ent; + __u64 e; + char __data[0]; +}; + +struct trace_event_raw_kvm_ioapic_set_irq { + struct trace_entry ent; + __u64 e; + int pin; + bool coalesced; + 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_mmu_get_page { + struct trace_entry ent; + long unsigned int mmu_valid_gen; + __u64 gfn; + __u32 role; + __u32 root_count; + bool unsync; + bool created; + char __data[0]; +}; + +struct trace_event_raw_kvm_mmu_invalidate_zap_all_pages { + struct trace_entry ent; + long unsigned int mmu_valid_gen; + unsigned int mmu_used_pages; + char __data[0]; +}; + +struct trace_event_raw_kvm_mmu_page_class { + struct trace_entry ent; + long unsigned int mmu_valid_gen; + __u64 gfn; + __u32 role; + __u32 root_count; + bool unsync; + char __data[0]; +}; + +struct trace_event_raw_kvm_mmu_pagetable_walk { + struct trace_entry ent; + __u64 addr; + __u32 pferr; + char __data[0]; +}; + +struct trace_event_raw_kvm_mmu_paging_element { + struct trace_entry ent; + __u64 pte; + __u32 level; + char __data[0]; +}; + +struct trace_event_raw_kvm_mmu_set_bit_class { + struct trace_entry ent; + __u64 gpa; + char __data[0]; +}; + +struct trace_event_raw_kvm_mmu_walker_error { + struct trace_entry ent; + __u32 pferr; + char __data[0]; +}; + +struct trace_event_raw_kvm_msi_set_irq { + struct trace_entry ent; + __u64 address; + __u64 data; + char __data[0]; +}; + +struct trace_event_raw_kvm_msr { + struct trace_entry ent; + unsigned int write; + u32 ecx; + u64 data; + u8 exception; + char __data[0]; +}; + +struct trace_event_raw_kvm_nested_intercepts { + struct trace_entry ent; + __u16 cr_read; + __u16 cr_write; + __u32 exceptions; + __u64 intercept; + char __data[0]; +}; + +struct trace_event_raw_kvm_nested_intr_vmexit { + struct trace_entry ent; + __u64 rip; + char __data[0]; +}; + +struct trace_event_raw_kvm_nested_vmexit { + struct trace_entry ent; + __u64 rip; + __u32 exit_code; + __u64 exit_info1; + __u64 exit_info2; + __u32 exit_int_info; + __u32 exit_int_info_err; + __u32 isa; + char __data[0]; +}; + +struct trace_event_raw_kvm_nested_vmexit_inject { + struct trace_entry ent; + __u32 exit_code; + __u64 exit_info1; + __u64 exit_info2; + __u32 exit_int_info; + __u32 exit_int_info_err; + __u32 isa; + char __data[0]; +}; + +struct trace_event_raw_kvm_nested_vmrun { + struct trace_entry ent; + __u64 rip; + __u64 vmcb; + __u64 nested_rip; + __u32 int_ctl; + __u32 event_inj; + bool npt; + char __data[0]; +}; + +struct trace_event_raw_kvm_page_fault { + struct trace_entry ent; + long unsigned int fault_address; + unsigned int error_code; + char __data[0]; +}; + +struct trace_event_raw_kvm_pi_irte_update { + struct trace_entry ent; + unsigned int host_irq; + unsigned int vcpu_id; + unsigned int gsi; + unsigned int gvec; + u64 pi_desc_addr; + bool set; + char __data[0]; +}; + +struct trace_event_raw_kvm_pic_set_irq { + struct trace_entry ent; + __u8 chip; + __u8 pin; + __u8 elcr; + __u8 imr; + bool coalesced; + char __data[0]; +}; + +struct trace_event_raw_kvm_pio { + struct trace_entry ent; + unsigned int rw; + unsigned int port; + unsigned int size; + unsigned int count; + unsigned int val; + char __data[0]; +}; + +struct trace_event_raw_kvm_ple_window { + struct trace_entry ent; + bool grow; + unsigned int vcpu_id; + int new; + int old; + char __data[0]; +}; + +struct trace_event_raw_kvm_pml_full { + struct trace_entry ent; + unsigned int vcpu_id; + char __data[0]; +}; + +struct trace_event_raw_kvm_pv_eoi { + struct trace_entry ent; + __u32 apicid; + int vector; + char __data[0]; +}; + +struct trace_event_raw_kvm_pvclock_update { + struct trace_entry ent; + unsigned int vcpu_id; + __u32 version; + __u64 tsc_timestamp; + __u64 system_time; + __u32 tsc_to_system_mul; + __s8 tsc_shift; + __u8 flags; + 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_skinit { + struct trace_entry ent; + __u64 rip; + __u32 slb; + char __data[0]; +}; + +struct trace_event_raw_kvm_track_tsc { + struct trace_entry ent; + unsigned int vcpu_id; + unsigned int nr_vcpus_matched_tsc; + unsigned int online_vcpus; + bool use_master_clock; + unsigned int host_clock; + char __data[0]; +}; + +struct trace_event_raw_kvm_update_master_clock { + struct trace_entry ent; + bool use_master_clock; + unsigned int host_clock; + bool offset_matched; + 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_wait_lapic_expire { + struct trace_entry ent; + unsigned int vcpu_id; + s64 delta; + char __data[0]; +}; + +struct trace_event_raw_kvm_write_tsc_offset { + struct trace_entry ent; + unsigned int vcpu_id; + __u64 previous_tsc_offset; + __u64 next_tsc_offset; + 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_map { + struct trace_entry ent; + u64 iova; + u64 paddr; + size_t size; + char __data[0]; +}; + +struct trace_event_raw_mark_mmio_spte { + struct trace_entry ent; + void *sptep; + gfn_t gfn; + unsigned int access; + unsigned int gen; + 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_mce_record { + struct trace_entry ent; + u64 mcgcap; + u64 mcgstatus; + u64 status; + u64 addr; + u64 misc; + u64 ip; + u64 tsc; + u64 walltime; + u32 cpu; + u32 cpuid; + u32 apicid; + u32 socketid; + u8 cs; + u8 bank; + u8 cpuvendor; + 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; + gfp_t gfp_mask; + enum migrate_mode mode; + 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; + char __data[0]; +}; + +struct trace_event_raw_mm_lru_activate { + struct trace_entry ent; + struct page *page; + long unsigned int pfn; + char __data[0]; +}; + +struct trace_event_raw_mm_lru_insertion { + struct trace_entry ent; + struct page *page; + long unsigned int pfn; + int 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; + enum migrate_mode mode; + int reason; + char __data[0]; +}; + +struct trace_event_raw_mm_numa_migrate_ratelimit { + struct trace_entry ent; + char comm[16]; + pid_t pid; + int dst_nid; + long unsigned int nr_pages; + char __data[0]; +}; + +struct trace_event_raw_mm_page { + struct trace_entry ent; + long unsigned int pfn; + unsigned int order; + int migratetype; + char __data[0]; +}; + +struct trace_event_raw_mm_page_alloc { + struct trace_entry ent; + long unsigned int pfn; + unsigned int order; + gfp_t 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; + int cold; + 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; + gfp_t gfp_flags; + long unsigned int pgs_scanned; + long unsigned int lru_pgs; + long unsigned int cache_items; + long long unsigned int delta; + long unsigned int total_scan; + char __data[0]; +}; + +struct trace_event_raw_mm_vmscan_direct_reclaim_begin_template { + struct trace_entry ent; + int order; + int may_writepage; + gfp_t 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 order; + char __data[0]; +}; + +struct trace_event_raw_mm_vmscan_lru_isolate_template { + struct trace_entry ent; + int order; + long unsigned int nr_requested; + long unsigned int nr_scanned; + long unsigned int nr_taken; + isolate_mode_t isolate_mode; + int file; + char __data[0]; +}; + +struct trace_event_raw_mm_vmscan_lru_shrink_inactive { + struct trace_entry ent; + int nid; + int zid; + long unsigned int nr_scanned; + long unsigned int nr_reclaimed; + int priority; + int reclaim_flags; + char __data[0]; +}; + +struct trace_event_raw_mm_vmscan_wakeup_kswapd { + struct trace_entry ent; + int nid; + int zid; + int order; + char __data[0]; +}; + +struct trace_event_raw_mm_vmscan_writepage { + struct trace_entry ent; + long unsigned int pfn; + int reclaim_flags; + 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_msr_trace_class { + struct trace_entry ent; + unsigned int msr; + u64 val; + int failed; + char __data[0]; +}; + +struct trace_event_raw_napi_poll { + struct trace_entry ent; + struct napi_struct *napi; + u32 __data_loc_dev_name; + 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_nmi_handler { + struct trace_entry ent; + void *handler; + s64 delta_ns; + int handled; + 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_pm_qos_request { + struct trace_entry ent; + int pm_qos_class; + s32 value; + 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_pm_qos_update_request_timeout { + struct trace_entry ent; + int pm_qos_class; + s32 value; + long unsigned int timeout_us; + 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_pstate_sample { + struct trace_entry ent; + u32 core_busy; + u32 scaled_busy; + u32 from; + u32 to; + u64 mperf; + u64 aperf; + u64 tsc; + u32 freq; + char __data[0]; +}; + +struct trace_event_raw_push_to_pool { + struct trace_entry ent; + const char *pool_name; + int pool_bits; + int input_bits; + char __data[0]; +}; + +struct trace_event_raw_random__extract_entropy { + struct trace_entry ent; + const char *pool_name; + int nbytes; + int entropy_count; + long unsigned int IP; + char __data[0]; +}; + +struct trace_event_raw_random__get_random_bytes { + struct trace_entry ent; + int nbytes; + long unsigned int IP; + char __data[0]; +}; + +struct trace_event_raw_random__mix_pool_bytes { + struct trace_entry ent; + const char *pool_name; + int bytes; + long unsigned int IP; + char __data[0]; +}; + +struct trace_event_raw_random_read { + struct trace_entry ent; + int got_bits; + int need_bits; + int pool_left; + int input_left; + char __data[0]; +}; + +struct trace_event_raw_rcu_utilization { + struct trace_entry ent; + const char *s; + 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; + int 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_reg { + struct trace_entry ent; + u32 __data_loc_name; + unsigned int reg; + 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_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_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_task_template { + 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_pi_setprio { + struct trace_entry ent; + char comm[16]; + pid_t pid; + int oldprio; + int newprio; + 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_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; + u64 vruntime; + 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_swap_numa { + 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_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 success; + 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; + 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_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; + 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; + 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_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_skb_copy_datagram_iovec { + struct trace_entry ent; + const void *skbaddr; + int len; + 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; + long int allocated; + int sysctl_rmem; + int rmem_alloc; + 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_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; + int swiotlb_force; + char __data[0]; +}; + +struct trace_event_raw_switch_mm { + struct trace_entry ent; + u32 ring; + struct intel_context *to; + struct i915_address_space *vm; + u32 dev; + 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_rename { + struct trace_entry ent; + pid_t pid; + char oldcomm[16]; + char newcomm[16]; + short int oom_score_adj; + 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 { + struct trace_entry ent; + u32 __data_loc_cpumask; + long unsigned int freq; + u32 __data_loc_load; + size_t load_len; + u32 dynamic_power; + u32 static_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 load; + u32 dynamic_power; + u32 static_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_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; + char __data[0]; +}; + +struct trace_event_raw_timer_start { + struct trace_entry ent; + void *timer; + void *function; + long unsigned int expires; + 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_udp_fail_queue_rcv_skb { + struct trace_entry ent; + int rc; + __u16 lport; + 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_urandom_read { + struct trace_entry ent; + int got_bits; + int pool_left; + int input_left; + char __data[0]; +}; + +struct trace_event_raw_vcpu_match_mmio { + struct trace_entry ent; + gva_t gva; + gpa_t gpa; + bool write; + bool gpa_match; + 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_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; + unsigned int cgroup_ino; + 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; + void *workqueue; + unsigned int req_cpu; + unsigned int cpu; + char __data[0]; +}; + +struct trace_event_raw_workqueue_work { + struct trace_entry ent; + void *work; + 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]; + unsigned int cgroup_ino; + char __data[0]; +}; + +struct trace_event_raw_writeback_congest_waited_template { + struct trace_entry ent; + unsigned int usec_timeout; + unsigned int usec_delayed; + char __data[0]; +}; + +struct trace_event_raw_writeback_dirty_inode_template { + struct trace_entry ent; + char name[32]; + long unsigned int ino; + long unsigned int state; + long unsigned int flags; + char __data[0]; +}; + +struct trace_event_raw_writeback_dirty_page { + struct trace_entry ent; + char name[32]; + long unsigned int ino; + long unsigned int index; + char __data[0]; +}; + +struct trace_event_raw_writeback_lazytime_template { + struct trace_entry ent; + dev_t dev; + long unsigned int 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; + unsigned int cgroup_ino; + char __data[0]; +}; + +struct trace_event_raw_writeback_sb_inodes_requeue { + struct trace_entry ent; + char name[32]; + long unsigned int ino; + long unsigned int state; + long unsigned int dirtied_when; + unsigned int cgroup_ino; + char __data[0]; +}; + +struct trace_event_raw_writeback_single_inode_template { + struct trace_entry ent; + char name[32]; + long unsigned int ino; + long unsigned int state; + long unsigned int dirtied_when; + long unsigned int writeback_index; + long int nr_to_write; + long unsigned int wrote; + unsigned int 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; + unsigned int cgroup_ino; + char __data[0]; +}; + +struct trace_event_raw_writeback_write_inode_template { + struct trace_entry ent; + char name[32]; + long unsigned int ino; + int sync_mode; + unsigned int cgroup_ino; + char __data[0]; +}; + +struct trace_event_raw_x86_exceptions { + struct trace_entry ent; + long unsigned int address; + long unsigned int ip; + long unsigned int error_code; + char __data[0]; +}; + +struct trace_event_raw_x86_irq_vector { + struct trace_entry ent; + int vector; + char __data[0]; +}; + +struct trace_event_raw_xfer_secondary_pool { + struct trace_entry ent; + const char *pool_name; + int xfer_bits; + int request_bits; + int pool_entropy; + int input_entropy; + char __data[0]; +}; + +struct trace_iterator___2 { + struct trace_array *tr; + struct tracer *trace; + struct trace_buffer *trace_buffer; + void *private; + int cpu_file; + struct mutex___2 mutex; + struct ring_buffer_iter **buffer_iter; + long unsigned int iter_flags; + struct trace_seq tmp_seq; + cpumask_var_t started; + 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 trace_probe { + unsigned int flags; + struct trace_event_class class; + struct trace_event_call call; + struct list_head files; + ssize_t size; + unsigned int nr_args; + struct probe_arg args[0]; +}; + +struct trace_kprobe { + struct list_head list; + 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_mmiotrace_map { + struct trace_entry ent; + struct mmiotrace_map map; +}; + +struct trace_mmiotrace_rw { + struct trace_entry ent; + struct mmiotrace_rw rw; +}; + +struct tracer_opt; + +struct tracer_flags; + +struct trace_option_dentry { + struct tracer_opt *opt; + struct tracer_flags *flags; + struct trace_array *tr; + struct dentry___2 *entry; +}; + +struct trace_options { + struct tracer *tracer; + struct trace_option_dentry *topts; +}; + +struct trace_pid_list { + int pid_max; + long unsigned int *pids; +}; + +struct trace_print_flags { + long unsigned int mask; + const char *name; +}; + +struct trace_subsystem_dir { + struct list_head list; + struct event_subsystem *subsystem; + struct trace_array *tr; + struct dentry___2 *entry; + int ref_count; + int nr_events; +}; + +struct tracefs_dir_ops { + int (*mkdir)(const char *); + int (*rmdir)(const char *); +}; + +struct tracefs_mount_opts { + kuid_t uid; + kgid_t gid; + umode_t mode; +}; + +struct tracefs_fs_info { + struct tracefs_mount_opts mount_opts; +}; + +struct tracepoint { + const char *name; + struct static_key key; + void (*regfunc)(void); + void (*unregfunc)(void); + struct tracepoint_func *funcs; +}; + +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___2 *, char *, size_t, loff_t *); + ssize_t (*splice_read)(struct trace_iterator *, struct file___2 *, loff_t *, struct pipe_inode_info___2 *, 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; + int ref; + bool print_max; + bool allow_instances; +}; + +struct tracer_flags { + u32 val; + struct tracer_opt *opts; + struct tracer *trace; +}; + +struct tracer_opt { + const char *name; + u32 bit; +}; + +struct tracer_stat { + const char *name; + void * (*stat_start)(struct tracer_stat *); + void * (*stat_next)(void *, int); + int (*stat_cmp)(void *, void *); + int (*stat_show)(struct seq_file *, void *); + void (*stat_release)(void *); + int (*stat_headers)(struct seq_file *); +}; + +struct track { + long unsigned int addr; + long unsigned int addrs[16]; + int cpu; + int pid; + long unsigned int when; +}; + +struct trackpoint_attr_data { + size_t field_offset; + unsigned char command; + unsigned char mask; + unsigned char inverted; + unsigned char power_on_default; +}; + +struct trackpoint_data { + unsigned char sensitivity; + unsigned char speed; + unsigned char inertia; + unsigned char reach; + unsigned char draghys; + unsigned char mindrag; + unsigned char thresh; + unsigned char upthresh; + unsigned char ztime; + unsigned char jenks; + unsigned char drift_time; + unsigned char press_to_select; + unsigned char skipback; + unsigned char ext_dev; +}; + +struct trampoline_header { + u64 start; + u64 efer; + u32 cr4; +}; + +struct tree_descr { + char *name; + const struct file_operations___2 *ops; + int mode; +}; + +struct trie { + struct key_vector kv[1]; +}; + +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 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_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[40]; +}; + +struct tso_t { + int next_frag_idx; + void *data; + size_t size; + u16 ip_id; + bool ipv6; + u32 tcp_seq; +}; + +struct tsq_tasklet { + struct tasklet_struct tasklet; + struct list_head head; +}; + +struct tss_segment_16 { + u16 prev_task_link; + u16 sp0; + u16 ss0; + u16 sp1; + u16 ss1; + u16 sp2; + u16 ss2; + u16 ip; + u16 flag; + u16 ax; + u16 cx; + u16 dx; + u16 bx; + u16 sp; + u16 bp; + u16 si; + u16 di; + u16 es; + u16 cs; + u16 ss; + u16 ds; + u16 ldt; +}; + +struct tss_segment_32 { + u32 prev_task_link; + u32 esp0; + u32 ss0; + u32 esp1; + u32 ss1; + u32 esp2; + u32 ss2; + u32 cr3; + u32 eip; + u32 eflags; + u32 eax; + u32 ecx; + u32 edx; + u32 ebx; + u32 esp; + u32 ebp; + u32 esi; + u32 edi; + u32 es; + u32 cs; + u32 ss; + u32 ds; + u32 fs; + u32 gs; + u32 ldt_selector; + u16 t; + u16 io_map; +}; + +struct x86_hw_tss { + u32 reserved1; + u64 sp0; + u64 sp1; + u64 sp2; + u64 reserved2; + u64 ist[7]; + u32 reserved3; + u32 reserved4; + u16 reserved5; + u16 io_bitmap_base; + long: 64; + long: 64; + long: 64; +} __attribute__((packed)); + +struct tss_struct { + struct x86_hw_tss x86_tss; + long unsigned int io_bitmap[1025]; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; +}; + +struct ttm_backend_func; + +struct ttm_tt { + struct ttm_bo_device *bdev; + struct ttm_backend_func *func; + struct page *dummy_read_page; + struct page **pages; + uint32_t page_flags; + long unsigned int num_pages; + struct sg_table *sg; + struct ttm_bo_global *glob; + struct file___2 *swap_storage; + enum ttm_caching_state caching_state; + enum { + tt_bound = 0, + tt_unbound = 1, + tt_unpopulated = 2, + } state; +}; + +struct ttm_agp_backend { + struct ttm_tt ttm; + struct agp_memory *mem; + struct agp_bridge_data *bridge; +}; + +struct ttm_backend_func { + int (*bind)(struct ttm_tt *, struct ttm_mem_reg *); + int (*unbind)(struct ttm_tt *); + void (*destroy)(struct ttm_tt *); +}; + +struct ttm_object_file; + +struct ttm_base_object { + struct callback_head rhead; + struct drm_hash_item hash; + enum ttm_object_type object_type; + bool shareable; + struct ttm_object_file *tfile; + struct kref refcount; + void (*refcount_release)(struct ttm_base_object **); + void (*ref_obj_release)(struct ttm_base_object *, enum ttm_ref_type); +}; + +struct ttm_bo_driver { + struct ttm_tt * (*ttm_tt_create)(struct ttm_bo_device *, long unsigned int, uint32_t, struct page *); + int (*ttm_tt_populate)(struct ttm_tt *); + void (*ttm_tt_unpopulate)(struct ttm_tt *); + int (*invalidate_caches)(struct ttm_bo_device *, uint32_t); + int (*init_mem_type)(struct ttm_bo_device *, uint32_t, struct ttm_mem_type_manager *); + void (*evict_flags)(struct ttm_buffer_object *, struct ttm_placement *); + int (*move)(struct ttm_buffer_object *, bool, bool, bool, struct ttm_mem_reg *); + int (*verify_access)(struct ttm_buffer_object *, struct file___2 *); + void (*move_notify)(struct ttm_buffer_object *, struct ttm_mem_reg *); + int (*fault_reserve_notify)(struct ttm_buffer_object *); + void (*swap_notify)(struct ttm_buffer_object *); + int (*io_mem_reserve)(struct ttm_bo_device *, struct ttm_mem_reg *); + void (*io_mem_free)(struct ttm_bo_device *, struct ttm_mem_reg *); + void (*lru_removal)(struct ttm_buffer_object *); + struct list_head * (*lru_tail)(struct ttm_buffer_object *); + struct list_head * (*swap_lru_tail)(struct ttm_buffer_object *); +}; + +struct ttm_mem_shrink { + int (*do_shrink)(struct ttm_mem_shrink *); +}; + +struct ttm_bo_global { + struct kobject___2 kobj; + struct ttm_mem_global *mem_glob; + struct page *dummy_read_page; + struct ttm_mem_shrink shrink; + struct mutex___2 device_list_mutex; + spinlock_t lru_lock; + struct list_head device_list; + struct list_head swap_lru; + atomic_t bo_count; +}; + +struct ttm_dma_tt { + struct ttm_tt ttm; + void **cpu_address; + dma_addr_t *dma_address; + struct list_head pages_list; +}; + +struct ttm_lock { + struct ttm_base_object base; + wait_queue_head_t queue; + spinlock_t lock; + int32_t rw; + uint32_t flags; + bool kill_takers; + int signal; + struct ttm_object_file *vt_holder; +}; + +struct ttm_mem_zone; + +struct ttm_mem_global { + struct kobject___2 kobj; + struct ttm_mem_shrink *shrink; + struct workqueue_struct *swap_queue; + struct work_struct work; + spinlock_t lock; + struct ttm_mem_zone *zones[2]; + unsigned int num_zones; + struct ttm_mem_zone *zone_kernel; + struct ttm_mem_zone *zone_dma32; +}; + +struct ttm_mem_type_manager_func { + int (*init)(struct ttm_mem_type_manager *, long unsigned int); + int (*takedown)(struct ttm_mem_type_manager *); + int (*get_node)(struct ttm_mem_type_manager *, struct ttm_buffer_object *, const struct ttm_place *, struct ttm_mem_reg *); + void (*put_node)(struct ttm_mem_type_manager *, struct ttm_mem_reg *); + void (*debug)(struct ttm_mem_type_manager *, const char *); +}; + +struct ttm_mem_zone { + struct kobject___2 kobj; + struct ttm_mem_global *glob; + const char *name; + uint64_t zone_mem; + uint64_t emer_mem; + uint64_t max_mem; + uint64_t swap_limit; + uint64_t used_mem; +}; + +struct ttm_object_device { + spinlock_t object_lock; + struct drm_open_hash object_hash; + atomic_t object_count; + struct ttm_mem_global *mem_glob; + struct dma_buf_ops ops; + void (*dmabuf_release)(struct dma_buf *); + size_t dma_buf_size; +}; + +struct ttm_object_file { + struct ttm_object_device *tdev; + spinlock_t lock; + struct list_head ref_list; + struct drm_open_hash ref_hash[3]; + struct kref refcount; +}; + +struct ttm_page_pool { + spinlock_t lock; + bool fill_lock; + struct list_head list; + gfp_t gfp_flags; + unsigned int npages; + char *name; + long unsigned int nfrees; + long unsigned int nrefills; +}; + +struct ttm_pool_opts { + unsigned int alloc_size; + unsigned int max_size; + unsigned int small; +}; + +struct ttm_pool_manager { + struct kobject___2 kobj; + struct shrinker mm_shrink; + struct ttm_pool_opts options; + union { + struct ttm_page_pool pools[4]; + struct { + struct ttm_page_pool wc_pool; + struct ttm_page_pool uc_pool; + struct ttm_page_pool wc_pool_dma32; + struct ttm_page_pool uc_pool_dma32; + }; + }; +}; + +struct ttm_pool_manager___2 { + struct mutex___2 lock; + struct list_head pools; + struct ttm_pool_opts options; + unsigned int npools; + struct shrinker mm_shrink; + struct kobject___2 kobj; +}; + +struct ttm_prime_object { + struct ttm_base_object base; + struct mutex___2 mutex; + size_t size; + enum ttm_object_type real_type; + struct dma_buf *dma_buf; + void (*refcount_release)(struct ttm_base_object **); +}; + +struct ttm_range_manager { + struct drm_mm mm; + spinlock_t lock; +}; + +struct ttm_ref_object { + struct callback_head callback_head; + struct drm_hash_item hash; + struct list_head head; + struct kref kref; + enum ttm_ref_type ref_type; + struct ttm_base_object *obj; + struct ttm_object_file *tfile; +}; + +struct ttm_validate_buffer { + struct list_head head; + struct ttm_buffer_object *bo; + bool shared; +}; + +struct tty_operations; + +struct tty_driver { + int magic; + 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 { + int magic; + char *name; + int num; + int flags; + int (*open)(struct tty_struct *); + void (*close)(struct tty_struct *); + void (*flush_buffer)(struct tty_struct *); + ssize_t (*read)(struct tty_struct *, struct file___2 *, unsigned char *, size_t); + ssize_t (*write)(struct tty_struct *, struct file___2 *, const unsigned char *, size_t); + int (*ioctl)(struct tty_struct *, struct file___2 *, unsigned int, long unsigned int); + long int (*compat_ioctl)(struct tty_struct *, struct file___2 *, unsigned int, long unsigned int); + void (*set_termios)(struct tty_struct *, struct ktermios *); + unsigned int (*poll)(struct tty_struct *, struct file___2 *, struct poll_table_struct *); + int (*hangup)(struct tty_struct *); + void (*receive_buf)(struct tty_struct *, const unsigned char *, char *, int); + void (*write_wakeup)(struct tty_struct *); + void (*dcd_change)(struct tty_struct *, unsigned int); + int (*receive_buf2)(struct tty_struct *, const unsigned char *, char *, int); + struct module *owner; + int refcount; +}; + +struct tty_operations { + struct tty_struct * (*lookup)(struct tty_driver *, struct file___2 *, int); + int (*install)(struct tty_driver *, struct tty_struct *); + void (*remove)(struct tty_driver *, struct tty_struct *); + int (*open)(struct tty_struct *, struct file___2 *); + void (*close)(struct tty_struct *, struct file___2 *); + void (*shutdown)(struct tty_struct *); + void (*cleanup)(struct tty_struct *); + int (*write)(struct tty_struct *, const unsigned char *, int); + int (*put_char)(struct tty_struct *, unsigned char); + void (*flush_chars)(struct tty_struct *); + int (*write_room)(struct tty_struct *); + 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 *, 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 *); + void (*set_ldisc)(struct tty_struct *); + void (*wait_until_sent)(struct tty_struct *, int); + void (*send_xchar)(struct tty_struct *, char); + int (*tiocmget)(struct tty_struct *); + int (*tiocmset)(struct tty_struct *, unsigned int, unsigned int); + int (*resize)(struct tty_struct *, struct winsize *); + int (*set_termiox)(struct tty_struct *, struct termiox *); + int (*get_icount)(struct tty_struct *, struct serial_icounter_struct *); + const struct file_operations___2 *proc_fops; +}; + +struct tty_port_operations { + int (*carrier_raised)(struct tty_port *); + void (*dtr_rts)(struct tty_port *, int); + void (*shutdown)(struct tty_port *); + int (*activate)(struct tty_port *, struct tty_struct *); + void (*destruct)(struct tty_port *); +}; + +struct tty_struct { + int magic; + struct kref kref; + struct device *dev; + struct tty_driver *driver; + const struct tty_operations *ops; + int index; + struct ld_semaphore ldisc_sem; + struct tty_ldisc *ldisc; + struct mutex atomic_write_lock; + struct mutex legacy_mutex; + struct mutex throttle_mutex; + struct rw_semaphore termios_rwsem; + struct mutex winsize_mutex; + spinlock_t ctrl_lock; + spinlock_t flow_lock; + struct ktermios termios; + struct ktermios termios_locked; + struct termiox *termiox; + char name[64]; + struct pid___2 *pgrp; + struct pid___2 *session; + long unsigned int flags; + int count; + struct winsize winsize; + long unsigned int stopped: 1; + long unsigned int flow_stopped: 1; + long: 30; + long unsigned int unused: 62; + int hw_stopped; + long unsigned int ctrl_status: 8; + long unsigned int packet: 1; + long: 23; + long unsigned int unused_ctrl: 55; + unsigned int receive_room; + int flow_change; + struct tty_struct *link; + struct fasync_struct *fasync; + int alt_speed; + 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; + struct list_head tty_files; + int closing; + unsigned char *write_buf; + int write_cnt; + struct work_struct SAK_work; + struct tty_port *port; +}; + +struct tuple_flags { + u_int link_space: 4; + u_int has_link: 1; + u_int mfc_fn: 3; + u_int space: 4; +}; + +struct tuple_t { + u_int Attributes; + cisdata_t DesiredTuple; + u_int Flags; + u_int LinkOffset; + u_int CISOffset; + cisdata_t TupleCode; + cisdata_t TupleLink; + cisdata_t TupleOffset; + cisdata_t TupleDataMax; + cisdata_t TupleDataLen; + cisdata_t *TupleData; +}; + +struct video_levels; + +struct tv_mode { + const char *name; + int clock; + int refresh; + u32 oversample; + int hsync_end; + int hblank_start; + int hblank_end; + int htotal; + bool progressive; + bool trilevel_sync; + bool component_only; + int vsync_start_f1; + int vsync_start_f2; + int vsync_len; + bool veq_ena; + int veq_start_f1; + int veq_start_f2; + int veq_len; + int vi_end_f1; + int vi_end_f2; + int nbr_end; + bool burst_ena; + int hburst_start; + int hburst_len; + int vburst_start_f1; + int vburst_end_f1; + int vburst_start_f2; + int vburst_end_f2; + int vburst_start_f3; + int vburst_end_f3; + int vburst_start_f4; + int vburst_end_f4; + int dda2_size; + int dda3_size; + int dda1_inc; + int dda2_inc; + int dda3_inc; + u32 sc_reset; + bool pal_burst; + const struct video_levels *composite_levels; + const struct video_levels *svideo_levels; + const struct color_conversion *composite_color; + const struct color_conversion *svideo_color; + const u32 *filter_table; + int max_srcw; +}; + +struct tvec { + struct hlist_head vec[64]; +}; + +struct tvec_root { + struct hlist_head vec[256]; +}; + +struct tvec_base { + spinlock_t lock; + struct timer_list *running_timer; + long unsigned int timer_jiffies; + long unsigned int next_timer; + long unsigned int active_timers; + long unsigned int all_timers; + int cpu; + bool migration_enabled; + bool nohz_active; + struct tvec_root tv1; + struct tvec tv2; + struct tvec tv3; + struct tvec tv4; + struct tvec tv5; + long: 64; +}; + +struct uart_8250_em485 { + struct timer_list start_tx_timer; + struct timer_list stop_tx_timer; + struct timer_list *active_timer; +}; + +struct uart_8250_ops { + int (*setup_irq)(struct uart_8250_port *); + void (*release_irq)(struct uart_8250_port *); +}; + +struct uart_8250_port { + struct uart_port port; + struct timer_list timer; + struct list_head list; + short unsigned int capabilities; + short unsigned int bugs; + bool fifo_bug; + unsigned int tx_loadsz; + unsigned char acr; + unsigned char fcr; + unsigned char ier; + unsigned char lcr; + unsigned char mcr; + unsigned char mcr_mask; + unsigned char mcr_force; + unsigned char cur_iotype; + unsigned int rpm_tx_active; + unsigned char canary; + unsigned char probe; + unsigned char lsr_saved_flags; + unsigned char msr_saved_flags; + struct uart_8250_dma *dma; + const struct uart_8250_ops *ops; + int (*dl_read)(struct uart_8250_port *); + void (*dl_write)(struct uart_8250_port *, int); + struct uart_8250_em485 *em485; +}; + +struct uart_driver { + struct module___2 *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 (*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 *, 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); +}; + +struct uart_state { + struct tty_port port; + enum uart_pm_state pm_state; + struct circ_buf xmit; + atomic_t refcount; + wait_queue_head_t remove_wait; + struct uart_port *uart_port; +}; + +struct ubuf_info { + void (*callback)(struct ubuf_info *, bool); + void *ctx; + long unsigned int desc; +}; + +struct ucode_cpu_info { + struct cpu_signature cpu_sig; + int valid; + void *mc; +}; + +struct ucode_patch { + struct list_head plist; + void *data; + u32 patch_id; + u16 equiv_cpu; +}; + +struct ucred { + __u32 pid; + __u32 uid; + __u32 gid; +}; + +struct udp_hslot { + struct hlist_head head; + int count; + spinlock_t lock; +}; + +struct udp_iter_state { + struct seq_net_private p; + sa_family_t family; + int bucket; + struct udp_table *udp_table; +}; + +struct udp_mib { + long unsigned int mibs[9]; +}; + +struct udp_seq_afinfo { + char *name; + sa_family_t family; + struct udp_table *udp_table; + const struct file_operations___2 *seq_fops; + struct seq_operations seq_ops; +}; + +struct udp_skb_cb { + union { + struct inet_skb_parm h4; + } header; + __u16 cscov; + __u8 partial_cov; +}; + +struct udp_sock { + struct inet_sock inet; + int pending; + unsigned int corkflag; + __u8 encap_type; + unsigned char no_check6_tx: 1; + unsigned char no_check6_rx: 1; + __u16 len; + __u16 pcslen; + __u16 pcrlen; + __u8 pcflag; + __u8 unused[3]; + int (*encap_rcv)(struct sock *, struct sk_buff *); + void (*encap_destroy)(struct sock *); + struct sk_buff ** (*gro_receive)(struct sock *, struct sk_buff **, struct sk_buff *); + int (*gro_complete)(struct sock *, struct sk_buff *, int); +}; + +struct udp_table { + struct udp_hslot *hash; + struct udp_hslot *hash2; + unsigned int mask; + unsigned int log; +}; + +struct uevent_sock { + struct list_head list; + struct sock *sk; +}; + +struct uid_gid_extent { + u32 first; + u32 lower_first; + u32 count; +}; + +struct uid_gid_map { + u32 nr_extents; + struct uid_gid_extent extent[5]; +}; + +struct uncached_list { + spinlock_t lock; + struct list_head head; +}; + +struct uncore_event_desc { + struct kobj_attribute attr; + const char *config; +}; + +struct uni_pagedir { + u16 **uni_pgdir[32]; + long unsigned int refcount; + long unsigned int sum; + unsigned char *inverse_translations[4]; + u16 *inverse_trans_unicode; +}; + +struct unipair; + +struct unimapdesc { + short unsigned int entry_ct; + struct unipair *entries; +}; + +struct unimapinit { + short unsigned int advised_hashsize; + short unsigned int advised_hashstep; + short unsigned int advised_hashlevel; +}; + +struct unipair { + short unsigned int unicode; + short unsigned int fontpos; +}; + +struct unity_map_entry { + struct list_head list; + u16 devid_start; + u16 devid_end; + u64 address_start; + u64 address_end; + int prot; +}; + +struct unix_address { + atomic_t refcnt; + int len; + unsigned int hash; + struct sockaddr_un name[0]; +}; + +struct unix_skb_parms { + struct pid___2 *pid; + kuid_t uid; + kgid_t gid; + struct scm_fp_list *fp; + u32 consumed; +}; + +struct unix_sock { + struct sock sk; + struct unix_address *addr; + struct path path; + struct mutex readlock; + struct sock *peer; + struct list_head link; + atomic_long_t inflight; + spinlock_t lock; + unsigned char recursion_level; + long unsigned int gc_flags; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + struct socket_wq peer_wq; + wait_queue_t peer_wake; + long: 64; + long: 64; + long: 64; +}; + +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___2 *pipe; + size_t size; + int flags; + unsigned int splice_flags; +}; + +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 usb_ctrlrequest { + __u8 bRequestType; + __u8 bRequest; + __le16 wValue; + __le16 wIndex; + __le16 wLength; +}; + +struct usb_debug_descriptor { + __u8 bLength; + __u8 bDescriptorType; + __u8 bDebugInEndpoint; + __u8 bDebugOutEndpoint; +}; + +struct used_address { + struct __kernel_sockaddr_storage name; + unsigned int name_len; + long: 0; +}; + +struct user_regs_struct { + long unsigned int r15; + long unsigned int r14; + long unsigned int r13; + long unsigned int r12; + long unsigned int bp; + long unsigned int bx; + long unsigned int r11; + long unsigned int r10; + long unsigned int r9; + long unsigned int r8; + long unsigned int ax; + long unsigned int cx; + long unsigned int dx; + long unsigned int si; + long unsigned int di; + long unsigned int orig_ax; + long unsigned int ip; + long unsigned int cs; + long unsigned int flags; + long unsigned int sp; + long unsigned int ss; + long unsigned int fs_base; + long unsigned int gs_base; + long unsigned int ds; + long unsigned int es; + long unsigned int fs; + long unsigned int gs; +}; + +struct user_i387_struct { + short unsigned int cwd; + short unsigned int swd; + short unsigned int twd; + short unsigned int fop; + __u64 rip; + __u64 rdp; + __u32 mxcsr; + __u32 mxcsr_mask; + __u32 st_space[32]; + __u32 xmm_space[64]; + __u32 padding[24]; +}; + +struct user { + struct user_regs_struct regs; + int u_fpvalid; + int pad0; + struct user_i387_struct i387; + long unsigned int u_tsize; + long unsigned int u_dsize; + long unsigned int u_ssize; + long unsigned int start_code; + long unsigned int start_stack; + long int signal; + int reserved; + int pad1; + long unsigned int u_ar0; + struct user_i387_struct *u_fpstate; + long unsigned int magic; + char u_comm[32]; + long unsigned int u_debugreg[8]; + long unsigned int error_code; + long unsigned int fault_address; +}; + +struct user_arg_ptr { + bool is_compat; + union { + const char * const *native; + const compat_uptr_t *compat; + } ptr; +}; + +struct user_desc { + unsigned int entry_number; + unsigned int base_addr; + unsigned int limit; + unsigned int seg_32bit: 1; + unsigned int contents: 2; + unsigned int read_exec_only: 1; + unsigned int limit_in_pages: 1; + unsigned int seg_not_present: 1; + unsigned int useable: 1; + unsigned int lm: 1; +}; + +struct user_element { + struct snd_ctl_elem_info info; + struct snd_card *card; + char *elem_data; + long unsigned int elem_data_size; + void *tlv_data; + long unsigned int tlv_data_size; + void *priv_data; +}; + +struct user_i387_ia32_struct { + u32 cwd; + u32 swd; + u32 twd; + u32 fip; + u32 fcs; + u32 foo; + u32 fos; + u32 st_space[20]; +}; + +struct user_key_payload { + struct callback_head rcu; + short unsigned int datalen; + char data[0]; +}; + +struct user_namespace { + struct uid_gid_map uid_map; + struct uid_gid_map gid_map; + struct uid_gid_map projid_map; + atomic_t count; + struct user_namespace *parent; + int level; + kuid_t owner; + kgid_t group; + struct ns_common ns; + long unsigned int flags; +}; + +struct user_regset; + +typedef int user_regset_get_fn(struct task_struct *, const struct user_regset *, unsigned int, unsigned int, void *, void *); + +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_get_fn *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 user_struct { + atomic_t __count; + atomic_t processes; + atomic_t sigpending; + atomic_t inotify_watches; + atomic_t inotify_devs; + atomic_long_t epoll_watches; + long unsigned int mq_bytes; + long unsigned int locked_shm; + long unsigned int unix_inflight; + atomic_long_t pipe_bufs; + struct key *uid_keyring; + struct key *session_keyring; + struct hlist_node uidhash_node; + kuid_t uid; + atomic_long_t locked_vm; +}; + +struct user_struct___2 { + atomic_t __count; + atomic_t processes; + atomic_t sigpending; + atomic_t inotify_watches; + atomic_t inotify_devs; + atomic_long_t epoll_watches; + long unsigned int mq_bytes; + long unsigned int locked_shm; + long unsigned int unix_inflight; + atomic_long_t pipe_bufs; + struct key___2 *uid_keyring; + struct key___2 *session_keyring; + struct hlist_node uidhash_node; + kuid_t uid; + atomic_long_t locked_vm; +}; + +struct userstack_entry { + struct trace_entry ent; + unsigned int tgid; + long unsigned int caller[8]; +}; + +struct ustat { + __kernel_daddr_t f_tfree; + __kernel_ino_t f_tinode; + char f_fname[6]; + char f_fpack[6]; +}; + +struct utf8_table { + int cmask; + int cval; + int shift; + long int lmask; + long int lval; +}; + +struct utimbuf { + __kernel_time_t actime; + __kernel_time_t modtime; +}; + +struct uts_namespace { + struct kref kref; + struct new_utsname name; + struct user_namespace *user_ns; + struct ns_common ns; +}; + +union uu { + short unsigned int us; + unsigned char b[2]; +}; + +struct uuidcmp { + const char *uuid; + int len; +}; + +struct v2_disk_dqheader { + __le32 dqh_magic; + __le32 dqh_version; +}; + +struct v2_disk_dqinfo { + __le32 dqi_bgrace; + __le32 dqi_igrace; + __le32 dqi_flags; + __le32 dqi_blocks; + __le32 dqi_free_blk; + __le32 dqi_free_entry; +}; + +struct v2r0_disk_dqblk { + __le32 dqb_id; + __le32 dqb_ihardlimit; + __le32 dqb_isoftlimit; + __le32 dqb_curinodes; + __le32 dqb_bhardlimit; + __le32 dqb_bsoftlimit; + __le64 dqb_curspace; + __le64 dqb_btime; + __le64 dqb_itime; +}; + +struct v2r1_disk_dqblk { + __le32 dqb_id; + __le32 dqb_pad; + __le64 dqb_ihardlimit; + __le64 dqb_isoftlimit; + __le64 dqb_curinodes; + __le64 dqb_bhardlimit; + __le64 dqb_bsoftlimit; + __le64 dqb_curspace; + __le64 dqb_btime; + __le64 dqb_itime; +}; + +struct v9fs_inode { + struct p9_qid qid; + unsigned int cache_validity; + struct p9_fid *writeback_fid; + struct mutex___2 v_mutex; + struct inode___2 vfs_inode; +}; + +struct v9fs_session_info { + unsigned char flags; + unsigned char nodev; + short unsigned int debug; + unsigned int afid; + unsigned int cache; + char *uname; + char *aname; + unsigned int maxdata; + kuid_t dfltuid; + kgid_t dfltgid; + kuid_t uid; + struct p9_client *clnt; + struct list_head slist; + struct backing_dev_info bdi; + struct rw_semaphore rename_sem; +}; + +struct va_alignment { + int flags; + long unsigned int mask; + long unsigned int bits; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; +}; + +struct va_format { + const char *fmt; + va_list *va; +}; + +struct value_name_pair { + int value; + const char *name; +}; + +struct var_mtrr_range_state { + long unsigned int base_pfn; + long unsigned int size_pfn; + mtrr_type type; +}; + +struct variable_validate { + efi_guid_t vendor; + char *name; + bool (*validate)(efi_char16_t *, int, u8 *, long unsigned int); +}; + +struct vbt_header { + u8 signature[20]; + u16 version; + u16 header_size; + u16 vbt_size; + u8 vbt_checksum; + u8 reserved0; + u32 bdb_offset; + u32 aim_offset[4]; +}; + +struct vbt_panel { + struct drm_panel panel; + struct intel_dsi *intel_dsi; +}; + +struct vc { + struct vc_data *d; + struct work_struct SAK_work; +}; + +struct vt_mode { + char mode; + char waitv; + short int relsig; + short int acqsig; + short int frsig; +}; + +struct vc_data { + struct tty_port port; + short unsigned int vc_num; + unsigned int vc_cols; + unsigned int vc_rows; + unsigned int vc_size_row; + unsigned int vc_scan_lines; + 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_color; + unsigned char vc_s_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; + unsigned int vc_x; + unsigned int vc_y; + unsigned int vc_saved_x; + unsigned int vc_saved_y; + 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___2 *vt_pid; + int vt_newvt; + wait_queue_head_t paste_wait; + unsigned int vc_charset: 1; + unsigned int vc_s_charset: 1; + 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_deccolm: 1; + unsigned int vc_intensity: 2; + unsigned int vc_italic: 1; + unsigned int vc_underline: 1; + unsigned int vc_blink: 1; + unsigned int vc_reverse: 1; + unsigned int vc_s_intensity: 2; + unsigned int vc_s_italic: 1; + unsigned int vc_s_underline: 1; + unsigned int vc_s_blink: 1; + unsigned int vc_s_reverse: 1; + unsigned int vc_ques: 1; + 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; + unsigned int vc_tab_stop[8]; + unsigned char vc_palette[48]; + short unsigned int *vc_translate; + unsigned char vc_G0_charset; + unsigned char vc_G1_charset; + unsigned char vc_saved_G0; + unsigned char vc_saved_G1; + unsigned int vc_resize_user; + 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_pagedir *vc_uni_pagedir; + struct uni_pagedir **vc_uni_pagedir_loc; + bool vc_panic_force_write; +}; + +struct vcpu_data { + u64 pi_desc_addr; + u32 vector; +}; + +struct vcpu_svm { + struct kvm_vcpu vcpu; + struct vmcb *vmcb; + long unsigned int vmcb_pa; + struct svm_cpu_data *svm_data; + uint64_t asid_generation; + uint64_t sysenter_esp; + uint64_t sysenter_eip; + uint64_t tsc_aux; + u64 next_rip; + u64 host_user_msrs[10]; + struct { + u16 fs; + u16 gs; + u16 ldt; + u64 gs_base; + } host; + u32 *msrpm; + ulong nmi_iret_rip; + struct nested_state nested; + bool nmi_singlestep; + unsigned int int3_injected; + long unsigned int int3_rip; + u32 apf_reason; + bool nrips_enabled: 1; + u32 ldr_reg; + struct page___2 *avic_backing_page; + u64 *avic_physical_id_cache; + bool avic_is_running; +}; + +struct vcpu_vmx { + struct kvm_vcpu vcpu; + long unsigned int host_rsp; + u8 fail; + bool nmi_known_unmasked; + u32 exit_intr_info; + u32 idt_vectoring_info; + ulong rflags; + struct shared_msr_entry *guest_msrs; + int nmsrs; + int save_nmsrs; + long unsigned int host_idt_base; + u64 msr_host_kernel_gs_base; + u64 msr_guest_kernel_gs_base; + u32 vm_entry_controls_shadow; + u32 vm_exit_controls_shadow; + struct loaded_vmcs vmcs01; + struct loaded_vmcs *loaded_vmcs; + bool __launched; + struct msr_autoload msr_autoload; + struct { + int loaded; + u16 fs_sel; + u16 gs_sel; + u16 ldt_sel; + u16 ds_sel; + u16 es_sel; + int gs_ldt_reload_needed; + int fs_reload_needed; + u64 msr_host_bndcfgs; + long unsigned int vmcs_host_cr4; + } host_state; + struct { + int vm86_active; + ulong save_rflags; + struct kvm_segment segs[8]; + } rmode; + struct { + u32 bitmask; + struct kvm_save_segment seg[8]; + } segment_cache; + int vpid; + bool emulation_required; + int soft_vnmi_blocked; + ktime_t entry_time; + s64 vnmi_blocked_time; + u32 exit_reason; + long: 64; + struct pi_desc pi_desc; + struct nested_vmx nested; + int ple_window; + bool ple_window_dirty; + struct page___2 *pml_pg; + u64 current_tsc_ratio; + bool guest_pkru_valid; + u32 guest_pkru; + u32 host_pkru; + long: 64; + long: 64; + long: 64; +}; + +struct vcs_poll_data { + struct notifier_block notifier; + unsigned int cons_num; + bool seen_last_update; + wait_queue_head_t waitq; + struct fasync_struct *fasync; +}; + +struct vdso_image { + void *data; + long unsigned int size; + long unsigned int alt; + long unsigned int alt_len; + long int sym_vvar_start; + long int sym_vvar_page; + long int sym_hpet_page; + long int sym_pvclock_page; + long int sym_VDSO32_NOTE_MASK; + long int sym___kernel_sigreturn; + long int sym___kernel_rt_sigreturn; + long int sym___kernel_vsyscall; + long int sym_int80_landing_pad; +}; + +struct verifier_state { + struct reg_state regs[11]; + u8 stack_slot_type[512]; + struct reg_state spilled_regs[64]; +}; + +struct verifier_stack_elem; + +struct verifier_state_list; + +struct verifier_env { + struct bpf_prog *prog; + struct verifier_stack_elem *head; + int stack_size; + struct verifier_state cur_state; + struct verifier_state_list **explored_states; + struct bpf_map *used_maps[64]; + u32 used_map_cnt; + bool allow_ptr_leaks; +}; + +struct verifier_stack_elem { + struct verifier_state st; + int insn_idx; + int prev_insn_idx; + struct verifier_stack_elem *next; +}; + +struct verifier_state_list { + struct verifier_state state; + struct verifier_state_list *next; +}; + +struct vers_iter { + size_t param_size; + struct dm_target_versions *vers; + struct dm_target_versions *old_vers; + char *end; + uint32_t flags; +}; + +struct vesafb_par { + u32 pseudo_palette[256]; + int wc_cookie; +}; + +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 vga_arb_user_card { + struct pci_dev *pdev; + unsigned int mem_cnt; + unsigned int io_cnt; +}; + +struct vga_arb_private { + struct list_head list; + struct pci_dev *target; + struct vga_arb_user_card cards[16]; + spinlock_t lock; +}; + +struct vga_device { + struct list_head list; + struct pci_dev *pdev; + unsigned int decodes; + unsigned int owns; + unsigned int locks; + unsigned int io_lock_cnt; + unsigned int mem_lock_cnt; + unsigned int io_norm_cnt; + unsigned int mem_norm_cnt; + bool bridge_has_one_vga; + void *cookie; + void (*irq_set_state)(void *, bool); + unsigned int (*set_vga_decode)(void *, bool); +}; + +struct vga_switcheroo_client_ops { + void (*set_gpu_state)(struct pci_dev *, enum vga_switcheroo_state); + void (*reprobe)(struct pci_dev *); + bool (*can_switch)(struct pci_dev *); +}; + +struct vgastate { + void *vgabase; + long unsigned int membase; + __u32 memsize; + __u32 flags; + __u32 depth; + __u32 num_attr; + __u32 num_crtc; + __u32 num_gfx; + __u32 num_seq; + void *vidstate; +}; + +struct vgt_if { + uint64_t magic; + uint16_t version_major; + uint16_t version_minor; + uint32_t vgt_id; + uint32_t rsv1[12]; + struct { + struct { + uint32_t base; + uint32_t size; + } mappable_gmadr; + struct { + uint32_t base; + uint32_t size; + } nonmappable_gmadr; + uint32_t fence_num; + uint32_t rsv2[3]; + } avail_rs; + uint32_t rsv3[488]; + uint32_t rsv4; + uint32_t display_ready; + uint32_t rsv5[4]; + uint32_t g2v_notify; + uint32_t rsv6[7]; + struct { + uint32_t lo; + uint32_t hi; + } pdp[4]; + uint32_t execlist_context_descriptor_lo; + uint32_t execlist_context_descriptor_hi; + uint32_t rsv7[488]; +}; + +struct video_event { + __s32 type; + __kernel_time_t timestamp; + union { + video_size_t size; + unsigned int frame_rate; + unsigned char vsync_field; + } u; +}; + +struct video_levels { + int blank; + int black; + int burst; +}; + +struct video_spu_palette { + int length; + __u8 *palette; +}; + +struct video_still_picture { + char *iFrame; + __s32 size; +}; + +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_9p_config { + __u16 tag_len; + __u8 tag[0]; +}; + +struct virtio_balloon_stat { + __virtio16 tag; + __virtio64 val; +} __attribute__((packed)); + +struct virtio_balloon { + struct virtio_device *vdev; + struct virtqueue *inflate_vq; + struct virtqueue *deflate_vq; + struct virtqueue *stats_vq; + struct work_struct update_balloon_stats_work; + struct work_struct update_balloon_size_work; + spinlock_t stop_update_lock; + bool stop_update; + wait_queue_head_t acked; + unsigned int num_pages; + struct balloon_dev_info vb_dev_info; + struct mutex___2 balloon_lock; + unsigned int num_pfns; + __virtio32 pfns[256]; + struct virtio_balloon_stat stats[7]; + struct notifier_block nb; +}; + +struct virtio_balloon_config { + __u32 num_pages; + __u32 actual; +}; + +struct virtio_chan { + bool inuse; + spinlock_t lock; + struct p9_client *client; + struct virtio_device *vdev; + struct virtqueue *vq; + int ring_bufs_avail; + wait_queue_head_t *vc_wq; + long unsigned int p9_max_pages; + struct scatterlist sg[128]; + int tag_len; + char *tag; + struct list_head chan_list; +}; + +typedef void vq_callback_t(struct virtqueue *); + +struct virtio_config_ops { + void (*get)(struct virtio_device *, unsigned int, void *, unsigned int); + void (*set)(struct virtio_device *, unsigned int, const void *, unsigned int); + u32 (*generation)(struct virtio_device *); + u8 (*get_status)(struct virtio_device *); + void (*set_status)(struct virtio_device *, u8); + void (*reset)(struct virtio_device *); + int (*find_vqs)(struct virtio_device *, unsigned int, struct virtqueue **, vq_callback_t **, const char * const *); + void (*del_vqs)(struct virtio_device *); + u64 (*get_features)(struct virtio_device *); + int (*finalize_features)(struct virtio_device *); + const char * (*bus_name)(struct virtio_device *); + int (*set_vq_affinity)(struct virtqueue *, int); +}; + +struct virtio_console_control { + __virtio32 id; + __virtio16 event; + __virtio16 value; +}; + +struct virtio_device_id { + __u32 device; + __u32 vendor; +}; + +struct vringh_config_ops; + +struct virtio_device { + int index; + bool failed; + bool config_enabled; + bool config_change_pending; + spinlock_t config_lock; + struct device___2 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_driver { + struct device_driver___2 driver; + const struct virtio_device_id *id_table; + const unsigned int *feature_table; + unsigned int feature_table_size; + const unsigned int *feature_table_legacy; + unsigned int feature_table_size_legacy; + int (*probe)(struct virtio_device *); + void (*scan)(struct virtio_device *); + void (*remove)(struct virtio_device *); + void (*config_changed)(struct virtio_device *); + int (*freeze)(struct virtio_device *); + int (*restore)(struct virtio_device *); +}; + +struct virtio_gpu_box { + __le32 x; + __le32 y; + __le32 z; + __le32 w; + __le32 h; + __le32 d; +}; + +struct virtio_gpu_ctrl_hdr { + __le32 type; + __le32 flags; + __le64 fence_id; + __le32 ctx_id; + __le32 padding; +}; + +struct virtio_gpu_cmd_submit { + struct virtio_gpu_ctrl_hdr hdr; + __le32 size; + __le32 padding; +}; + +struct virtio_gpu_config { + __u32 events_read; + __u32 events_clear; + __u32 num_scanouts; + __u32 num_capsets; +}; + +struct virtio_gpu_ctx_create { + struct virtio_gpu_ctrl_hdr hdr; + __le32 nlen; + __le32 padding; + char debug_name[64]; +}; + +struct virtio_gpu_ctx_destroy { + struct virtio_gpu_ctrl_hdr hdr; +}; + +struct virtio_gpu_ctx_resource { + struct virtio_gpu_ctrl_hdr hdr; + __le32 resource_id; + __le32 padding; +}; + +struct virtio_gpu_cursor_pos { + __le32 scanout_id; + __le32 x; + __le32 y; + __le32 padding; +}; + +struct virtio_gpu_mman { + struct ttm_bo_global_ref bo_global_ref; + struct drm_global_reference mem_global_ref; + bool mem_global_referenced; + struct ttm_bo_device bdev; +}; + +struct virtio_gpu_rect { + __le32 x; + __le32 y; + __le32 width; + __le32 height; +}; + +struct virtio_gpu_display_one { + struct virtio_gpu_rect r; + __le32 enabled; + __le32 flags; +}; + +struct virtio_gpu_update_cursor { + struct virtio_gpu_ctrl_hdr hdr; + struct virtio_gpu_cursor_pos pos; + __le32 resource_id; + __le32 hot_x; + __le32 hot_y; + __le32 padding; +}; + +struct virtio_gpu_output { + int index; + struct drm_crtc crtc; + struct drm_connector conn; + struct drm_encoder enc; + struct virtio_gpu_display_one info; + struct virtio_gpu_update_cursor cursor; + int cur_x; + int cur_y; +}; + +struct virtio_gpu_queue { + struct virtqueue *vq; + spinlock_t qlock; + wait_queue_head_t ack_queue; + struct work_struct dequeue_work; +}; + +struct virtio_gpu_fence_driver { + atomic64_t last_seq; + uint64_t sync_seq; + struct list_head fences; + spinlock_t lock; +}; + +struct virtio_gpu_fbdev; + +struct virtio_gpu_drv_capset; + +struct virtio_gpu_device { + struct device *dev; + struct drm_device *ddev; + struct virtio_device *vdev; + struct virtio_gpu_mman mman; + struct virtio_gpu_fbdev *vgfbdev; + struct virtio_gpu_output outputs[16]; + uint32_t num_scanouts; + struct virtio_gpu_queue ctrlq; + struct virtio_gpu_queue cursorq; + struct list_head free_vbufs; + spinlock_t free_vbufs_lock; + void *vbufs; + bool vqs_ready; + struct idr resource_idr; + spinlock_t resource_idr_lock; + wait_queue_head_t resp_wq; + spinlock_t display_info_lock; + bool display_info_pending; + struct virtio_gpu_fence_driver fence_drv; + struct idr ctx_id_idr; + spinlock_t ctx_id_idr_lock; + bool has_virgl_3d; + struct work_struct config_changed_work; + struct virtio_gpu_drv_capset *capsets; + uint32_t num_capsets; + struct list_head cap_cache; +}; + +struct virtio_gpu_drv_cap_cache { + struct list_head head; + void *caps_cache; + uint32_t id; + uint32_t version; + uint32_t size; + atomic_t is_valid; +}; + +struct virtio_gpu_drv_capset { + uint32_t id; + uint32_t max_version; + uint32_t max_size; +}; + +struct virtio_gpu_framebuffer { + struct drm_framebuffer base; + struct drm_gem_object *obj; + int x1; + int y1; + int x2; + int y2; + spinlock_t dirty_lock; + uint32_t hw_res_handle; +}; + +struct virtio_gpu_fbdev { + struct drm_fb_helper helper; + struct virtio_gpu_framebuffer vgfb; + struct virtio_gpu_device *vgdev; + struct delayed_work work; +}; + +struct virtio_gpu_fence { + struct fence f; + struct virtio_gpu_fence_driver *drv; + struct list_head node; + uint64_t seq; +}; + +struct virtio_gpu_fpriv { + uint32_t ctx_id; +}; + +struct virtio_gpu_get_capset { + struct virtio_gpu_ctrl_hdr hdr; + __le32 capset_id; + __le32 capset_version; +}; + +struct virtio_gpu_get_capset_info { + struct virtio_gpu_ctrl_hdr hdr; + __le32 capset_index; + __le32 padding; +}; + +struct virtio_gpu_mem_entry { + __le64 addr; + __le32 length; + __le32 padding; +}; + +struct virtio_gpu_object { + struct drm_gem_object gem_base; + uint32_t hw_res_handle; + struct sg_table *pages; + void *vmap; + bool dumb; + struct ttm_place placement_code; + struct ttm_placement placement; + struct ttm_buffer_object tbo; + struct ttm_bo_kmap_obj kmap; +}; + +struct virtio_gpu_resource_attach_backing { + struct virtio_gpu_ctrl_hdr hdr; + __le32 resource_id; + __le32 nr_entries; +}; + +struct virtio_gpu_resource_create_2d { + struct virtio_gpu_ctrl_hdr hdr; + __le32 resource_id; + __le32 format; + __le32 width; + __le32 height; +}; + +struct virtio_gpu_resource_create_3d { + struct virtio_gpu_ctrl_hdr hdr; + __le32 resource_id; + __le32 target; + __le32 format; + __le32 bind; + __le32 width; + __le32 height; + __le32 depth; + __le32 array_size; + __le32 last_level; + __le32 nr_samples; + __le32 flags; + __le32 padding; +}; + +struct virtio_gpu_resource_detach_backing { + struct virtio_gpu_ctrl_hdr hdr; + __le32 resource_id; + __le32 padding; +}; + +struct virtio_gpu_resource_flush { + struct virtio_gpu_ctrl_hdr hdr; + struct virtio_gpu_rect r; + __le32 resource_id; + __le32 padding; +}; + +struct virtio_gpu_resource_unref { + struct virtio_gpu_ctrl_hdr hdr; + __le32 resource_id; + __le32 padding; +}; + +struct virtio_gpu_resp_capset { + struct virtio_gpu_ctrl_hdr hdr; + __u8 capset_data[0]; +}; + +struct virtio_gpu_resp_capset_info { + struct virtio_gpu_ctrl_hdr hdr; + __le32 capset_id; + __le32 capset_max_version; + __le32 capset_max_size; + __le32 padding; +}; + +struct virtio_gpu_resp_display_info { + struct virtio_gpu_ctrl_hdr hdr; + struct virtio_gpu_display_one pmodes[16]; +}; + +struct virtio_gpu_set_scanout { + struct virtio_gpu_ctrl_hdr hdr; + struct virtio_gpu_rect r; + __le32 scanout_id; + __le32 resource_id; +}; + +struct virtio_gpu_transfer_host_3d { + struct virtio_gpu_ctrl_hdr hdr; + struct virtio_gpu_box box; + __le64 offset; + __le32 resource_id; + __le32 level; + __le32 stride; + __le32 layer_stride; +}; + +struct virtio_gpu_transfer_to_host_2d { + struct virtio_gpu_ctrl_hdr hdr; + struct virtio_gpu_rect r; + __le64 offset; + __le32 resource_id; + __le32 padding; +}; + +struct virtio_gpu_ttm_tt { + struct ttm_dma_tt ttm; + struct virtio_gpu_device *vgdev; + u64 offset; +}; + +struct virtio_gpu_vbuffer; + +typedef void (*virtio_gpu_resp_cb)(struct virtio_gpu_device *, struct virtio_gpu_vbuffer *); + +struct virtio_gpu_vbuffer { + char *buf; + int size; + void *data_buf; + uint32_t data_size; + char *resp_buf; + int resp_size; + virtio_gpu_resp_cb resp_cb; + struct list_head list; +}; + +struct virtio_mmio_device { + struct virtio_device vdev; + struct platform_device *pdev; + void *base; + long unsigned int version; + spinlock_t lock; + struct list_head virtqueues; +}; + +struct virtio_mmio_vq_info { + struct virtqueue *vq; + struct list_head node; +}; + +struct virtio_net_config { + __u8 mac[6]; + __u16 status; + __u16 max_virtqueue_pairs; +}; + +struct virtio_net_ctrl_hdr { + __u8 class; + __u8 cmd; +}; + +struct virtio_net_ctrl_mac { + __virtio32 entries; + __u8 macs[0]; +}; + +struct virtio_net_ctrl_mq { + __virtio16 virtqueue_pairs; +}; + +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 virtio_pci_common_cfg { + __le32 device_feature_select; + __le32 device_feature; + __le32 guest_feature_select; + __le32 guest_feature; + __le16 msix_config; + __le16 num_queues; + __u8 device_status; + __u8 config_generation; + __le16 queue_select; + __le16 queue_size; + __le16 queue_msix_vector; + __le16 queue_enable; + __le16 queue_notify_off; + __le32 queue_desc_lo; + __le32 queue_desc_hi; + __le32 queue_avail_lo; + __le32 queue_avail_hi; + __le32 queue_used_lo; + __le32 queue_used_hi; +}; + +struct virtio_pci_vq_info; + +struct virtio_pci_device { + struct virtio_device vdev; + struct pci_dev *pci_dev; + u8 *isr; + struct virtio_pci_common_cfg *common; + void *device; + void *notify_base; + size_t notify_len; + size_t device_len; + int notify_map_cap; + u32 notify_offset_multiplier; + int modern_bars; + void *ioaddr; + spinlock_t lock; + struct list_head virtqueues; + struct virtio_pci_vq_info **vqs; + int msix_enabled; + int intx_enabled; + struct msix_entry *msix_entries; + cpumask_var_t *msix_affinity_masks; + char (*msix_names)[256]; + unsigned int msix_vectors; + unsigned int msix_used_vectors; + bool per_vq_vectors; + struct virtqueue * (*setup_vq)(struct virtio_pci_device *, struct virtio_pci_vq_info *, unsigned int, void (*)(struct virtqueue *), const char *, u16); + void (*del_vq)(struct virtio_pci_vq_info *); + u16 (*config_vector)(struct virtio_pci_device *, u16); +}; + +struct virtio_pci_vq_info { + struct virtqueue *vq; + struct list_head node; + unsigned int msix_vector; +}; + +struct virtio_scsi_event { + __virtio32 event; + __u8 lun[8]; + __virtio32 reason; +}; + +struct virtio_scsi; + +struct virtio_scsi_event_node { + struct virtio_scsi *vscsi; + struct virtio_scsi_event event; + struct work_struct work; +}; + +struct virtio_scsi_vq { + spinlock_t vq_lock; + struct virtqueue *vq; +}; + +struct virtio_scsi { + struct virtio_device *vdev; + struct virtio_scsi_event_node event_list[8]; + u32 num_queues; + bool affinity_hint_set; + struct notifier_block nb; + bool stop_events; + struct virtio_scsi_vq ctrl_vq; + struct virtio_scsi_vq event_vq; + struct virtio_scsi_vq req_vqs[0]; +}; + +struct virtio_scsi_cmd_req { + __u8 lun[8]; + __virtio64 tag; + __u8 task_attr; + __u8 prio; + __u8 crn; + __u8 cdb[32]; +} __attribute__((packed)); + +struct virtio_scsi_cmd_req_pi { + __u8 lun[8]; + __virtio64 tag; + __u8 task_attr; + __u8 prio; + __u8 crn; + __virtio32 pi_bytesout; + __virtio32 pi_bytesin; + __u8 cdb[32]; +} __attribute__((packed)); + +struct virtio_scsi_ctrl_tmf_req { + __virtio32 type; + __virtio32 subtype; + __u8 lun[8]; + __virtio64 tag; +}; + +struct virtio_scsi_ctrl_an_req { + __virtio32 type; + __u8 lun[8]; + __virtio32 event_requested; +}; + +struct virtio_scsi_cmd_resp { + __virtio32 sense_len; + __virtio32 resid; + __virtio16 status_qualifier; + __u8 status; + __u8 response; + __u8 sense[96]; +}; + +struct virtio_scsi_ctrl_tmf_resp { + __u8 response; +}; + +struct virtio_scsi_ctrl_an_resp { + __virtio32 event_actual; + __u8 response; +} __attribute__((packed)); + +struct virtio_scsi_cmd { + struct scsi_cmnd *sc; + struct completion *comp; + union { + struct virtio_scsi_cmd_req cmd; + struct virtio_scsi_cmd_req_pi cmd_pi; + struct virtio_scsi_ctrl_tmf_req tmf; + struct virtio_scsi_ctrl_an_req an; + } req; + union { + struct virtio_scsi_cmd_resp cmd; + struct virtio_scsi_ctrl_tmf_resp tmf; + struct virtio_scsi_ctrl_an_resp an; + struct virtio_scsi_event evt; + } resp; + long: 64; +} __attribute__((packed)); + +struct virtio_scsi_config { + __u32 num_queues; + __u32 seg_max; + __u32 max_sectors; + __u32 cmd_per_lun; + __u32 event_info_size; + __u32 sense_size; + __u32 cdb_size; + __u16 max_channel; + __u16 max_target; + __u32 max_lun; +}; + +struct virtio_scsi_target_state { + seqcount_t tgt_seq; + atomic_t reqs; + struct virtio_scsi_vq *req_vq; +}; + +struct virtnet_stats; + +struct virtnet_info { + struct virtio_device *vdev; + struct virtqueue *cvq; + struct net_device *dev; + struct send_queue *sq; + struct receive_queue *rq; + unsigned int status; + u16 max_queue_pairs; + u16 curr_queue_pairs; + bool big_packets; + bool mergeable_rx_bufs; + bool has_cvq; + bool any_header_sg; + u8 hdr_len; + struct virtnet_stats *stats; + struct delayed_work refill; + struct work_struct config_work; + bool affinity_hint_set; + struct notifier_block nb; + struct virtio_net_ctrl_hdr ctrl_hdr; + virtio_net_ctrl_ack ctrl_status; + u8 ctrl_promisc; + u8 ctrl_allmulti; + u8 duplex; + u32 speed; +}; + +struct virtnet_stats { + struct u64_stats_sync tx_syncp; + struct u64_stats_sync rx_syncp; + u64 tx_bytes; + u64 tx_packets; + u64 rx_bytes; + u64 rx_packets; +}; + +struct virtqueue { + struct list_head list; + void (*callback)(struct virtqueue *); + const char *name; + struct virtio_device *vdev; + unsigned int index; + unsigned int num_free; + void *priv; +}; + +struct vlan_ethhdr { + unsigned char h_dest[6]; + unsigned char h_source[6]; + __be16 h_vlan_proto; + __be16 h_vlan_TCI; + __be16 h_vlan_encapsulated_proto; +}; + +struct vlan_hdr { + __be16 h_vlan_TCI; + __be16 h_vlan_encapsulated_proto; +}; + +struct vm_userfaultfd_ctx {}; + +struct vm_area_struct___2 { + long unsigned int vm_start; + long unsigned int vm_end; + struct vm_area_struct___2 *vm_next; + struct vm_area_struct___2 *vm_prev; + struct rb_node vm_rb; + long unsigned int rb_subtree_gap; + struct mm_struct *vm_mm; + pgprot_t vm_page_prot; + long unsigned int vm_flags; + 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___2 *vm_ops; + long unsigned int vm_pgoff; + struct file___2 *vm_file; + void *vm_private_data; + struct mempolicy *vm_policy; + struct vm_userfaultfd_ctx vm_userfaultfd_ctx; +}; + +struct vm_area_struct { + long unsigned int vm_start; + long unsigned int vm_end; + struct vm_area_struct *vm_next; + struct vm_area_struct *vm_prev; + struct rb_node vm_rb; + long unsigned int rb_subtree_gap; + struct mm_struct___2 *vm_mm; + pgprot_t vm_page_prot; + long unsigned int vm_flags; + 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 mempolicy *vm_policy; + struct vm_userfaultfd_ctx vm_userfaultfd_ctx; +}; + +struct vm_event_state { + long unsigned int event[67]; +}; + +struct vm_fault { + unsigned int flags; + gfp_t gfp_mask; + long unsigned int pgoff; + void *virtual_address; + struct page___2 *cow_page; + struct page___2 *page; + void *entry; + long unsigned int max_pgoff; + pte_t *pte; +}; + +struct vm_fault___2 { + unsigned int flags; + gfp_t gfp_mask; + long unsigned int pgoff; + void *virtual_address; + struct page *cow_page; + struct page *page; + void *entry; + long unsigned int max_pgoff; + pte_t *pte; +}; + +struct vm_operations_struct___2 { + void (*open)(struct vm_area_struct___2 *); + void (*close)(struct vm_area_struct___2 *); + int (*mremap)(struct vm_area_struct___2 *); + int (*fault)(struct vm_area_struct___2 *, struct vm_fault *); + int (*pmd_fault)(struct vm_area_struct___2 *, long unsigned int, pmd_t *, unsigned int); + void (*map_pages)(struct vm_area_struct___2 *, struct vm_fault *); + int (*page_mkwrite)(struct vm_area_struct___2 *, struct vm_fault *); + int (*pfn_mkwrite)(struct vm_area_struct___2 *, struct vm_fault *); + int (*access)(struct vm_area_struct___2 *, long unsigned int, void *, int, int); + const char * (*name)(struct vm_area_struct___2 *); + int (*set_policy)(struct vm_area_struct___2 *, struct mempolicy *); + struct mempolicy * (*get_policy)(struct vm_area_struct___2 *, long unsigned int); + struct page___2 * (*find_special_page)(struct vm_area_struct___2 *, long unsigned int); +}; + +struct vm_operations_struct { + void (*open)(struct vm_area_struct *); + void (*close)(struct vm_area_struct *); + int (*mremap)(struct vm_area_struct *); + int (*fault)(struct vm_area_struct *, struct vm_fault___2 *); + int (*pmd_fault)(struct vm_area_struct *, long unsigned int, pmd_t *, unsigned int); + void (*map_pages)(struct vm_area_struct *, struct vm_fault___2 *); + int (*page_mkwrite)(struct vm_area_struct *, struct vm_fault___2 *); + int (*pfn_mkwrite)(struct vm_area_struct *, struct vm_fault___2 *); + int (*access)(struct vm_area_struct *, long unsigned int, void *, int, int); + const char * (*name)(struct vm_area_struct *); + int (*set_policy)(struct vm_area_struct *, struct mempolicy *); + struct mempolicy * (*get_policy)(struct vm_area_struct *, long unsigned int); + struct page * (*find_special_page)(struct vm_area_struct *, long unsigned int); +}; + +struct vm_special_mapping { + const char *name; + struct page___2 **pages; + int (*fault)(const struct vm_special_mapping *, struct vm_area_struct___2 *, struct vm_fault *); +}; + +struct vm_struct { + struct vm_struct *next; + void *addr; + long unsigned int size; + long unsigned int flags; + struct page___2 **pages; + unsigned int nr_pages; + phys_addr_t phys_addr; + const void *caller; +}; + +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; +}; + +struct vmap_area { + long unsigned int va_start; + long unsigned int va_end; + long unsigned int flags; + struct rb_node rb_node; + struct list_head list; + struct llist_node purge_list; + struct vm_struct *vm; + struct callback_head callback_head; +}; + +struct vmap_block { + spinlock_t lock; + struct vmap_area *va; + long unsigned int free; + long unsigned int dirty; + long unsigned int dirty_min; + long unsigned int dirty_max; + struct list_head free_list; + struct callback_head callback_head; + struct list_head purge; +}; + +struct vmap_block_queue { + spinlock_t lock; + struct list_head free; +}; + +struct vmcb_control_area { + u32 intercept_cr; + u32 intercept_dr; + u32 intercept_exceptions; + u64 intercept; + u8 reserved_1[42]; + u16 pause_filter_count; + u64 iopm_base_pa; + u64 msrpm_base_pa; + u64 tsc_offset; + u32 asid; + u8 tlb_ctl; + u8 reserved_2[3]; + u32 int_ctl; + u32 int_vector; + u32 int_state; + u8 reserved_3[4]; + u32 exit_code; + u32 exit_code_hi; + u64 exit_info_1; + u64 exit_info_2; + u32 exit_int_info; + u32 exit_int_info_err; + u64 nested_ctl; + u64 avic_vapic_bar; + u8 reserved_4[8]; + u32 event_inj; + u32 event_inj_err; + u64 nested_cr3; + u64 lbr_ctl; + u32 clean; + u32 reserved_5; + u64 next_rip; + u8 insn_len; + u8 insn_bytes[15]; + u64 avic_backing_page; + u8 reserved_6[8]; + u64 avic_logical_id; + u64 avic_physical_id; + u8 reserved_7[768]; +} __attribute__((packed)); + +struct vmcb_seg { + u16 selector; + u16 attrib; + u32 limit; + u64 base; +}; + +struct vmcb_save_area { + struct vmcb_seg es; + struct vmcb_seg cs; + struct vmcb_seg ss; + struct vmcb_seg ds; + struct vmcb_seg fs; + struct vmcb_seg gs; + struct vmcb_seg gdtr; + struct vmcb_seg ldtr; + struct vmcb_seg idtr; + struct vmcb_seg tr; + u8 reserved_1[43]; + u8 cpl; + u8 reserved_2[4]; + u64 efer; + u8 reserved_3[112]; + u64 cr4; + u64 cr3; + u64 cr0; + u64 dr7; + u64 dr6; + u64 rflags; + u64 rip; + u8 reserved_4[88]; + u64 rsp; + u8 reserved_5[24]; + u64 rax; + u64 star; + u64 lstar; + u64 cstar; + u64 sfmask; + u64 kernel_gs_base; + u64 sysenter_cs; + u64 sysenter_esp; + u64 sysenter_eip; + u64 cr2; + u8 reserved_6[32]; + u64 g_pat; + u64 dbgctl; + u64 br_from; + u64 br_to; + u64 last_excp_from; + u64 last_excp_to; +}; + +struct vmcb { + struct vmcb_control_area control; + struct vmcb_save_area save; +}; + +struct vmcore { + struct list_head list; + long long unsigned int paddr; + long long unsigned int size; + loff_t offset; +}; + +struct vmcs { + u32 revision_id; + u32 abort; + char data[0]; +}; + +struct vmcs02_list { + struct list_head list; + gpa_t vmptr; + struct loaded_vmcs vmcs02; +}; + +struct vmcs12 { + u32 revision_id; + u32 abort; + u32 launch_state; + u32 padding[7]; + u64 io_bitmap_a; + u64 io_bitmap_b; + u64 msr_bitmap; + u64 vm_exit_msr_store_addr; + u64 vm_exit_msr_load_addr; + u64 vm_entry_msr_load_addr; + u64 tsc_offset; + u64 virtual_apic_page_addr; + u64 apic_access_addr; + u64 posted_intr_desc_addr; + u64 ept_pointer; + u64 eoi_exit_bitmap0; + u64 eoi_exit_bitmap1; + u64 eoi_exit_bitmap2; + u64 eoi_exit_bitmap3; + u64 xss_exit_bitmap; + u64 guest_physical_address; + u64 vmcs_link_pointer; + u64 guest_ia32_debugctl; + u64 guest_ia32_pat; + u64 guest_ia32_efer; + u64 guest_ia32_perf_global_ctrl; + u64 guest_pdptr0; + u64 guest_pdptr1; + u64 guest_pdptr2; + u64 guest_pdptr3; + u64 guest_bndcfgs; + u64 host_ia32_pat; + u64 host_ia32_efer; + u64 host_ia32_perf_global_ctrl; + u64 padding64[8]; + natural_width cr0_guest_host_mask; + natural_width cr4_guest_host_mask; + natural_width cr0_read_shadow; + natural_width cr4_read_shadow; + natural_width cr3_target_value0; + natural_width cr3_target_value1; + natural_width cr3_target_value2; + natural_width cr3_target_value3; + natural_width exit_qualification; + natural_width guest_linear_address; + natural_width guest_cr0; + natural_width guest_cr3; + natural_width guest_cr4; + natural_width guest_es_base; + natural_width guest_cs_base; + natural_width guest_ss_base; + natural_width guest_ds_base; + natural_width guest_fs_base; + natural_width guest_gs_base; + natural_width guest_ldtr_base; + natural_width guest_tr_base; + natural_width guest_gdtr_base; + natural_width guest_idtr_base; + natural_width guest_dr7; + natural_width guest_rsp; + natural_width guest_rip; + natural_width guest_rflags; + natural_width guest_pending_dbg_exceptions; + natural_width guest_sysenter_esp; + natural_width guest_sysenter_eip; + natural_width host_cr0; + natural_width host_cr3; + natural_width host_cr4; + natural_width host_fs_base; + natural_width host_gs_base; + natural_width host_tr_base; + natural_width host_gdtr_base; + natural_width host_idtr_base; + natural_width host_ia32_sysenter_esp; + natural_width host_ia32_sysenter_eip; + natural_width host_rsp; + natural_width host_rip; + natural_width paddingl[8]; + u32 pin_based_vm_exec_control; + u32 cpu_based_vm_exec_control; + u32 exception_bitmap; + u32 page_fault_error_code_mask; + u32 page_fault_error_code_match; + u32 cr3_target_count; + u32 vm_exit_controls; + u32 vm_exit_msr_store_count; + u32 vm_exit_msr_load_count; + u32 vm_entry_controls; + u32 vm_entry_msr_load_count; + u32 vm_entry_intr_info_field; + u32 vm_entry_exception_error_code; + u32 vm_entry_instruction_len; + u32 tpr_threshold; + u32 secondary_vm_exec_control; + u32 vm_instruction_error; + u32 vm_exit_reason; + u32 vm_exit_intr_info; + u32 vm_exit_intr_error_code; + u32 idt_vectoring_info_field; + u32 idt_vectoring_error_code; + u32 vm_exit_instruction_len; + u32 vmx_instruction_info; + u32 guest_es_limit; + u32 guest_cs_limit; + u32 guest_ss_limit; + u32 guest_ds_limit; + u32 guest_fs_limit; + u32 guest_gs_limit; + u32 guest_ldtr_limit; + u32 guest_tr_limit; + u32 guest_gdtr_limit; + u32 guest_idtr_limit; + u32 guest_es_ar_bytes; + u32 guest_cs_ar_bytes; + u32 guest_ss_ar_bytes; + u32 guest_ds_ar_bytes; + u32 guest_fs_ar_bytes; + u32 guest_gs_ar_bytes; + u32 guest_ldtr_ar_bytes; + u32 guest_tr_ar_bytes; + u32 guest_interruptibility_info; + u32 guest_activity_state; + u32 guest_sysenter_cs; + u32 host_ia32_sysenter_cs; + u32 vmx_preemption_timer_value; + u32 padding32[7]; + u16 virtual_processor_id; + u16 posted_intr_nv; + u16 guest_es_selector; + u16 guest_cs_selector; + u16 guest_ss_selector; + u16 guest_ds_selector; + u16 guest_fs_selector; + u16 guest_gs_selector; + u16 guest_ldtr_selector; + u16 guest_tr_selector; + u16 guest_intr_status; + u16 host_es_selector; + u16 host_cs_selector; + u16 host_ss_selector; + u16 host_ds_selector; + u16 host_fs_selector; + u16 host_gs_selector; + u16 host_tr_selector; +} __attribute__((packed)); + +struct vmcs_config { + int size; + int order; + u32 revision_id; + u32 pin_based_exec_ctrl; + u32 cpu_based_exec_ctrl; + u32 cpu_based_2nd_exec_ctrl; + u32 vmexit_ctrl; + u32 vmentry_ctrl; +}; + +struct vmem_altmap { + const long unsigned int base_pfn; + const long unsigned int reserve; + long unsigned int free; + long unsigned int align; + long unsigned int alloc; +}; + +struct vmx_capability { + u32 ept; + u32 vpid; +}; + +struct vring_desc; + +struct vring_avail; + +struct vring_used; + +struct vring { + unsigned int num; + struct vring_desc *desc; + struct vring_avail *avail; + struct vring_used *used; +}; + +struct vring_avail { + __virtio16 flags; + __virtio16 idx; + __virtio16 ring[0]; +}; + +struct vring_desc { + __virtio64 addr; + __virtio32 len; + __virtio16 flags; + __virtio16 next; +}; + +struct vring_desc_state { + void *data; + struct vring_desc *indir_desc; +}; + +struct vring_used_elem { + __virtio32 id; + __virtio32 len; +}; + +struct vring_used { + __virtio16 flags; + __virtio16 idx; + struct vring_used_elem ring[0]; +}; + +struct vring_virtqueue { + struct virtqueue vq; + struct vring vring; + bool weak_barriers; + bool broken; + bool indirect; + bool event; + unsigned int free_head; + unsigned int num_added; + u16 last_used_idx; + u16 avail_flags_shadow; + u16 avail_idx_shadow; + bool (*notify)(struct virtqueue *); + bool we_own_ring; + size_t queue_size_in_bytes; + dma_addr_t queue_dma_addr; + struct vring_desc_state desc_state[0]; +}; + +struct vringh { + bool little_endian; + bool event_indices; + bool weak_barriers; + u16 last_avail_idx; + u16 last_used_idx; + u32 completed; + struct vring vring; + void (*notify)(struct vringh *); +}; + +typedef void vrh_callback_t(struct virtio_device *, struct vringh *); + +struct vringh_config_ops { + int (*find_vrhs)(struct virtio_device *, unsigned int, struct vringh **, vrh_callback_t **); + void (*del_vrhs)(struct virtio_device *); +}; + +struct vsyscall_gtod_data { + unsigned int seq; + int vclock_mode; + cycle_t cycle_last; + cycle_t mask; + u32 mult; + u32 shift; + u64 wall_time_snsec; + gtod_long_t wall_time_sec; + gtod_long_t monotonic_time_sec; + u64 monotonic_time_snsec; + gtod_long_t wall_time_coarse_sec; + gtod_long_t wall_time_coarse_nsec; + gtod_long_t monotonic_time_coarse_sec; + gtod_long_t monotonic_time_coarse_nsec; + int tz_minuteswest; + int tz_dsttime; +}; + +struct vt1618_uaj_item { + short unsigned int mask; + short unsigned int shift; + const char * const items[4]; +}; + +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___2 *pid; + int sig; +}; + +struct vt_stat { + short unsigned int v_active; + short unsigned int v_signal; + short unsigned int v_state; +}; + +struct wait_bit_key { + void *flags; + int bit_nr; + long unsigned int timeout; +}; + +struct wait_bit_queue { + struct wait_bit_key key; + wait_queue_t wait; +}; + +struct wait_exceptional_entry_queue { + wait_queue_t wait; + struct exceptional_entry_key key; +}; + +struct wait_opts { + enum pid_type wo_type; + int wo_flags; + struct pid___2 *wo_pid; + struct siginfo *wo_info; + int *wo_stat; + struct rusage *wo_rusage; + wait_queue_t child_wait; + int notask_error; +}; + +struct wake_irq { + struct device *dev; + int irq; + bool dedicated_irq: 1; +}; + +struct wake_q_head { + struct wake_q_node *first; + struct wake_q_node **lastp; +}; + +struct wakeup_header { + u16 video_mode; + u32 pmode_entry; + u16 pmode_cs; + u32 pmode_cr0; + u32 pmode_cr3; + u32 pmode_cr4; + u32 pmode_efer_low; + u32 pmode_efer_high; + u64 pmode_gdt; + u32 pmode_misc_en_low; + u32 pmode_misc_en_high; + u32 pmode_behavior; + u32 realmode_flags; + u32 real_magic; + u32 signature; +} __attribute__((packed)); + +struct wakeup_source { + const char *name; + 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; + bool active: 1; + bool autosleep_enabled: 1; +}; + +struct warn_args { + const char *fmt; + va_list args; +}; + +struct watchdog_device; + +struct watchdog_core_data { + struct kref kref; + struct cdev cdev; + struct watchdog_device *wdd; + struct mutex lock; + long unsigned int last_keepalive; + long unsigned int last_hw_keepalive; + struct delayed_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; + unsigned int bootstatus; + unsigned int timeout; + 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; + void *driver_data; + struct watchdog_core_data *wd_data; + long unsigned int status; + struct list_head deferred; +}; + +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); + 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 wb_completion { + atomic_t cnt; +}; + +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_writeback_work { + long int nr_pages; + struct super_block___2 *sb; + long unsigned int *older_than_this; + 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 widget_attribute { + struct attribute attr; + ssize_t (*show)(struct hdac_device *, hda_nid_t, struct widget_attribute *, char *); + ssize_t (*store)(struct hdac_device *, hda_nid_t, struct widget_attribute *, const char *, size_t); +}; + +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_queue_wrapper { + struct work_struct work; + struct scsi_device *sdev; +}; + +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; + bool desc_valid; + 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[24]; + struct workqueue_struct *rescue_wq; +}; + +struct worker_pool { + spinlock_t lock; + int cpu; + int node; + int id; + unsigned int flags; + long unsigned int watchdog_ts; + struct list_head worklist; + int nr_workers; + int nr_idle; + struct list_head idle_list; + struct timer_list idle_timer; + struct timer_list mayday_timer; + struct hlist_head busy_hash[64]; + struct mutex manager_arb; + struct worker *manager; + struct mutex attach_mutex; + struct list_head workers; + struct completion *detach_completion; + struct ida worker_ida; + struct workqueue_attrs *attrs; + struct hlist_node hash_node; + int refcnt; + long: 64; + long: 64; + long: 64; + atomic_t nr_running; + struct callback_head rcu; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; +}; + +struct workqueue_attrs { + int nice; + cpumask_var_t cpumask; + bool no_numa; +}; + +struct wq_flusher; + +struct wq_device; + +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 saved_max_active; + struct workqueue_attrs *unbound_attrs; + struct pool_workqueue *dfl_pwq; + struct wq_device *wq_dev; + char name[24]; + struct callback_head rcu; + long: 64; + long: 64; + long: 64; + long: 64; + unsigned int flags; + struct pool_workqueue *cpu_pwqs; + struct pool_workqueue *numa_pwq_tbl[0]; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; + long: 64; +}; + +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_flusher { + struct list_head list; + int flush_color; + struct completion done; +}; + +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; +}; + +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; +}; + +struct x86_cpu { + struct cpu cpu; +}; + +struct x86_cpu_id { + __u16 vendor; + __u16 family; + __u16 model; + __u16 feature; + kernel_ulong_t driver_data; +}; + +struct x86_cpuinit_ops { + void (*setup_percpu_clockev)(void); + void (*early_percpu_clock_init)(void); + void (*fixup_cpu_id)(struct cpuinfo_x86 *, int); +}; + +struct x86_emulate_ops { + ulong (*read_gpr)(struct x86_emulate_ctxt *, unsigned int); + void (*write_gpr)(struct x86_emulate_ctxt *, unsigned int, ulong); + int (*read_std)(struct x86_emulate_ctxt *, long unsigned int, void *, unsigned int, struct x86_exception *); + int (*read_phys)(struct x86_emulate_ctxt *, long unsigned int, void *, unsigned int); + int (*write_std)(struct x86_emulate_ctxt *, long unsigned int, void *, unsigned int, struct x86_exception *); + int (*fetch)(struct x86_emulate_ctxt *, long unsigned int, void *, unsigned int, struct x86_exception *); + int (*read_emulated)(struct x86_emulate_ctxt *, long unsigned int, void *, unsigned int, struct x86_exception *); + int (*write_emulated)(struct x86_emulate_ctxt *, long unsigned int, const void *, unsigned int, struct x86_exception *); + int (*cmpxchg_emulated)(struct x86_emulate_ctxt *, long unsigned int, const void *, const void *, unsigned int, struct x86_exception *); + void (*invlpg)(struct x86_emulate_ctxt *, ulong); + int (*pio_in_emulated)(struct x86_emulate_ctxt *, int, short unsigned int, void *, unsigned int); + int (*pio_out_emulated)(struct x86_emulate_ctxt *, int, short unsigned int, const void *, unsigned int); + bool (*get_segment)(struct x86_emulate_ctxt *, u16 *, struct desc_struct *, u32 *, int); + void (*set_segment)(struct x86_emulate_ctxt *, u16, struct desc_struct *, u32, int); + long unsigned int (*get_cached_segment_base)(struct x86_emulate_ctxt *, int); + void (*get_gdt)(struct x86_emulate_ctxt *, struct desc_ptr *); + void (*get_idt)(struct x86_emulate_ctxt *, struct desc_ptr *); + void (*set_gdt)(struct x86_emulate_ctxt *, struct desc_ptr *); + void (*set_idt)(struct x86_emulate_ctxt *, struct desc_ptr *); + ulong (*get_cr)(struct x86_emulate_ctxt *, int); + int (*set_cr)(struct x86_emulate_ctxt *, int, ulong); + int (*cpl)(struct x86_emulate_ctxt *); + int (*get_dr)(struct x86_emulate_ctxt *, int, ulong *); + int (*set_dr)(struct x86_emulate_ctxt *, int, ulong); + u64 (*get_smbase)(struct x86_emulate_ctxt *); + void (*set_smbase)(struct x86_emulate_ctxt *, u64); + int (*set_msr)(struct x86_emulate_ctxt *, u32, u64); + int (*get_msr)(struct x86_emulate_ctxt *, u32, u64 *); + int (*check_pmc)(struct x86_emulate_ctxt *, u32); + int (*read_pmc)(struct x86_emulate_ctxt *, u32, u64 *); + void (*halt)(struct x86_emulate_ctxt *); + void (*wbinvd)(struct x86_emulate_ctxt *); + int (*fix_hypercall)(struct x86_emulate_ctxt *); + void (*get_fpu)(struct x86_emulate_ctxt *); + void (*put_fpu)(struct x86_emulate_ctxt *); + int (*intercept)(struct x86_emulate_ctxt *, struct x86_instruction_info *, enum x86_intercept_stage); + void (*get_cpuid)(struct x86_emulate_ctxt *, u32 *, u32 *, u32 *, u32 *); + void (*set_nmi_mask)(struct x86_emulate_ctxt *, bool); +}; + +struct x86_init_iommu { + int (*iommu_init)(void); +}; + +struct x86_init_irqs { + void (*pre_vector_init)(void); + void (*intr_init)(void); + void (*trap_init)(void); +}; + +struct x86_init_mpparse { + void (*mpc_record)(unsigned int); + void (*setup_ioapic_ids)(void); + int (*mpc_apic_id)(struct mpc_cpu *); + void (*smp_read_mpc_oem)(struct mpc_table *); + void (*mpc_oem_pci_bus)(struct mpc_bus *); + void (*mpc_oem_bus_info)(struct mpc_bus *, char *); + void (*find_smp_config)(void); + void (*get_smp_config)(unsigned int); +}; + +struct x86_init_oem { + void (*arch_setup)(void); + void (*banner)(void); +}; + +struct x86_init_resources { + void (*probe_roms)(void); + void (*reserve_resources)(void); + char * (*memory_setup)(void); +}; + +struct x86_init_paging { + void (*pagetable_init)(void); +}; + +struct x86_init_timers { + void (*setup_percpu_clockev)(void); + void (*timer_init)(void); + void (*wallclock_init)(void); +}; + +struct x86_init_pci { + int (*arch_init)(void); + int (*init)(void); + void (*init_irq)(void); + void (*fixup_irqs)(void); +}; + +struct x86_init_ops { + struct x86_init_resources resources; + struct x86_init_mpparse mpparse; + struct x86_init_irqs irqs; + struct x86_init_oem oem; + struct x86_init_paging paging; + struct x86_init_timers timers; + struct x86_init_iommu iommu; + struct x86_init_pci pci; +}; + +struct x86_instruction_info { + u8 intercept; + u8 rep_prefix; + u8 modrm_mod; + u8 modrm_reg; + u8 modrm_rm; + u64 src_val; + u64 dst_val; + u8 src_bytes; + u8 dst_bytes; + u8 ad_bytes; + u64 next_rip; +}; + +struct x86_io_apic_ops { + unsigned int (*read)(unsigned int, unsigned int); + void (*disable)(void); +}; + +struct x86_legacy_devices { + int pnpbios; +}; + +struct x86_legacy_features { + int rtc; + int ebda_search; + struct x86_legacy_devices devices; +}; + +struct x86_mapping_info { + void * (*alloc_pgt_page)(void *); + void *context; + long unsigned int pmd_flag; + bool kernel_mapping; +}; + +struct x86_msi_ops { + int (*setup_msi_irqs)(struct pci_dev *, int, int); + void (*teardown_msi_irq)(unsigned int); + void (*teardown_msi_irqs)(struct pci_dev *); + void (*restore_msi_irqs)(struct pci_dev *); +}; + +struct x86_perf_task_context { + u64 lbr_from[32]; + u64 lbr_to[32]; + u64 lbr_info[32]; + int tos; + int lbr_callstack_users; + int lbr_stack_state; +}; + +struct x86_platform_ops { + long unsigned int (*calibrate_tsc)(void); + void (*get_wallclock)(struct timespec *); + int (*set_wallclock)(const struct timespec *); + void (*iommu_shutdown)(void); + bool (*is_untracked_pat_range)(u64, u64); + void (*nmi_init)(void); + unsigned char (*get_nmi_reason)(void); + int (*i8042_detect)(void); + void (*save_sched_clock_state)(void); + void (*restore_sched_clock_state)(void); + void (*apic_post_init)(void); + struct x86_legacy_features legacy; + void (*set_legacy_features)(void); +}; + +struct x86_pmu_quirk; + +struct x86_pmu { + const char *name; + int version; + int (*handle_irq)(struct pt_regs *); + void (*disable_all)(void); + void (*enable_all)(int); + void (*enable)(struct perf_event *); + void (*disable)(struct perf_event *); + int (*hw_config)(struct perf_event *); + int (*schedule_events)(struct cpu_hw_events *, int, int *); + unsigned int eventsel; + unsigned int perfctr; + int (*addr_offset)(int, bool); + int (*rdpmc_index)(int); + u64 (*event_map)(int); + int max_events; + int num_counters; + int num_counters_fixed; + int cntval_bits; + u64 cntval_mask; + union { + long unsigned int events_maskl; + long unsigned int events_mask[1]; + }; + int events_mask_len; + int apic; + u64 max_period; + struct event_constraint * (*get_event_constraints)(struct cpu_hw_events *, int, struct perf_event *); + void (*put_event_constraints)(struct cpu_hw_events *, struct perf_event *); + void (*start_scheduling)(struct cpu_hw_events *); + void (*commit_scheduling)(struct cpu_hw_events *, int, int); + void (*stop_scheduling)(struct cpu_hw_events *); + struct event_constraint *event_constraints; + struct x86_pmu_quirk *quirks; + int perfctr_second_write; + bool late_ack; + unsigned int (*limit_period)(struct perf_event *, unsigned int); + int attr_rdpmc_broken; + int attr_rdpmc; + struct attribute **format_attrs; + struct attribute **event_attrs; + ssize_t (*events_sysfs_show)(char *, u64); + struct attribute **cpu_events; + int (*cpu_prepare)(int); + void (*cpu_starting)(int); + void (*cpu_dying)(int); + void (*cpu_dead)(int); + void (*check_microcode)(void); + void (*sched_task)(struct perf_event_context___2 *, bool); + u64 intel_ctrl; + union perf_capabilities intel_cap; + unsigned int bts: 1; + unsigned int bts_active: 1; + unsigned int pebs: 1; + unsigned int pebs_active: 1; + unsigned int pebs_broken: 1; + unsigned int pebs_prec_dist: 1; + int pebs_record_size; + int pebs_buffer_size; + void (*drain_pebs)(struct pt_regs *); + struct event_constraint *pebs_constraints; + void (*pebs_aliases)(struct perf_event *); + int max_pebs_events; + long unsigned int free_running_flags; + long unsigned int lbr_tos; + long unsigned int lbr_from; + long unsigned int lbr_to; + int lbr_nr; + u64 lbr_sel_mask; + const int *lbr_sel_map; + bool lbr_double_abort; + bool lbr_pt_coexist; + atomic_t lbr_exclusive[3]; + unsigned int amd_nb_constraints: 1; + struct extra_reg *extra_regs; + unsigned int flags; + struct perf_guest_switch_msr * (*guest_get_msrs)(int *); +}; + +struct x86_pmu_capability { + int version; + int num_counters_gp; + int num_counters_fixed; + int bit_width_gp; + int bit_width_fixed; + unsigned int events_mask; + int events_mask_len; +}; + +union x86_pmu_config { + struct { + u64 event: 8; + u64 umask: 8; + u64 usr: 1; + u64 os: 1; + u64 edge: 1; + u64 pc: 1; + u64 interrupt: 1; + u64 __reserved1: 1; + u64 en: 1; + u64 inv: 1; + u64 cmask: 8; + u64 event2: 4; + u64 __reserved2: 4; + u64 go: 1; + u64 ho: 1; + } bits; + u64 value; +}; + +struct x86_pmu_quirk { + struct x86_pmu_quirk *next; + void (*func)(void); +}; + +struct xattr { + const char *name; + void *value; + size_t value_len; +}; + +struct xattr_handler { + const char *name; + const char *prefix; + int flags; + bool (*list)(struct dentry___2 *); + int (*get)(const struct xattr_handler *, struct dentry___2 *, struct inode *, const char *, void *, size_t); + int (*set)(const struct xattr_handler *, struct dentry___2 *, struct inode *, const char *, const void *, size_t, int); +}; + +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_encap_tmpl { + __u16 encap_type; + __be16 encap_sport; + __be16 encap_dport; + xfrm_address_t encap_oa; +}; + +struct xfrm_id { + xfrm_address_t daddr; + __be32 spi; + __u8 proto; +}; + +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_state_afinfo; + +struct xfrm_mode { + int (*input2)(struct xfrm_state *, struct sk_buff *); + int (*input)(struct xfrm_state *, struct sk_buff *); + int (*output2)(struct xfrm_state *, struct sk_buff *); + int (*output)(struct xfrm_state *, struct sk_buff *); + struct xfrm_state_afinfo *afinfo; + struct module *owner; + unsigned int encap; + int flags; +}; + +struct xfrm_replay { + void (*advance)(struct xfrm_state *, __be32); + int (*check)(struct xfrm_state *, struct sk_buff *, __be32); + int (*recheck)(struct xfrm_state *, struct sk_buff *, __be32); + void (*notify)(struct xfrm_state *, int); + int (*overflow)(struct xfrm_state *, struct sk_buff *); +}; + +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_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_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_state { + possible_net_t xs_net; + union { + struct hlist_node gclist; + struct hlist_node bydst; + }; + struct hlist_node bysrc; + struct hlist_node byspi; + atomic_t refcnt; + spinlock_t lock; + struct xfrm_id id; + struct xfrm_selector sel; + struct xfrm_mark mark; + 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 trailer_len; + u32 extra_flags; + } 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; + struct xfrm_encap_tmpl *encap; + 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; + struct xfrm_replay *repl; + u32 xflags; + u32 replay_maxage; + u32 replay_maxdiff; + struct timer_list rtimer; + struct xfrm_stats stats; + struct xfrm_lifetime_cur curlft; + struct tasklet_hrtimer mtimer; + long int saved_tmo; + long unsigned int lastused; + const struct xfrm_type *type; + struct xfrm_mode *inner_mode; + struct xfrm_mode *inner_mode_iaf; + struct xfrm_mode *outer_mode; + struct xfrm_sec_ctx *security; + void *data; +}; + +struct xfrm_tmpl; + +struct xfrm_state_afinfo { + unsigned int family; + unsigned int proto; + __be16 eth_proto; + struct module *owner; + const struct xfrm_type *type_map[256]; + struct xfrm_mode *mode_map[5]; + int (*init_flags)(struct xfrm_state *); + void (*init_tempsel)(struct xfrm_selector *, const struct flowi *); + void (*init_temprop)(struct xfrm_state *, const struct xfrm_tmpl *, const xfrm_address_t *, const xfrm_address_t *); + int (*tmpl_sort)(struct xfrm_tmpl **, struct xfrm_tmpl **, int); + int (*state_sort)(struct xfrm_state **, struct xfrm_state **, int); + int (*output)(struct net *, struct sock *, struct sk_buff *); + int (*output_finish)(struct sock *, struct sk_buff *); + int (*extract_input)(struct xfrm_state *, struct sk_buff *); + int (*extract_output)(struct xfrm_state *, struct sk_buff *); + int (*transport_finish)(struct sk_buff *, int); + void (*local_error)(struct sk_buff *, u32); +}; + +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_type { + char *description; + struct module *owner; + u8 proto; + u8 flags; + int (*init_state)(struct xfrm_state *); + 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 *); + int (*hdr_offset)(struct xfrm_state *, struct sk_buff *, u8 **); + u32 (*get_mtu)(struct xfrm_state *, int); +}; + +struct xps_map; + +struct xps_dev_maps { + struct callback_head rcu; + struct xps_map *cpu_map[0]; +}; + +struct xps_map { + unsigned int len; + unsigned int alloc_len; + struct callback_head rcu; + u16 queues[0]; +}; + +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, + } 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 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; +}; + +typedef struct z_stream_s z_stream; + +typedef z_stream *z_streamp; + +struct zap_details { + struct address_space___2 *check_mapping; + long unsigned int first_index; + long unsigned int last_index; + bool ignore_dirty; + bool check_swap_entries; +}; + +typedef acpi_status (*acpi_exception_handler)(acpi_status, acpi_name, u16, u32, void *); + +typedef acpi_status (*acpi_execute_op)(struct acpi_walk_state *); + +typedef void (*acpi_gbl_event_handler)(u32, acpi_handle, u32, void *); + +typedef acpi_status (*acpi_gpe_callback)(struct acpi_gpe_xrupt_info *, struct acpi_gpe_block_info *, void *); + +typedef acpi_status (*acpi_init_handler)(acpi_handle, u32); + +typedef u32 (*acpi_interface_handler)(acpi_string, u32); + +typedef u32 (*acpi_osd_handler)(void *); + +typedef acpi_status (*acpi_pkg_callback)(u8, union acpi_operand_object *, union acpi_generic_state *, void *); + +typedef acpi_status (*acpi_table_handler)(u32, void *, void *); + +typedef acpi_status (*acpi_walk_aml_callback)(u8 *, u32, u32, u8, void **); + +typedef acpi_status (*acpi_walk_resource_callback)(struct acpi_resource *, void *); + +typedef int (*arch_set_vga_state_t)(struct pci_dev *, bool, unsigned int, u32); + +typedef unsigned int (*ata_xlat_func_t)(struct ata_queued_cmd *); + +typedef void blk_log_action_t(struct trace_iterator *, const char *); + +typedef int (*bpf_aux_classic_check_t)(struct sock_filter *, unsigned int); + +typedef void (*bpf_jit_fill_hole_t)(void *, unsigned int); + +typedef void busy_iter_fn(struct blk_mq_hw_ctx *, struct request *, void *, bool); + +typedef void busy_tag_iter_fn(struct request *, void *, bool); + +typedef int (*check_reserved_t)(u64, u64, unsigned int); + +typedef int (*cmp_stat_t)(void *, void *); + +typedef void compound_page_dtor(struct page *); + +typedef void compound_page_dtor___2(struct page___2 *); + +typedef void crash_vmclear_fn(void); + +typedef void detailed_cb(struct detailed_timing *, void *); + +typedef int dio_iodone_t___2(struct kiocb *, loff_t, ssize_t, void *); + +typedef int (*dr_match_t)(struct device *, void *, void *); + +typedef int (*dr_match_t___2)(struct device___2 *, void *, void *); + +typedef void (*dr_release_t___2)(struct device___2 *, void *); + +typedef int drm_ioctl_compat_t(struct file *, unsigned int, long unsigned int); + +typedef int drm_ioctl_compat_t___2(struct file___2 *, unsigned int, long unsigned int); + +typedef int (*efi_memattr_perm_setter)(struct mm_struct *, efi_memory_desc_t *); + +typedef bool (*ex_handler_t)(const struct exception_table_entry *, struct pt_regs *, int); + +typedef void (*exitcall_t)(void); + +typedef int filler_t(void *, struct page___2 *); + +typedef int filler_t___2(void *, struct page *); + +typedef int (*filter_pred_walkcb_t)(enum move_type, struct filter_pred *, int *, void *); + +typedef void fn_handler_fn(struct vc_data *); + +typedef const u8 * (*fn_mipi_elem_exec)(struct intel_dsi *, const u8 *); + +typedef void free_page_t(struct page *, long unsigned int); + +typedef void free_page_t___2(struct page___2 *, long unsigned int); + +typedef unsigned int (*get_num_bios_fn)(struct dm_target___2 *); + +typedef int gifconf_func_t(struct net_device *, char *, int); + +typedef int (*hda_codec_patch_t)(struct hda_codec *); + +typedef int (*initxattrs)(struct inode *, const struct xattr *, void *); + +typedef int instantiate_t(struct inode___2 *, struct dentry *, struct task_struct___2 *, const void *); + +typedef int instantiate_t___2(struct inode *, struct dentry___2 *, struct task_struct *, const void *); + +typedef ssize_t (*io_fn_t)(struct file *, char *, size_t, loff_t *); + +typedef int (*ioctl_fn)(struct dm_ioctl *, size_t); + +typedef int (*iommu_fault_handler_t___2)(struct iommu_domain *, struct device___2 *, long unsigned int, int, void *); + +typedef bool (*is_split_required_fn)(struct dm_target___2 *); + +typedef ssize_t (*iter_fn_t)(struct kiocb *, struct iov_iter *); + +typedef void k_handler_fn(struct vc_data *, unsigned char, char); + +typedef struct kobject___2 *kobj_probe_t___2(dev_t, int *, void *); + +typedef enum lru_status (*list_lru_walk_cb)(struct list_head *, struct list_lru_one *, spinlock_t *, void *); + +typedef int (*map_slave_func_t)(struct hda_codec *, void *, struct snd_kcontrol *); + +typedef struct page *new_page_t(struct page *, long unsigned int, int **); + +typedef struct page___2 *new_page_t___2(struct page___2 *, long unsigned int, int **); + +typedef void (*nmi_shootdown_cb)(int, struct pt_regs *); + +typedef void (*node_registration_func_t)(struct node *); + +typedef void (*online_page_callback_t)(struct page *); + +typedef void * (*pcpu_fc_alloc_fn_t)(unsigned int, size_t, size_t); + +typedef int pcpu_fc_cpu_distance_fn_t(unsigned int, unsigned int); + +typedef void (*pcpu_fc_free_fn_t)(void *, size_t); + +typedef void (*pcpu_fc_populate_pte_fn_t)(long unsigned int); + +typedef int (*percpu_ida_cb)(unsigned int, void *); + +typedef void perf_event_aux_output_cb(struct perf_event___2 *, void *); + +typedef int (*pm_callback_t)(struct device *); + +typedef void (*poll_queue_proc___3)(struct file *, wait_queue_head_t *, struct poll_table_struct *); + +typedef int (*printk_func_t)(const char *, struct __va_list_tag *); + +typedef int (*pte_fn_t)(pte_t *, pgtable_t, long unsigned int, void *); + +typedef int (*pte_fn_t___2)(pte_t *, pgtable_t___2, long unsigned int, void *); + +typedef printk_func_t pto_T_____27; + +typedef int (*put_call_t)(struct snd_kcontrol *, struct snd_ctl_elem_value *); + +typedef irqreturn_t (*rtc_irq_handler)(int, void *); + +typedef ssize_t rw_iter_op(struct kiocb *, struct iov_iter *); + +typedef void (*set_debug_port_t)(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 int (*sk_read_actor_t)(read_descriptor_t *, struct sk_buff *, unsigned int, size_t); + +typedef bool (*slot_level_handler)(struct kvm *, struct kvm_rmap_head *); + +typedef int (*snd_seq_dump_func_t)(void *, void *, int); + +typedef int splice_actor(struct pipe_inode_info___2 *, struct pipe_buffer *, struct splice_desc *); + +typedef int splice_actor___2(struct pipe_inode_info *, struct pipe_buffer___2 *, struct splice_desc *); + +typedef int splice_direct_actor(struct pipe_inode_info___2 *, struct splice_desc *); + +typedef int (*subbuf_actor_t)(size_t, struct rchan_buf *, size_t, read_descriptor_t *); + +typedef long int (*sys_call_ptr_t)(long unsigned int, long unsigned int, long unsigned int, long unsigned int, long unsigned int, long unsigned int); + +typedef void (*task_work_func_t)(struct callback_head *); + +typedef int (*tg_visitor)(struct task_group *, void *); + +typedef int (*trace_func_graph_ent_t)(struct ftrace_graph_ent *); + +typedef void (*trace_func_graph_ret_t)(struct ftrace_graph_ret *); + +typedef int (*transfer_f)(struct snd_pcm_substream *, unsigned int, long unsigned int, unsigned int, snd_pcm_uframes_t); + +typedef struct sock * (*udp_lookup_t)(struct sk_buff *, __be16, __be16); + +typedef int user_regset_active_fn___2(struct task_struct___2 *, const struct user_regset *); + +typedef int user_regset_get_fn___2(struct task_struct___2 *, const struct user_regset *, unsigned int, unsigned int, void *, void *); + +typedef int user_regset_set_fn___2(struct task_struct___2 *, const struct user_regset *, unsigned int, unsigned int, const void *, const void *); + +typedef int user_regset_writeback_fn___2(struct task_struct___2 *, const struct user_regset *, int); + +typedef bool (*vlv_pipe_check)(struct drm_i915_private *, enum pipe); + +typedef int wait_bit_action_f(struct wait_bit_key *, int); + +typedef int (*writepage_t)(struct page___2 *, struct writeback_control *, void *); + +typedef int (*writepage_t___2)(struct page *, struct writeback_control *, void *); + +struct hpet_dev; + +typedef void **pto_T_____28; + +struct blk_integrity; + +struct hugetlb_cgroup; + +struct led_cdev; + +struct lockdep_map; + +struct rtc; + +struct virtio_gpu_command; + + +/* BPF kfuncs */ +#ifndef BPF_NO_KFUNC_PROTOTYPES +#endif + +#ifndef BPF_NO_PRESERVE_ACCESS_INDEX +#pragma clang attribute pop +#endif + +#endif /* __VMLINUX_H__ */ diff --git a/scheds/include/vmlinux/vmlinux.h b/scheds/include/vmlinux/vmlinux.h index 9c3f1adef..b6300cfcd 120000 --- a/scheds/include/vmlinux/vmlinux.h +++ b/scheds/include/vmlinux/vmlinux.h @@ -1 +1 @@ -vmlinux-v6.12-rc0-ga748db0c8c6a.h \ No newline at end of file +/home/patso/repos/scx-backports/scheds/include/vmlinux/vmlinux-feb245e.h \ No newline at end of file